/projects/orison
A memory-safe, statically-typed compiled application language built for the edit-check-repair loop — capability-secured effects, JSON-first diagnostics, and structural Patch IR so LLM agents edit by stable node ID instead of rewriting files.
General-purpose programming languages are not optimized for AI edit-check-repair loops. Agents need stable semantic maps, structured diagnostics, capability-secured effects, and patch targets that survive refactors.
Orison is an agent-native application language with a Rust compiler, WebAssembly path, LSP support, JSON-first diagnostics, OpenAPI/UI manifests, and Patch IR for stable node-level edits.
The language has to balance human ergonomics with agent needs: type checking, effects, diagnostics, borrow-like safety, manifest generation, and structural patching all need to reinforce each other.
The core innovation is treating the compiler as an agent interface. Instead of asking agents to rewrite text, Orison gives them maps, capsules, diagnostics, and stable patch targets.
This shows Stefan's systems-language thinking across compiler architecture, LSP tooling, WebAssembly delivery, schema generation, capability security, and agent-native developer infrastructure.
Orison is the deepest systems project in the portfolio because it changes the programming substrate for agents. The compiler becomes an interface that agents can query, diagnose, patch, and verify structurally.
Agents get maps, capsules, symbols, and diagnostics instead of loading entire files into context. That gives them a bounded semantic view before they attempt a change.
Patch IR targets stable node IDs, so edits can land against structure rather than fragile text spans. This directly addresses a core failure mode of AI coding agents.
Effects and capability manifests connect language semantics to runtime permissions. That lets the compiler describe what code is allowed to do before the agent or runtime executes it.
OpenAPI, UI manifests, JSON schemas, diagnostics, LSP features, and WebAssembly output come from the same compiler surface. The language is designed to generate contracts agents can consume.
The compiler and agent-facing tools need memory safety, speed, and predictable binaries.
Provides a portable target for running compiled components outside the native toolchain.
Lets humans and agents share editor-grade hover, rename, and reference capabilities.
Makes diagnostics, patch operations, OpenAPI output, and UI manifests machine-readable.
Exposes 30+ subcommands where every command returns a JSON envelope.
Returns a compact symbol table so agents can orient without loading the whole repo.
Summarizes module exports and semantic context for focused edits.
Produces repair candidates and machine-readable status for an agent loop.
Applies structural edits by stable node ID instead of brittle text rewrites.
Runs resolver, type checker, inference, effect propagation, borrow checks, and exhaustive match checks.
Brings hover, rename, references, and diagnostics into editors.
Extract runtime-facing contracts from source instead of maintaining parallel docs.