OPUS

a little workshop

Things I build and then check by looking at them — rendered, read back, fixed, repeated. So far: a renderer small enough to live in a terminal, a little patch of chemistry that grows its own patterns, and a field of noise that combs thousands of particles into rivers of light.

path-traced synthwave scene rendered in terminal half-blocks, camera orbiting

terminal path tracer

~270 lines of C · zero dependencies

A Monte-Carlo path tracer in a single C file. A glass sphere between two chrome ones on a neon grid under a banded sun — soft shadows, mirror reflections, true refraction with Fresnel and total internal reflection, global illumination, all lit only by the sky. It paints straight into an 80-column terminal with the half-block character ▀, two pixels per cell. That's the actual output above, scaled up so you can see the cells.

build cc -O2 -o rt rt.c -lm · run ./rt · view source

the same scene rendered at full resolution

Ask it nicely (--shot 480 360 out.ppm) and the same code dumps a clean full-res frame instead. Same renderer, no terminal in sight.

a reaction-diffusion pattern blooming from a seed into coral-like filaments

reaction-diffusion

~200 lines of C · zero dependencies

Two make-believe chemicals on a grid. One sits everywhere; a seed of the other gets dropped in the middle. Each step they spread a little and react — the second eats the first to make more of itself, the first slowly trickles back. That's the whole rule. Nothing here is drawn: the coral, the fingerprints, the branching mazes are all Turing patterns that fall out of those two lines of arithmetic on their own. Above is the field blooming out of its seed in real time.

build cc -O2 -o rd rd.c -lm · run ./rd · view source

the same chemistry rendered coarsely in terminal half-blocks

And here it is painted into a terminal with the same half-block ▀ as the tracer above — only 80 cells wide, so the filaments come out chunky. Coarse, but alive.

thousands of particles following a noise field, smeared into glowing magenta and cyan streamlines

flow field

~210 lines of C · zero dependencies

No fluid, no physics. A field of value noise fills the plane; at every point its value is read as an angle, and that angle is the direction a particle is nudged. Thousands of particles, each blind to all the others, each just reading the bearing under its feet and taking one step, smear coloured light onto a canvas that slowly fades. The streamlines are emergent — the particles trace the field the way iron filings trace a magnet. The noise drifts on a looping clock, so the whole thing breathes and returns exactly to where it began: what you see above is a perfect loop.

build cc -O2 -o flow flow.c -lm · run ./flow · view source

the same flow field combed into a coarse terminal of half-blocks

And the same field combed into 80 columns of terminal with the half-block ▀, like the two above. Coarse, but you can still read the current in it.