Validated on a live IBM i 7.5 / 2026-05-27 / SlimeRESCUE patent family

SlimeRESCUE-AS400

CL rescue PROVEN Data rescue PROVEN RPG / COBOL rescue IN DEVELOPMENT

Rescue programs and data from an IBM i (AS/400) *PGM binary — even when the original source file is gone.

An IBM i *PGM is fundamentally different from a z/Architecture load module: it is not raw machine code but encapsulates TIMI / MI (the Machine Interface, a machine-independent high-level intermediate representation), with the native PowerPC hidden by the SLIC. So SlimeRESCUE-AS400 does not disassemble machine code — it uses the recoverable information the *PGM carries. That is precisely why AS/400 is more favorable than z/Arch here: AS/400 systems run unattended for 20–30 years, so the builder SIer is often gone and the source (floppies, old PCs, tapes) is especially often lost — yet the running *PGM survives on the machine.

🎛 AI GATE This page, at your resolution.

Hand rewrites drift on subtle numeric/exception differences (boundary conditions), and verifying that (old-vs-new testing) costs enormous labour. SlimeNENC faithfully mirrors language-specific traps, proves "zero divergence" via differential testing, backed by an independent reference implementation. The deliverable is a machine-checkable "certificate of behavioural invariance," not human UAT. No overstating; what it can't do isn't hidden.

📋 "Ask your AI at this level" copies this page's explanation with an instruction matched to the level you picked. Paste it into your own AI (Claude · GPT · Gemini · Grok) to dig deeper at that resolution.

Three rescue layers — status stated honestly

SlimeRESCUE-AS400 rescues in three layers, depending on what the *PGM carries. The table reflects the actual state validated on real hardware.

Layer	What it does	Status	Validation (live IBM i 7.5)
CL rescue ✓	`RTVCLSRC` recovers the full CL source from the `PGM` → SlimeCL* → Rust / bash (Java later)	PROVEN	From a `PGM` whose source-file slot is empty, `RTVCLSRC` (CPC0560) recovered the real source and variable names → SlimeCL → Rust, matching the live `CALL` by value (= 425).Note: the observation is the return value only, N=1. This `PGM` was compiled from a stream file (`SRCSTMF`), and such a compile records no source file on the object, which is why the slot is empty. An experiment that demonstrates recovery after the source is actually lost is in preparation.
Data rescue ✓	Every physical-file record read byte-exact as character (EBCDIC) / zoned / packed (COMP-3) / binary / float / DECFLOAT	PROVEN	P10–P19: byte-exact against the live member bytes (fixed-length RECFM, COMP-3 sign, IEEE float, DECFLOAT16/34 included)
RPG / COBOL rescue ⧖	Reconstruct source & names from the `*PGM` observability (ILE debug view / MI template)	IN DEV	The retrieval API (`QTEDBGS`: `QteRetrieveModuleViews` / `QteRetrieveViewText`) is reached and bound. Completion needs a debug-mode context (dedicated / interactive) — evaluated case-by-case in a joint PoC

Honest scope. What is proven on real hardware today is CL rescue and data rescue. RPG / COBOL rescue is in development — the retrieval API has been reached. A *PGM whose observability has been stripped (RMVOBS) cannot have its program recovered (data rescue still works). Real cases are assessed individually via a free PoC / joint validation.

Validated on a live IBM i 7.5

Not on paper — end-to-end on a live IBM i 7.5 (a public IBM i operated by RZKH GmbH). There is a working artifact on IBM i already.

Environment	IBM i 7.5 (5250 / SSH; real objects created in a writable library)
CL rescue	`RTVCLSRC PGM(...)` → `CPC0560`, with the recovered header's "original source file" empty. From the CL source recovered out of the `PGM`* alone, SlimeCL → Rust matched the live `CALL` by value (425)Note: the comparison is of the returned value, not of bytes. The empty slot is a consequence of compiling from a stream file.
Data rescue	Interactive-screen reconstruction + full CRUD (RCVF / embedded RUNSQL) + EBCDIC fixed-length zoned / packed COMP-3 / binary BE / IEEE float / DECFLOAT16/34 compared byte-exact against the live member bytes with no conversion
RPG / COBOL API	An ILE C harness was bound via `CRTCMOD` → `CRTPGM ... BNDSRVPGM(QSYS/QTEDBGS)` and reached the live API. The chain `QteRetrieveModuleViews` → `QteRegisterDebugView` → `QteRetrieveViewText` is confirmed (completion needs a debug-mode context)

Live example (CL rescue)

A real-hardware log of reviving modern Rust from the *PGM binary alone, using no source file:

== SlimeRESCUE-AS400 — *PGM binary -> recovered source -> SlimeCL -> Rust ==
  RTVCLSRC          : CPC0560   (original source file on object: <EMPTY>)
  live *PGM (IBM i) : 00000000425
  rescued->SlimeCL  : 00000000425
  => PASS  — *PGM -> RTVCLSRC -> SlimeCL -> Rust,
            return value matches live IBM i = 425

Correction (2026-07-26): our own audit of the comparison path established that this demonstration compares the returned value, not bytes, and that the empty "original source file" slot is a consequence of compiling from a stream file rather than evidence that the source was lost. We have therefore withdrawn "world-first" and "byte-exact" from the CL rescue claim and limited it to what was demonstrated. An experiment that demonstrates recovery after the source is actually deleted, and a change that raises the comparison to the byte level, are in preparation. The byte-exact claim for data rescue (P10-P19) rests on an unconverted comparison against the live member bytes and is unchanged.

The corrected harness, what the earlier one actually compared, and the figures measured on real hardware on 2026-07-27 are documented in the verification materials.

The original .clp is never read. The candidate is built only from the source that RTVCLSRC pulls back out of the *PGM object itself.

Technical specification

Target	IBM i (AS/400 / iSeries / System i) `*PGM` objects and physical files
`*PGM` nature	Encapsulates TIMI / MI (machine-independent high-level IR); native PowerPC hidden by the SLIC. Not machine-code disassembly — uses the recoverable-information path
CL recovery	`RTVCLSRC` (no source file required; recovers real source from the `PGM` when observability is retained, which is the default) → SlimeCL* to modern languages
RPG / COBOL path	Observability from the ILE debug view (`DBGVIEW`) / MI template, retrieved via the `QTEDBGS` source-debug API (`QteRetrieveModuleViews` / `QteRetrieveViewText`). Requires a debug-mode context (CPF9541 otherwise)
Data formats	EBCDIC (cp037 family) / zoned decimal / packed COMP-3 / binary BE two's-complement / IEEE float (BE single & double) / DECFLOAT (decimal64 & decimal128, DPD declets)
Output languages	SlimeCL → Rust / bash (single binary, no external libraries). Java later; integrates with SlimeNENC assets
Caveat	A `*PGM` whose observability has been stripped (`RMVOBS`) cannot have its program recovered (data rescue still works). Program recovery depends on observability state

Where it applies

Builder SIer gone, source lost: an AS/400 running unattended for 20–30 years where the source vanished with the floppies / old PCs / tapes and only the live *PGM remains
RPG programmers retired, no handover: nobody left who can change it; only the running workload survives
Post-M&A asset cleanup: after consolidation the source location is unknown and only objects and physical files remain
Audit & visibility: document what the *PGM implements and what the business data holds
Modernization with continuity: don't stop the AS/400 abruptly — move rescued assets to modern code in stages, in a continuity / co-existence framing

Related / pricing

SlimeRESCUE-AS400 is a binary-start premium SKU. Its pricing relative to source-start SKUs (scarcity of alternatives + the AS/400 source-loss market) follows the common SlimeRESCUE family policy. Volume discounts, SIer partner margins, and free PoC / joint-validation terms are on the partners page; details disclosed under NDA.