Tesseract
Interactive audiovisual piece
Self-initiated experiment · 2026 · Built using Claude Opus 5.5 · three.js (WebGPU, TSL), Web Audio
A tiny 4D universe, experienced on a flat screen.
- The question
- What makes an interactive experience feel immersive on a 2D screen?
- How it was made
- Built using Claude Opus 5.5 in two days, from research done first, and judged against it at every pass.
- What it shows
- The research decides how well the model builds, and judgment closes the loop.
See it live
tesseract.postminimal.agency
Tesseract is a small universe on the surface of a four-dimensional sphere, unfolded, turned and heard with your hands. A fourth dimension can't be shown, only felt through interaction, which makes it a pure test of the question. The subject was a pick, and it turned out to be a good one.
| Phase | You | It answers |
|---|---|---|
| 1Threshold | Press and hold | A line, a square, a cube, a tesseract, each with a voice and a line of narration |
| 2Bloom | Watch | The tesseract presses onto a 4D sphere, and its light falls into linked circles |
| 3World | Arrive | One hint at a time, each gone once it's done |
| Drag | It turns through the fourth dimension with the hand, then coasts | |
| Scroll | It turns toward you, so you seem to move forward, and the light warms and cools | |
| Tap | A bell, its echo from the far side, then the homecoming | |
| Hold | Time slows into long exposures, and the sound sinks like a record | |
| 4Outside time | Press T | The visit as one shape, a knot for each signal, and a playhead to play it back |
| 5Return | Come back | Your last signals are still arriving, and hints already learned are skipped |
The gesture is the tutorial.
Browsers won't play sound without a gesture, so instead of a start button the piece asks you to press and hold. A point, moved, draws a line, then a square, a cube, a tesseract. Each dimension latches, so letting go early costs nothing. Only then does the next lesson appear. Drag, and it turns through the fourth dimension, which shows as colour, warm for anaHinton's names for the two directions along the fourth axis, ana and kata. and cool for kata.
Every lesson after that works the same way. Each hint is keyed to what you've done, not to a clock. It waits its turn, is skipped if you already did the thing, and disappears when you do. Two explanations interrupt on purpose, at the moment they become true, when your first signal reaches the far side and when it comes home.
You travel the fourth dimension by hand.
The universe is the surface of a 4D sphere, so moving through it means turning it. Every movement is a rotationIn 4D, things turn in a plane, not around an axis. W is the fourth axis.. Scroll, and it feels like going forward, but you stay put and the universe turns toward you, like a globe turning under your feet. Dragging turns it through the fourth dimension. Hold Shift for an ordinary 3D turn, and on a phone, tilt to lean it through.
How four dimensions become pixels
The universe is computed in four dimensions. It's turned there, projected from one of its poles down to three dimensions, then filmed by an ordinary camera. The projection keeps circles as circles, so the linked rings of the Hopf fibrationThe 3-sphere filled with circles, each one linked with every other. stay linked on screen.
- 01On the 3-sphere4D
Every particle is a point on the surface of a 4D ball, on a Hopf fiber or a tesseract edge.
- Hopf fibers
- Tesseract edges
- 02Turned by the handSO(4)
Plane rotations, composed into one matrix. Drag turns XW and YW, scroll turns ZW.
- XW
- YW
- ZW
- 03Projected to 3DStereographic
From one of the poles. Circles stay circles, so linked rings stay linked.
- W kept as colour
- 04Seen through a lens3D to 2D
An ordinary perspective camera with depth of field, so points out of focus become soft discs.
Every particle starts as a unit 4-vector. On a Hopf fiber, it's
picks the torus, the fiber on it and the point along it. Advancing with time moves light along every fiber at once.
The hand turns it with plane rotations, each one turning toward by and leaving the other two directions alone. They compose into one matrix in SO(4)All the rotations of four-dimensional space..
The projection to three dimensions is taken from a point on the W axis.
With it's stereographic projectionProjecting a sphere onto flat space from one of its poles. from the pole. With it's a perspective view from a 4D eye, which is how the tesseract is drawn, and the bloom slides from one to the other. Near the pole the denominator nears zero, so it's clamped, and those points fade out with distance rather than running off to infinity.
The projection packs the far side of the sphere into the centre and stretches the near side. Each particle's brightness is scaled by that local stretch, , clamped, so the dense centre stays readable. The coordinate the projection throws away, , comes back as colour, warm toward ana and cool toward kata.
A tap goes the other way. The ray through the pixel meets the unit sphere, and inverse stereographic projection lifts that point onto the 3-sphere.
The inverse rotation then puts it in the universe's own frame, so the signal turns with the universe.
/**
* Stereographic projection from the pole (0, 0, 0, 1)
* of the unit 3-sphere.
*/
function stereographic(
q: Vec4Like,
out: { x: number; y: number; z: number }
): number {
const k = 1 / Math.max(1 - q[3]!, 0.03)
out.x = q[0]! * k
out.y = q[1]! * k
out.z = q[2]! * k
return k
}
/**
* Inverse stereographic projection: any point of ℝ³
* back onto the unit 3-sphere.
*/
function inverseStereographic(
x: number, y: number, z: number, out: Vec4
): Vec4 {
const r2 = x * x + y * y + z * z
const d = 1 / (r2 + 1)
out[0] = 2 * x * d
out[1] = 2 * y * d
out[2] = 2 * z * d
out[3] = (r2 - 1) * d
return out
}Direct, then physical.
While your hand is on it, the universe follows the hand exactly, with no easing in between. Let go, and it coasts on the momentum you gave it, then slows down. Anything that answers you directly is critically damped, as fast as possible without overshooting, a rule borrowed from control engineering.
Why it feels the same at any frame rate
Frame rates run anywhere from 30 to 120 a second, depending on the screen and the load. A spring integratedAdvanced in small time steps from its velocity, rather than solved outright. the usual way, one step per frame, feels different at each, and a stiff one can blow up when frames drop.
This spring isn't integrated. Its equation has an exact solution, and each frame evaluates it from the current offset and velocity .
sets how fast it settles. No error builds up between frames, so it behaves the same at any frame rate. The camera, the cursor and the clock all use it. The springs allowed to wobble, like the latch settling, are stepped in fixed slices of s instead, small enough to stay stable when frames drop.
/**
* Critically damped: the fastest settle with no overshoot.
* Exact for any dt.
*/
step(dt: number): number {
const x = this.value - this.target
const e = Math.exp(-this.omega * dt)
const t = (this.velocity + this.omega * x) * dt
this.velocity = (this.velocity - this.omega * t) * e
this.value = this.target + (x + t) * e
return this.value
}Every tap is heard, and comes back.
A tap rings a glass bell whose pitch is its colour. The wave spreads through the 3-sphere, meets itself on the opposite point and comes home, a real property of the sphere, and each meeting rings again. Sound and light read one function, so every echo lands on the frame its light converges. Every sound is synthesized live.
Why the echo is always in sync
On the web, sound is usually scheduled ahead on the audio hardware's clock. That doesn't work here, because holding can slow the universe's time at any moment, so an echo's arrival time isn't known in advance.
Instead, light and sound read the same clock, the universe's, once per frame. The GPU gets each signal's wavefront radius from it, and the score counts how many times the front has closed to a point.
An odd rings the echo from the far side, an even one the homecoming. Because there is only one clock, light and sound can't drift apart, and slowing time slows both.
const age = now - s.born
const crossings = Math.floor(age / this.halfPeriod)
while (s.crossings < crossings) {
s.crossings++
const level = s.amplitude * Math.exp(
-(s.crossings * this.halfPeriod) / this.lifetime
)
listener({
kind: s.crossings % 2 === 1 ? 'focus' : 'return',
signal: s, level, crossing: s.crossings
})
}Your visit, laid out as a timeline.
Hold, and time slows. Light smears into long exposures and the sound sinks like a slowing record. Press T and the light becomes your visit, your hand's path with time as its length and a knot for every signal. From the present it's a scribble, from the side a shape, and a playhead plays it back. Come back later and your last signals are still arriving.
Judgment closes the loop.
The piece was built using Claude Opus 5.5, in two days. The research came first, so the model had something solid to build from. Judgment did the correcting, and what it found went back into the thesis before the next prompt.
- ResearchThe thesis, what it should be and why
- BuildClaude Opus 5.5 writes the code
- JudgeCompare the result with the thesis
- RefineImprove the thesis, not just the output
The public sources it stands on (8)
- Page Laubheimer, Onboarding Tutorials vs. Contextual Help, NN/g, 2023hints that arrive when they're needed
- Apple, Designing Fluid Interfaces, WWDC 2018following the hand, then momentum
- Karl J. Åström, Richard M. Murray, Feedback Systems, 2021critical damping (free book)
- Jos Leys, Étienne Ghys, Aurélien Alvarez, Dimensions, 2008stereographic projection and the Hopf fibration (free film)
- C. H. Hinton, A New Era of Thought, 1888the tesseract, ana and kata
- John Chowning, The Synthesis of Complex Audio Spectra by Means of Frequency Modulation, 1973FM synthesis, the glass bells
- Charles Howard Hinton, What is the Fourth Dimension?, 1880motion as a cross-section, the timeline
- W3C, WCAG 2.2, Animation from Interactionsmotion that can be turned off
An experiment by Post Minimal, Montréal, 2026. Built using Claude Opus 5.5, with research and direction by Bahae Ben. three.js (WebGPU, TSL) and the Web Audio API. Every gesture has a key, reduced motion is respected, and sound is never required.