Understand the failure.
Verify the repair.
Small, reproducible software failures. The broken implementation, the fix that didn’t work, and the one that passed—preserved together.
Explore the cases ↓How results are verified ↗WHAT THE ARCHIVE CONTAINS
100840 executable cases. 20168 are open.
Every case records the implementation that fails, the fix that did not work, and the repair that passed its checks—with recorded outputs and source hashes. This release adds 100840 cases across 20168 failure mechanisms and 254 domains.
The open tier gives you the failure and the unsuccessful fix for one case in every mechanism. The remaining 80672 cases, 5 variants per mechanism, are member-only: the verified repair, its recorded checks, and the full fixture suite are held in the member archive. Read the methodology ↗
A RECORD OF WHAT WENT WRONG
Browse the archive / 100840
Trial deletion: only external roots keep gray objects alive · case 01
Objects kept alive by references from outside the candidate subgraph are collected.
Trial deletion: only external roots keep gray objects alive · case 02
Objects kept alive by references from outside the candidate subgraph are collected.
Trial deletion: only external roots keep gray objects alive · case 03
Objects kept alive by references from outside the candidate subgraph are collected.
Trial deletion: only external roots keep gray objects alive · case 04
Objects kept alive by references from outside the candidate subgraph are collected.
Trial deletion: only external roots keep gray objects alive · case 05
Objects kept alive by references from outside the candidate subgraph are collected.
Trial deletion: children whitened without being scanned · case 01
Cycle members beyond the first child stay gray and survive, while children with outside references are whitened.
Trial deletion: children whitened without being scanned · case 02
Cycle members beyond the first child stay gray and survive, while children with outside references are whitened.
Trial deletion: children whitened without being scanned · case 03
Cycle members beyond the first child stay gray and survive, while children with outside references are whitened.
Trial deletion: children whitened without being scanned · case 04
Cycle members beyond the first child stay gray and survive, while children with outside references are whitened.
Trial deletion: children whitened without being scanned · case 05
Cycle members beyond the first child stay gray and survive, while children with outside references are whitened.
Trial deletion: external references ignored · case 01
Every candidate subgraph is collected, including ones held by the mutator.
Trial deletion: external references ignored · case 02
Every candidate subgraph is collected, including ones held by the mutator.
Trial deletion: external references ignored · case 03
Every candidate subgraph is collected, including ones held by the mutator.
Trial deletion: external references ignored · case 04
Every candidate subgraph is collected, including ones held by the mutator.
Trial deletion: external references ignored · case 05
Every candidate subgraph is collected, including ones held by the mutator.
Cheney copy: objects copied again on every reference · case 01
Shared objects are duplicated and cycles copy until to-space is exhausted.
Cheney copy: objects copied again on every reference · case 02
Shared objects are duplicated and cycles copy until to-space is exhausted.
Cheney copy: objects copied again on every reference · case 03
Shared objects are duplicated and cycles copy until to-space is exhausted.
Cheney copy: objects copied again on every reference · case 04
Shared objects are duplicated and cycles copy until to-space is exhausted.
Cheney copy: objects copied again on every reference · case 05
Shared objects are duplicated and cycles copy until to-space is exhausted.
Cheney copy: copies bump-allocated at their raw size · case 01
Objects with sizes that are not multiples of 8 leave later copies misaligned.
Cheney copy: copies bump-allocated at their raw size · case 02
Objects with sizes that are not multiples of 8 leave later copies misaligned.
Cheney copy: copies bump-allocated at their raw size · case 03
Objects with sizes that are not multiples of 8 leave later copies misaligned.
Cheney copy: copies bump-allocated at their raw size · case 04
Objects with sizes that are not multiples of 8 leave later copies misaligned.
Cheney copy: copies bump-allocated at their raw size · case 05
Objects with sizes that are not multiples of 8 leave later copies misaligned.
Cheney copy: exactly filling to-space reported as overflow · case 01
A heap whose survivors fit to-space exactly fails with out-of-memory.
Cheney copy: exactly filling to-space reported as overflow · case 02
A heap whose survivors fit to-space exactly fails with out-of-memory.
Cheney copy: exactly filling to-space reported as overflow · case 03
A heap whose survivors fit to-space exactly fails with out-of-memory.
Cheney copy: exactly filling to-space reported as overflow · case 04
A heap whose survivors fit to-space exactly fails with out-of-memory.
Cheney copy: exactly filling to-space reported as overflow · case 05
A heap whose survivors fit to-space exactly fails with out-of-memory.
Cheney copy: scanning stops before the last copied object · case 01
Fields of the most recently copied object keep pointing into from-space.
Cheney copy: scanning stops before the last copied object · case 02
Fields of the most recently copied object keep pointing into from-space.
Cheney copy: scanning stops before the last copied object · case 03
Fields of the most recently copied object keep pointing into from-space.
Cheney copy: scanning stops before the last copied object · case 04
Fields of the most recently copied object keep pointing into from-space.
Cheney copy: scanning stops before the last copied object · case 05
Fields of the most recently copied object keep pointing into from-space.
Sliding compaction: dead objects still advance the compaction pointer · case 01
Live objects keep the gaps left by dead objects and the heap never shrinks.
Sliding compaction: dead objects still advance the compaction pointer · case 02
Live objects keep the gaps left by dead objects and the heap never shrinks.
Sliding compaction: dead objects still advance the compaction pointer · case 03
Live objects keep the gaps left by dead objects and the heap never shrinks.
Sliding compaction: dead objects still advance the compaction pointer · case 04
Live objects keep the gaps left by dead objects and the heap never shrinks.
Sliding compaction: dead objects still advance the compaction pointer · case 05
Live objects keep the gaps left by dead objects and the heap never shrinks.
Sliding compaction: new addresses assigned in input order · case 01
Objects are permuted instead of slid, so live objects can overtake each other.
Sliding compaction: new addresses assigned in input order · case 02
Objects are permuted instead of slid, so live objects can overtake each other.
Sliding compaction: new addresses assigned in input order · case 03
Objects are permuted instead of slid, so live objects can overtake each other.
Sliding compaction: new addresses assigned in input order · case 04
Objects are permuted instead of slid, so live objects can overtake each other.
Sliding compaction: new addresses assigned in input order · case 05
Objects are permuted instead of slid, so live objects can overtake each other.
Sliding compaction: interior pointers snapped to object starts · case 01
Pointers into the middle of objects are redirected to the object headers.
Sliding compaction: interior pointers snapped to object starts · case 02
Pointers into the middle of objects are redirected to the object headers.
Sliding compaction: interior pointers snapped to object starts · case 03
Pointers into the middle of objects are redirected to the object headers.
Sliding compaction: interior pointers snapped to object starts · case 04
Pointers into the middle of objects are redirected to the object headers.
Sliding compaction: interior pointers snapped to object starts · case 05
Pointers into the middle of objects are redirected to the object headers.
Sliding compaction: pointers to object starts resolve to the previous object · case 01
References to an object's first byte are reported as dangling or attributed to its neighbour.
Sliding compaction: pointers to object starts resolve to the previous object · case 02
References to an object's first byte are reported as dangling or attributed to its neighbour.
Sliding compaction: pointers to object starts resolve to the previous object · case 03
References to an object's first byte are reported as dangling or attributed to its neighbour.
Sliding compaction: pointers to object starts resolve to the previous object · case 04
References to an object's first byte are reported as dangling or attributed to its neighbour.
Sliding compaction: pointers to object starts resolve to the previous object · case 05
References to an object's first byte are reported as dangling or attributed to its neighbour.
Free-list sweep: free blocks merged across live blocks · case 01
Coalesced free blocks swallow live objects that sit between them.
Free-list sweep: free blocks merged across live blocks · case 02
Coalesced free blocks swallow live objects that sit between them.
Free-list sweep: free blocks merged across live blocks · case 03
Coalesced free blocks swallow live objects that sit between them.
Free-list sweep: free blocks merged across live blocks · case 04
Coalesced free blocks swallow live objects that sit between them.
Free-list sweep: free blocks merged across live blocks · case 05
Coalesced free blocks swallow live objects that sit between them.
Free-list sweep: slivers below the minimum block size created · case 01
Allocations leave 8-byte free fragments that can never hold a block header.
Free-list sweep: slivers below the minimum block size created · case 02
Allocations leave 8-byte free fragments that can never hold a block header.
Free-list sweep: slivers below the minimum block size created · case 03
Allocations leave 8-byte free fragments that can never hold a block header.
Free-list sweep: slivers below the minimum block size created · case 04
Allocations leave 8-byte free fragments that can never hold a block header.
Free-list sweep: slivers below the minimum block size created · case 05
Allocations leave 8-byte free fragments that can never hold a block header.
Free-list sweep: split block keeps the allocated address · case 01
The next allocation is handed the same address again.
Free-list sweep: split block keeps the allocated address · case 02
The next allocation is handed the same address again.
Free-list sweep: split block keeps the allocated address · case 03
The next allocation is handed the same address again.
Free-list sweep: split block keeps the allocated address · case 04
The next allocation is handed the same address again.
Free-list sweep: split block keeps the allocated address · case 05
The next allocation is handed the same address again.
Free-list sweep: sweep report aliases the live free list · case 01
The reported post-sweep free list changes as allocations consume blocks.
Free-list sweep: sweep report aliases the live free list · case 02
The reported post-sweep free list changes as allocations consume blocks.
Free-list sweep: sweep report aliases the live free list · case 03
The reported post-sweep free list changes as allocations consume blocks.
Free-list sweep: sweep report aliases the live free list · case 04
The reported post-sweep free list changes as allocations consume blocks.
Free-list sweep: sweep report aliases the live free list · case 05
The reported post-sweep free list changes as allocations consume blocks.
Free-list sweep: exact fits skipped · case 01
A request that exactly matches a free block is served from a later, larger block.
Free-list sweep: exact fits skipped · case 02
A request that exactly matches a free block is served from a later, larger block.
Free-list sweep: exact fits skipped · case 03
A request that exactly matches a free block is served from a later, larger block.
Free-list sweep: exact fits skipped · case 04
A request that exactly matches a free block is served from a later, larger block.
Free-list sweep: exact fits skipped · case 05
A request that exactly matches a free block is served from a later, larger block.
Heap pacing: reaching the goal exactly does not trigger · case 01
Collections start one allocation late whenever the heap lands exactly on its goal.
Heap pacing: reaching the goal exactly does not trigger · case 02
Collections start one allocation late whenever the heap lands exactly on its goal.
Heap pacing: reaching the goal exactly does not trigger · case 03
Collections start one allocation late whenever the heap lands exactly on its goal.
Heap pacing: reaching the goal exactly does not trigger · case 04
Collections start one allocation late whenever the heap lands exactly on its goal.
Heap pacing: reaching the goal exactly does not trigger · case 05
Collections start one allocation late whenever the heap lands exactly on its goal.
Heap pacing: goal counts only the growth allowance · case 01
With GOGC=100 the next goal equals the live heap, so collections run back to back.
Heap pacing: goal counts only the growth allowance · case 02
With GOGC=100 the next goal equals the live heap, so collections run back to back.
Heap pacing: goal counts only the growth allowance · case 03
With GOGC=100 the next goal equals the live heap, so collections run back to back.
Heap pacing: goal counts only the growth allowance · case 04
With GOGC=100 the next goal equals the live heap, so collections run back to back.
Heap pacing: goal counts only the growth allowance · case 05
With GOGC=100 the next goal equals the live heap, so collections run back to back.
Heap pacing: tiny live heaps get tiny goals · case 01
After a collection that leaves little live data, the next collections run after a few bytes.
Heap pacing: tiny live heaps get tiny goals · case 02
After a collection that leaves little live data, the next collections run after a few bytes.
Heap pacing: tiny live heaps get tiny goals · case 03
After a collection that leaves little live data, the next collections run after a few bytes.
Heap pacing: tiny live heaps get tiny goals · case 04
After a collection that leaves little live data, the next collections run after a few bytes.
Heap pacing: tiny live heaps get tiny goals · case 05
After a collection that leaves little live data, the next collections run after a few bytes.
Heap pacing: zero percent treated as disabled · case 01
Setting the percentage to 0 stops collections instead of collecting at every goal crossing.
Heap pacing: zero percent treated as disabled · case 02
Setting the percentage to 0 stops collections instead of collecting at every goal crossing.
Heap pacing: zero percent treated as disabled · case 03
Setting the percentage to 0 stops collections instead of collecting at every goal crossing.
Heap pacing: zero percent treated as disabled · case 04
Setting the percentage to 0 stops collections instead of collecting at every goal crossing.
Heap pacing: zero percent treated as disabled · case 05
Setting the percentage to 0 stops collections instead of collecting at every goal crossing.
INSPECTABLE BY DESIGN
Every result has a runnable source.
Runnable implementations with recorded outputs, source hashes, and explicit contracts. Related variants share a failure mechanism and belong together in evaluation splits.
Read the methodology ↗