The universe computes physics equations.
We built the compiler.
One computational surface for physics, built on a time base all its own — the 1.287 Hz HulyaPulse and the 0.777 s Zeqond. Select, compose, and compute the known equations from quantum to relativity; every result phase-locked to the pulse, signed, and re-derivable by anyone.
Add real-world, highly accurate physics to your research, software, apps, games, and AI agents with a single HTTP request. Free tokens a day, forever.
Search the framework
⌕Search 1,597 operators, 316 state contracts, API, docs…Run it from the CLI
→ 49.05 N · signed · zeqond 2293953964
$ _
Start in three steps
Pick your language
One command, under 80 Zeqonds.
npm config set @zeq:registry https://zeqsdk.com/registry
npm install @zeq/sdk
Hello, Zeq
Your first verified computation.
import { ZeqClient } from "@zeq/sdk";
const zeq = new ZeqClient();
const r = await zeq.compute({
domain: "Classical Mechanics",
inputs: { m: 5, a: 9.81 },
});
console.log(r.value, r.unit); // 49.05 N
Your state machine
Mint your ZID, keys, balance + page.
curl -fsSL https://zeqsdk.com/install.sh | sh
zeq signup "four memorable words"
# → account equation + machine + zeq_ak_ key
Install · Hello, Zeq · Spin up your machine · How Zeq computes
Two ways to compute
compute() — exact, textbook physics. One operator, closed form, CODATA constants. F = ma, a Schwarzschild radius, a plasma frequency: the standard result, phase-stamped and signed, independently re-derivable by anyone. This is the accurate-physics path.
solve() — an evolving, multi-force problem. Some problems aren't a single number — they're a system changing over time under several forces at once. solve() integrates the framework's master equation (a nonlinear field, evolved on the shared clock, energy conserved to ≤0.1%) with the operators you choose driving it. A free body under gravity, drag and a restoring force is one evolving solve, not three separate calls — the math lives in the SDK, the master equation →:
import { ZeqClient } from "@zeq/sdk";
const zeq = new ZeqClient({ apiKey: process.env.ZEQ_API_KEY });
const r = await zeq.solve({
prompt: "free body: gravity + drag + restoring",
mass: 5, location: "earth", medium: "air",
koSettings: { NM19: 1.0, NM21: 1.0, NM30: 0.5 },
tMax: 5, dt: 0.01,
});
console.log(r.ckoId, r.masterEquationTerms.operatorCoupling);
// CKO_1782399365156 -15.2263
operatorCoupling is the value of that φc²·Σ w_k C_k(ϕ) coupling term — it moves as you add or reweight operators. Swap solve for multibody and every body evolves on the same clock (the Sun–Earth–Moon three-body setup runs exactly this way).
Explore the framework
Understand the framework
The full explanation, folded for readability
What Zeq is — one surface for physics
Zeq's foundation is its time base — the 1.287 Hz HulyaPulse and the 0.777-second Zeqond. This is the framework's signature: a single computational clock, defined exactly (τ = 777,000,777 ns, so f·τ = 1 exactly), that everything runs on. Every operator is evaluated on it, every result is phase-stamped to it, every state transition is Zeqond-stamped by it. No other system computes on a shared proper-time base like this — it is the constant the whole framework is built on.
On that foundation, Zeq is one computational surface for physics — a methodology for selecting, composing, and computing the known equations, from Schrödinger to Einstein, as sibling operators. Quantum mechanics, Newtonian mechanics, general relativity and computer science sit side by side: Schrödinger next to Newton, the Dirac equation next to KE = ½mv², Big-O next to the Friedmann cosmology equation — one surface, no translation layer. It does not introduce new physical laws — but when it combines equations on the shared clock, it produces genuinely new composite mathematics: solves that exist as no single textbook formula.
It returns its work: the response carries the equations it used alongside the number — the operators selected, the master-equation register, the constants bound. It is client-agnostic: the same calls from any client, bit-identical, re-derivable offline by anyone, no account, no secrets. ZeqVM runs it; its instruction set is the operator catalogue, and a state machine is your instance of the VM, bound to your ZID.
State Contracts — what replaced protocols
A state contract is deployable JSON logic bound to your state machine, fired on triggers — every Zeqond, cron, on-event, on-aggregate, dry-run, replay. All 230 named protocols are now shipped as deployable state contracts (316 templates in all): instead of a static formula bundle, you deploy, version, and fire real logic that writes Zeqond-stamped rows to your entangled state, each carrying a ZeqProof. This is the framework's primary build primitive — the thing you compose to ship a real system, from an emergency-triage pipeline to a drug-interaction checker to a physics-backed game loop. Contracts are authored in the four-surface workbench (LEARN · SKILL · PLAN · BUILD), validated by the compliance gate, then deployed to your machine. Browse state contracts →
The time base — Zeq's defining constant (1.287 Hz · 0.777 s)
The time base is the framework's signature. ZeqVM runs on one clock: the HulyaPulse at f = 1.287 Hz, ticking once per Zeqond (τ = 0.777 s, the defined constant 777,000,777 ns). The tick and phase are exact integer arithmetic on the clock — zeqond = floor(unix_ms / 777), phase = (unix_ms mod 777)/777 — computed, never received: no time-server, no consensus round, so two nodes that never talk still agree on the tick, and there's no drift to accumulate. This shared time base is what lets operators from different regimes compose and what every result is phase-locked and signed against. Unix time isn't replaced — it's bridged losslessly. The HulyaPulse and Zeqond →
How it works — four moves
Every framework feature is reachable from one of four moves. Spin up: register an equation-derived ZID; the framework mints your machine, two API keys (zeq_ak_* to build with, zsm_* for devices), a balance, and your /s/<machine>/ page. Compose: open the four-surface workbench — LEARN (kernel-aware Q&A), SKILL (pick or generate a skill), PLAN (spec + state contracts), BUILD (emit the page). Deploy: the compliance gate validates the output, then publishes. Observe: drop observers into devices (Web JS, Python, Embedded C, network tap), call POST /api/zeq/compute, and watch transitions land on your entangled state — every receipt independently verify-able by a third party with no key.
State machines — your hash-linked backend
A state machine is your instance of ZeqVM — one user, one machine. It holds an owner ZID and public machine ID; an entangled state (the hash-linked, Zeqond-stamped audit log, every transition linked to the previous, tamper-evident); your two API keys; a balance in ZEQ with daily Promo Credits and a tier-aware burn rate; a page surface at /s/<machine>/; your state contracts; and a regulatory envelope returned on every compute call (13 standards via ZeqCompliance v1). The entangled state is your machine — it's how the math tells the truth. State machines →
Operators — the catalogue of the language
Operators are the verbs. 1,500+ catalogued across 64 domains: quantum (QM1–QM17), Newtonian (NM18–NM30), general relativity (GR31–GR41), computer science (CS43+), plus resonance and a frontier research surface (information, complexity, neural dynamics — some are established equations like Landauer's principle and Shannon entropy). Every computation carries the KO42 modulation and the HulyaPulse phase stamp. The frontier family is a research surface, distinct from the standard physics compute path. Browse all operators →
Verification & proof — trust nothing, verify everything
Every result comes back in a CKO envelope carrying the operator chain, the master sum, R(t), phase, the Zeqond it ran at, a ZeqProof (HMAC(operator | result | zeqond)), and the precision bound. The proof is Ed25519-signed and any third party can re-derive the result offline — no account, no secrets, no trust required. Open any tick on the State Observer and the generated equation for that exact computation is printed at the top. The math is the artifact, not a hidden implementation detail. Verification envelope →
Why Zeq
One time base
The 1.287 Hz HulyaPulse — Zeq's defining constant. Quantum to relativity on one clock, no two-runtimes problem.
Verifiable
Every result Ed25519-signed and re-derivable offline by anyone.
Transparent
Send a problem; get the equations it used back, not just a number.
Agnostic
Same language from any client — bit-identical, registry-versioned.
If you want to understand what kind of computation this is before you build on it — the kernel every response announces, how the solvers turn an operator into a physical answer, and the computed clock that lets any node verify any other — read How Zeq computes.