Tower of Babel: The Single-File 3D Scene That Replaces Assets with Math

A Three.js diorama where stone, storm, sound, and divine intervention are all generated at runtime inside one `index.html`.

8 min read • View on GitHub • More from emollick

A wide mythic desert scene with a towering ziggurat rising into a stormy sky. Tiny workers climb a spiraling ramp around the structure while a luminous beam cuts down from above, showing that the scene is alive rather than static. The image explains the article’s core idea: this world feels rich because code is generating motion, weather, and texture in real time.
A monument assembled from math, not an asset pipeline.
Key Takeaways

The first surprise is the packaging. emollick/tower-of-babel is not a traditional 3D project with folders of meshes, textures, and audio files. It is a single-file performance: one HTML document, one browser, and a world that appears to have a real production pipeline even though the pipeline is mostly code.

That constraint changes the reading of everything else. The tower is not impressive because someone modeled every brick by hand. It is impressive because the scene keeps inventing what it needs: stone grain, atmosphere, sound, motion, and the mythic rupture at the center of the story.

One file, many systems

The repository follows an extreme monolith pattern. HTML carries the shell, CSS handles the minimal interface, JavaScript drives scene setup and animation, and GLSL shaders fill in the sky and effects. There is no build step to hide behind, which means the article of faith here is also the architecture: if the experience is worth making, it should be shippable as-is.

Everything lives inside one browser-native bundle. The scene is organized by systems, not by files.

That matters for more than cleanliness. A single-file scene is portable, inspectable, and hard to misconfigure. It also forces a discipline that many web projects lose: every effect must justify its existence because every effect has to pay rent inside the same document.

Stone, sky, and sound are all generated

A close-up workshop scene where a stone block is being assembled from layered marks, waveform curves, and shader fragments. The image shows that the tower’s realism comes from generated texture and effects rather than imported art files. It explains the project’s procedural pipeline at the most concrete level.
The illusion is built from runtime texture, shader, and audio generation.

The stone is especially revealing. Instead of importing a texture map, the project draws its own masonry at runtime with canvas code, layering noise, seams, and irregularity until the surface reads as weathered rock. That is a small technical choice with a big editorial effect. The tower feels materially coherent because the same logic that builds the image also builds the image’s imperfections.

The rest of the environment follows the same principle. The sky is shader-driven, the beam is shader-driven, and the thunder is synthesized instead of sampled. The result is not just visual compression. It is conceptual compression. Every part of the scene speaks the same language.

The tower is not static. It behaves like a scene

The geometry is doing real work here. Tier construction introduces unevenness and decay, so the tower does not read as a perfect museum replica. The spiral ramp gives the workers a believable path, and instancing keeps the crowd readable without turning the scene into a draw-call tax.

That is the key distinction. This is not a tower model with some motion layered on top. It is a construction site simulation dressed as myth. The workers are part of the composition, not decoration around it.

DimensionConventional 3D web projecttower-of-babel approachEditorial takeaway
AssetsImported textures, models, and audio filesTextures, sound, and effects generated at runtimeThe world is authored by systems, not stocked by assets
LoadingHeavier downloads and more moving partsOne browser-ready HTML fileDistribution is part of the aesthetic
Visual variationVariation comes from source artVariation comes from procedural noise and geometry rulesImperfection is computed, not painted
AudioRecorded samplesSynthesized thunder and ambienceThe soundscape belongs to the same machine as the visuals
Code structureMultiple folders and build stepsOne monolithic documentThe repo reads like a finished artifact
MaintenanceAsset management is a major costFewer external dependencies to coordinateLess infrastructure, more intention
PortabilityOften tied to a pipelineRuns directly in a modern browserThe piece is easy to open, inspect, and share

The comparison is not about purity for its own sake. It is about control. If the world is built from math, then the artist can tune the world from the inside. Density, decay, rhythm, weather, and timing all become parameters instead of hand-edited files.

The most cinematic trick: Confound Their Tongues

The best moment in the project is not a camera move. It is a state change. The scene moves from construction to rupture when the "Confound Their Tongues" event fires, and the whole tower responds as if a myth has entered the physics.

A beam appears. Stone starts to shear. Glyphs erupt. The mood changes from labor to intervention. That sequence matters because it makes the project legible as storytelling, not just rendering. The code is not only drawing a place. It is staging an event.

Stable tower state
  -> trigger event
  -> beam activation
  -> structural failure
  -> glyph eruption
  -> aftermath

This is where the repo earns the word cinematic. A lot of demos can render a beautiful scene. Fewer can make that scene behave like a dramatic machine. Here, the event system gives the world memory. After the rupture, the tower is not quite the same object anymore.

Why this belongs in the same conversation as toolchains

The obvious reading is that this is a clever tech demo. The better reading is that it is a production argument. If code can generate enough texture, enough atmosphere, and enough motion, then a single file can carry a surprising amount of expressive weight without a conventional asset pipeline.

That does not make asset pipelines obsolete. It does make them feel optional in places where coherence matters more than raw fidelity. For a piece like this, the absence of external assets is not a limitation. It is the signature.

That is what makes the project memorable. It is not trying to imitate a larger studio workflow. It is proposing a different one: lighter, stranger, and more tightly bound to the logic of the scene itself.