The physics virtual machine
Zeq is a physics virtual machine. Real physical laws are the instruction set — you compute against 1,612 operators across 67 domains, from quantum to classical to relativistic, on one computational surface with no translation layer between regimes. Every computation is synchronized to the 1.287 Hz HulyaPulse — one tick is one Zeqond (0.777 s) — and resolved to ≤0.1% precision. And because the whole surface is deterministic and clock-locked, a result comes back byte-identical across every node and carries a proof any node re-verifies: physics you can reproduce and check, not a floating-point number you have to trust.
It's physics infrastructure, not an AI product. AI is one consumer of it — through the harness, an MCP surface, and a kernel skill — but the substrate underneath is synchronized, verifiable physics.
Physics-native, on one clock
One surface, every regime
Quantum, classical, and relativistic physics on a single computational surface — 1,612 operators, no translation layer between regimes.
Synchronized to 1.287 Hz
Every computation runs on the HulyaPulse — one tick is one Zeqond (0.777 s) — so all of physics shares a single, exact time base.
Deterministic & provable
Byte-identical across every node, resolved to ≤0.1%, with a ZeqProof on every result — reproducible physics, not floating-point drift you must trust.
Compute something real, right now
No signup. Mint a free key and derive the Schwarzschild radius of the Sun — from r_s = 2GM/c²,
not a lookup:
ZEQ_KEY=$(curl -sX POST https://zeqsdk.com/api/demo-key/mint | jq -r .key)
curl -sX POST https://zeqsdk.com/api/zeq/compute \
-H "Authorization: Bearer $ZEQ_KEY" -H "Content-Type: application/json" \
-d '{"operators":["KO42","GR37"],"inputs":{"mass":1.98892e30}}'
# → 2954.0077 m — with the equation, the bound constants, an uncertainty, and a signed proof
Swap the operator and you have a different science: MED_BMI {mass:70,height:1.75} → 22.857
kg/m² · BLACK_SCHOLES {S:100,K:100,r:0.05,T:1,sigma:0.2} → 10.4506 · KEPLER_THIRD
{a:1.496e11,M:1.989e30} → ≈ 1 year. Watch the clock itself live:
GET https://zeqsdk.com/api/zeq/pulse (public).
Want to see exactly how that number is produced on the CPU — no black box? Follow one real request step by step in the execution model.
Three primitives
The machine
Your computational backend — keys, hash-linked state, the audit chain. Everything else is built on it.
Contracts
Deployable logic that lives inside the machine and runs on its clock: states, transitions, operators, proofs.
Channels
Hosted pages and apps built on a machine, computing through a key-free proxy.
Operators — the vocabulary
Every compute names the operators it runs, every contract names the operator each transition fires, every audit row names the operator it proves. The catalogue is 1,612 operators across 67 categories — quantum, relativity, fluid dynamics, condensed matter, finance, signal processing, and more — each a named, standard formula the engine evaluates for real:
| Operator | Is | A call returns |
|---|---|---|
NM19 | F = ma | {m:10,a:3} → 30 N |
GR37 | r_s = 2GM/c² | {mass:1.99e30} → 2954 m |
QM9 | de Broglie λ = h/p | {m:9.109e-31,v:1e6} → 7.27×10⁻¹⁰ m |
CMP4 | conductivity σ = neμ | {n:1e23,mu:0.1} → 1602 S/m |
An unknown operator ID is refused (UNKNOWN_OPERATOR), never faked — the registry is the
type. Browse the whole catalogue in the operator reference, each category
labelled with how it computes (dedicated closed form vs the transparent ODE fallback).
State contracts — logic you can execute
A state contract turns operators into running logic: named states, transitions that fire operators under conditions, and a ZeqProof per proof-required fire — all on the machine's audit chain. 316 templates ship ready-made across 45 categories. Deploy one, fire it, watch it:
# deploy a force-threshold watchdog (NM19 on every reading) into your machine
… "name":"zeq_contract_deploy", "arguments":{"templateId":"force-threshold-alarm"}
# fire a transition — it lands on your audit chain, clock-stamped
… "name":"zeq_contract_fire", "arguments":{"id":"CONTRACT_ID","input":{}}
The full walkthrough — verified end to end against a live node — is in Deploy your first contract; the mechanics are in anatomy and the lifecycle.
Why you can trust a result
Zeq's doctrine is never say "trust me." Every compute returns a signed
envelope carrying a ZeqProof (HMAC(operator | result | zeqond)); any
node can re-verify it. Private machine histories are made tamper-resistant by a
Proof-of-Elapsed-Zeqonds seal spine — rewriting the past costs
real sequential time. And the honesty contract means the machine
computes, asks for what it needs, or refuses — it never fabricates.
Applications built on Zeq
Real apps, running on machines, computing through the same surface these docs describe:
Entangled-State Explorer
Browse any public machine's hash-linked audit chain, transition by transition.
Observer
Watch a machine's state and every recorded transition live, as it ticks.
Contract IDE
Author, dry-run, and deploy state contracts in the browser.
Physics Wizard
The operators as a game — compose them and see real physics resolve.
Zeq Compress
Compression framed in the kernel's own operators.
HITE Encryption
The framework's own encryption surface, in the browser.
Zeq Mail
Encrypted mail on a machine — the audit chain as the record.
Zeq CLI
The command core, running in your browser — the same one the binary ships.
Lattice Globe
The node fleet on a globe — the lattice, visualised.
More, all live: ZeqSSL, ZSP, BYOK, Audit Daemon, Skills, TESC, Message, Edge. See the full applications gallery.
Explore the docs
Learn the maths
How it computes, from first principles.
Build
From first compute to a hosted app.
Trust & operate
Why results hold, and how the fleet runs.
Everything on this site is generated from or verified against the live system — the endpoint reference from the node's own route registry, the operators from the live registry, and every worked example prints a number you can reproduce with the exact command shown. If a page fails that bar, it's a bug.