Blog·Product
Replay 0.8: copybooks, and a hunt for the cases nobody tested
Replay 0.8 works with programs that use copybooks, and adds a bug hunter that looks for the inputs your tests never tried.
Tanveer Singh, Founder·

Today we're releasing Replay 0.8. It's our biggest update so far. It brings Replay closer to real COBOL estates, and it goes looking for the bugs that recorded tests miss.
Replay checks a migration against the original. It records how the COBOL behaves, runs the same cases against the migrated code, and signs the result so anyone can check it. Version 0.8 adds two things to that.
Copybooks
Almost no production COBOL program stands alone. Record layouts and shared logic live in copybooks, pulled in with COPY and changed with REPLACING. Until now, Replay only took programs that didn't use them. That ruled out most real code.
With 0.8, you upload the program with its copybooks, or a whole folder. Folders work as copybook libraries, so COPY X OF LIB finds X in the folder LIB. GnuCOBOL expands the program in a sandbox, and Replay checks that the compiler read exactly the copybooks Replay chose. Everything after that reads that one expanded text. We tested this end to end on copybooks from public COBOL code.
When something is wrong, Replay says so instead of guessing. A missing copybook, a name found in two folders, or one copybook stored twice with different text: the program is refused, with the reason. Each result is bound to the program and every copybook it copies. Change one copybook and it's a different source, so old evidence can't quietly carry over to new code.
The bug hunter
Recorded cases only test what someone thought to record. The bugs that matter in a migration tend to live elsewhere: the rounding on an exact half, the branch no test reached, the field that overflows once a year.
The bug hunter goes after those. It traces the migrated code and works out inputs that would take each path no test took. Then it runs every one against the compiled COBOL. If the two disagree, the file fails, just like a recorded difference, and the input is offered back as a regression case. Every catch is kept for good: replacing or rolling back a result can't make it disappear.
Just as important is what the hunter won't do. A hunt that finds nothing doesn't make a result pass. Nor does one that ran out of time or couldn't run. Not finding a bug isn't evidence that there are none, and Replay never presents it that way.
Think you can get a wrong migration past it? More on Thursday 19 November.
Stricter evidence everywhere else
Inputs are now generated from the program itself: its fields, its conditions and its literals. Coverage is measured from GnuCOBOL's own trace. Every result has one verdict, pass, fail or inconclusive. If the evidence is thin, the result is inconclusive, not a pass. That includes results where most inputs were refused or a field never varied. Migrated code is also checked before it runs, for things that would make a replay meaningless, like reading the wall clock.
What's not in this release
Some programs still need a captured reference from the original system rather than a recompile. These are programs that call other programs, read files or depend on the clock. The release notes below list every change and every known limitation.
If you have COBOL you can't afford to get wrong, we're taking on a small number of design partners.
Release notes: highlights
Replay 0.8, released 16 November 2026.
- Copybooks. Programs that use COPY and REPLACE can now be recompiled, replayed and hunted. Upload the program with its copybooks, or a whole folder, and every result names the exact copybooks it was built from.
- The bug hunter. The hunter traces your migration, works out the inputs that take paths no test took, and runs each one against the compiled COBOL. If it finds a disagreement, the file fails, and the catch is kept for good.
New: copybooks
- Programs that COPY copybooks, with or without REPLACING, can be recompiled, replayed and hunted.
- Upload copybooks as .cpy or .copy files with the program.
- Folders work as copybook libraries: COPY X OF LIB finds X in a folder named LIB. Folder uploads and GitHub imports keep each file's folder.
- GnuCOBOL expands the program in the sandbox, and Replay checks that the compiler read exactly the copybooks Replay chose. The reference, the coverage figures and the hunt all read that one expanded text.
- If a copybook is missing, found in two folders, or stored twice with different text, the program is refused and Replay says why.
- A result is bound to the program and every copybook it copies. Change one copybook and it counts as a different source.
- Signed results list each copybook with its hash, and the standalone verifier checks them.
- A finding on a line that came from a copybook names the copybook and the line within it.
New: the bug hunter
- Start a hunt from the replay report or the workbench.
- The hunt traces the migration, solves for inputs that take each untried path, and checks every candidate against the compiled COBOL.
- Its outcome is a signed part of the result.
- A disagreement it finds fails the file, just like a recorded difference. It is offered as a regression input, and it can only be overridden with a logged reason.
- Every catch is kept permanently. Replacing or rolling back a result can't remove it.
- A hunt that found nothing, didn't finish or couldn't run never makes a result pass.
- Three cases are flagged for a person to judge rather than decided: an answer that depends on earlier calls, an input that stalls, and a migration that answers differently while it is traced.
New: stronger evidence
- Inputs for a recompiled reference are generated from the program itself: its fields, conditions and literals, with dates that hold together. A set holds up to 1,000 inputs, each kept for what it adds.
- Branch coverage is measured from GnuCOBOL's own trace. Seeded faults show which mistakes the inputs would catch.
- Every result has one verdict, pass, fail or inconclusive, and states how strong its evidence is.
- Thin evidence is inconclusive, not a pass: half or more of the inputs refused, an input field that never varied, or 95% or more of inputs giving the same answer.
- Every input runs on its own, and also in sequence in one process. An answer that changes with the order of calls goes to a person.
Improvements
- The hunter solves more: products of two inputs; decisions made without a comparison, such as abs, min, max and integer division; and inputs one step from a value that is rounded twice.
- The hunter can't hang. The solver runs in a separate process with a hard deadline.
- More varied inputs: near ties at every magnitude, sums and products that overflow their PICTURE, every case and cut of accepted text values, and boundary dates in every date field at once.
- Migrated code is checked before it runs. Replay flags code that reads the wall clock or time zone, uses values that change between processes, or keeps state between calls. A finding blocks finalising until a person overrides it with a logged reason.
- Each replay runs with a fixed clock, so time can't change the answer.
- A recompile, its coverage build and its replay share one 15-minute limit. A recompile that runs out of time is refused, never cut short.
- Clearer errors: Replay says whether time ran out, the step can't run here, or something in the program's text means it can't be replayed.
- A clearer finalise flow: assemble, replay, gate, finalise. The gate shows thin evidence and refused inputs, and says why a result doesn't cover a file.
- An updated verifier that also checks copybook programs against their parts.
Fixes
- Copybook parsing: COPY inside a name or a literal is no longer read as a COPY statement; a full stop inside pseudo-text no longer ends the statement; a literal REPLACING operand now matches next to a hyphen.
- Comparison: numbers are compared by value; very large values no longer match by overflowing together; the same abend now counts as agreement.
- The gate: a decision stands only for the evidence and the code it judged. A result built from a different COBOL source covers nothing, and says so.
- Inputs: an input that never ends is refused on its own, not the whole reference. A field the program may read before writing is now driven and compared.
- CALL detection: a CALL in any form is treated as a dependency, so the program is refused rather than replayed without what it calls.
- Signed packed fields: a signed packed field holding sign F now reads as positive.
Compatibility
- Results made before 0.8 are superseded and need a fresh replay. Replaying clears them.
- Programs with copybooks need new evidence: assemble and reconcile the candidates again, and rebuild the reference.
- Signed results gain two fields: the copybook list and the hunt outcome. Use the verifier shipped with this release to check them.
Known limitations
- Programs with outside dependencies aren't recompiled: calls to other programs, files, embedded EXEC statements, or the system clock. They need a captured reference from the original system.
- Copybooks must be in fixed or free source format, and must be uploaded with the program.
- Files picked one by one carry no folder, so COPY X OF LIB needs a folder upload or a GitHub import.
- A recompiled reference shows what GnuCOBOL does with the program, which may differ from what production runs.
- On very large projects, with hundreds of programs and thousands of copybooks, the finalise gate takes a few seconds the first time after any file changes.
- Two programs with the same file name in different folders share one slot.
- A hunt takes up to about ten minutes. Each person can run one hunt at a time, and a result must be replayed again after an engine update before it can be hunted.
See it on your own code.
Montora is taking on a small number of design partners: banks, insurers and other teams with COBOL they can't afford to get wrong.