Apeiron

Inspiration

Modern AI application development relies on fragile Python stacks (LangChain, CrewAI, PyTorch) glued together with JSON schemas and custom parsers. Apeiron was inspired by the need for a unified, rigorous, and deterministic system-level language designed specifically for building artificial cognitive architectures and multi-agent swarms.

What it does

Apeiron is an experimental, AI-native declarative programming language and cognitive runtime written entirely in Rust. Instead of treating intelligence and probability as external libraries, Apeiron treats them as first-class language primitives:

• Tensors & Autodiff: First-class tensor types (tensor, parameter), matrix multiplication (@), and automatic differentiation (gradient ... with_respect_to) backed by an execution tape and optimizers (SGD/Adam).
• Epistemic Beliefs & Probabilities: Native distribution and belief primitives with causal justifications (because) and Bayesian posterior updates.
• Causal Engine: First-class causal graphs (cause A -> B), observations, do-calculus interventions (intervene), and counterfactual simulations.
• Multi-Tier Memory & Cognition: Declarative memory tiers (memory episodic), working memory, consolidation, planning (plan), and runtime architectural self-modification (architecture).
• Multi-Agent Societies: Primitives for agent, society, cluster, and economic token/latency budgeting (route, budget).

How we built it

Apeiron is implemented as a modular Rust workspace consisting of 14 specialized crates:

• Pipeline: core → lexer → parser (Pratt parser) → ast → analyzer (type checking & shape inference) → ir (SSA-like IR & passes) → interpreter / codegen.
• Tooling: A fully-featured CLI (apeiron), an idempotent comment-preserving formatter (apeiron fmt), an interactive REPL, an LSP server for IDE integration, and an embedded 3D web studio (apeiron studio).
• Quality: 307 passing tests, zero compiler warnings, and deterministic execution validated via golden snapshots.

Challenges we ran into

• Designing a robust Pratt parser that handles both traditional math/control flow and complex domain-specific cognitive blocks (like belief ... update and architecture) without ambiguity.
• Balancing expressive declarative syntax with a strict, deterministic compilation pipeline and SSA-like intermediate representation in Rust.

What we learned

Building a complete compiler pipeline, runtime, and LSP server from scratch in a 14-crate workspace revealed the immense power of treating language-level primitives as first-class citizens for AI workloads, bypassing the typical Python overhead.

What's next

• Native machine code generation (AOT/JIT) via Cranelift or LLVM.
• Expanded async I/O and native HTTP/gRPC client integrations for LLM/Ollama API routing.
• Publishing the official VS Code extension to the Marketplace.

Built With

• ai-native
• cli
• cognitive-architecture
• compiler
• ir
• lsp
• multi-agent
• parser
• rust