SlimeNENC family · structural translation · Phase 1–4 PoC

SlimePython — Python → Rust bit-exact transpiler

The same structural-translation engine that converts legacy COBOL / JCL / MUMPS / PL/I / RPG to Java & Rust now covers a modern language. Python source becomes Rust source, and the two produce SHA-256-identical output on the same input. Not “approximately equivalent”. Byte-for-byte.

LANGUAGE · SlimeNENC

Not only legacy. Modern languages too.

We do not “understand the meaning” of your Python and rewrite it. Meaning depends on human perception — there is no mathematical rigor in it. The source is structure. SlimePython projects (π) that structure onto Slot IR and transcribes it, structure-preserving, into Rust. No probabilistic code generation, no LLM in the path — deterministic, bit-exact, third-party reproducible.

Legacy sibling: SlimeCOBOL → Request a PoC →

Python 3.12+→ Rust 1.75+SHA-256 bit-exactWASI reproducibleSlot IRno LLM in path

What it does

SlimePython takes a statically-analyzable, type-hinted subset of Python and emits a complete Rust (Cargo) project. The contract is exact: for the same input, the Python program and the generated Rust program produce byte-for-byte identical output, verified by SHA-256. Every conversion ships with the comparison harness and a WASI reproduction script so anyone can re-run the proof.

InputPython 3.12+, from __future__ import annotations, passes mypy --strict. Statically-analyzable subset only.
OutputRust 1.75+ source, full Cargo project (Cargo.toml + Cargo.lock), plus the SHA-256 verification script.
GuaranteePhase 1–2: bit-exact (SHA-256 identical). Phase 3–4: token-exact for numerical / LLM inference.
ReproducibilityWASI sandbox — wasmtime run in three lines. Third parties reproduce the bit-exact result independently.
PathStructure → Slot IR → Rust. No LLM, no probabilistic generation anywhere in the pipeline.

Bit-exact, not “understood”

The whole point is to refuse the “semantic understanding” step. “Meaning” depends on human perception and reads differently to different people, so any “understand-it-then-rewrite” migration injects that wobble. SlimePython treats the source as structure (unambiguous, uniquely determined), projects it onto Slot IR, and transcribes it structure-preserving into Rust. Because no meaning layer is crossed, the result is mathematically rigorous: run it as many times as you like, the output is bit-identical.

Hard rule. “Approximately equivalent” / “semantically the same” output is never emitted. If the input uses a construct outside the static subset, SlimePython rejects it at step 0 with the offending line and a fix suggestion — it does not guess.

What is rejected (and why)

To keep the guarantee real, dynamic / non-deterministic Python is rejected up front:

Construct	Reason
`eval` / `exec`	runtime code generation — out of scope
`setattr`/`__getattr__`/`type()` dynamic class	not statically analyzable
monkey patching (`module.func = ...`)	runtime rewrite
`random.` (no seed), value-significant `time.`	non-deterministic
`threading` / `multiprocessing` (no explicit single-thread)	non-deterministic
untyped variables, `Any`, arbitrary `args/*kwargs`	type information insufficient
`globals()` / `locals()`, C extensions (cffi / cython)	not statically analyzable / out of scope

Where it pays off

AI inferencePort Python ML / LLM inference to Rust (and WASM) — 3-way (Python / Rust / WASM) token-exact, validated on Qwen2.5-class models. The weights never change.
numpy → ndarrayNumerical Python (numpy) mapped to Rust ndarray with the same results, not a re-implementation that “mostly matches”.
Prototype → productionKeep prototyping in Python; ship the deterministic, single-binary, memory-safe Rust — provably the same behaviour.
Audit / regulated“Same output, proven by hash” is the deliverable — no manual “looks right” UAT.

Status

SlimePython is at Phase 1–4 PoC (Phase 1–2 bit-exact over the general static subset; Phase 3–4 token-exact for numerical / LLM inference), with a paper draft prepared. It is the modern-language member of the SlimeNENC structural-translation family — the legacy members convert COBOL / JCL / MUMPS / PL/I / RPG and assembler. Pricing and engagement terms: contact us.