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
Stack maps: derived pointers rebased on the already-relocated base · case 01
Interior pointers into moved objects end up offset by the distance the object moved.
Stack maps: derived pointers rebased on the already-relocated base · case 02
Interior pointers into moved objects end up offset by the distance the object moved.
Stack maps: derived pointers rebased on the already-relocated base · case 03
Interior pointers into moved objects end up offset by the distance the object moved.
Stack maps: derived pointers rebased on the already-relocated base · case 04
Interior pointers into moved objects end up offset by the distance the object moved.
Stack maps: derived pointers rebased on the already-relocated base · case 05
Interior pointers into moved objects end up offset by the distance the object moved.
Stack maps: slots relocated when their value matches a moved address · case 01
Integers that happen to equal an old object address are silently rewritten.
Stack maps: slots relocated when their value matches a moved address · case 02
Integers that happen to equal an old object address are silently rewritten.
Stack maps: slots relocated when their value matches a moved address · case 03
Integers that happen to equal an old object address are silently rewritten.
Stack maps: slots relocated when their value matches a moved address · case 04
Integers that happen to equal an old object address are silently rewritten.
Stack maps: slots relocated when their value matches a moved address · case 05
Integers that happen to equal an old object address are silently rewritten.
Stack maps: derived pointer offset dropped · case 01
Derived pointers are reset to the object start after a move.
Stack maps: derived pointer offset dropped · case 02
Derived pointers are reset to the object start after a move.
Stack maps: derived pointer offset dropped · case 03
Derived pointers are reset to the object start after a move.
Stack maps: derived pointer offset dropped · case 04
Derived pointers are reset to the object start after a move.
Stack maps: derived pointer offset dropped · case 05
Derived pointers are reset to the object start after a move.
Adaptive tenuring: reaching the desired size lowers the threshold · case 01
Survivor populations exactly at the target size are promoted a cycle early.
Adaptive tenuring: reaching the desired size lowers the threshold · case 02
Survivor populations exactly at the target size are promoted a cycle early.
Adaptive tenuring: reaching the desired size lowers the threshold · case 03
Survivor populations exactly at the target size are promoted a cycle early.
Adaptive tenuring: reaching the desired size lowers the threshold · case 04
Survivor populations exactly at the target size are promoted a cycle early.
Adaptive tenuring: reaching the desired size lowers the threshold · case 05
Survivor populations exactly at the target size are promoted a cycle early.
Adaptive tenuring: target ratio truncated to zero · case 01
Every survivor is promoted after its first collection.
Adaptive tenuring: target ratio truncated to zero · case 02
Every survivor is promoted after its first collection.
Adaptive tenuring: target ratio truncated to zero · case 03
Every survivor is promoted after its first collection.
Adaptive tenuring: target ratio truncated to zero · case 04
Every survivor is promoted after its first collection.
Adaptive tenuring: target ratio truncated to zero · case 05
Every survivor is promoted after its first collection.
Adaptive tenuring: objects at the threshold age neither promoted nor kept · case 01
Survivors whose age equals the threshold vanish from both lists.
Adaptive tenuring: objects at the threshold age neither promoted nor kept · case 02
Survivors whose age equals the threshold vanish from both lists.
Adaptive tenuring: objects at the threshold age neither promoted nor kept · case 03
Survivors whose age equals the threshold vanish from both lists.
Adaptive tenuring: objects at the threshold age neither promoted nor kept · case 04
Survivors whose age equals the threshold vanish from both lists.
Adaptive tenuring: objects at the threshold age neither promoted nor kept · case 05
Survivors whose age equals the threshold vanish from both lists.
Adaptive tenuring: oldest survivors placed first · case 01
On overflow the youngest objects are promoted while older ones stay in survivor space.
Adaptive tenuring: oldest survivors placed first · case 02
On overflow the youngest objects are promoted while older ones stay in survivor space.
Adaptive tenuring: oldest survivors placed first · case 03
On overflow the youngest objects are promoted while older ones stay in survivor space.
Adaptive tenuring: oldest survivors placed first · case 04
On overflow the youngest objects are promoted while older ones stay in survivor space.
Adaptive tenuring: oldest survivors placed first · case 05
On overflow the youngest objects are promoted while older ones stay in survivor space.
Adaptive tenuring: survivor space never filled exactly · case 01
An object that would fill the survivor space exactly is promoted instead.
Adaptive tenuring: survivor space never filled exactly · case 02
An object that would fill the survivor space exactly is promoted instead.
Adaptive tenuring: survivor space never filled exactly · case 03
An object that would fill the survivor space exactly is promoted instead.
Adaptive tenuring: survivor space never filled exactly · case 04
An object that would fill the survivor space exactly is promoted instead.
Adaptive tenuring: survivor space never filled exactly · case 05
An object that would fill the survivor space exactly is promoted instead.
Collection set: liveness ratio truncated to zero · case 01
Nearly full old regions are treated as empty and chosen for evacuation.
Collection set: liveness ratio truncated to zero · case 02
Nearly full old regions are treated as empty and chosen for evacuation.
Collection set: liveness ratio truncated to zero · case 03
Nearly full old regions are treated as empty and chosen for evacuation.
Collection set: liveness ratio truncated to zero · case 04
Nearly full old regions are treated as empty and chosen for evacuation.
Collection set: liveness ratio truncated to zero · case 05
Nearly full old regions are treated as empty and chosen for evacuation.
Collection set: least garbage collected first · case 01
The pause budget is spent on regions that reclaim the least memory.
Collection set: least garbage collected first · case 02
The pause budget is spent on regions that reclaim the least memory.
Collection set: least garbage collected first · case 03
The pause budget is spent on regions that reclaim the least memory.
Collection set: least garbage collected first · case 04
The pause budget is spent on regions that reclaim the least memory.
Collection set: least garbage collected first · case 05
The pause budget is spent on regions that reclaim the least memory.
Collection set: selection skips over regions that do not fit · case 01
Cheaper, less profitable regions are packed in after a better region was rejected.
Collection set: selection skips over regions that do not fit · case 02
Cheaper, less profitable regions are packed in after a better region was rejected.
Collection set: selection skips over regions that do not fit · case 03
Cheaper, less profitable regions are packed in after a better region was rejected.
Collection set: selection skips over regions that do not fit · case 04
Cheaper, less profitable regions are packed in after a better region was rejected.
Collection set: selection skips over regions that do not fit · case 05
Cheaper, less profitable regions are packed in after a better region was rejected.
Collection set: candidate exactly using the remaining budget rejected · case 01
A set that would meet the pause budget exactly stops one region short.
Collection set: candidate exactly using the remaining budget rejected · case 02
A set that would meet the pause budget exactly stops one region short.
Collection set: candidate exactly using the remaining budget rejected · case 03
A set that would meet the pause budget exactly stops one region short.
Collection set: candidate exactly using the remaining budget rejected · case 04
A set that would meet the pause budget exactly stops one region short.
Collection set: candidate exactly using the remaining budget rejected · case 05
A set that would meet the pause budget exactly stops one region short.
Collection set: humongous regions chosen for evacuation · case 01
Empty humongous regions are scheduled for copying.
Collection set: humongous regions chosen for evacuation · case 02
Empty humongous regions are scheduled for copying.
Collection set: humongous regions chosen for evacuation · case 03
Empty humongous regions are scheduled for copying.
Collection set: humongous regions chosen for evacuation · case 04
Empty humongous regions are scheduled for copying.
Collection set: humongous regions chosen for evacuation · case 05
Empty humongous regions are scheduled for copying.
Mark parity: new cycle starts with pages left unswept · case 01
Dead objects from the previous cycle are resurrected when the parity flips back to their stale mark.
Mark parity: new cycle starts with pages left unswept · case 02
Dead objects from the previous cycle are resurrected when the parity flips back to their stale mark.
Mark parity: new cycle starts with pages left unswept · case 03
Dead objects from the previous cycle are resurrected when the parity flips back to their stale mark.
Mark parity: new cycle starts with pages left unswept · case 04
Dead objects from the previous cycle are resurrected when the parity flips back to their stale mark.
Mark parity: new cycle starts with pages left unswept · case 05
Dead objects from the previous cycle are resurrected when the parity flips back to their stale mark.
Mark parity: new objects always get mark 0 · case 01
Objects allocated in odd epochs look dead to the current cycle and alive to the next one.
Mark parity: new objects always get mark 0 · case 02
Objects allocated in odd epochs look dead to the current cycle and alive to the next one.
Mark parity: new objects always get mark 0 · case 03
Objects allocated in odd epochs look dead to the current cycle and alive to the next one.
Mark parity: new objects always get mark 0 · case 04
Objects allocated in odd epochs look dead to the current cycle and alive to the next one.
Mark parity: new objects always get mark 0 · case 05
Objects allocated in odd epochs look dead to the current cycle and alive to the next one.
Mark parity: live objects marked with the previous epoch's parity · case 01
Every object reported live is swept as dead.
Mark parity: live objects marked with the previous epoch's parity · case 02
Every object reported live is swept as dead.
Mark parity: live objects marked with the previous epoch's parity · case 03
Every object reported live is swept as dead.
Mark parity: live objects marked with the previous epoch's parity · case 04
Every object reported live is swept as dead.
Mark parity: live objects marked with the previous epoch's parity · case 05
Every object reported live is swept as dead.
Mark parity: mark 0 always treated as dead · case 01
In even epochs live objects are swept and dead ones kept.
Mark parity: mark 0 always treated as dead · case 02
In even epochs live objects are swept and dead ones kept.
Mark parity: mark 0 always treated as dead · case 03
In even epochs live objects are swept and dead ones kept.
Mark parity: mark 0 always treated as dead · case 04
In even epochs live objects are swept and dead ones kept.
Mark parity: mark 0 always treated as dead · case 05
In even epochs live objects are swept and dead ones kept.
Block offset table: back-skip entries never replaced by a real start · case 01
Cards entered by a spanning object keep pointing back even though an object starts inside them.
Block offset table: back-skip entries never replaced by a real start · case 02
Cards entered by a spanning object keep pointing back even though an object starts inside them.
Block offset table: back-skip entries never replaced by a real start · case 03
Cards entered by a spanning object keep pointing back even though an object starts inside them.
Block offset table: back-skip entries never replaced by a real start · case 04
Cards entered by a spanning object keep pointing back even though an object starts inside them.
Block offset table: back-skip entries never replaced by a real start · case 05
Cards entered by a spanning object keep pointing back even though an object starts inside them.
Block offset table: last card spanned by an object left empty · case 01
Lookups in the final card covered by a large object find no owner.
Block offset table: last card spanned by an object left empty · case 02
Lookups in the final card covered by a large object find no owner.
Block offset table: last card spanned by an object left empty · case 03
Lookups in the final card covered by a large object find no owner.
Block offset table: last card spanned by an object left empty · case 04
Lookups in the final card covered by a large object find no owner.
Block offset table: last card spanned by an object left empty · case 05
Lookups in the final card covered by a large object find no owner.
Block offset table: back-skips always point one card back · case 01
Lookups deep inside large objects take one hop per card and the table encoding differs from the contract.
Block offset table: back-skips always point one card back · case 02
Lookups deep inside large objects take one hop per card and the table encoding differs from the contract.
Block offset table: back-skips always point one card back · case 03
Lookups deep inside large objects take one hop per card and the table encoding differs from the contract.
Block offset table: back-skips always point one card back · case 04
Lookups deep inside large objects take one hop per card and the table encoding differs from the contract.
Block offset table: back-skips always point one card back · case 05
Lookups deep inside large objects take one hop per card and the table encoding differs from the contract.
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 ↗