I Ported My Favorite Fractal Tool to Linux With a Clean-Room AI Rewrite

Look, I have a favorite fractal tool, and it's Visions of Chaos: a free, closed-source Windows program from Softology (the sample files credit Jason Rampe), full of cellular automata, fractals, strange attractors and thousands of shaders. I run Linux, and under Wine a handful of its modes showed up greyed out with the program's own caption: "(Unsupported Intel GPU)". Multiple Neighborhoods CA 2, Root-Finding Fractals 2 and 3D Gravity, all sitting there, labelled, unclickable.

A reasonable person would have found a Windows machine. Yes, I have a problem.

So I had AI agents do a clean-room rewrite for Linux. It's a rewrite, not a copy. One set of agents read the program and its files and wrote a description of what it does. A separate set of agents wrote all-new Rust from that description alone, and never saw the original. None of Softology's code, shaders or data files are in it.

Here's what came back: a Rust program called voc-rs, about 100,000 lines, with 110 modes and 262 built-in presets. It runs on my laptop's Intel UHD 620, 3D Gravity included. I didn't write a line of it. I set the rules, built the wall between the two sides, reviewed screenshots, and recorded the clips you're about to see.

What Clean Room Means Here

"Ported" is the casual word in the title. What actually happened is a clean-room reimplementation, an old technique for rebuilding software without carrying over how the original was written. There are two sides, and they never share a screen:

• The spec side studies the original, the shipped program and its data files, and writes down what it does: prose, parameter tables, file-format grammars. No code. This is the reverse engineering half.
• The implementation side writes new code from that description, plus the public references it cites for textbook algorithms. It never opens the original.

Between them sits the wall: a checksum manifest listing exactly which spec files crossed over, and nothing else did. It was checked at the end of each milestone, and both times all 38 entries matched. Each milestone also carries a written attestation: implemented from the spec only, original not opened.

graph LR
    subgraph spec["Spec side: reads the original"]
        A["Visions of Chaos
program and data files"] --> B["Open-model pipeline
writes prose, tables, grammars
no code"]
    end
    subgraph wall["The wall"]
        M["Checksum manifest
38 spec files
38 of 38 matched"]
    end
    subgraph impl["Implementation side: never opens the original"]
        C["16 Claude and Codex agents
one worktree per family"] --> R["Reviewer per branch
plus token audit"] --> V["voc-rs
all-new Rust, 110 modes"]
    end
    B --> M --> C
    P["Public references
textbook algorithms"] --> C
    U["Your own VoC install
optional, at run time"] -.-> V

Here's the honest limit. I'm not a lawyer. Clean room gives you a process and a record you can check; whether that holds up legally is a question for an actual lawyer.

Here's What I Actually Did

Step 1 of 3: Reverse Engineer the Behaviour (Mostly by Reading Text Files)

The spec side was a separate pipeline built on an open-source model, run outside the coding sessions. It cost a couple of dollars. That's cheap, and it's cheap because the job was less dramatic than "reverse engineering" sounds.

The installer lays down about 42,000 files. Only 13 of them are the program. The rest are machine-learning projects (21,305 files, out of scope), 9,580 shader files (9,560 GLSL plus 20 OpenCL), 7,730 per-mode settings files, 3,479 Fractint palettes and 266 scripts. Most of what the program does is written down in plain text right there.

The shader interface came out of grep. Across all 9,560 GLSL files, comments stripped, the uniforms are short and boring:

That's the GLSL Sandbox convention, and it's nearly the whole interface for the pure-shader modes. The mode list came from the file dialogs: Delphi stores open and save filters as plain strings, so the executable hands you 207 file extensions that map onto the modes' settings formats, and the 7,730 shipped settings files describe every mode's parameters.

The spec side did get a decompiler running (REA, a reverse-engineering front end, plus Ghidra, which took some coaxing on NixOS). Its append-only log still has the line I care about most: Ghidra decompile text, none read. Most modes are textbook algorithms with public references, so the binary was rarely needed.

The licensing settled the biggest rule. 6,999 shader files carry a Shadertoy URL, and Shadertoy's default licence when an author states nothing else is CC BY-NC-SA 3.0. Another 784 say CC BY-NC-SA outright. Those are counts from a script, and a lawyer would want more. They were still enough to set the rule: no shader bodies in the repository. voc-rs reads shaders, palettes and settings from your own install at run time, where the installer put them. Every test fixture was written fresh, and the only third-party data is a few MergeLife test vectors from Jeff Heaton's public reference repository, under its MIT licence.

Step 2 of 3: Hand Over the Description, and Only the Description

Everything the spec side wrote went into an "outbox" directory. The manifest (the wall above) froze that outbox, and the coding agents got the outbox and nothing else from the original.

Step 3 of 3: Let Sixteen Agents Loose

The coding happened in an encrypted vault on my server. A coordinator agent wrote the shared foundations. Then sixteen implementation agents, Claude and Codex, each took one family of modes (2D cellular automata, fractals, attractors, fluids and so on) and worked in its own isolated git worktree.

Every branch got its own reviewer agent. The reviewer re-checked the work against the spec, ran a clean-room audit looking for anything that shouldn't have crossed, and committed fixes. Each family shows up in the history as its own merge, and each milestone carries the same attestation: implemented from the spec only, original not opened.

I Got Excited When I Saw How Much Came Back

On paper, the first milestone was a shader player and Life-like cellular automata. What came back covers most of the program:

• Cellular automata: Life and Generations, 18 cyclic CA presets, hodgepodge, MergeLife, hexagonal and triangular grids, SmoothLife, rock-paper-scissors in two to four dimensions, all fifteen 1D formats
• Fractals: Mandelbrot and Julia, Ducks, Newton and other root-finding, Buddhabrot, Lyapunov, Thorn, magnetic pendulum, Gravity Set, quaternion Julia
• Attractors and friends: 2D and 3D strange attractors, IFS and L-systems, fractal flames, spirographs, harmonographs, knots
• Simulations: reaction-diffusion, boids, particle life, physarum, Wa-Tor, fluids (ripple tank, Stam, lattice Boltzmann, SPH), diffusion-limited aggregation, snowflakes, terrain
• Shaders: a GLSL host for the Visions of Chaos shader conventions, plus the Shadertoy dialect

There's a real desktop app too, drawn with egui on OpenGL: a searchable preset browser, editable parameters, settings files you can open and save, and a showcase tour.

And it ran on my laptop on the first try. The code went from the vault to the vault's own git forge, which stores everything in a bucket that can't be changed for 30 days. My NixOS config pulls it from there with a read-only token, pinned to an exact revision, and installs it like any other package. I typed voc and the window opened.

Some Things It Draws

I kept recording. Clips from my laptop and a few still renders straight from the built-in presets, all from voc-rs:

What It Isn't Yet

It's private. There's no public repository and no release date. Shader screenshots don't work yet, a few showcase presets still look weak (the Gosper glider gun among them), and the parameter panels could use grouping. The machine-learning modes are out of scope, and so are OpenCL kernels.

Softology hasn't reviewed or endorsed any of this. Their site says the program is "100% free to use in any situation". That's about using the program; it doesn't speak to redistributing its files, which is why voc-rs ships none of them. I'm a Softology Patreon supporter now, because the person who built my favorite fractal tool should get paid for it.

And Jason, if you're reading this and you want the source, it's yours. Email me at me@jquaintance.com.

3D Gravity isn't greyed out any more.

Sixteen agents rebuilt 110 modes of a program none of them was allowed to look at, and a checksum file shows exactly what they were given. The agents were the cheap part. The expensive part was deciding, before any code existed, what each side was allowed to see and how I'd prove it afterwards. That question is cheap to answer before the agents start and expensive to answer after something leaks. A production readiness report from JustinTime Systems asks it in week one. Here's how I build the map.

Header: Newton z^3-1, rendered by voc-rs. The clips and the desktop screenshot are screen captures of voc-rs on my laptop; the other stills were rendered with voc render.

Content on this blog was created using human and AI-assisted workflows described in my standards and workflow posts. Original ideas and editorial decisions by Justin Quaintance.