The expression language of MilkDrop presets, as cases you can run.

The corpus

Every case, read live from the same cases/*.json files the package ships. Search by id, name, program text or note.

Runner contract

A conforming runner executes one case like this.

1. Start from zero. Every variable is 0 until assigned. Reading an unknown name is legal and yields 0, never an error. Apply the case's env on top.
2. Allocate both guest buffers at 1,048,576 f32 slots each, zero-filled, then apply megabuf and gmegabuf from the case. megabuf is per-preset scratch; gmegabuf is shared across presets.
3. Execute program as one block, in order. It is a single program, not independent lines: state carries from each statement to the next.
4. Use the fixed RNG. Every rand() / randint() draw returns exactly 0.5. Randomness is not what these cases test, and a fixed draw is what makes them portable.
5. Compare. For each entry in expected, the variable must be within 1e-12 + |expected| * 1e-9. Same for expectedMegabuf / expectedGmegabuf against buffer slots. Absent variables read as 0, so {"x": 0} is a real assertion.

Buffer size is part of the contract, not an implementation detail. Bounds behaviour is only defined against a declared size, and a runner that allocates a short buffer will read past its end and produce garbage where the specification requires 0.

Run it against your engine

The TypeScript harness does the seeding and comparing; you supply the one thing that is yours. A runner in any other language reads the JSON directly.

import { conforms, formatReport, runConformance } from 'eel-conformance';
import { execute } from './my-eel-engine';

const report = await runConformance(({ program, env, megabuf, gmegabuf, random }) => {
  execute(program.join('\n'), { env, megabuf, gmegabuf, rand: random });
});

console.log(formatReport(report));
process.exit(conforms(report) ? 0 : 1);

A thrown error is recorded on that case and the run continues, because the useful output is the whole table. conforms is true when every pinned case passed; provisional failures are reported separately and never count. Variable names in env are lower-cased, matching the language's case-insensitivity.

The eel-conformance CLI lists sections and cases, shows one case as JSON, and validates the shape of a corpus against the schema's rules without a schema library.

Rules that catch new implementations

• Division by zero is 0, but the guard is exact zero: 1 / 0.0000001 divides normally. A tolerance guard silently zeroes results real presets depend on.
• % truncates both operands to integers first; float remainder is mod() / fmod().
• Truthiness is |v| > 1e-5, not v != 0, for if, &&, ||, ! and bnot.
• == is exact; equal() uses the close factor. Only one of them is tolerant.
• bor() and band() are logical, not bitwise, despite the names. bor(2,4) is 1, not 6.
• frac() subtracts the floor, so frac(-0.25) is 0.75.
• step(edge, v) takes the edge first.
• pi and e are ordinary prepopulated variables, and assignments to them stick.
• Names are case-insensitive. contVol and contvol are one variable.
• Non-finite values are clamped to 0 at the statement boundary, so one escaped Infinity cannot poison a variable for the preset's lifetime.
• smoothstep() with equal edges is defined here as v < edge ? 0 : 1; GLSL and WGSL leave it undefined, so a GPU backend must special-case it.

Open questions

The provisional cases are places where the originating implementation had to pick a behaviour and the reference is unverified. Resolving them against ns-eel would be the most useful contribution.

1. while condition truthiness. A while() condition is tested against exact zero, while every other boolean context uses the close-factor threshold. If the threshold turns out to be correct, a class of presets is currently spinning to the iteration cap every frame.
2. Unary minus versus ^. -2 ^ 2 parses as (-2)^2 = 4. Most languages that spell exponentiation as an operator bind unary minus more loosely.
3. ^ associativity. 2 ^ 3 ^ 2 parses left-associatively as 64, not the more usual 512.