SlimeJava — Bit-Exact Java → Rust Isolate Model
The same structural-translation engine that converts legacy COBOL / JCL / MUMPS / PL/I / RPG to Java & Rust now covers Java. Java source becomes Rust source, and the two produce byte-for-byte identical output (SHA-256) on the same input. Not “approximately equivalent”. Byte-for-byte.
LANGUAGE · SlimeNENC
We don’t understand the meaning. We project the structure into Rust.
We do not “understand the meaning” of your Java and rewrite it. Meaning depends on human perception — there is no mathematical rigor in it. The source is structure. SlimeJava projects (π) that structure onto Slot IR and transcribes it, structure-preserving, into Rust. Java’s two’s-complement wrapping, shift masking, and divide-by-zero exception are reproduced in Rust down to the last bit. No probabilistic code generation, no LLM in the path — deterministic, bit-exact, third-party reproducible.
A tool that "moves" old Java programs into the sturdy Rust language. It doesn't interpret meaning — it copies only the "skeleton," so the computed core (integers) is byte-for-byte identical to the original (proven by ~60,000 automated tests). After the move it's faster to start, lighter on memory, more predictable. Not everything becomes Rust — only what can be copied faithfully.
Hand-porting Java to Rust always drifts on integer overflow or exception behaviour. It reproduces integer traps (wrapping, shift masking, divide-by-zero exceptions) down to the last bit, with zero divergence over ~60,000 differential-fuzz cases + 31 all-input SMT proofs, 0 counterexamples. UAT becomes a machine-checkable "certificate of behavioural invariance." Honest on speed — hot throughput is on par with Java; the wins are startup and memory.
Not all-to-Rust but auto-partitioned into 3 regions (Hybrid Bit-Exact Isolate). The static core is projected via Slot IR to pure Rust (a+b→wrapping_add(b), >>>→logical shift, MIN/-1). Dynamic goes to a deterministic JVM Isolate; true nondeterminism is explicitly rejected. Acceptance 98.7–100%, startup ~41×, RSS ~22× smaller, flat p99.
Projection (π) of source as unique structure, not semantics. Primitives modelled as two's-complement = SMT bit-vector theory; Z3 formally proves equivalence over all inputs (2³²/2⁶⁴/2⁸) with no counterexample (UNSAT), 31 proofs. Loops are covered by Csmith-style differential fuzzing (~63,000 cases) — a two-tier guarantee. The dynamic region emits bit-exact code via tier-② Lisp-JIT the moment context settles at runtime. Exception-text drift (array bounds, NPE, negative-array, …) is reproduced per JDK and confirmed on real OpenJDK 8/17/21; the target JDK major is stamped into the certificate (version-scoped byte-diff 0).
📋 "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.
What it does
SlimeJava takes a statically analyzable Java subset (int/long arithmetic, control flow, bit operations, arrays, exception paths) and emits a Rust (Cargo) project. The contract is strict — on the same input, the original Java and the generated Rust produce byte-identical output. Every conversion ships with a Java/Rust comparison harness, so any third party can re-run the proof with sha256sum.
We don’t “understand.” That’s why it’s bit-exact.
The crux is to deliberately discard the “understand the meaning” step. “Meaning” depends on human perception and varies — so an “understand and rewrite” migration imports that variance. SlimeJava treats the source as structure (unambiguous, unique), projects it onto Slot IR, and transcribes it into Rust structure-preserving. Because it never passes through the meaning layer, the result is mathematically rigorous — Java’s two’s-complement wrapping, shift masking, and divide-by-zero exception are reproduced down to the last bit.
Full Java — Hybrid Bit-Exact Isolate
“Full Java” does not mean rewriting everything into Rust (objects/String/double/reflection cannot be made bit-exact in Rust). It means accepting all Java. Any Java is auto-partitioned into three regions, each given the strongest honest guarantee:
| Region | Target | Guarantee |
|---|---|---|
| Static core (integer/control/array/bit) | → pure Rust | 100% bit-exact (+ SMT proof over all inputs) |
| Dynamic (object/String/double/reflection) | → Java, on a deterministic JVM Isolate | fixed-JVM 95-99% |
| True nondeterminism (unseeded random/wall-clock/I/O/concurrency) | → reject | bit-exact not guaranteed (explicit) |
Measured Hybrid acceptance is 98.7–100% (breaking past the static-only 37% wall). An auto-partitioner Hybridizes mixed Java in one command and verifies byte-identity against the original.
Evidence — all third-party reproducible
Every claim is backed by real compilation & byte-diff / SMT proof over all inputs:
- No-holes proof~60,000-case differential fuzzing (random + exhaustive corner cases) byte-identical to Java, zero divergence. 603 real OpenJDK cases (23 methods) also match.
- Formal (SMT)bitCount (32/64-bit) equals popcount, etc. — 12 methods + division machine-proven over all inputs (0 counterexamples).
- PerformanceThroughput on par; startup ~41×, RSS ~22× smaller, p99 tail flat (no GC). The value is “light, predictable, bit-exact.”
- Hybrid330 programs auto-Hybridized, 2,259 boundary calls — byte-identical through the exception boundary.
The measurement procedure, full verification data, and reproduction commands are consolidated on the resource page (measurement procedure & primary data).
The three-tier model — the SlimeNENC desk
| Tier | Computation | Guarantee |
|---|---|---|
| ① Static projection (SlimeJava) | reproducible integer / logic | byte-identical |
| ② Lisp-JIT | reproducible once it settles at run time | byte-identical (after settling) |
| ③ Semantic judge | non-reproducible (float / parallel / AI) | meaning-equivalence + convergence + residual |
Using it as a product — certificate + CI gate
One command does convert → run → byte-diff → issue certificate. The exit code drops into a CI gate that goes red if behavior changes by a single bit. The certificate records input SHA-256, converted methods, output hashes, and verdict, re-runnable by a third party. Human “close enough” UAT is replaced by a machine-checkable “certificate of behavioral invariance.”
| Tier | Contents | Guarantee |
|---|---|---|
| Free / Open | converter + differential verifier + certificate CLI | byte-diff 0 (practical) |
| Pro | + SMT all-input formal proof + CI integration + audit trail | all-input machine proof + diff |
Pricing / SLA are quoted per use case and scale — contact us. Ideal as the “peel the integer core from Java to Rust” phase extending a COBOL / PL/I legacy migration.
Status
Update 2026-06 — version-scoped certificate. Exception message text varies by JDK (array bounds, NullPointer, negative-array, …). SlimeJava reproduces each per JDK version and stamps the target JDK major (e.g. 8 / 17 / 21) into the behavior-invariance certificate. Byte-identical output for the target JDK is confirmed on real OpenJDK 8 / 17 / 21.
SlimeJava is at the Isolation-Method PoC stage, with everything above demonstrated. It is a member of the SlimeNENC structural-translation family — legacy side: COBOL / JCL / MUMPS / PL/I / RPG & assembler; modern side: Python. Full verification data is on the resource page. For pricing and contracts, contact us.
Contact / request a PoC Measurement procedure & full data SlimePython Other products