TerraForge: Shipping a 3D Science App Thousands of People Experiment with Every Day

The problem

I've always been drawn to space science: how planets form, why one world ends up with oceans and another with a crushing atmosphere, what the thousands of exoplanets we've found might actually look like. For a long time I had ideas for apps that would let people explore those questions, but as one person with a full-time job, building them was always out of reach.

TerraForge is the first of those ideas I finally brought to life. I wanted to build a planet you could actually understand. Not a pretty sphere with a texture on it, but a world whose oceans, continents, and atmosphere come from the physics: how big it is, how far it sits from its star, and what billions of years of geology would do to it.

That's TerraForge. You shape a planet, the app simulates its evolution over geological time, and you can save it, share it in a public gallery, and place it in a star system. It also builds worlds from real data. TerraForge takes 5,574 rows from NASA's exoplanet archive and constructs each planet from what's known about it, and it's honest about where measurement ends and inference starts.

The hard part wasn't any single feature. It was making a real-time 3D simulation run well in an ordinary browser, for people who never asked how hard that is.

My role

I designed and built it solo under inkOrange Studios, my studio for educational and science software, working with Claude as an agentic coding partner. That covers the product, the interface, the 3D rendering, the backend, and the marketing. It runs on Next.js, Three.js, Supabase, and Vercel, and its interface is built on SpaceUI, the open-source design system I extracted from it.

Key Decisions

Use agentic coding to make a solo build possible. What changed wasn't my ideas, it was how I could build them. I work with Claude as a coding agent: I set the direction, break the work into pieces, review what it produces, and decide what ships. It handles a lot of the implementation, which lets one person cover the range a project like this needs, from 3D rendering and simulation to the backend and the interface. The judgment stays with me. Agentic coding didn't replace knowing what good looks like. It's what finally let me act on it at this scale.

A community of users can save their star systems on a collection of 3 galaxies in the universe of TerraForge

Use real data, and say where it stops. It would have been easier to make planets that just look plausible. I chose to ground them in NASA's archive and in physics, and to show users which parts are measured and which are inferred. That matters even more once it's in front of students.

Direct the shaders, and judge the output hard. The planet rendering uses custom GLSL shaders, developed through AI-assisted workflows that I directed. I don't hand-write the shader code. My job is the direction and the judgment:

• I describe the look I want in words and references, then iterate.
• I review the renders and feed screenshots back to correct what's off.
• I check the output against the science, so a planet looks the way its data says it should.
• I profile frame rate on every change and reject anything that costs too much.

That last check matters most. A beautiful shader nobody's device can run is a failed shader.

Design for the slowest device in the room. The biggest performance problems were weaker devices and shader cost. Plenty of my users, students included, aren't on gaming PCs. So I built an adaptive-quality mode: when frame rate drops, the app lowers 3D render resolution to keep things smooth. Combined with keeping shader cost in check through constant profiling, it lets the same planet run on a modest laptop and a high-end desktop.

Pull the UI into its own system. Once I started building more space and science apps, I extracted TerraForge's interface into SpaceUI so every app could share it. TerraForge became the system's first and toughest customer.

Take it to mobile. A lot of curiosity about space happens on a phone, so a mobile app is in development. The first Android build comes from the same Next.js code using Capacitor, and I also built Exoplanet Explorer, a native Android app that extends TerraForge. Both are pre-release.

What happened

• 6,000 to 7,000 daily users.
• 250+ planets created every day, with dozens of new accounts daily.
• Growth came from three places: Reddit and social posts, search, and educators bringing it to students.

What I'd do next

The most common request from users is more control over their planets. That's the next big area of work: more ways to shape a world while keeping the science honest underneath. Alongside it, I'm finishing the mobile app and building a presence in the app stores through native apps, so TerraForge and its companion apps can be found where people already look for them, not just on the web.