For decision-makers · audit-first / Language
Without a rewrite, use every core.
Your bill to 1/3, your bugs to zero.
You want to parallelize. But touch the source and bugs appear; leave it and cores sit idle. We resolve that dilemma at build time.
It wakes idle cores, so you get faster without adding servers. Measured 2.97–4.23×. See whether you can compress EC2 / GKE to 1/3–1/4, estimated on next month's bill with your production jar.
The sequential and parallel versions are SHA-256 matched on every run; on any mismatch it rolls back instantly (90/90 verified). So every regression test passes unchanged.
OrderBatch.java doesn't change by a single byte. At build time it reads the bytecode and adds a parallel version (Java agent / .NET profiler / Rust proc-macro). 0 lines of source changed, no build changes required.
Slime Boy: How can it get faster without touching anything!? 💡
▾
OrderBatch.javadoesn't change by a single byte (git diffis empty)- At build time it reads the bytecode and adds a parallel version (Java agent / .NET profiler / Rust proc-macro)
- On every run it matches the sha256 of the sequential and parallel versions. On mismatch, instant rollback (90/90 verified)
Test whether your jar gets faster → Verify bit-for-bit equality right here →
* “Why others stall” traces the lineage of tens-of-billions-yen failures in meaning-based rewrites — CBA / IRS / TSB Bank and others.
* Measured 2.97–4.23× (this estimate uses the lower bound ≈3× = 67% reduction). Injected at build time without a rewrite. Amounts are a simple estimate of input × reduction rate and vary by contract terms.
PSDP — Phase-Synchronous Deterministic Parallelism (internals)
Deterministic parallelism, injected at build time with zero source changes.
PSDP is a standalone product that reads an existing app's intermediate representation (bytecode / IL / proc-macro expansion) and generates, at build time, a parallel version guaranteed to produce results identical to the sequential one. The source doesn't change by a single byte (git diff is empty). Supports 16 languages (Java / C# / Rust / Go / Kotlin and more).
A Java agent reads the bytecode at load time and injects parallel-version classes.
Rewrites the IL via the Profiler API, switching to the parallel version before JIT.
Expanded at compile time via proc-macro. Zero-cost abstraction preserved.
- On every run, the sequential and parallel outputs are SHA-256 matched; on mismatch, instant rollback (90/90 verified).
- Phase-sync eliminates execution-order nondeterminism across threads → bit-identical no matter how many times you run it.
- Measured 2.97–4.23× (workload-dependent). Cut EC2 / GKE server count to 1/3–1/4.
# 0 files changed (source unchanged; parallelization injected at build time)
It projects the source structure onto Slot IR (π) and transcribes it structure-preserving to the target. No wobbly “understand the meaning” step. 378/378 for Java 8→17 / 17→21, 5,270/5,270 for COBOL→Java (NIST FIPS 21-3 501/501 + 11 external corpora), all bit-exact and third-party reproducible in a sandbox.
PSDP — how it works → SlimeNENC → Estimate with your workload →
AS/400 · IBM i — keep your core running / Device × Language
If the AS/400 stops, the company stops.
So we transplant the whole box.
End-of-support, no one left who can read the RPG, can't-fix-because-can't-touch — all of it. Drop the hardware; keep the contents running as-is.
Hardware maintenance, a dedicated data center, power draw. Retire the box and next year's renewal contract disappears with it. The contents run as portable code in Linux containers — the same on EC2 or on-prem.
CL, RPG, COBOL, the job flow, the return values — identical down to decimal rounding. Users won't even notice the screens changed. Not a “migration,” a “continuation.”
Not everything at once. We byte-compared bash / Rust output against results from real IBM i hardware and verified 3/3 exact matches. Fixed-length CHAR and decimal-format gaps were ironed out on real hardware. Over 1,700 real RPG programs already processed.
From worries like these
Afraid of end-of-support Our RPG expert is retiring Want to connect to cloud via API
A/B compare with your CL → Transplant a single RPG →
AS/400 · IBM i — device → language (products / verification)
Bring your AS/400 — the whole box — into the present.
CL, RPG, COBOL — the entire box into portable code. 1,700+ real RPG programs already fed through the pipeline and processed (our own RPG corpus, pass count). Not a “migration,” a “continuation.”
For CL, we byte-compared the original run on real IBM i hardware against SlimeCL's bash / Rust output — 3/3 bit-exact verified. The fixed-length CHAR and decimal-format gaps that real hardware exposed have been fixed and published.
SlimeCL / SlimeRPG / SlimeCOBOL-400. Continuous, unit-by-unit modernization. Not a rewrite — a transport.
SlimeCL details → SlimeCOBOL → LANGUAGE category →
LANGUAGE — COBOL modernization / Language
COBOL migrations fail
because they try to understand the meaning.
No. Embrace the black box. The source itself is the spec. Skip the wobbly “meaning” step and copy the whole structure without changing a single bit.
CBA / IRS / TSB Bank. Every tens-of-billions-yen failure came from the “understand the meaning and rewrite it” step. Even for the same code, how people read its meaning wobbles. We discard that wobbly step and transport only the 0101 structure, preserved. That's why it doesn't fail.
Across US federal COBOL validation FIPS 21-3 + 11 external corpora + 7 Medicare lineages, all 5,270 / 5,270 bit-exact at 100.000%. Anyone can reproduce it third-party in a sandbox. In the Medicare domain, where 1¢ off is a federal violation, 675/675 succeeded. Not stalling under audit is what audit-first means.
LLM-based migration wobbles even on the same input. We use algebra, not probability. Every run gives an exact SHA-256 match. Even when the source is lost, SlimeRESCUE reconstructs C / Java from the executable alone (an estimated 12–24 billion-line market). Not just legacy — Python→Rust is bit-exact on the same engine too.
Transplant a single COBOL program bit-for-bit → See the 5,270/5,270 third-party reproduction →
LANGUAGE · highlights (rationale / products)
The common narrative
No. Embrace the black box.
COBOL migration needs no “understand the meaning” step. Treat the source code itself as the spec and transcribe it bit-exact, deterministically. That's all.
Avoids the tens-of-billions-yen failures of CBA / IRS / TSB Bank. Just transport it without changing a single bit.
No contradiction with “no silver bullet.” A lineage that preserves and transports rather than re-expresses.
LLM-based migration gives wobbling results. Ours is a single-bit match every run.
SlimeRESCUE reconstructs C / Java from the executable alone, covering an estimated 12–24 billion-line uncontested market.
Measured (2026-05-20): Across US federal COBOL validation (FIPS 21-3) + 11 corpora + 7 Medicare lineages, all 5,270 / 5,270 bit-exact matches (100.000%). Anyone can reproduce it third-party in a sandbox.
Not just legacy — modern languages too. The same structural translation, Python → Rust. Transcribed bit-exact (exact SHA-256 match) with SlimePython →
LANGUAGE category details → LANGUAGE service → Latest news →
★ LANGUAGE impact ★ DEVICE I/O included SlimeTree-VSAM / Storage
The moment migration ends,
the nightly batch stops finishing.
Even copied bit-exact via the black box, if the target is PostgreSQL the financial core's nightly window collapses. 19.5 hours for a billion records won't finish by morning.
480× vs PostgreSQL 16 on a same-host bench. Sequential cursor 480×, random 267×. A billion-record nightly batch goes 19.5h → 4.4 min. A direct answer to overnight-window collapse. Because the batch finishes, the next morning's accounts run.
A SHA-256 audit chain is built into the backend. Tamper detection works even air-gapped. Who did what, when — the trail stays intact, so when audit asks, you hand over that one binary and you're done.
You don't throw away PostgreSQL. Just set VSAM-compatible KSDS / ESDS / RRDS alongside it as a single Rust binary. The general-purpose DB stays as-is; only the batch routes to the VSAM side. So re-migration risk is zero. A simple record-body variant, a member of the Slime storage family.
Estimate how many minutes your batch takes → Reproduce the billion-record 4.4-min bench →
★ LANGUAGE impact ★ DEVICE I/O included
Once migration's done, storage is next.
Even after transporting bit-exact by embracing the black box, if the target is a general-purpose DB like PostgreSQL, many financial cores see the nightly-batch window collapse. SlimeTree-VSAM provides VSAM (KSDS / ESDS / RRDS)-compatible native storage as a single Rust binary — 480× faster than PostgreSQL on a same-host bench, with a built-in SHA-256 audit chain so tamper detection works even air-gapped. A simple record-body variant, a member of the Slime storage family.
Same-host bench, vs PostgreSQL 16 (random 267×).
A direct answer to the overnight-window collapse problem.
Built into the backend; runs air-gapped.
“A batch that starts at 9 pm and still isn't done by 4:30 pm the next day now finishes in the time it takes to brew a coffee.” 19.5h → 4.4 min lands not as a number but as a wall-clock time.
SlimeTree-VSAM details → Primary sources / white papers → LANGUAGE category →
③ Sovereignty — AI / RLM / AI
Cut, clamp, keep.
Borrow the intelligence if you like. But as long as you hold the “clamp” that ultimately validates the AI's output, sovereignty never leaves your hands. The clamp is 272KB, zero transmission, deterministic. Its 8 functions fold into these 3 verbs.
A fully in-house AI pipeline — self-contained with RLM + a local LM + LoRA; external AI is a gated exception (BYOK). The full picture of sovereignty →
① Cut — Cost / FinOps / AI
LLM cost, to 1/5.
Same intelligence.
Just wrap a 272KB clamp around the outside. It sorts questions: cheap model first → RLM re-judges → only the shortfall goes to the expensive model.
Meaning-driven routing minimizes external LLM calls.
Further cuts via 18 published Meta / X / Google routes.
Measured on a full cost-tier B run.
See the measured savings → The on-top savings numbers →
* Measured 60–80% reduction (meaning-driven routing D/µ/R + staged calls). This estimate uses the 80% upper bound. Amounts are a simple estimate of input × reduction rate and vary by model configuration and traffic.
SlimeTree-RLM — meaning-driven routing (internals)
Split questions into D / µ / R; use the expensive model minimally.
Machine-classifies questions into D (direct answer) / µ (decay) / R (residual) and minimizes external LLM calls. Every step carries a SHA-256 audit chain. Platform integration spans 18 published Meta / X / Google routes, with a full cost-tier B run and a measured 28% R ratio. “Cheap LLM first → RLM re-judges → only the shortfall to the expensive LLM” avoids wasteful high-cost calls.
SlimeTree-RLM details → Measured dashboard → DEVICE category →
② Clamp & keep — Frontline / Legal / Audit / AI
Lies, to 1/3. The evidence trail, 10 years on, in one second.
The weights are never touched, not one bit. Clamp with a table, keep with SHA-256.
Rows = requests, columns = rules. Say in plain language “overseas travel up to ¥300,000 with a director's approval” and the tool translates it to S-expressions (Gemma4). You never write Lisp. Standard cases up front; sudden non-standard ones can be added on the spot with no deploy, pinned by version for the audit trail. Pick from a template and issue via golden tests.
Same input → byte-for-byte identical. Each step is hash-chained with SHA-256; tampering is caught instantly and replayable. With weights unchanged, hallucination 66%→22% (σ4%, 100 questions ×3). Same meaning regardless of word order → the same judgment in Japanese, English, and Korean.
A single 272KB Rust binary; WASM-only, no server needed. Fully in-browser, zero transmission, runs even air-gapped. That's why sovereignty never leaves your hands.
Test whether it clamps your policy → In-browser demo: lies cut to 1/3 →
SlimeTree-RLM — meaning-driven record body (full capabilities)
Layer it orthogonally over your existing systems.
Layered orthogonally over LLMs / decision engines / business rules, it adds meaning-driven constraints and recording. Deterministic behavior; no server on browser / mobile / embedded. Usable from AI and non-AI alike.
SlimeTree-RLM details → Primary sources / white papers → RoleSlot live demo →
All 7 domains connect through one idea: determinism, bit-exactness, and sovereignty. The video platform for a different persona (media / surveillance) works the same flip way. The lead act is the core modernization above; this is one more piece of evidence extending sideways.
Video delivery — Cost / Experience / Adoption / Video
Just the video delivery cost — to one quarter.
Quality kept high.
Just drop it into your H.264 / AV1 pipeline. No changes to viewers' devices or your app. Verify 4K delivered over a single LTE line with your own video for 30 days.
Keeps quality at VMAF 83.25 while only the bill drops. No player or app swap, zero migration effort.
4K that never stalls on a single LTE line (VMAF 84.36). High detail only where people look, so it feels like 4K while cutting drop-off from load waits.
Just add a 544KB WASM, 41.79fps on 2 cores. Verified 4K@30fps on iPhone / Intel / AMD, no need to re-test every device.
* Measured transfer −74.3% (VMAF 83.25 maintained). Amounts are a simple estimate of input × measured ratio and vary by contract terms.
Pick by challenge
Cut delivery cost No stalls on mobile Support low-spec devices
A/B compare with your video → 30-day trial →
VIDEO · highlights (products / how it works)
4K, at 1.79 Mbps.
You can't tell the difference by eye anymore. A mechanism that concentrates bits only where the human eye looks (commutator norm), built straight into existing H.264 / AV1.
Browser decode: 41.79 fps with a 544 KB WASM, smooth 4K playback on just a 2-core CPU. Verified 4K 30 fps on real iPhone / Intel laptop / AMD desktop.
VIDEO category details → Toggle live demo → 30-day trial →
Patents pending: JP App. 2026-046898 / 046609 · Paper: submitted to IEEE TCSVT v8