Eve is a local-first runtime designed for AI models to author compact .eve semantic source, compile it into typed DAGs, and generate verified targets - while humans inspect, approve, and govern.
Eve is an AI-native executable semantic protocol and local-first runtime. AI models write compact .eve source files, which are lowered into a typed semantic DAG, canonical binary artifacts, execution plans, and generated target outputs such as Web applications. Humans inspect, approve, govern, debug, and audit through projections and tools - they are not the primary source authors.
.eve files are the only truth. Generated traditional code is an output - never a source of logic. Every change flows through the semantic DAG and leaves an auditable trail.
Runs entirely on your machine. No cloud dependency. Semantic DAGs, execution plans, capability RPC, receipts, replay, and checkpoints live under .eve/.
Every OS interaction - files, network, processes, clipboard, browser - goes through typed capability contracts with allow/deny/approval/budget/redact policies.
Every execution produces cryptographic receipts with SHA-256 content digests. Full replay and checkpoint support for audit, debugging, and compliance.
Generate complete HTML/CSS/JS applications from .eve semantic truth. Generated output is fully traceable to its semantic source with target diff reporting.
Preview and apply incremental changes via intent fragments. Only affected targets are rebuilt. Digest-anchored patches keep everything traceable.
The eve binary is the complete toolchain. From source creation to production operations.
eve new my-app --template reference-webCreate a new project from an official template
eve checkValidate and diagnose .eve source files
eve graphCompile and inspect the semantic DAG
eve planLower DAG into an execution plan
eve runExecute the plan with capability adapters
eve testRun semantic tests with capability mocks
eve verifyVerify receipts, replay, and checkpoints
eve buildGenerate target artifacts (Web, data, API)
eve doctorRun full project diagnostics
eve fmt --checkFormat and validate .eve source style
eve ops healthProduction health check from semantic truth
eve ops replay-incidentReplay and audit production incidents
Every phase is independently verified, with frozen fixtures, documentation, and retro conclusions.
Traditional languages are designed for humans to write every line of code. Eve is designed for AI models to author .eve semantic source. The source of truth is always the semantic representation - generated traditional code is an output, never the logic truth. This eliminates the mismatch between what AI models think about (semantics) and what they produce (syntax).
No. Eve's binary is intentionally compact - it carries a full parser, semantic DAG compiler, canonical encoder, execution planner, runtime with capability adapters, Web target generator, and production ops toolchain. The small size reflects the protocol's design: semantic truth is expressed compactly, and generated host-code targets are projections, not the runtime itself.
The eve build command generates traditional code (HTML/CSS/JS for the Web target) as a projection of the semantic DAG. This provides practical deployment to browsers and existing infrastructure while preserving the .eve source as the sole semantic truth. Every generated file is traceable to its source DAG node, with target-diff reporting for change tracking.
Natural language β (AI model) β .eve semantic source β (Eve toolchain) β Semantic DAG β Execution Plan β (Eve runtime) β Generated targets & receipts. The AI model handles the intent-to-semantics translation. Eve handles semantics-to-execution. Traditional code is an output surface - browsers, APIs, and native apps consume it, but they never become the truth.
Eve's protocol is model-agnostic. Any AI model that can produce valid .eve source syntax can author Eve projects. The toolchain validates, compiles, and executes the result independently. Phase 30 includes model integration guides and conformance certification for model providers.
Yes - the author describes Eve as a personal vibe coding project built in collaboration with GPT, DeepSeek, Qwen, and other AI models. But it has been executed with rigorous engineering discipline: 16 Rust crates, comprehensive tests, frozen fixtures for every phase, and full CI/CD with binary releases.
Eve runs on macOS (arm64) and Linux (x86_64). It can generate Web targets (HTML/CSS/JS applications), data workflows, API backends, and local agent automations. Native UI and OS automation are supported through bounded capability adapters with policy-controlled execution.