I downloaded the standalone HTML file and took it apart. First surprise: the number in the headline is real — 1,423,668 bytes, about 6,195 lines, roughly 443KB gzipped. Second surprise: the interesting part isn't the 1.4MB, it's the zero. No image files, no audio files, no 3D model files.

The game is Saltline, a first-person shooter demo set in a container port on a rainy night. It keeps getting described as “a 1.4MB AAA game”. That description is wrong in an informative way: it isn't AAA, and 1.4MB isn't a win for compression. It's a single-file browser game whose content isn't loaded — it's generated by code at runtime.

1.42 MBOne HTML file, uncompressed
443 KBActually transferred gzipped
0Separate images / audio / models

Unpack the number first

Composition matters more than the total. About half is three.js inlined into the same file; the other half is the game itself: world building, materials, shaders, player and enemy logic, level data, UI and audio synthesis.

Rough composition of the 1.42MB file.Local unpacking / 2026

This is why the “small file” discussion so often goes sideways. Traditional games are big because textures, models, animation and audio are data. Saltline replaces that data with process. The code is smaller than the content it generates, not because it compressed the content, but because it never stored it.

It isn't unprecedented either. In 2004, .kkrieger fit a complete FPS into 96KB. What's new isn't the idea of procedural generation; it's the cost of writing the generator: one model, one prompt, about eight hours, and — per the creator — about $550 in API bills.

Zero assets is not zero content

The scene has containers, forklifts, jersey barriers, light masts, chain-link fence, pallets, crates, bollards, a gatehouse, stairs, catwalks and ships. None of them load as meshes. They're assembled from a kit table, using real metric dimensions:

container40:    [12.19, 2.59, 2.44, "paint_blue", "metal"]
container40hc:  [12.19, 2.90, 2.44, "paint_green", "metal"]
jersey_barrier: [3.00, 0.81, 0.60, "concrete", "concrete"]
light_mast:     [0.50, 14.0, 0.50, "steel_galv", "metal"]

A scene is essentially a table of coordinates plus a set of assembly functions. Boxes, cylinders, extrusions and lathes combine into props; static geometry is merged; repeated objects are instanced. What counts as “art” here isn't a model file — it's dimensions, material keys and placement.

Surfaces work the same way. There is no texture atlas; the code carries about 29 surface functions: asphalt, concrete, rust, galvanized steel, diamond plate, corrugated sheet, chain-link, water… plus a material preset table that adds color, roughness, metalness, wetness and macro variation to each one. At startup they're computed into height / ORM / albedo, the shader turns height into normals, triplanar projection kills the stretching, and puddles, wetness and color variation are layered on top.

The content wasn't compressed. It was never stored as content in the first place.

Six layers of generation

1. Geometry is a kit

36 props, real metric dimensions, assembled from primitives, batched, instanced. A container isn't a model, it's a function of dimensions.

2. Surfaces are functions

Noise, distance fields and material parameters generate the surfaces. One 256×256 noise texture is enough, because the detail is computed, not painted. Triplanar projection handles the seams.

3. Lighting is composition

No baked lightmaps. A low warm sun, cold grey fog, a sky gradient, a PMREM environment probe, planar reflections on wet ground, plus a full post chain: SSAO, volumetric fog, motion blur, Karis bloom, auto exposure, ACES, FXAA and grain.

4. Animation is simulation

The Hound robot dog isn't a character with a skeletal animation file. It's an object hierarchy plus four-leg IK, spring damping and a procedural death simulation. Motion is a parametric system, not a recorded performance.

5. Audio is synthesis

Rain, wind, sea, gunshots and machinery are synthesized live with WebAudio buffers, filters, wave shapers and a compressor; the reverb impulse is code-generated too. It even ships an OfflineAudioContext self-test: run a scripted scene offline for 10 seconds and check peak, RMS, NaN and clipping.

6. Verification is part of the product

The build accepts URL parameters for a fixed seed, screenshot mode, benchmark, running one subsystem on its own, frozen enemies, a specific camera; it collects console errors into window.__errors; it has quality tiers that step down automatically on a weak GPU. This wasn't an afterthought. An agent with no human sitting next to it has to be able to see its own output.

Why it looks better

Most of the “AI 3D” we see is a scene script: a ground plane, a few boxes, default materials, one directional light, a casually placed camera. Saltline is an engine written for one scene. The gap isn't a single shader; it's a chain of decisions that reinforce each other.

  • One scale. Eye height 1.68m, a 40-foot container 12.19m, a bollard 0.7m. The brain judges “real” from these small references, not from polygon counts.
  • The light has one idea. A warm low sun against cold grey fog, light bouncing off wet ground, strong silhouettes. The scene was designed to be seen in this light from the start.
  • Materials vary. Roughness, wetness, rust, corrugation and decals all change. A single grey material just looks like plastic.
  • Post-processing does the expensive part. Bloom, exposure, fog, motion blur and grain turn correct geometry into an image with air in it.
  • Motion has weight. Acceleration, coyote time, the landing dip, camera bob, ADS field of view, recoil and shake are all parameterized. A still frame doesn't show it; a few seconds of play do.
  • Detail establishes scale. Barriers, pallets, cable spools and container numbers aren't decoration. They tell the eye how big everything else is.
  • Frame rate is also look. Batching, instancing, object pools, half-resolution effects and quality tiers keep the image responsive.

One more smart choice: it avoids the hardest subjects in procedural work. No forests, faces, cloth, hair or daylight. A night scene, rain, fog, backlight and wet industrial surfaces are forgiving. The constraint hides the gaps and amplifies the contrast.

Why the old pipeline didn't do this

Procedural content isn't new. Terrain, vegetation, cities, materials, destruction — the game industry has used it for decades. It didn't become the default because it wasn't a good deal, not because nobody thought of it.

  • Size was never the bottleneck. 50GB Blu-rays and 100GB downloads are normal. Saving 99% of the size doesn't save 99% of the budget; people, iteration and review are the expensive parts.
  • Players remember specificity. Procedural work naturally drifts toward “statistically plausible”. Hero assets, characters and key moments are still made by hand, because they need intent, not variation.
  • The iteration loop is different. Artists are used to direct manipulation: drag a slider, see it now. A generator demands that you translate taste into parameters, after spending months building the tool first.
  • Organizational risk. Outsourcing, certification, legal and single points of failure all favor an asset pipeline that many people can operate.
  • The generator itself was too expensive. A tech-art team might need months. The economics only flip when writing the generator gets cheap enough.

So the real change isn't “AI can write code”. It's that the cost of writing the workstation that makes content collapsed. When the generator is cheaper than the asset, the pipeline flips.

What's worth borrowing

For my own experiments, the useful lessons are much smaller than “build a 3D engine” — and much more practical.

  1. Write generators, not content. Anything that repeats more than three times should become a parametric system: props, HUD, level blocks, material variants, animation layers.
  2. Put verification inside the artifact. A fixed seed, screenshot mode, benchmark, error collection and self-tests are worth more than another prompting trick. An agent that can't see its output can't iterate.
  3. Set the light, then model. One sun angle, one color temperature, one weather. Composition is cheaper than detail and moves “does this look expensive” further.
  4. Use meters, use a human camera. Eye height, field of view, door height, object dimensions should all be boringly real. Toy scale is the most common tell.
  5. Build a post-processing baseline. ACES, bloom, vignette, grain — four items buy you a tier.
  6. Mix pipelines. Procedural for repeated elements and backgrounds, hand-made or Blender-assisted for hero assets. “All procedural” is a valid research constraint, not a strategy every product should adopt.
The one I'd keep

A build isn't a result until it can be inspected. The most important code in Saltline may not be the bloom. It's the screenshot toggle, the fixed seed and the self-tests.

What it doesn't prove

It doesn't prove that 1.4MB is AAA. Saltline is a short piece of work: one map, a few enemies, simple AI, no narrative density, no long progression, no console certification. The $550 is an API bill; it doesn't include the human taste, selection and acceptance.

It also doesn't prove “all procedural” is the right strategy. This scene works because it was narrowed hard: one location, one time of day, one weather, one accent color. Swap in a sunlit forest, characters and cloth, and the same method exposes every weakness.

“Downloads nothing” also has a small asterisk: the page still pulls Google Fonts. Strictly speaking the game assets are self-contained, but the page is not a fully zero-request runtime.

What it does prove is more interesting: a model can write a coherent content generator — geometry kit, surface functions, lighting, animation simulation, audio and tests — and then use that generator to produce something playable. An asset stops being a file and becomes a function.

Method / The file was downloaded from Saltline's standalone play page and unpacked locally; observations about size, shaders, materials, props, audio and debug switches all come from that file. Generation time, token counts and cost are the creator's own claims, not independently measured. Sources: saltline.games, technical teardown, TechPowerUp. This is an engineering read, not a product review.