every program compiles to prime-field arithmetic and produces a proof — zheng on nox by default, STARK on Triton — post-quantum, no trusted setup.
The weapon is their language. They gave it all to us. If you learn it, when you really learn it, you begin to perceive time the way that they do. So you can see what's to come.
$ cargo install trident-lang cyber-joy
the compiler + joy, the nox warrior · then: trident build · run · prove · verify · audit · bench
program hello_proof fn main() -> Field { let a: Field = divine() let b: Field = divine() a + b }
a cryptographic proof that a + b = 20 without revealing a or b.
$ trident build hello.tri Compiled -> hello.nox $ trident prove hello.tri --secret 7,13 Proved in 8 ms: 17 reductions, 1387 bytes $ trident verify hello.zheng Verification: PASS (zheng proof) · output: [20] $ trident audit transfer.tri All 3 properties verified (0.2s) No counterexample exists for any input
bounded loops, no recursion, finite fields — verification is decidable, so audit proves correctness automatically.
provable VMs are not CPUs. the machine word is a field element, not a byte — Rust compiled to RISC-V wraps every field operation in byte-level emulation. trident's word is the field element itself. on nox, the default target, a program is a formula over 18 reduction patterns: every field operation is one reduction, the execution trace is the zheng witness, and the cost report before you run equals the reduction count after. on Triton VM the same source compiles to TASM, and the gap to byte-emulating zkVMs is not marginal:
| operation | trident on nox (default) | trident on Triton VM | Rust on SP1 | Rust on RISC Zero |
|---|---|---|---|---|
| one hash (Poseidon2 / Tip5 / SHA-256) | 25 reductions | 1 cycle | ~3,000 | ~1,000 |
| Merkle path (depth 32) | 1,906 reductions (825 in hashes) | ~100 cycles | ~96,000 | ~32,000 |
units are the machine's own: a nox reduction is one
trace row — one CCS step the prover folds — so the number
is the proving bill (a hash is 24 Poseidon2 rounds +
1 squeeze row, and the Merkle path above is 33 of them plus
limb plumbing); a Triton cycle is one instruction across
six tables. both are exact and static, from
trident build --costs. the zkVM columns are
cycle counts of RISC-V code emulating field arithmetic.
Field · Digest · XField map directly to what the VM computes. costs are known before you run: trident build --costs bills reductions on nox, instructions on Triton — statically.
annotate #[requires] / #[ensures], run trident audit — the compiler proves correctness for every input in Field. no manual proof construction.
every function's identity is the hash of its normalized AST. names are metadata; certificates travel with the hash, not the name.
the compiler self-hosts and emits a proof that compilation was faithful. Ken Thompson's 1984 backdoor dies here — not audited, proven.
one lookup table over Goldilocks reads four ways: hash S-box, neural activation, FHE bootstrap, STARK lookup. quantum · privacy · AI — one field.
a proof verifies another proof inside itself. any chain of transactions collapses into a single cryptographic check.
a trident program is written once against field elements;
the target is a config, not a rewrite. 21 engines are
declared in vm/, each at an honest integration
level — declared → documented → lowering → costed → tested.
trident build --target <engine> picks one.
nox (default · zheng via joy · Goldilocks) ·
triton (Triton VM · STARK via trisha) ·
miden (Miden VM · Goldilocks)
sp1 (Mersenne31) · openvm · cairo (Starknet field)
arm64 · x86-64 · riscv (native) · nock (Nockchain)
risczero · jolt · aztec · avm (Aleo) ·
evm · wasm · sbpf (Solana) ·
movevm · polkavm · ckb · tvm (TON)
above the engines sit 25 unions — the operating systems and chains a
program can be deployed into, each binding an engine:
neptune (bound: runtime bindings in trident, on triton) ·
linux macos android browser wasi
on native and wasm engines ·
ethereum arbitrum solana polkadot ton
near cosmwasm icp sui aptos
starknet aztec aleo miden nervos
nockchain succinct boundless openvm-network
— declared and documented, awaiting bindings. the honest map is
reference/targets.md.
a nox formula is a tree over 18 patterns — small enough to
hand-emit for any machine. trident compile -t
<backend> turns the very formula joy proves into
native code for 28 backends: every one below emitted
real output for hello.nox today. honest scope:
the emitters cover the atom-level patterns (axis, quote,
branch, field arithmetic, bitwise) — programs using
hash, divine, structs or state
reads are refused with UnsupportedPattern —
and they emit code, not traces: execution and proving on
this hardware are not wired. the point is that one program
already speaks to all of it; making it run and prove there
is the next tier.
x86-64 arm64 (JIT) rv64 rv32 (ESP32) rvv (RISC-V vector) thumb2 (Cortex-M · STM32 · RP2040) hexagon (Qualcomm DSP)
ptx (CUDA) tensor-cores (wmma) wgsl (WebGPU) spirv (Vulkan)
ane (Apple Neural Engine) amx (Apple matrix) intel-amx xla (TPU) onnx cerebras (wafer-scale CSL) upmem (processing-in-memory)
ebpf (Linux kernel) wasm (browser · WASI · every wasm chain)
qasm (OpenQASM 3.0 circuits) qir (Quantum IR · Azure Quantum)
verilog (FPGA) systemverilog (ASIC) vhdl
soft3 — the default.
trident build emits a nox formula; the
joy warrior
executes it on nox,
proves it with zheng
(SuperSpartan + Brakedown + HyperNova folding — hash-based,
post-quantum, no trusted setup), reads state from
bbg with
proofs. one algebra (strata), one hash (hemera), one
field, from source to proof.
Neptune Cash —
--target triton. the only blockchain with
recursive STARK proofs in production.
trident is its native language, targeting
Triton VM: fungible
tokens, cards, locks and type scripts are specified in
trident, compile to TASM today, and pass tests. the
architecture expands targets over time without changing what
a trident program is.