[ f=1.287 Hz ]

[ τ=0.777s Zeqond ]

FOUNDATION STATE MACHINE · FOUNDATION · — TICKS SINCE GENESIS · 1.287 HZ LIVE · OPEN OBSERVER ↗

✓ ENERGY CONSERVED
f=1.287 Hz · τ=Zeqond · 10⁻⁴ numeric bound

HULYAS.
The foundation behind the framework.

The foundation that keeps the Zeq framework's mathematics open, correct, and public.

HULYAS keeps the mathematics at the centre of Zeq — HULYAS math, the kinematic spectrum of 42+ kinematic operators, and KO42 for universal phase-locking — all running on a discovered 1.287 Hz timebase. It is a mathematics that checks its own work: it measures itself, proves itself, and tightens until error collapses below 0.1%.

It was engineered by a father-and-son team, published openly, and it exists as real, running software. HULYAS operates today as Zeq OS 1.287 Hz Limited and is becoming a community-backed organisation — so the work stays answerable to the people who build on it, funded by subscriptions that pay for its advancement.

New here? HULYAS is the steward, not the product — Zeq runs on the nodes; this is who protects it and keeps it public. Watch the waves fall into phase on the pulse below, then read the story and the papers.

Continue Read the docs Zeq Store
HULYAS, in full — the people, the discovery, the mathematics, the papers, and where it's going

HULYAS is the organisation that looks after the Zeq mathematical framework. Not the code that runs on the nodes, and not any single machine — HULYAS is the steward: the body responsible for keeping the mathematics correct, public, and free to build on. This is the long version — who built it, what was discovered, the mathematics at its centre, the papers it is published in, and the community-backed organisation it is becoming.

A father-and-son team

The framework was built by a father-and-son team: Mohammed Ali Hammoudeh Zeq and his son Aydan Zeq (21, a Computer Science graduate). The founder spent more than two decades at the intersection of signal analysis and software architecture — an RF engineer who learned early that “every signal has a carrier frequency beneath the static.” The turning point was a conversation about dark matter with Aydan; it reframed the question, and the two of them followed it all the way to a new computational timebase. HULYAS exists to protect that work and keep it open.

From radio static to a computational timebase

The path was empirical, not abstract. Years of RF engineering and a decade of software — including Ænomaly (2019), a search engine that let teachers and educators build curated, trusted knowledge for students — produced a set of proprietary pattern-recognition algorithms for finding subtle signals hidden in noisy, complex systems. Pointed at the universe's own data, that same forensic approach surfaced a single, precise rhythm: 1.287 Hz.

Not a claim — a working timebase

This is the part to be precise about. HULYAS is not arguing a hypothesis about a frequency that might be “out there” in nature. The founders discovered and engineered a precise computational timebase — 1.287 Hz, the HulyaPulse, with a 0.777-second Zeqond — and built a working system that runs on it. As an engineering timebase it is the “Goldilocks zone”: the shared clock rate at which otherwise-disconnected physics domains — quantum, classical, relativistic — couple and stay phase-synchronized during computation. It does not modify any physical law; standard physics is recovered exactly by averaging over one Zeqond. It is backwards-compatible and it runs — a shared proper-time clock across physics domains that did not exist before Zeq.

The mathematics: HULYAS math and the kinematic spectrum

From the timebase grew a whole mathematics. HULYAS math is the language; the kinematic spectrum is its table of 42+ kinematic operators spanning quantum mechanics through relativity; and KO42 is the operator for universal phase-locking that ties them to the pulse. It is built to be self-checking — it measures itself, proves itself, and tightens until error collapses below 0.1% — so results come from execution and verification, not argument.

What the timebase makes possible

Because it is real and running, the timebase is a foundation to build on, not a paper to debate. It drops in as a universal timing layer — the mechanism that keeps quantum-scale, classical, and relativistic models in step inside one computation — and it is the base clock of the Zeq state machine and every application built on it. That is the whole point of HULYAS: this working timebase, together with HULYAS math and its operators, is what makes it possible to build genuinely new technology and, with it, the next evolution of mathematics.

The papers

Everything is published openly under CC BY 4.0 — “knowledge belongs to humanity.” In their first year the framework's papers have together been downloaded over 5,000 times. The foundational write-ups are on Zenodo: Zeq — Evolution of Mathematics (HULYAS math, the kinematic operators, the 1.287 Hz HulyaPulse and the 0.777s Zeqond) and Zeq: Universal Proper-Time Modulation — the Zeq Equation, R(t) = S(t)[1 + α sin(2πft + φ₀)], which synchronizes physics across quantum, classical and relativistic domains without changing a single law. You don't have to take our word for any of it — read them, run them, and watch what happens.

Open science, kept in the open

HULYAS exists to keep the framework legible, reproducible, and public — papers on Zenodo, code in public repositories, live nodes anyone can watch and verify in real time. Open science here is not a slogan; it is the operating principle the organisation is built to defend, so the mathematics never becomes a private black box.

Zeq OS 1.287 Hz Limited — the entity today

As of now, the foundation operates as Zeq OS 1.287 Hz Limited — the legal entity that currently holds the work, publishes the papers, and maintains the code and live infrastructure. It is the practical vehicle that lets the framework exist as real, running software while its longer-term governance is put in place.

Becoming a community-backed organisation

The intended direction is clear: in the near future the structure changes, and HULYAS becomes a community-backed organisation — governed by the people who build on and use the framework, rather than by a single owner. A mathematical framework that people rely on should not depend on any one person continuing to steer it; community backing is how the openness is made permanent.

How the work is funded

The model is simple: subscriptions to the framework pay for the advancement of the mathematics. What comes in goes back into research, maintenance, and the infrastructure that keeps the framework alive, correct, and free to read — funding the science in the open rather than locking it behind a paywall.

Why a foundation at all

Frameworks that matter need a keeper. Left to a single company, open science can quietly close; left to no one, it can rot. A foundation — especially a community-backed one — is the structure that keeps a body of mathematics correct, public, and answerable over the long run. That is the whole reason HULYAS exists: to make sure the framework outlives any one owner and stays open for everyone.

integrator · 1.287 Hz PULSE ON 
// running ON the 1.287 Hz pulse
const dt = τ/60;  // pulse: ON  ✓
for (let i=0; i < bodies.length; i++) {
  b.v += a[i] * dt;
  b.x += b.v * dt;
}
✓ on course  |  ΔE/E₀ < 0.001
step 2 · how you'll talk to your state machine

Two ways
to drive it.

The state machine is itself a mathematical language — it doesn't need AI to run. The optional Pulse (Mathematical Intelligence) is laid on top of an LLM as a translator: it turns Plain English into Zeq contracts. The LLM never computes the math. The kernel does. The entangled state proves it. Pick the surface that suits you — switch any time.

Mathematical Intelligence vs Root — the LLM is a translator, not a calculator

This is the part most people get wrong about Zeq. The state machine is itself a mathematical language. The kernel runs real equations at sub-percent precision — quantum mechanics, general relativity, fluid dynamics, orbital mechanics, the lot. None of that needs an LLM. The state machine doesn't run on AI; it runs on math. AI is an optional surface laid on top of the kernel, only there to help you describe what contracts you want. The math always runs on the server, on the state machine. The LLM never touches the answer.

What we mean by "Mathematical Intelligence" (MI)

Standard AI is a language model that guesses the next token. It hallucinates because it has no ground truth — only statistical patterns over text. Mathematical Intelligence is what you get when you put a kinematic-spectrum kernel under a language model: the LLM proposes a contract in human terms ("simulate three planets in mutual orbit"), the kernel verifies the math actually works, picks the right operators, binds the real constants, runs the equations, issues a ZeqProof. Whatever the LLM produces gets checked against physics before any byte hits your screen. The result is an agent that can't lie about a number — the kernel won't let it. That's MI: AI that's been physics-grounded by a state machine.

The LLM is a translator. The kernel is the calculator. The entangled state is the receipt.

Pulse — Mathematical Intelligence on top of an LLM

Pulse mode gives you a chat surface where you describe contracts in Plain English (or any language) and the system turns your words into Zeq contracts. Two ways to power the LLM underneath:

Option A · Free limited model from us

Sign in and you get a free quota of contract translations on a model we host. It's rate-limited and capped per day, but it's free, it's instant, and it requires no setup. Good for trying the framework, prototyping a couple of contracts, getting the feel. The translations are always shown to you before they fire, and the math still runs on your kernel — the model only decides what contract to write, never what the answer is.

Option B · Bring your own API key (BYOK)

Paste an API key from a provider you already pay for — OpenAI, Anthropic, Fireworks, DeepSeek, Cerebras, Together, Groq, or any OpenAI-compatible endpoint. Your key is encrypted with HITE (AES-256-GCM under KO42) and stored against your state machine. From that point Pulse calls your account, on your tier, with your model of choice. The framework never sees the cleartext key, and you can revoke or rotate it at any tick. This unlocks longer contexts, smarter translations, vision input — whatever your provider gives you. Same kernel, same math, smarter translator.

What the LLM never does: the LLM never computes a physics value. It cannot output a number that wasn't produced by the kernel. If a contract requires R(t) at zeqond N, the kernel runs it; the LLM is told the result and weaves it into the prose. There is no path where an LLM hallucination can become an entangled state entry — the seven-step wizard rejects anything not produced by the operators.

Root — pure mathematical language, no AI in the loop

The state machine doesn't need an LLM at all. Root (the CLI) is a web terminal where you type contracts directly — zeq.compute(KO42, ψ), zeq.bind(QM5, …), zeq.pulse(), zeq.verify(proofDigest), zeq.shift(τ * 100), the entire SDK surface. The kernel ticks them through the same seven-step pipeline as the Pulse path, but with no model, no translator, no quota, no provider — just you, the math, and the entangled state. Best when you know the operator names, you're scripting reproducible work, you want zero latency, or you're paranoid about ever having an LLM in your stack.

Switch any time

The pick on this step is your first-touch preference, not a commitment. After step 7, every page on your state machine carries a Pulse at the bottom-right with a tiny ⌘ CLI toggle. Talk through a problem, drop into CLI to verify a proof digest, flip back. Contracts written one way are visible the other way. The kernel doesn't care which mouth you use — it computes the same way for both, on every Zeqond.

step 2 / 4continue↓
step 3 · your identity

Your equation
is your key.

No email. No password. No recovery questions. Type a few words — the kernel runs the 7-step wizard against the 1.287 Hz pulse and mints an equation that's only yours. You remember it; we never store it. That equation unlocks your state machine on any device.

Why an equation is your identity — sovereign, irrecoverable, mathematically yours

A password is a string a server compares to its database. A Zeq equation is a unique state-vector generated from your query, the current zeqond, the kernel's HMAC seed, and the kinematic operators selected for that exact moment in time. The server never sees the cleartext. The framework never stores the cleartext. Even an attacker who somehow obtained both your query and the precise zeqond you registered at would still need the framework's ZEQ_NODE_SECRET to reproduce the operator set you got. That is what makes an equation an identity: it's mathematically derived from your intent and the moment and the kernel — three independent factors no attacker controls all of.

Query-driven — minimum four meaningful tokens

The wizard rejects two-word inputs. Stop-words ("the", "of", "a", "and") are stripped before counting; tokens shorter than three characters are stripped. What remains must be at least four distinct meaningful words. This is non-negotiable: the equation's strength comes from the entropy of the query, and "my orbit" or "test password" cannot anchor a sovereign identity. The chip suggestions on this step are intentionally five and six tokens long — physics, materials science, quantum mechanics, oceanography phrases — so you have a starting palette that already meets the floor. Edit them, extend them, write your own. The longer and more specific your query, the more entropy and the harder to guess.

Phase-locked — bound to the exact zeqond

Every request to /api/zeq/wizard/auth-bootstrap is HMAC-bound to its zeqond. The seed is HMAC-SHA256(ZEQ_NODE_SECRET, "zeq.seed.v1|" + zeqond + "|" + queryHash), sliced to 16 bytes. The seed is fed into the operator selector, which scores all 1,500+ catalogued operators in the catalogue — token-driven semantic match plus a per-request jitter derived from the seed — and picks the top six, with one wildcard pulled from a non-matching domain to guarantee multi-domain synthesis. The same query at zeqond N and zeqond N+1 produces different operator sets and different modulated R(t) values, because the sine term in R(t) = S(t) · [1 + α · sin(2π·1.287·t)] has visibly shifted by 0.777 seconds. Two snapshots of the same query, even one beat apart, do not yield the same equation.

Zero-knowledge — the server never sees the equation

The client computes HMAC-SHA256(equation, salt) and POSTs only { equation_hash, equation_salt, display_name }. The cleartext equation never crosses the wire. The framework's database stores the HMAC and the salt — both irreversible without the equation itself. Forgetting the equation makes the account irrecoverable, by design. There is no "recover password" link, no email reset, no admin override. The framework cannot read your equation any more than someone else can.

How to save it

Three options, ranked by safety: (1) click Copy in the equation block's top-right corner and paste into a password manager (1Password, Bitwarden, etc.) — the equation is a single string of text and lives happily there. (2) click .zeq to download a PIN-encrypted recovery file (HITE encryption, AES-256-GCM with KO42) — store it on a USB, an external disk, or any secondary location. (3) screenshot or photograph the equation block — every character is captured, and an offline image is one of the most resilient backups in existence. Combine two of the three for genuine insurance. Whatever you do, do not let the equation live only in your browser's local storage; clear that storage and the equation is gone unless you have a backup.

What this gives you

One equation unlocks your machine on every device, anywhere on the network, without an account-recovery flow, without password fatigue, without revealing anything to the framework. The same equation is also the seed for the entangled state that records your contracts, so signing in and authenticating a future computation are the same operation under the hood. The framework's other apps — Vault, Mail, Message, HITE Encryption, ZSP Security — accept the same identity. One equation, every surface.

① Pick or type a topic
② Display name · optional
③ Mint your equation

No email · No password · No recovery questions · ~2 minutes
The kernel mints it. We never store it. Save it yourself in step ④ below.

① Email · how you'll sign in
② Four words · pre-filled — just generate
0 / 4 words These seed your password and are never needed again — no need to remember them.
③ Password strength · how secure
④ Display name · optional

Sign in next time with your email + that password. We store neither — only your public Zeq ID.

step 4 · meet your state machine

It's already
running.

Your state machine has a Zeq ID, an entangled state, and a clock — ticking right now at 1.287 Hz. A live page is already deployed at /s/<zid>/ with a Pulse on it — open the page in a new tab and you can architect, build, and edit your application directly on the live site. The Pulse on this page and the Pulse on your page are the same Pulse on different URLs.

Your personal Pulse is a state machine of its own — ZID ZEQORB…, own entangled state, own balance, auditable in the explorer any time.

Your state machine has a Zeq ID, an entangled state, and a clock — ticking right now at 1.287 Hz. A live page is already deployed at /s/<zid>/ — and you drive all of it from the terminal. Type contracts directly — compute NM19 mass=5 acceleration=2, contracts, chain — the kernel ticks them through the same seven-step pipeline, no model, no translator, no quota.

No AI runs on this route — every contract is ZeqProof-verified and hash-linked. The AI surface stays one switch away; nothing is lost by starting here.

0 zeqonds since genesis · 1 tick = 0.777 s
machine · —
genesis · —  ·  now · —  ·  phase · —
Open your page & Pulse ↗ Open Pulse State ↗
Open your page & Root ↗ Open Root standalone ↗

your ecosystem — every door, one equation

Apps ↗ SDK ↗ MCP ↗ State Observer ↗ Vault ↗ Root ↗ Zeq paper ↗ Framework paper ↗

Pulse here and Pulse on your live page are the same Pulse — both write to the same entangled state.

Root talks to the same kernel every other surface uses — same seven-step pipeline, same entangled state, same proofs. Start with tutorial for the 5-step walkthrough, or hello for a real one-shot compute.

What lives at your state machine — entangled state, observer, audit, sovereign by default

Your Zeq machine is a self-contained computational substrate. It has its own audit entangled state, its own embedded api-core, its own state observer, and its own clock — synced to the same 1.287 Hz pulse as every other machine on the network. The Zeq ID minted from your equation in step 3 is permanent: it cannot be reassigned, cannot be silently changed, cannot be impersonated. Whatever you build on this machine is hash-linked to that ID forever.

Tamper-evident entangled state — proof, not promises

Every contract that fires on your state machine writes a hash-linked entry to the entangled state. Each entry references the previous entry's hash, so any retroactive edit to history would invalidate every subsequent entry — a Merkle-style integrity guarantee on your machine's own entangled state, not a global ledger. Each contract carries a ZeqProof: an HMAC-SHA256 over the operator IDs picked, the modulated state R(t) at firing, the zeqond, and the queryHash. Anyone in the world with the proof digest can later verify what happened on what tick, in what state, with what inputs — without trusting you, without trusting the framework, and without re-running the computation. The entangled state is the receipt.

Fault-isolated — your state machine doesn't depend on ours

Each Zeq state machine runs on its own embedded api-core and its own clock. If a peer state machine crashes, yours never feels it. If the framework's mesh fabric (the consensus layer that coordinates 10 origins) degrades, your state machine keeps ticking on its own pulse until quorum returns; transitions queue locally and replay onto the mesh on reconnect. Resource limits and crash-loop protection are enforced per-state-machine: a runaway contract on one tenant cannot starve another. The fault model assumes adversarial neighbours and degraded networks as the steady state — not the exception.

Five surfaces other people reach you through

Messaging — end-to-end-encrypted address inside the framework, drop-in for email, no plaintext on any server: <zid>@zeq.dev. Public site — folder-portable page at /s/<zid>/ that anyone with the URL can reach. State observer — your entangled state rendered live at /state/?slug=<zid>, filter pills for compute / agent / contract / audit-source / proof events. API — Authorization: Bearer zsm_… for admin scope, zeq_ak_… for site publish, all keys revocable per-scope. Audit entangled state — anyone with a proof digest calls /api/zeq/verify and the entangled state proves the entire path from genesis to that point. Hash-linked under origin: zeq.dev:<zid>.

Folder-portable — your state machine isn't trapped here

The state-machine folder under /s/<zid>/ contains everything required to boot the same state machine on a different framework instance: the entangled state, the contracts, the cached operator catalogue, the public-site assets. Copy it to another VPS, point a Zeq-compatible runtime at it, and the same state machine resumes ticking. There is no "you can only run on our cloud" lock-in; the framework is the protocol, not the host.

Other apps your equation already unlocks

The Apps menu at the top of every page lists every Zeq application — Vault, Mail, Message, Zeq MI, HITE Encryption, ZSP Security, HZC Compress, Globe, Audit Daemon, Skills, Physics Wizard, Wallet — and each one is a state machine of its own. The equation that minted this machine signs you into all of them. You don't need to set them up now; they're there whenever you want them.

How Pulse drives this machine

Pulse is Mathematical Intelligence laid on top of an LLM: the model translates your Plain English into Zeq contracts, the kernel computes them, the entangled state proves them. The LLM never computes a physics value — it cannot output a number the kernel didn't produce. Your personal Pulse is itself a state machine (its ZID is shown above): its own entangled state, its own balance, auditable in the State Observer like any other machine on the network. Free limited model from us, or BYOK — paste a key from OpenAI, Anthropic, Fireworks, DeepSeek and Pulse runs on your provider, your tier.

How Root drives this machine

Root is the kernel's native mouth — no model, no translator, no quota. compute NM19 mass=5 acceleration=2 runs a real operator and prints the CKO envelope; contracts deploys, fires, and dry-runs state contracts against the audit trail; verify walks the hash-linked log and re-checks any proof; zsc is the encrypted secret vault that replaces .env files. The same surface is scriptable from outside the browser: every Root verb maps to a real API route under your zeq_ak_ key, and any MCP-capable LLM client can drive the same endpoints — that's the MCP button above — without an AI ever running on your machine.

steps 5 · 6 · 7 happen on your live page

Click Open your page & Pulse above, then the ▲ Workbench pill. It walks the same four-step journey on every machine:

  1. LEARN — free-form Q&A with Pulse about the framework before you build.
  2. 5 · SKILL — pick or generate the operator skill your build needs.
  3. 6 · PLAN — spec, state contracts, APIs — Pulse architects, you approve.
  4. 7 · BUILD — edit files, deploy apps to /p/<app>/, every version hash-linked. The terminal rides under every step if you want the kernel directly.

Every deploy and every compute is a transition on your entangled state — same pipeline, same proofs as the CLI route.

steps 5 · 6 · 7 happen on your live page

Click Open your page & Root above, then the ▲ Root · CLI pill. The Root IDE walks the same four-step journey on every machine:

  1. LEARN — the written guide: Zeqonds, operators, contracts, proofs — no model involved.
  2. 5 · OPERATORS — browse the catalogue by domain, run any operator live in the terminal.
  3. 6 · CONTRACTS — the contracts IDE: Templates or Expert; dry-run and fire from the terminal.
  4. 7 · BUILD — edit files, deploy apps to /p/<app>/, every version hash-linked. The terminal rides under every step.

Every deploy and every compute is a transition on your entangled state — same pipeline, same proofs as the AI route. No AI ran, none will — unless you ever flip it on yourself.

backup your access

Your equation credential is the primary key to this machine — keep the printed copy somewhere safe. Want a fallback? Set an optional recovery password in your portal settings. It only works alongside the equation; it never replaces it.

Set recovery password →