A senior Solidity engineer who wishes to deploy a contract with fully homomorphic computation, post-quantum signature verification, and selective disclosure of state must, today, assemble four or more independent libraries, each with its own ABI conventions, gas models, and key serialization formats. The integration code is not checked by any compiler. The bugs live at the joints.

This is not merely inconvenient. It is a structural failure of the toolchain. When a developer writes fhe.decrypt(pk, ciphertext) after a zkVerify(proof, publicInputs), the compiler does not know whether the key used for FHE encryption is the same key identity that the ZK proof asserts. It cannot know, because these primitives are not part of the language; they are external calls. The composition is the developer's responsibility, and the developer is fallible.

Covenant treats FHE, post-quantum signatures, ZK proofs, and cryptographic amnesia as first-class language primitives. The compiler reasons about key identities, data flows, and privacy invariants across all four layers simultaneously. An operation that would violate a privacy guarantee fails at compile time, not at runtime — not in production, not in an audit, not in a postmortem.

fn process_private_vote(
    vote:  fhe<u256>,       // FHE-encrypted ballot
    voter: identity<pq>    // post-quantum identity
) -> amnesia {
    // @non_reentrant        auto-injected by compiler
    // privacy flow          verified: fhe → pq → zk consistent
    // compiled to           2,847 bytes

    let cleartext = decrypt(vote, voter.key);  // key identity enforced
    self.tally(cleartext);

} // scope exit: amnesia auto-triggered, ciphertext destroyed, proven on-chain

Styx Protocol is Covenant's native standard library — the substrate on which every Covenant contract runs. It is not a dependency to be imported. It is the runtime. Styx defines four named cryptographic layers, each responsible for a distinct class of guarantee. A Covenant contract may use any subset; the compiler verifies that compositions are sound.

The four layers are not independent modules. OBLIVION can trigger termination of keys held by FORTRESS. VEIL's homomorphic computations may be verified by PRISM without decrypting. FORTRESS provides the identity substrate for all three. These interactions are the reason a language-level approach is necessary: no library-level API can express them.

Version 0.9.4 — the "fail-loud pass" — shipped July 2026 from an OMEGA V6 self-audit. min/max/abs/pow/sqrt no longer miscompile to a+b (E424); division by a literal 0 is a compile error and non-literal divisors get a runtime guard (E519); text constants over 32 bytes error (E521); test actions are stripped from on-chain output; non-zero constant field defaults are now written; and the LSP surfaces every one of these diagnostics live. A 21-crate workspace, 1102 tests, zero clippy warnings. EVM (default), Robinhood Chain (Arbitrum Orbit L2), and WebAssembly targets. Source-level compatibility with V0.7–V0.9 is preserved.

Covenant ships a complete in-browser development environment at playground.covenant-lang.org. The playground loads in any modern browser — no Rust, no PATH setup, no toolchain. Compile to real EVM bytecode, deploy to MockChain (deterministic, instant) or Sepolia (real testnet, ~12–24 s block confirmation), interact with deployed contracts in a typed UI, persist state across reloads via IndexedDB, and follow a guided 20-lesson tour (4 modules: basics, privacy, advanced, V0.9 features) from record Hello to amnesia ceremony, NFT auto-synthesis, and Sepolia deploy.

State persists across page reloads (IndexedDB) and syncs across tabs (BroadcastChannel). Events display as human-readable names, not raw hex topics. The playground is the fastest way to evaluate Covenant — and the recommended on-ramp for anyone considering adoption.

What follows is the public roadmap. Shipped phases are marked accordingly. The current phase is distinguished by a live indicator on the left margin.

The question arises. A number of projects have occupied adjacent positions. The distinctions are not trivial.

This site is both a project document and a living specification. The sections on language design and architecture are normative: any deviation between the compiler and this document is a compiler bug. The roadmap sections are informative: they describe our intentions, which are subject to revision.

We distinguish two kinds of sections explicitly, via badges next to each section number:

• Foundational — the permanent argument: what Covenant is, why a language-level approach, the four-layer architecture of Styx Protocol. These sections change only when the philosophy changes, which is rarely.
• Living · V0.9 — the current state: what has shipped, what is in flight, what is planned. These sections update with each release. The pulsing indicator marks the active version.

When you read this manifesto, the Foundational sections describe what we are building and why. The Living sections describe where we are on the road to V1.0. Together they form a single document — but they evolve on different timescales.

The specifications published here are released under CC0-1.0. You may use them, fork them, implement them independently, and publish derivative work without attribution. The compiler implementation is released under Apache-2.0.

Covenant is early. We have a working compiler, a deployed contract, a test suite, and a roadmap. We are selectively seeking collaborators in four areas.

On compensation

Covenant has no venture funding and no token. There is currently no paid position available for contributors. We acknowledge this openly — the project cannot pay competitive market rates today, and we do not ask collaborators to pretend otherwise.

What we can offer

• Authorship — every technical contribution is credited publicly in release notes, documentation, and academic publications produced from this work.
• Research visibility — Covenant operates in the open. Contributors build a verifiable portfolio on a project of non-trivial technical ambition.
• Priority consideration for future paid roles — when funding becomes available (whether via grants, foundation support, or consulting revenue), contributors who shipped meaningful work receive first refusal on paid positions.
• Reference letters — for academic and industrial applications, we provide detailed reference letters documenting the specific technical work completed.
• Access to the production codebase — vetted contributors receive read/write access to the private V0.9 working branches of the 21-crate compiler workspace, the EVM and WASM backends, the helper-contract bridge, and unreleased protocol drafts, ahead of public publication. The signal of seriousness is access.

What we cannot offer

• Competitive salaries or hourly rates.
• Equity, revenue share, or token allocation.
• Guarantees about future paid work.

If this arrangement doesn't align with your constraints, we understand. Covenant is not for everyone at this stage, and we would rather you commit your time to work that compensates you properly than contribute with unvoiced expectations.

For contributors whose interest is fundamentally in the work itself — the research, the systems design, the opportunity to shape a language from first principles — we welcome you. The road from V0.1 to V1.0 is long and technically substantive. Every serious contribution will be acknowledged as such.

Reach out: covenant@kairos-lab.org

Watch this space. Private until V1.0.