What it actually is

It's not a skybox with planet textures. It's the solar system at true 1:1 kilometer scale, with every planet placed where NASA JPL ephemerides say it is right now:

• 
  Real positions. Planets are within 0.074° of JPL Horizons; the Moon within ~0.12°; 21 moons fitted from Horizons state vectors stay within 0.22° ten days out. Change the system clock and everything moves like the real thing — you can run time forward a decade at 10 years/second and watch the moons wind around their planets.


• 
  Seamless, no loading screens. Orbit → atmosphere → surface → walking → underwater is one continuous transition. Pinch down toward Earth and you fall through the atmosphere and land on the ocean; the water has buoyancy and you can dive.


• 
  The whole thing. 8 planets, the Moon, 21 fitted moons, the asteroid belt, the Kuiper belt, 28 real trans-Neptunian objects, 4 comets with anti-solar tails, and 21 real stars placed at their true 3D distances (they show parallax as you move). Out to 100,000 AU — the Oort Cloud, about 1.6 light-years from the Sun in every direction.
  


• 
  Tiny. ~200 kB gzipped, no backend, no account, MIT licensed. It's a static site.

Here's the part that still feels slightly unreal to me: you can pinch from Earth orbit straight down until you're standing on the ocean, watching the sun glint off the water — and it's the same continuous zoom the whole way.

The three hard problems

If you've tried to render space at real scale, you already know the enemy: floating-point precision. Three problems had to be solved together.

1. You cannot fit the solar system into float32

A GPU works in 32-bit floats. The distance from the Sun to the Oort Cloud is ~1.5 × 10¹³ km. Float32 has ~7 significant digits. If you store positions in absolute coordinates, by the time you're standing on a planet the per-vertex quantization is kilometers — the ground visibly shudders and shears.

The fix is a floating origin. All astronomy is computed in Float64 (heliocentric ecliptic J2000, in km), but before anything reaches the GPU, the camera's own position is subtracted out, so the scene is always centered on the viewer and the numbers handed to WebGL are small. The world quietly re-bases as you fly. Terrain noise is evaluated in tile-local coordinates for the same reason — sample noise at planet-radius magnitudes and fp32 banding wrecks it.

2. One depth buffer from 0.5 m to 10¹³ km

A normal perspective depth buffer can't span "half a meter in front of my feet" and "Neptune's orbit" at once — you get catastrophic z-fighting. The answer is a logarithmic depth buffer, which redistributes precision so near and absurdly-far geometry coexist. camera.far is set to 1 × 10¹⁵ km — about 106 light-years — so the 21 real background stars sit at honest distances and shift with parallax.

3. Making the landing seamless

The thing people feel but can't name is that there's no "enter planet" button. Orbiting, descending, atmospheric entry, touchdown, walking, and diving are not separate scenes — they're one camera following a single continuous dist-to-surface curve. On desktop the scroll wheel drives that curve; on mobile, the pinch gesture is mapped onto the exact same curve, so landing with a finger feels identical to landing with a wheel. The atmosphere is ray-marched (Rayleigh + Mie, Nishita-style) per planet, so the sky reddens correctly as you sink into it, and gas giants let you fly down into the cloud layers.

Try it

• 
  Open it:
  


• The verification is real: npm run verify checks live positions against the JPL Horizons API; npm test runs the offline ephemeris accuracy suite.

Pinch out until Earth is a pale blue dot. Then keep going.

Built with Three.js + WebGL2. MIT licensed. No account, no backend, no tracking.