fluidfix · demo

fluidfix

Repairs the bug. Refuses the guess.

A guard for your test suite: it restores what breaks, refuses what it cannot prove, and never spends a token. Every decision is a ruling from one integer law, judged by your own tests.

→ / space to advance · N for speaker notes · F for full screen · hover and click anything amber

the problem

Someone tidies a formula. The suite goes red.

A regression is usually one line. Finding it is a person's afternoon, or a few thousand tokens of an agent reading files it does not need.

fluidfix runs where the suite runs. It does not read your code as prose. It measures.

def invoice_total(shipments): net = sum(quote(w, z) for w, z in shipments) gross = net * (1 + VAT) return round(gross, 2)
✓test_quote_domestic
✓test_express_eu
✓test_invoice
3 passed
what it does

Four steps. One of them decides.

the brain

Every situation it can ever be in, and what it decides.

Gold: it edits your code. Grey: it refuses, and says why. One expression over one byte: 178 integer operations, 2.01 ns per ruling, no floats, no branches, no weights.

observationstoggle any bit
byte 1 00000001
SHIP
watch it rule

A repair, then a refusal.

fluidfix guard .

the repair
The candidate that greens the suite is written byte for byte and committed as fluidfix: restore file:line.

the refusal
Two green candidates are two programs until proven otherwise. The differential probe finds the input that separates them; the law rules BUILT+AMB → ADD_STATE; a pinning test is written and the file is left alone.

Killed mid-write? The next run restores the original bytes from the journal before judging anything. Nothing is re-queued; there is no queue.

teach it once

One structured example. A whole class, forever.

When it refuses, the refusal is the teach-me signal. Write the incident down once, as structure, not prose.

Kinds 4–7 are yours. The act code is derived from the example on every call, never stored: 4,096 / 4,096 routes verified by selfcheck.

why it can be trusted

A wrong repair cannot land.

  • A candidate that fails your suite is rolled back byte for byte, CRLF included.
  • Two different green programs are refused as ambiguous; the pinning test is written for you.
  • A class it was never taught is refused, tree untouched, exit code 2 for CI.
  • A process killed mid-write is restored from the journal on the next run, before anything is judged.
  • It does not reason and it does not learn. It picks one of eight acts, only one of which writes code, and your suite decides whether that write was right.
the guard's own words
$ fluidfix guard .
REFUSED: fault is outside the taught vocabulary
hint: AMBIGUOUS: 2 candidates pass this suite and they are
DIFFERENT PROGRAMS — rate(10, 0) returns '0.0' vs '0'.
Your tests cannot tell them apart. A pinning test is written
beside the refusal (engine law: BUILT+AMB -> ADD_STATE, never guess)
refusal report: .fluidfix/last_refusal.json
pinning test: .fluidfix/pin_me_test.py
measured, not claimed

Every number has a file behind it.

on real repositories · 2026-09-10

What a maintenance run found, and fixed.

defect, shipped vocabularyreleased 0.15.0master, fixed oracle
cglm D3 · ray.h:140 comparisonrefusedrepaired byte-exact · 56 runs
Box2D D5 · aabb.c:13 comparisonrefused (0.13.0)repaired byte-exact · 9 runs · 20 s
cglm D1, D2, D4refusedcorrect line green, withheld as unproven-unique
wrong bytes written, 32 C runs00

Refusals carry the law's ruling and every rejected candidate with the test that killed it. research/maintenance-2026-09-10/RESULT.md

the finding
GNU make 3.81 compares timestamps at whole seconds. A candidate written in the same second as the previous compile was never rebuilt, so the suite judged the previous candidate's binary: 7 of 8 fast cycles judged the pristine line red. Fixed, pinned with a fake whole-second make: 0 of 8 after.

seven fixes from one run
Two vocabulary signals, the stale build, a suite testing the installed package, a fixture weaker than the vocabulary, a harness path, a report that undercounted. None was a ruling.

where it stops

What it will not do, stated plainly.

  • Weak suites bound it. A test that cannot see the defect cannot judge a repair; on cglm, 3 of 6 real one-token fixes are invisible to its own tests.
  • One file at a time. Multi-file fixes are out of reach today; on Box2D that is most of them. The PAIR law's PARTITION lane exists and is not yet actuated.
  • C path: order and proof. The wrong file ranked first eats the budget, and "unique" means finishing the search, ~5 s per candidate. A C differential probe is the next lane.
  • Untaught means refused. The vocabulary ships with nine classes; yours come from your incidents, one structured example each.
try it · price it

Three commands. Then a number for your repo.

pip install -U fluidfix pytest-cov fluidfix selfcheck # re-proves all six laws on your machine, ~1 s fluidfix guard . --commit # restores what breaks, refuses what is novel
open sourceFreeAGPL-3.0Everything. All six laws, every language path, unlimited repositories, no feature gate.
measurement pilot$5,000six weeksWe run it against your history and your suite and produce the number: how many of your regressions are this shape. Credited in full against a licence.
commercial licence$12,000/ yearClosed-source use, up to 10 repositories, one language path, CI integration, the hotspots report.
studio$40,000/ yearUnlimited repositories, all paths, and we author and maintain the fault classes from your worked examples.

No per-seat pricing: it runs on your machine and costs nothing per repair.

questions

Repairs the bug. Refuses the guess.

Every decision a ruling. Every ruling verifiable. Every repair judged by your own tests.

github.com/devkancheti4-design/fluidfix pypi.org/project/fluidfix devkancheti4@gmail.com
speaker notes
1 / 12