SlimeNatural — Software AG Natural / ADABAS → Java + PostgreSQL bit-exact transpiler
Frees you from Software AG’s per-CPU multi-million-USD license. The eighth SlimeNENC product, with semantics-preserving migration of both Natural language and ADABAS data.
Natural 4GL applications and ADABAS hierarchical databases that run banks, insurers, pensions, municipalities, and defense systems — migrated, bit-exact, with audit chains and tamper detection, into Java and PostgreSQL. Not a human-review-gated rewrite. The S2-S5 / S7-S9 stages are shared with SlimeCOBOL, SlimeMUMPS, SlimePL/I, SlimeRPG, and SlimeFORTRAN; only S1 (Natural FST + ADABAS DDM parser) and S6 (Java + PostgreSQL DDL emitters) are language-specific.
- Natural language — DEFINE DATA / IF / FOR / REPEAT / DECIDE / COMPUTE / COMPRESS / EXAMINE / CALLNAT / WRITE all transpiled bit-exact to Java
- ADABAS data operations — FIND / READ LOGICAL BY descriptor / HISTOGRAM / STORE / UPDATE / DELETE / END-OF-TRANSACTION / BACKOUT TRANSACTION / ESCAPE TOP|BOTTOM[IMMEDIATE] all mapped to Java JDBC + JPA
- ADABAS DDM — Predict column-anchored DDM is parsed; MU (multi-value) / PE (periodic group) / SUPER / HYPER / SUB descriptors all recognized
- DDM → PostgreSQL DDL — MU becomes a child table, PE GROUP becomes a child table with pe_idx, SUPER becomes a composite INDEX, HYPER becomes an INDEX hint. Type mapping (A→VARCHAR, N/P→BIGINT/NUMERIC, F→DOUBLE, D→DATE, T→TIMESTAMP, L→BOOLEAN, B→BYTEA)
- S9 5-axis bench passes 75/75 (15 samples × 5 axes = dialect-detect / token-recover / mutation-detect / determinism / round-trip)
- byte-exact regression — Natural FST 15/15 + DDM parser 3/3 + DDL emitter 3/3 + Java emit→javac→run→stdout 15/15
Auditors can re-verify "no information lost in conversion" after the fact —
the world’s first lossless migration tool that handles Natural language and ADABAS data in one shot (per our research).
A SlimeNENC-family tool that moves legacy code into a modern language without changing its meaning. A hand rewrite quietly drifts and causes incidents; SlimeNENC doesn't interpret meaning — it copies only the "skeleton" (structure), so the computed results stay identical to the original. It proves the behaviour first, so migration anxiety disappears. It copies only what it can, honestly, and isolates what it can't.
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.
Source is projected onto a Slot IR (language-independent structural intermediate form) and transcribed structure-preserving into the target. The statically-determined core is made bit-exact; dynamic, state-dependent parts are honestly isolated (isolate, don't confabulate). Backed by differential fuzzing plus formal methods where applicable, with deterministic verification a third party can reproduce locally.
Projection (π) of source as unique structure, not semantics. Primitives are modelled rigorously in bit-vector theory and formally verified over all inputs; composition/loops are covered by Csmith-style differential fuzzing — a two-tier guarantee. Non-reproducible computation (float/parallel/AI) goes to tier-③: meaning-equivalence + convergence + residual. "Where there is form, prove it in bytes; where there is none, in meaning. Lie on neither face."
📋 "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.
Headline numbers (measured 2026-05-10)
- Natural FST tokenizerC11, 66+ keywords + 12 END-* compound forms, TYPE_DESIG (`(I4)`, `(N5.2)`, `(A20)` etc.), SYSVAR (`*NUMBER`, `*OCC`, ...), VIEW recognition, hyphenated names like `#DEPT-IN`. 15-sample byte-exact regression PASS.
- ADABAS DDM parserPredict column-anchored layout, 9 formats (A/N/P/B/F/D/T/L/GROUP), level 1-9, short/long names, MU/PE/SUPER/HYPER/D/NULL flags. 3 DDMs / 58 fields parsed byte-exact.
- DDM → PostgreSQL DDLmain table + MU child tables + PE child tables + composite INDEXes for SUPER. 3 DDMs byte-exact + sqlite syntax check 3/3 PASS.
- Natural → Java emitterPhase 4 complete; structured control (IF/FOR/REPEAT/DECIDE), ADABAS statements (FIND/READ/HISTOGRAM/STORE/UPDATE/DELETE), transaction control (END-OF-TRANSACTION/BACKOUT), and ESCAPE all covered. 15/15 samples pass emit→javac→run→stdout regression.
- S9 5-axis benchdialect / token-recover / mutation-detect (5 SOH-injection trials × 15 samples) / determinism / round-trip — 75/75 PASS.
- Hash-chain auditPluggable into the SlimeNENC shared S7 stage (SHA-256 monotonic chain). Aligns with the 30-year retention requirements of pension, health insurance, and defense.
- Build-time LLM onlyLLM is used only to construct conversion rules; runtime is deterministic rule-based. Same basis for the 100.000% claim as SlimeCOBOL (validated against NIST CCVS85 501).
Market context — Software AG lock-in
Software AG’s Natural / ADABAS has been running banks, insurers, pensions, governments, defense, and large manufacturers since the 1970s. Following Software AG’s shifting support policies and per-CPU multi-million-USD licensing, exit projects have surged worldwide.
Competitive positioning:
- CONNX / ADABAS-to-RDB / ADASQL — data-side migration only; the Natural language side is out of scope
- Software AG own (Adabas SQL Gateway etc.) — Software AG licensing remains, halving the wedge
- Major SI reimplementation projects — no bit-exact guarantee, human-dependent, per-LOC pricing
- SlimeNatural (this product) — the Natural language and ADABAS data are migrated lossless from a single vendor, with bit-exact correctness and an audit chain
Supported features (Phase 4 complete, 2026-05-10)
Natural language
| Area | Coverage |
|---|---|
| DEFINE DATA | LOCAL / GLOBAL / PARAMETER / INDEPENDENT, types (I4/I2/I1/N5.2/N9/P9.2/A20/B5/F8/L/D/T), VIEW OF FILE, nested GROUPs, arrays (Phase 5) |
| Control flow | IF/THEN/ELSE/END-IF, FOR ... TO ... STEP / END-FOR, REPEAT [WHILE|UNTIL] cond / END-REPEAT, DECIDE ON FIRST VALUE OF / VALUE / NONE VALUE / END-DECIDE |
| Compute / assignment | `:=` assignment, COMPUTE, MOVE TO, `+ - * /`, relational operators (EQ/NE/LT/LE/GT/GE plus symbolic), logical operators (AND/OR/NOT) |
| String processing | COMPRESS … INTO, EXAMINE … FOR … GIVING NUMBER, SUBSTRING, SCAN, MASK |
| Subprograms | CALLNAT 'NAME' arg-list, SUBROUTINE … END-SUBROUTINE, PERFORM, RETURN, INCLUDE / COPYCODE |
| System variables | *NUMBER / *OCC / *ISN / *COUNTER / *PROGRAM / *USER / *DATX / *TIMX |
| Dialect detection | Natural for Adabas (mainframe) / Linux/Unix/Windows / Natural ONE — auto-fingerprint |
ADABAS data operations
| Natural | Java + PostgreSQL |
|---|---|
FIND view WITH descriptor = X | SELECT … WHERE descriptor = ? + ResultSet loop |
READ view BY descriptor STARTING FROM lo THRU hi | SELECT … WHERE descriptor BETWEEN ? AND ? ORDER BY descriptor |
HISTOGRAM view descriptor | SELECT descriptor, COUNT(*) FROM view GROUP BY descriptor |
STORE view | INSERT + entityManager.persist |
UPDATE / DELETE | UPDATE / DELETE WHERE id = ? |
END-OF-TRANSACTION | conn.commit() |
BACKOUT TRANSACTION | conn.rollback() |
ESCAPE TOP / BOTTOM [IMMEDIATE] / ROUTINE | break / continue / return as appropriate |
ADABAS DDM → PostgreSQL DDL
| DDM construct | Relational mapping |
|---|---|
| scalar field (level 2+) | main-table column |
| GROUP (no MU/PE) | flatten — sub-fields lifted into the main table |
| MU (multi-value) | child table <main>_<short>_mu, parent FK + mu_idx PK |
| PE (periodic group) | child table <main>_<short>_pe, parent FK + pe_idx PK, all PE-GROUP sub-fields expanded |
| SUPER descriptor | composite INDEX CREATE INDEX idx_<table>_<short> ON <table> (col1, col2, …) |
| HYPER descriptor | INDEX hint comment (Phase 5 turns these into functional indexes) |
| format A nn / N nn[.dd] / P nn[.dd] | VARCHAR(nn) / BIGINT or NUMERIC(p,s) |
| format F / B / D / T / L | DOUBLE PRECISION / BYTEA / DATE / TIMESTAMP / BOOLEAN |
Pipeline (Phase 4, 9 stages)
The S2-S5 / S7-S9 stages are reused verbatim from the SlimeNENC family. Only S1 (FST tokenizer + DDM parser) and S6 (Java + DDL emitter) are language-specific.
- S1 — Natural FST tokenizer + ADABAS DDM parser (this product, C11)
- S2 — Slot IR (shared with SlimeCOBOL S2)
- S3 — Π_R idempotent transform (claim 3)
- S4 — SOLOT 4-axis E_D (claim 6)
- S5 — Acceptor 64-dim encoder (claims 2/7/8)
- S6 — Java emitter + PostgreSQL DDL emitter (this product)
- S7 — SHA-256 hash-chain audit (claim 9)
- S8 — Mini-PSV bigram language model (claim 7)
- S9 — 5-axis bench harness (dialect / token / mutation / determinism / round-trip)
Industry context — typical use cases
- Regional-bank cores — credit decisioning and account management running on Natural + ADABAS, migrated to Java + PostgreSQL with full Software AG exit.
- Life and non-life insurance — the typical layout has policy management on Natural and rate tables in ADABAS. MU/PE expressing multi-party policies and contact lists are reproduced through child-table decomposition.
- Pensions and health insurance — 30-year retention and 1-yen drift litigation risk. bit-exact + hash-chain audit is mandatory.
- Municipalities and public sector — resident-record interconnect and tax statistics that use ADABAS Hyperdescriptors. Phase 5 turns those into functional INDEXes.
- Defense and coast guard — alongside the Japanese-vendor lock-in cases, Software AG-bound base systems are an additional target.
License model
The same tool-only pricing as SlimeCOBOL / SlimePL/I / SlimeRPG. The transpiled Java + PostgreSQL DDL is yours to use forever, free of further charge. Quotes scale with the Natural / ADABAS asset size (KLOC + DB-file count + MU/PE ratio); priced to fully replace the per-CPU Software AG license.
An initial PoC is offered on the same terms as the Japanese-mainframe PoC offer — bring 50-200 LOC of Natural source plus one related DDM, and we deliver a dialect-identification report in 3-5 business days and a bit-exact transpilation sample in 2-4 weeks.
Resources — SlimeNENC family
- SlimeCOBOL — COBOL → Java/Rust bit-exact transpiler (S2-S9 base of this product)
- SlimePL/I — PL/I → Java bit-exact transpiler
- SlimeRPG — RPG → Java bit-exact transpiler
- SlimeFORTRAN — FORTRAN → 9-language Multi-target
- SlimeJCL — JCL → POSIX shell transpiler
- SlimeMUMPS — Caché ObjectScript → Java
- Japanese-mainframe PoC offer (Hitachi OpenTP1 / Fujitsu GS21 / NEC ACOS)
- PSDP — Provable Semantic Difference Protocol