every program compiles to prime-field arithmetic and produces a proof that binds the computation to its public result. one compiler, two proof runtimes: joy proves on nox with zheng, trisha proves on Triton 7. post-quantum, no trusted setup.
meet Trinity: AI · privacy · quantumThe 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.
$ tar xzf cyber-tools-*.tar.gz && export PATH="$PWD/cyber-tools/bin:$PATH"
then: trident build · run · prove · verify · audit · SHA-256 checksums · crates.io still carries 0.2 — the 0.3 toolchain ships as native archives
measured with the released 0.3.0 binaries on an Apple M4 Max, 2026-09-16
Trinity · research demo
Three frontiers of computing, expressed in the same algebra. Trinity brings neural inference, encryption arithmetic and a simulated quantum circuit into one Trident program. Their calculations share a finite field and can be checked in one proof trace.
Today's milestone: an arithmetic demonstration, checked against independent reference fixtures on Triton. Secure FHE and private inference remain research goals; the quantum stage is a simulation.
program hello_proof fn main() -> Field { let a: Field = divine() let b: Field = divine() a + b }
a proof that a + b = 20 without revealing a or b. secret inputs select the private mode: the checker is derived from the same zheng relation and proved with a randomized Triton 7 STARK, so private columns never enter the artifact.
$ trident build hello.tri --costs Compiled -> hello.nox reductions: 32..=96 (branch-dependent) $ trident prove hello.tri --secret 7,13 Proved private execution (Triton ZK) in 1621 ms: 32 reductions, 817612 bytes Output: [20] $ trident verify hello.zheng Verification: PASS (private execution; Triton ZK) public input: [] · public output: [20] · reductions: 32 $ trident prove pub.tri --input-values 7,13 Proved public execution in 3 ms: 26 reductions, 2219 bytes $ trident prove hello.tri --target triton --secret 7,13 Proof generated (9 cycles) · 29 ms · trisha, Triton 7 STARK
the cost report before you run equals the reduction count after. the verifier checks the proof against the statement — program, inputs, selected path, output — and never re-executes.
the default on nox. joy derives the zheng relation from the canonical program and checks every constraint, the complete public input/output and the selected-path cost. transparent — the witness is disclosed — and linear in size and verification work.
3 ms · 2.2 KB · verify 30 ms--secret inputs stay with the prover. the same relation becomes a checker proved by trisha's randomized Triton 7 STARK. the artifact carries statement, proof and formula — nothing that reveals a private column.
each public lookup binds its namespace, index, returned value and the complete state root from bbg. private queries hide the selected coordinates inside the proved relation over bounded public tables.
state commitment v2 · opening v3neither mode can silently fall back to a legacy statement or a different checker. earlier trace statements are no longer accepted as proof of execution or output — they require an explicit inspection opt-in and are labelled as such.
module safe_add #[requires(x == 3)] #[ensures(result == 4)] pub fn bump(x: Field) -> Field { x + 1 }
bounded loops, no recursion, finite fields — verification is decidable. obligations are isolated by function and variable identity.
$ trident audit safe_add.tri --z3 bump: SAFE (1 obligations) · 70 ms $ trident audit safe_add.tri # no solver installed bump: UNKNOWN (1 obligations) $ trident audit bad.tri --z3 # ensures(result == 5) bump: UNSAFE (1 obligations)
a counterexample or a solver error fails the check. incomplete analysis reports UNKNOWN. a partial pass is never presented as evidence that the whole program is correct.
trident 0.3.0, trisha 0.3.0 and joy 0.5.0 are one coordinated release on compiler API 3. the full notes are on github; the shape of it:
Bool/U32 ranges — inside proofs too.SAFE · UNSAFE · UNKNOWN, as above.source → typed IR → nox formula with a static cost report. build · check · fmt · test · audit · hash · equiv · package; run · prove · verify delegate to the warrior that owns the target.
executes the formula on nox, proves with zheng, verifies without re-execution. public certificates, private proofs, authenticated bbg state.
typed IR → TASM, CPU execution, native and recursive Triton 7 STARK proofs, Neptune SDK and the validated transaction flow. also the private-mode checker behind joy.
diagnostics, types and hashes in your editor. a tree-sitter grammar is generated from the same Rust grammar definition the compiler uses.
receipts bind validation to the released source and binary hashes: validation summary · logs, receipts, proof corpora · SHA256SUMS · native builds · cross-platform verification · source commit 531e93c
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 (a hash is 24
Poseidon2 rounds + 1 squeeze row; the Merkle path 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, the warrior's own report on a stack target — statically.
annotate #[requires] / #[ensures], run trident audit — obligations per function, counterexamples fail, incomplete analysis says so.
every function's identity is the hash of its normalized AST. names are metadata; certificates travel with the hash, not the name. trident equiv checks two functions mean the same thing.
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, and 0.3 binds the complete inner claim — program, public input, public output. any chain of transactions collapses into a single check of the statement you asked for.
a trident program is written once against field elements;
the target is a config, not a rewrite. 21 engines are
declared in the catalog; the compiler resolves a target
once, and only an installed owner can authorize
compilation. trident build --target <engine>
picks one; a catalog entry does not provide a backend or a
working deployment.
nox (default · reference compiler in trident · zheng via joy · Goldilocks) ·
triton (Triton adapter in trisha · Triton 7 STARK) ·
neptune (triton + trisha's Neptune SDK and transaction policy)
miden · sp1 · openvm · cairo · risczero · jolt ·
aztec · avm (Aleo) · evm · wasm · sbpf (Solana) ·
movevm · polkavm · ckb · tvm (TON) ·
nock (Nockchain) · arm64 · x86-64 · riscv
— an absent or incompatible owner fails rather than falling back to a stale machine literal
above the engines sit 25 unions — the operating systems and chains a
program can be deployed into, each binding an engine:
neptune (trisha-owned SDK and validated transaction flow, 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. silicon — an
in-repo, unpublished crate at
trident/silicon — turns the very formula joy
proves into native code for 25 backends: every one
below emits real output for hello.nox.
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, one warrior per machine — which is exactly the shape
0.3 gave trisha.
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
authenticated openings. one algebra (strata), one hash
(hemera), one field, from source to proof.
Neptune Cash —
--target triton / neptune. the
blockchain with recursive STARK proofs in production.
trisha
owns the bindings: proposed coin and card standards, lock
and type scripts are written in trident, compile to TASM,
prove on Triton 7, and a compiled lock becomes a validated
SingleProof transaction intent. admission was checked
against an isolated pinned Neptune node — not claimed as a
public-network confirmation.
scope, honestly. this is the default CPU release.
public certificates are transparent and linear. private
proofs cover the documented bounded relation; private
query coordinates do not make the database private. full
GPU proving, dynamic nox continuations, variable branch
shapes and live node/database integration are separate
work. Z3 is an optional install for
trident audit --z3.