Hey Three.js community! I’ve been working on The Atlas for the past couple years and wanted to share it with you all. It’s a real-time procedural universe that generates infinite cosmic structures without any pre-stored assets, everything comes from… Pure math.
Live Demo | Alternative Demo | GitHub
*Also docker pull bansheetech/atlas:latest
Actual screenshots
What is this about?
So basically, I created this giant deterministic cube of 10M×10M×10M coordinates. Each point in this cube contains a complete galaxy, which means we’re talking about 1 sextillion galaxies in a single seed. To put that in perspective, that’s 133 times more galaxies than there are grains of sand on all Earth’s beaches combined. Each galaxy can contain from 1M to billions of systems, and each system can contain from 1 to 6 planets (I’m still working on this to create more system variation).
The whole thing runs on SHA-256 hashed seeds that get iterated over themselves. No database, no pre-saved data, just pure mathematics. The backend is Python/Flask and Three.js handles all the visual rendering. What’s crazy is that using the same seed guarantees you’ll get identical universes down to individual cloud formations, no matter what device you’re using.
I kind of implemented Einstein’s block universe theory where time is treated as a coordinate and all moments exist simultaneously. This means planets keep orbiting even when you shut everything down for weeks. When you come back, the system calculates exactly where every celestial body should be based on real Kepler orbital mechanics.
The planet generation stuff
I went a bit overboard and built 50+ custom visual effects from scratch. There are 27 different planet types ranging from boring rocky worlds to completely exotic crystalline formations. Each planet can contain up to 119 elements, including this fictional element I called Z-Divinium. Temperature calculations are based on actual orbital distance and gravity is calculated from real mass.
My PlanetLayerSystem can stack up to 15 simultaneous render passes. It starts with base terrain using displacement mapping and triplanar texturing, then adds atmospheric layers with scattering, particle effects for weather, and dynamic lighting that actually changes as planets orbit their stars.
The moon system was probably where I got most carried away. Planets can have complex moon systems with real hydrostatic relaxation physics. Small moons stay all jagged and irregular, but larger ones gradually become spherical over millions of years. The system actually calculates this evolution and shows you how moons would look at different points in cosmic time, without collisions yet.
The synchronization nightmare
The most challenging part was making sure two people looking at the same planet from different devices see exactly the same thing at exactly the same moment. Every single cloud formation, particle effect, and atmospheric animation has to be perfectly synchronized based on universal time.
This was a pain because I had to solve massive scale differences from universe-wide views down to planetary surface details while maintaining identical mathematical precision across all platforms. Floating-point precision became this huge issue when you’re dealing with coordinates spanning 10 million units and time spans going back to what I call the “Bit Bang”, the moment you create the universe, defined by the cosmic_origin_time value.
I actually built two different universe modes. Core Continuum is a shared universe that started on April 17, 1986 (my birth year), so it’s been evolving for almost 40 years now. Everyone who chooses Core Continuum explores the exact same cosmos. Then there’s Design The Multiverse, where you create your own personal universe with a fresh random seed and a cosmic_origin_time set to the moment you hit create. The deterministic math means your universe will evolve uniquely from that point forward.
How it evolved
The project actually started as a Pillow-based image renderer before I realized I needed real-time interaction and migrated everything to Three.js this past August. There’s probably still some legacy code from that first implementation lurking around in the ./pymodules folder.
The scale is honestly mind-bending. A fully evolved universe after 1.9 million years contains about 50 quintillion solar systems and 300 tredecillion planets. Even if you visited one planet per second without stopping, it would take… 300 trillion years to explore 0.001% of a single universe according to ChatGPT calculations 
Stack: Three.js, React, Vite-Fusion, Hypercorn, Flask and Python
Would love to hear from other Three.js developers about the rendering techniques, especially if anyone’s tackled similar scale challenges or deterministic procedural generation. It includes a small gamification system implemented entirely on localStorage, but you can Export / Import data values too.
Also, the QRs from the screenshots actually take you to the location instantly by using Stargate Links, so you can share instantly the view with others.
Thank you for reaching this far! 
