Project
Galaxy
A multiplayer space simulation built on honest orbital mechanics across three real star systems — full-scale Sol, Alpha Centauri, and Barnard’s Star — where you fly spacecraft from orbit all the way down to the surface, under Newtonian physics that never looks the other way.
What it is
Galaxy is a multiplayer space simulation, and it’s where my aerospace training does real work again. Three real star systems, modeled at full scale: our own Sol with its eight planets and twenty moons; the Alpha Centauri triple, with its confirmed exoplanets; and Barnard’s Star — forty-nine celestial bodies in all, each system its own N-body simulation, running every tick whether or not a player is there to watch it.
It’s deliberately a slow burn. Real orbital mechanics at real scale means travel takes real time — a run to the Moon is about three hours, Mars about two days — so continuous-thrust trajectories keep it manageable, and the automation flies your ship through transfers, rendezvous, and landings while you’re offline.
The physics
Nothing about the motion is faked. Gravity is a real N-body simulation over all forty-nine bodies, integrated with a symplectic scheme chosen because it stays stable over the long haul rather than slowly bleeding energy the way a naive integrator does. Positions are carried in the same inertial frame astronomers use, at sixty-four-bit precision and meters scale, with sphere-of-influence logic picking the right body to reference as a ship crosses between regimes. There’s an atmosphere model, with drag and co-rotation, for the worlds that have one.
The detail that gives away who built it: energy drift and momentum drift are tracked on every single tick, as a standing check that the integration is telling the truth. If the numbers start to lie, the simulation says so.
From orbit to the surface
You can fly a ship all the way down and land on it. The terrain system spans eight orders of magnitude in one continuous view — from a dot in orbit to standing on the ground — using a quadtree level-of-detail scheme wrapped over the sphere. The Moon and Mars use real NASA elevation data; the other rocky and icy worlds are generated procedurally. Forty of the bodies are landable.
The part that makes it honest: the terrain is generated identically on the server and on your machine, so collision and height-above-ground agree on both sides. A touchdown that looks good on your screen is one the physics server also believes.
The ships, and the flying
Four ship classes, each with an honest mass, thrust, specific-impulse, and delta-v budget — from a hundred-tonne cargo hauler to a light planetary lander. The drives obey the rocket equation, so fuel is finite and every burn costs you. Rotation comes from reaction wheels (free, but they saturate and have to be bled off) and RCS thrusters (strong, but they spend propellant); the inertia tensor shifts as the tanks drain, and a critically-damped attitude controller holds the ship steady through all of it.
On top of that sits the pilot’s vocabulary you’d actually want: sixteen attitude modes (prograde, retrograde, radial, target-relative, and the rest), manual rotation, and six-degree-of-freedom translation for the close, careful work of docking.
Automation — the hard part
The part I find most interesting is that a ship can fly itself. A server-side rule engine runs every tick, even while you’re logged off: player-defined rules with conditions on orbital elements — apoapsis, periapsis, eccentricity, true anomaly — and actions like circularize this orbit, change inclination, rendezvous with that station, land on that moon.
That last set is where the real difficulty lives, and it’s the corner of the project I’ve spent the most time in lately. Planning a rendezvous in a system where everything is moving is hard enough on its own; the genuinely hard version is time — a trajectory computed a few minutes ago can already be stale by the moment the ship arrives to fly it, and proving a plan against the live simulation rather than a hopeful offline one turns out to be most of the work. The honest test never changes: does it dock, live, or not?
Python and a set of microservices on Kubernetes, each star system its own simulation space, with the orbital mechanics in a dedicated trajectory planner. In active development, and — like anything that models real physics — mostly an ongoing argument with the numbers.
Access
Galaxy is a private project for now. If you’d like a look at it, get in touch.