kalku breaks your code on purpose, one small defect at a time, and sees whether any test notices. A defect that no test catches is a hole in your suite, and kalku shows it to you with a file, a line and a diff.
brew install lnds/kalku/kalku 
$ kalku run lib/green.ex --limit 6 --verbose
lib/green.ex:4 compare Green.classify/1
- >=
+ >
covered by 4 tests
No test tells `>=` apart from `>` in
`Green.classify/1`. Add a case at the boundary
where the two sides are equal.
score 60% · 3 killed · 2 survived · 1 compile errorthe report of a run, as it appears in the README of kalku
What it does
Coverage tells you which lines ran. kalku tells you whether any test would notice when one of them is wrong.
A report starts with the survivors: the defects no test caught, each with its file, its line, its diff and a hint. The score comes after, as context, because the survivor is the thing you can act on.
$ kalku run lib/green.ex --limit 6
lib/green.ex:4 compare Green.classify/1
- >=
+ >
covered by 4 testsThe score is killed / (killed + survived) and nothing else moves it. A timeout, a crash, a wekufe that did not compile or a line no test reaches are reported apart: they never count as a kill.
$ kalku info outcomes
killed counts towards the score
survived counts towards the score
timeout reported apart from the score
no_coverage reported apart from the score
compile_error reported apart from the score
crashed reported apart from the score
score 60% · 3 killed · 2 survived · 1 compile errorWekufe are cast in the reni, an isolated workspace under the temporary directory of your machine. A project with no configuration is measured as it is and left as it is: nothing is written into it.
$ kalku run lib/thing.ex
kalku: no .kalku.toml in this directory:
measuring it as elixir and leaving it as it is.
What the run keeps is in $TMPDIR/kalku/thing;
`kalku init` sets the project up to keep it.Each wekufe is loaded into a warm kalku and runs only against the tests that cover it, stopping at the first one that fails. With kalku serve, the kalku a project was measured with outlive the run, and the next one does not set the project up again.
$ kalku serve # a 0600 Unix socket
$ kalku cast <wekufe> # re-cast just that one,
# against a warm kalkukalku run --since origin/main measures the lines the change touched and blocks only on the holes that change introduced. Old debt does not punish whoever touches the file, and the exit codes separate "your tests have holes" from "kalku could not measure".
$ kalku run --since origin/main
# exit 0 measured; nothing to report
# exit 1 your tests have holes
# exit 2 kalku could not measureAgents write tests fast; kalku tells them whether those tests test anything. Each survivor arrives as one JSON object with everything needed to act, and kalku mcp serves four tools over stdio. None of them suppresses, excludes or ignores anything.
Hints come from a fixed template per spell, not from a model. An agent can only propose an equivalent mutant; a person has to accept it.
$ kalku run lib/my_app/parser.ex --format agent
{"wekufe":"c1f3…",
"file":"lib/my_app/parser.ex","line":42,
"enclosing":"MyApp.Parser.next_token/2",
"spell":"compare",
"original":">=","replacement":">",
"covering_count":1,"hint":"No test tells…"}Video
Three minutes on what mutation testing is, how you use kalku and why it matters. Kalku tells it in the first person: he is a sorcerer, and breaking code is his trade.
Commands
One binary. And kalku info documents the spells, the outcomes and the formats from the program itself.
kalku runkalku castkalku showkalku initkalku propose-equivalentkalku acceptkalku rejectkalku infokalku servekalku mcpIt installs with one command and needs no configuration. Start with kalku run on one file of your project.
brew install lnds/kalku/kalku