How We Got Here

Western Spiral Arm (working title) is a cockpit-led space combat MMO. The shortest, most direct pitch I have is: Feels like X-Wing, but it's really X-Wing in Guild Wars 2 clothing. Classic flight-assist starfighter combat — planes in space, not 6DOF — inside a persistent world of zones, events, and a world story "front line" that moves because of what players actually do in game.

This first DevLog entry covers everything before the first line of engine code: where the idea came from, what the game is, and the six weeks of design that this build now stands on.

Development proper starts today.

It all started as a search for a game to play

I have this really bad habit: when I start looking for a game, I usually can't find it and I end up designing one. This is the first one I thought was really worth actually building.

I wasn't looking to make anything. I was looking for something to play.

I play Guild Wars 2. It's my go-to game, and I've had a lot of time in the last 12+ years to think about how it was built. That being said, I was in a drifty phase, probably on-set by the announcement of GW3 and the slow wrap on new development of GW2. I've done my stint with Overwatch and Fortnite. I cannot play 4X games. 4X games are crack to me; I can't put them down. Dawn comes up and bites me. I won't touch 'em. Cold turkey stays cold. What I wanted was a space flight sim — and nothing had scratched that itch since the original X-Wing. Elite Dangerous felt samey. EVE Online is a lifestyle more than a game. X-Wing from EA? My mother told me that if I have nothing polite to say, say nothing. I tried various recommendations. None of them was the game I was looking for. I came to the conclusion that was because the game I was looking for doesn't exist.

So the question changed shape from Where is that mythical space-sim? to Why can't the original X-Wing be made multiplayer?

So then I began to research. History says it was tried: X-Wing vs. TIE Fighter, 1997. Failed on execution — it shipped without a campaign — not on premise. There have been others, but this isn't a history lesson. One thing that stood out as a key component was story, and campaign. And in the intervening time GW2 quietly solved that problem: Who's the protagonist in a multiplayer story? Answer: Everyone! Every player is The Commander, or The Wayfinder or, in our case, Captain.

This brought me to the larger picture, especially since space is naturally located, and not a continuous streaming world: If GW2 has solved the STORY issues, can we leverage the instanced model of zones, metas, and a progressing story? Everyone has their own story. Yet everyone comes together at the briefing. Everyone launches from the fighter bay in a heap. Everyone forms up to meet the threat. Commanders, with carrier space, organizing the fight. Multiple simultaneous goals to defeat that threat. Shields to take down. Armored modules to crack. Fighters to deal with. Bombers to intercept and knock off their attack run.

I kept asking "Why not this?" and "Why not that?" The answer kept coming back "There's no good reason." The bad habit had struck again, but this one was really good.

What the game is

The core loop, as it stands on paper:

• Zones with living events. Each zone has story related content; both for the individual pilot, and for the zone in general. Each zone outside of the starting zones, runs population-weighted metas with stages and multiple simultaneous objectives, so players self-distribute rather than stack on one marker. Individual objectives can be structures, capital ships, and escorts with shared health pools; the enemy fighter screen is the texture you must deal with to reach the objective. Players could choose different ship chassis to build custom loadouts for specific roles and play styles.
• Failure is content. Events don't reset to a checkpoint when they fail — the world state accepts the outcome, moves on and the next meta deals with the current state.
• A seasonal front line is authored from the aggregate outcomes of all players in all zones. What players collectively do shapes where the story goes.
• Cockpit flight, X-Wing handling. Pitch and yaw do the work, roll is how you orient, mass is a stat you feel every second. The depth comes from your ship's loadout, not from six-axis gymnastics. There may (will?) be drift abilities, but these are special cases, not the standard 6DoF from other games. 6DoF doesn't fit this world.

And some early rulings that shape everything downstream:

• The power plateau. There won't be the ever-bigger-ship treadmill. That kills this kind of design. Progression is horizontal. You get different, not endlessly bigger. Which leads directly to:
• Your pilot is never a stake. In EVE, losing a ship means losing time-denominated value — that's why it's a lifestyle. Here, the plateau plus salvage means defeat costs you the fight, not your progress. Consequence lives at the collective level, in the seasonal front, not in personal ruin. Pilot progression is a question of versatility as much as power.
• Capital ships are a population, not characters. They're weather systems you fly around and against. Both enemy and player factions will have large capital ship — including fun variants such as the shield frigate, the advancing umbrella that paces an assault on an enemy capital ship: the one scheduled moment the whole map is slow, close, and pointed the same way.
• Carriers and other multi-ship platforms come in the mid-game.
• Personal Living Space will start early but small. A place to stash your trophies.
• One pilot, one ship (at a time!) No crew management. You fly. That being said, a Pilot could have access to several hulls, and mid-game there are scenarios for multiple players sharing a single hull.
• As an instanced game there will be special scenarios where the standard pattern shifts completely.

Building it: the ground rules

I'm one developer. That fact drives every technical decision, and three rules were set before anything else:

1. Networked from day one. The single biggest cause of death for indie multiplayer projects is bolting networking on later. Here, even single-player is a server with one client. The very first playable milestone isn't a fun demo — it's a hundred headless clients flying dead-reckoned shapes while I measure tick rate and bandwidth. Prove the skeleton before dressing it.
2. Everything is data. Code is verbs; data is nouns and numbers. Events, enemies, ships, and loadouts are all definitions the systems read — which is what makes a one-person content pipeline survivable.
3. Plan your Dive and Dive your Plan. Everything is planned on paper before any work is done. No fishing expeditions. No rescues. You will see in the Six weeks on paper that I am trying to predict and design as much as I can before committing any work in any engine with any code.

The stack is Unreal Engine 5 with its modern networking and mass-simulation systems, targeting around a hundred concurrent pilots per zone instance.

Off-the-shelf flight kits were evaluated and rejected — the deciding factor was networking architecture, and that told me the order of operations: networking package first, flight sim fitted into it.

I use AI-assisted tooling openly in the programming workflow — that's part of what makes a solo project at this scope thinkable at all, and it'll be visible throughout these logs.

The art side has its own story and deserves its own post. My background includes physical model-building and miniature work for screen. Exactly how that craft translates to a digital pipeline is a topic for a proper workshop entry down the line.

Six weeks on paper - The Dive Plan

Here's what "designing one" actually looks like, dated. Dates are taken from each document's last edit, so most entries cover several days of work leading up to them. I didn't think to keep a proper log, so the actual dates are a bit forensic. Everything below happened before a single line of engine code.

Early July — Inception

• The game hunt, the question, and one long design run that produced the core loop: zones, metas, failure-as-content, the seasonal front.
• The foundational rulings above, plus: item rarity converging at the top of the ladder, enemies that read your kit, the dock as the waypoint.
• 8 July — first design document cut: 17 sections. The feedback pass added the first meta (six-phase building up to a capital-ship conflict) the shields-vs-armour archetype split, regional markets, weapon families.
• Flight kits evaluated and rejected; the engine stack researched and chosen; the prototype gate defined as a networking proof, not a flight demo.
• The setting frame established alongside the mechanics: a political map of small states and principalities, an antagonist polity, a speculative alien species, and an underworld layer. Oh - and of course, pirates.
• 9 July — design document v2: 28 sections plus a phase plan with gates — each phase has a test it can fail and tells us what survives and what dies.

9–14 July — The design consolidation week

• 9–10 July — zone design settled: three-tier travel (combat speed / cruise / micro-jump to discovered beacons), zone boundaries as a gradient with in-fiction feedback ("no nav fix — insufficient beacon triangulation"), seamless zone-jumps as a three-beat sequence. Guild institutions, cosmetics, and ambient discovery drafted.
• 10 July — full consistency audit (~25 findings) triaged and merged. The death cycle ruled: a four-grade loss gradient from disengage down to riding it in, with insurance making rebuilds free and time the only cost. Transient-content ruling: authored content never gets deleted, it retires into a library; permanent world changes must explain themselves in-fiction.
• 11 July — finalizing the diegetic layer for most content and solidifying the core rule that everything is described diegetically.
• 12 July — ship ontology: chassis = class = role (Scout, Fighter, Bomber, Support, Torpedo-boat), not weight classes; role classes. Three limiters with three jobs: typed sockets for identity, energy budget as the build governor, mass for feel. Ships are Hulls that use a stock Chassis, can are equipped with Items & Utilities allowing a large build variety in every chassis. Terrible build choices are possible.
• 13 July — identity architecture: the account owns, the pilot is, hulls are owned biographical objects. The ship is the player's ledger; the pilot is the world's ledger. Carriers, jump rules, and facility services ruled the same day.
• 13–14 July — the whole record restructured from session notes into a new proper design document, then converted to implementation-spec format. This took five failed attempts across multiple sessions before landing. Then the schedule split out into its own build plan as the milestone authority.

15–22 July — Money, pipeline, and infrastructure

• 15 July — sustainability model built: pricing structure, break-even bands, and the rule that the plan is made against the floor case, with anything better treated as upside. (The numbers stay internal; the discipline is the point.)
• 15–18 July — the asset pipeline found its shape the hard way. First approach failed its kill test — mechanically sound, output quality dead on arrival. Four more attempts at the first hull failed the same way. What survived: a reference-driven rebuild approach, hard gates on every pass, and a parts catalogue that grows as residue of real hulls rather than being pre-built. Knowing which road is dead is worth as much as knowing which one is open.
• 17 July — enemy AI architected: maneuver playbooks instead of point-and-chase pursuit, proportional navigation for gun-runs and missiles, a stalemate detector as the anti-circling valve — verified against how the classic sims actually did it.
• 18 July — persistence designed: database engine chosen, an event-ledger write model, and the identity spine (accounts → pilots → hulls) as the schema's backbone. Working principle stated: never pour concrete that future versions have to break. Stay clean and fluid if possible. Leave drill-holes in the concrete when things need to be rigid when and where they cost nothing, allowing the future content the access and anchor points it needs. (Plan/Dive)
• 18 July — 90-day production inventory built: every asset and system the first milestone needs, as a flat list plus a dependency map; triggered by the first line of code.
• 22 July — external architecture research (clean-room, no project documents open) to check the plan against sharded-MMO best practice. World-building filed: the first faction, the antagonist species' biology, and the first location concepts entered a 20-category world wiki, ready for lore intake. This took a few days.

Late July – early August — Family holiday

• The gap is a gap. Tools down, family time.

10–22 August — System deep-dives

• 10 Aug — flight system ruled: a two-stat model (Mass, Power) with all behaviour derived from global constants. Pitch and yaw at equal authority, roll presentational, top speed as thrust/drag equilibrium. Accessibility ruling: gamepad is first-class; no expensive-hardware lock. KBM is a must as a possibility.
• 14 Aug — fitting system ruled: four layers — Chassis, Modules, Infrastructure, Actions — over a shared generation pool feeding three power banks. Overflow is wasted by default; infrastructure can route it, lossily. Ship logistics ruled the same day: ships stay where you leave them. Players can easily move to different ships.
• 19 Aug — extensive due-diligence review: five alternative structural spines for the game assessed against the current direction. Verdict: current direction is the lowest-risk viable path, and the one serious rival is reachable as an evolution later, not a fork now.
• 22 Aug — player identity ruled: pilot names, earned call signs, ship names, friend nicknames — all public strings non-unique, because uniqueness is a database problem and the database has it covered invisibly.

23–24 August — Architecture week

• 23 Aug — the architecture bible: full deployed topology from client through login, orchestration, zone servers, and persistence, with the complete data spine and its invariants. Ground rule enforced throughout: architecture wins over prior documents and previous desires — every position stands on engineering merit, and the design docs get amended when they lose.
• 23 Aug — a narrative session settled the campaign's escalation arc — three tiers, from local squabbles up to something much stranger — and the first-contact mystery that opens it.
• 23–24 Aug — networking contract, four rulings: every weapon is a travelling projectile, server-authoritative, no lag-rewind of any kind; your own flight and power banks are fully client-predicted and deterministic; every aimable ship is presented identically regardless of how it's simulated under the hood; replication runs in three rings by combat relevance.
• 24 Aug — documentation reconciliation begun.
• 26 Aug — Documentation reconciliation continues. Devlog opened. The line is drawn.

What happens next

That line matters: In a perfect world, everything above it is design; everything after it is build. That's never going to be true. What we have done is enough proof of concept and design shape that we can get started; that we must get started. There is a lot of design yet to come, but we need to get to our first gate so we know we are a go and we can stick to our 90 day schedule.

Today — Wednesday 26 August — is Day 1 of the development clock.

First up is the least glamorous milestone imaginable: a server, a hundred fake clients, and a bandwidth graph. If that holds, flight feel comes next, then the first zone and the first meta event.

Posts here will be short and roughly fortnightly, aligned to what actually got built. If there's a quiet stretch, there'll be a quiet log — I'd rather write "wrestled the build system for a week" than pad.

The clock is running.