The libraries.

Everything Generative Charts knows, grown up into a real 3D engine. Build whole scenes the way you'd build a chart: hills from a spreadsheet, a city block from footprints, a molecule from a list of atoms — each a few lines of code — lit with real light and shadow, finished with a cinematic glow, and alive: forms breathe, bodies orbit, tissue pulses. Still zero dependencies, and chart code runs here unchanged. Free for personal, charity and small-business use.

• Real light — shadows fall where they should, highlights glint, and the whole frame gets a cinematic finish (glow, soft shading, a filmic grade) — not a CSS filter.
• Shapes in a line — hills from your data, tubes along a path, spheres, turned profiles, extruded footprints — the geometry library builds them, smooth shading included.
• Ribbons — strokes with real width that live inside the scene: paths, trails, beams, waves.
• Motion for free — blend one shape into another, move whole groups — the heavy lifting happens on the GPU, so nothing stutters.
• Crowds of thousands — build one tree, one bird, one blade of grass and the GPU draws ten thousand: each swaying to its own wind, or flying in a murmuration that splits and merges.
• Real water — the scene reflects in it, waves and all: birds overhead, trees on the bank, lights at dusk.
• Figures that walk — skeletons grown from code: people, animals, your own rigs — knees, wings and tails moving on real joints.
• Fly it — free-flight controls when a scene deserves exploring: drag to look, scroll to fly.
• A living skin — blood, pulse and light-through-tissue, for when your subject is alive.
• Zero dependencies — one package; the browser is the whole runtime.
• Charts port forward — the engine speaks the charts API, so your chart recipes run here as-is.
• Objectives — give a scene a goal and it drives itself there; a live meter tells you what's moving and when it has settled.
• Collision control — flag a mesh collider: true and the world knows where it is: bounce off it, probe it, cast a beam that stops at the first thing it touches. Colliders ride their group transforms.
• Poster frames — every window paints its own first frame as a still at page load, and the animation starts only when watched: the placeholder-image pattern, built in.

• A real depth buffer — occlusion exact, always on, for solids and light alike.
• An HDR post chain — the frame renders to a floating-point target: bloom, SSAO, a filmic tone map, FXAA. Opt-in flags, not defaults you fight.
• Hardware-PCF shadow maps — real depth textures with comparison sampling; soft penumbrae for free.
• GGX specular + procedural micro-relief — material response and surface grain computed in the shader — no textures, no normal maps, no asset pipeline.
• Morphs & transforms in the vertex stage — the CPU never re-builds a vertex; motion is free.
• Instanced animation in the vertex stage — per-instance wind phase and whole flight paths evaluated from time alone; crowds cost the CPU nothing.
• A reflected second scene pass — real planar reflections clipped at the water plane, sampled through a wave-displaced fresnel surface.
• Rigid skinning — one bone per vertex, matrices composed on the CPU (16 per figure), applied in the shader — scene, shadows and reflections alike.
• Depth of field & motion blur — CoC gather from the real depth buffer; camera blur by depth reprojection into the previous frame.
• Screen-space ribbon expansion — true pixel-width strokes, feathered in the shader.
• WebGL2 · GLSL ES 3.00 · zero dependencies — no scene graph, no quality presets, one small package.

Each scene shows one thing the engine does, with the camera close enough to see it working: a moon gate weaving its own lattice, a ribbon dragon and its pearl, four hundred sky lanterns over real water, ink mountains in fog, a skeleton walking its lantern across a bridge, a ten-thousand-bird flock, and a universe you fly. Drag to orbit; go full screen. Everything is grown from code — no model files, no textures, no asset pipeline.

Qing window-makers had an algorithm three centuries before code: split the biggest pane, again and again, until no two cells match. Here it runs as real recursion — sixty splits of a moon gate, every crack a depth-tested ribbon with true pixel width, the whole lattice casting a real shadow into the courtyard. Drag to orbit; the window sways as if hung.

The dragon chases the pearl, as it has on temple walls for a thousand years. The whole serpent is drawn fresh every frame — fourteen tapering ribbon strokes along a moving spine, golden at the head, ember at the tail — while the pearl pulses at the centre of the circle. Immediate-mode ribbons: geometry that exists only for the frame that needs it.

Four hundred paper lanterns, one lathe profile, one instanced draw — each rising on its own sway phase, each a warm point in the bloom, the whole festival reflected in real water below. The GPU carries every bob and flicker; the CPU sleeps.

Shan shui with a heightfield: ridge behind ridge dissolving into fog the engine computes per-fragment, a still lake at the valley floor, a lathe-turned pagoda keeping watch, and mist that drifts because a grow() hook says so. Atmosphere is not a texture — it is distance, honestly rendered.

The skeletal walker, given somewhere to go: across a stone bridge over still water, carrying their own lantern — a real point light that moves with the figure, swings with the pace, and comes back in the reflection. Eleven bones bending in the vertex stage, shadows and water included.

Nothing but the flock: ten thousand birds in three lobes that split and merge, every orbit and every wingbeat computed in the vertex stage from time alone.

New in 1.9.0 — collision control: the three stones register their bounding spheres with one flag (collider: true). Forty motes fall under gravity and collide() hands each one its contact normal to bounce off; the sweeping beam is rayHit() — it ends exactly where the world gets in its way.

The dreamer's cosmology, drawn live. At the centre, the dark that is held and never crossed — a black hole with its accretion fire. Around it, nine realms: each a bubble-universe born from a prompt (the prompt still floats above it), each with its own stars, its own hue, its own heart, all falling around the same gravity — the inner realms fast, the outer ones slow, as gravity insists. Drag to look, scroll to fly, W/A/S/D to move. Visit a realm; read its prompt on approach.

You've just used the entire engine. Every door it has, one line each: the API reference — and the package is one install away: generative-engine on npm.