DEV Community: Eric He

I’ve wanted this for years. Then Fable 5 dropped — and in 48 hours I crammed the entire solar system into a web page.

Eric He — Wed, 17 Jun 2026 13:57:31 +0000

Have you ever had this feeling?

We grow up knowing the solar system by heart. Mercury, Venus, Earth, Mars — most kids can rattle them off before they learn fractions. We’ve seen the posters, the documentaries, the textbook diagrams. It is, hands down, the part of the universe we know best.

But then go try to actually experience it.

Try to find one place where you can fly through the real solar system at real scale, land on a real moon, look up at a planet hanging overhead, and feel like you’re actually there.

You won’t find it.

It’s either a static image, a pre-rendered animation, or a game that squishes the planets so close together they might as well be billiard balls on a table. We know the names of our cosmic backyard. We’ve never been allowed to walk around inside it.

I’ve wanted to fix that for a long time.

The solar system is the perfect doorway to the universe. It’s close enough to be real, documented enough to be accurate, beautiful enough to be unforgettable. If you can show someone the full scale of our own neighborhood, the rest of the cosmos stops feeling abstract.

I just needed the right tool. On June 9, it arrived.

The moment Fable 5 launched, I knew the clock was running

If you were following AI that week, you felt it. Claude Fable 5 — the strongest model Anthropic had ever released publicly — wasn’t just incrementally better. It was the kind of leap that made you reorder your todo list.

My first thought wasn’t “let me test some prompts.”

It was: can this thing finally build the solar system I’ve been carrying around in my head?

Real scale. Real ephemeris. Real physics. Seamless landing. Runs in a browser. Works on a phone.

Any one of those is a serious problem. Together, they’re the kind of project that normally eats months. But Fable 5 had a quality I hadn’t seen before: it could hold an entire complex system in context and reason about it as one piece.

I didn’t hesitate. I bought the subscription that night, opened a new repo, and started. And then, for two days straight, I basically didn’t sleep.

Two days. Really, just two days.

Between June 9 and June 11, I built the skeleton: ephemeris layer, camera system, renderer, planets and moons, the seamless orbit-to-surface transition. On June 11 I committed roughly twelve thousand lines in one drop.

How do you do that in two days?

Because the hardest part of a real-scale solar system isn’t the graphics. It’s precision. A planet’s radius is thousands of kilometers. The Oort Cloud sits at 100,000 AU. Standard GPU floats can’t hold both in the same scene — if you try, the ground shudders and tears under your feet as you land.

The fix is Float64 computation, a floating origin, and a logarithmic depth buffer. Those three things have to be right from the start. If the foundation is wrong, every fix afterward is a band-aid.

Fable 5 got the foundation right on the first try. Not by writing code fast, but by understanding the architecture. It didn’t feel like pair programming. It felt like finally explaining your idea to someone who actually gets it.

Open it. Then you’ll understand why I’m excited.

https://sw.icodestar.net

No download. No account. Free. Works on your phone, your laptop, your tablet.

What it looks like when you open the link on a phone. No splash screen, no login wall — just Earth, rotating, waiting.

Put two fingers on the screen and pinch.

You fall from Earth orbit, through the atmosphere, watch the sky fade from black to blue to sunset orange, and settle onto the ocean. One continuous shot. No “enter planet” button. No loading screen.

That smoothness can’t be described. You have to feel it. The first time you pinch through the atmosphere and realize there’s no seam anywhere, something clicks.

It’s not painted. It’s computed.

Most “solar system” demos are art projects. Planet sizes are fudged. Positions are hand-placed. Orbits are looped animations.

This one is built from NASA JPL ephemerides. Every planet is where it actually is right now.

The Earth you see — clouds, continents, the lit hemisphere — matches the real sky at this moment.

Against JPL Horizons, planets are within 0.074°, the Moon within ~0.12°, and 21 fitted moons stay within 0.22° ten days out. You can run npm run verify and it will query NASA’s own API to check. For astronomy people, that matters more than any fancy shader.

And when you fly close, the detail holds up:

Jupiter’s belts and zones don’t collapse into a blur when you zoom in.

Mars is dry, rusty, cratered — instantly recognizable.

Saturn’s rings have structure, gaps, and cast real shadows across the sphere.

It’s accurate enough to teach with. And gorgeous enough to stare at.

The part that gave me goosebumps: land, look up

Fly to Io. Touch down. Look up.

Rugged ground under your feet. Jupiter filling half the sky overhead.

Land on Mimas and align your view with the ring plane.

Saturn’s rings collapse into a razor-thin line across the black. I froze the first time I saw it in a browser.

But the one that really gets people is the Moon.

Land. Turn around. Find that tiny blue marble in the black.

Gray lunar wilderness in the foreground. That faint blue dot in the upper right is Earth.

You are standing on the Moon. That lonely blue point is everyone you’ve ever known.

This is the thing the Apollo astronauts could never quite put into words when they came home — the quiet that settles in when you see Earth that small, that far, hanging in nothing. This is why I wanted to build it. Not because it looks nice. Because for a second, you really are there.

You think that’s far? You’re still inside the inner suburbs.

Everything above is just the inner solar system. The actual range of this thing is absurd: from 0.5 meters under your feet to 100,000 AU at the Oort Cloud. The Sun-to-edge distance is about 1.6 light-years; the full solar system diameter exceeds 3 light-years.

Eight planets. The Moon. Twenty-one fitted moons. The asteroid belt. The Kuiper belt. Twenty-eight real trans-Neptunian objects. Four comets with anti-solar tails. Twenty-one real bright stars placed at their true 3D distances, so they shift with parallax as you move.

Pinch out. Keep pinching. Earth becomes a dot. Then disappears. Voyager 1 has been traveling for over forty years and still hasn’t left this volume. You can pull back through it in one gesture.

And the whole thing ships in about 200KB gzipped. No backend. No account. Free. Open source. A static website.

Then the tool that built it was pulled offline

On June 12–13, Fable 5 was suspended worldwide under US export controls.

I had used it for roughly three days.

The rest of the work — full mobile overhaul, bilingual UI, rendering fixes, GPU auto-tiering — was finished with Claude Opus and Sonnet. I shipped v2.0.0, which is the version you can open today.

I’m not here to argue about the policy. I’m here because the artifact survived. It’s real. It’s open. It’s at the URL below.

The solar system deserves to be built properly

This is our neighborhood. We’ve memorized its names since childhood, but we’ve never truly walked through it. I want to change that — even if it’s just one webpage, one person at a time, seeing Earth rise over the Moon, watching Saturn’s rings slice the sunlight, pulling back until Voyager’s lifetime looks like a short commute.

If you’re curious about the universe, if you’ve ever wanted to stand on another world and look up, if you also think this should have existed already —

https://sw.icodestar.net

Do exactly two things:

Fly to the Moon, land, turn around, and find Earth.
Pull back. Keep pulling back until Earth disappears.

You’ll be glad your curiosity brought you here.

Source code and git history: https://github.com/hyqzz/Solar-Wanderer

If it moves you, share it with one person who would also want to look up at the sky tonight.

I built a 1:1 solar system with Fable 5 in the days before it was pulled offline

Eric He — Mon, 15 Jun 2026 16:33:46 +0000

I built a 1:1 solar system with Fable 5 in the days before it was pulled offline

On June 9, Anthropic released Claude Fable 5 — the most capable model they'd ever made publicly available. I used it to build the core of a 1:1, real-time solar system that runs in a browser.

Three days later, on June 12–13, the US government ordered the model pulled offline worldwide over export controls. The tool that built this is gone.

I finished the rest with older Claude models, added full mobile support, and shipped v2.0.0. You can open it on your phone right now:

👉 https://sw.icodestar.net — pinch to fly from Earth orbit down to standing on the Moon.

The source and the entire (short) git history are public: https://github.com/hyqzz/Solar-Wanderer

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: https://sw.icodestar.net (works on phones; even better on a desktop)
Source / git history: https://github.com/hyqzz/Solar-Wanderer
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.