inauguration
AI-native orchestration compiler and backend systems language.
inauguration is not a frontend framework or UI runtime.
Frontend rendering, declarative UI, and cross-platform view abstraction belong to crepuscularity.
Inauguration focuses entirely on:
- orchestration
- backend execution
- compiler infrastructure
- graph scheduling
- capability systems
- incremental compilation
- distributed execution
- parallel compilation
- AI-agent-native tooling
- semantic runtime infrastructure
Crepuscularity becomes one consumer of inauguration infrastructure, not part of the language itself. (github.com)
⸻
Core Philosophy
Most programming languages expose implementation details directly to developers.
Inauguration instead focuses on:
- semantic intent
- orchestration topology
- compiler-managed execution
- graph-oriented infrastructure
- machine-readable source
- AI-native development
The compiler becomes:
- orchestrator
- scheduler
- semantic analyzer
- distributed execution runtime
- incremental build daemon
- dependency graph engine
rather than just:
source -> binary
⸻
Design Goals
- Compiler-managed orchestration
Developers express:
- intent
- relationships
- capabilities
- execution boundaries
Compiler handles:
- scheduling
- dependency resolution
- parallelization
- caching
- orchestration
- worker allocation
- incremental rebuilds
- distributed execution
- ABI generation
- package indexing
⸻
- AI-agent-native source code
Source should optimize for:
- deterministic ASTs
- canonical formatting
- semantic introspection
- bounded transforms
- partial rewrites
- machine readability
- stable diffs
The language is intentionally designed for:
- humans
- agents
- automated refactors
- semantic tooling
equally.
⸻
- Universal language ingestion
Inauguration should compile and orchestrate:
- .in
- C
- C++
- Objective-C
- Swift
- Go
- Rust
- V
- TypeScript
- JavaScript
- Java
- other Tree-sitter-compatible languages
through:
frontend parsers ↓ Core IR ↓ compile graph ↓ backend lowering
This aligns with the current multi-frontend Core IR architecture already present in inauguration. 
⸻
Core Architecture
Core IR
Every language lowers into canonical Core IR.
Core IR is:
- deterministic
- serializable
- graph-oriented
- parallelizable
- language-neutral
- incrementally cacheable
Core IR becomes the semantic center of the compiler.
⸻
Compilation as Graph Scheduling
Compilation is treated as orchestration.
Compiler builds:
- dependency graphs
- symbol graphs
- execution graphs
- package graphs
- capability graphs
- reactive compile graphs
Then schedules work across:
- threads
- processes
- distributed workers
- GPUs
- remote agents
⸻
GPU-Oriented Compilation
One of inauguration’s core differentiators.
Compiler architecture should eventually support:
- GPU tokenization
- SIMD parsing
- GPU AST transforms
- graph batching
- SSA optimization waves
- parallel semantic indexing
- distributed IR transforms
Compiler passes should therefore be:
- immutable where possible
- stateless where possible
- bounded
- parallel-safe
- graph-oriented
⸻
Compile Waves
Compilation executes in waves.
Example:
Parse Wave Semantic Wave IR Construction Wave Optimization Wave Capability Validation Wave Backend Lowering Wave Linking Wave
Each wave is:
- distributable
- resumable
- cacheable
- parallelizable
⸻
Persistent Compiler Daemon
Compiler operates as a persistent orchestration daemon.
The daemon continuously watches:
- filesystem changes
- imports
- package graph mutations
- capabilities
- symbol references
- dependency invalidation
- compile regions
rather than rebuilding projects from scratch.
Very similar philosophically to:
- Turbopack
- Bazel
- Vercel orchestration infrastructure
(vercel.com)
⸻
inauguration.package
Projects contain a single semantic package graph.
Example:
name: hyperchat version: 0.1.0 targets: linux: true macos: true web: true dependencies: postgres: version: ^1.0.0 redis: version: latest capabilities:
- filesystem.read
- filesystem.write
- network.http extensions:
- postgres-driver
- distributed-workers
- gpu-optimizer
The compiler automatically manages:
- dependency installation
- indexing
- ABI tracking
- graph invalidation
- symbol discovery
- extension loading
- semantic caching
No fragmented package management.
⸻
Semantic Imports
Imports are semantic.
Preferred:
use database.postgres use cache.redis use auth.oauth
Avoid:
import x from "../../../../"
Compiler resolves:
- physical topology
- package location
- ABI bindings
- versioning
Benefits:
- easier refactors
- stable graphs
- agent readability
- semantic tooling
⸻
Canonicalization
All source canonicalizes internally.
Human:
x:=5
Canonical:
let x: int = 5
Benefits:
- stable ASTs
- deterministic diffs
- semantic hashing
- incremental recompilation
- safer AI transforms
Compiler exposes:
in canonicalize
⸻
Language Syntax Philosophy
Syntax should feel:
- lightweight
- readable
- explicit
- structurally rigid
- minimally symbolic
Influences:
- Go
- Swift
- Python
- V
Braces required. Semicolons optional.
⸻
Variables
name := "max" let age: int = 19 mut counter: int = 0
Immutable by default.
⸻
Functions
fn greet(name string) string { return "hello " + name }
Canonical:
fn greet( name: string, ) -> string { return ("hello " + name) }
⸻
Structs
struct User { name string age int }
⸻
Methods
fn (u User) greet() { print(u.name) }
Mutable:
fn (mut u User) birthday() { u.age += 1 }
⸻
Parallel Regions
Explicit orchestration regions.
parallel { load_users() warm_cache() build_index() }
Compiler may:
- schedule independently
- distribute remotely
- batch optimize
- cache regionally
- execute on worker pools
⸻
Distributed Tasks
Example:
distributed fn process_video(video Video) { ... }
Compiler/runtime handles:
- worker assignment
- retries
- orchestration
- persistence
- task scheduling
Inspired partly by:
- Vercel workflows
- durable execution systems
(vercel.com)
⸻
Capability System
Capabilities are explicit.
capability filesystem.read capability network.http capability gpu.compute
Compiler validates:
- access boundaries
- sandboxing
- deployment permissions
- extension safety
- runtime guarantees
⸻
Extensions
Compiler extensions may provide:
- parsers
- transforms
- lowers
- macros
- runtime bindings
- orchestration systems
- backend integrations
Example:
enable distributed-workers enable postgres enable gpu-optimizer
The compiler becomes a platform.
⸻
Error Handling
Swift/Go-inspired.
fn read_file(path string) !string { ... }
Usage:
content := try read_file("a.txt")
or:
content := read_file("a.txt") catch { return err }
⸻
Agent Metadata
Structured annotations.
@pure @gpu @parallel_safe fn dot(a vec4, b vec4) float { ... }
Compiler and agents use metadata for:
- scheduling
- optimization
- caching
- orchestration
- semantic transforms
⸻
Introspection
Everything should be queryable.
in graph in graph --imports in graph --capabilities in graph --symbols in graph --parallel in graph --gpu
Critical for:
- debugging
- tooling
- orchestration visibility
- agents
⸻
Relationship to Crepuscularity
Crepuscularity handles:
- frontend UI
- declarative view trees
- rendering
- backend UI lowering
- cross-platform visual abstraction
Inauguration handles:
- orchestration
- compilation
- runtime scheduling
- backend systems execution
- package graphs
- distributed infrastructure
Crepuscularity should compile through inauguration infrastructure, not be replaced by it. (github.com)
⸻
Long-Term Vision
Inauguration is not:
- another systems language
- another Rust clone
- another backend framework
It is:
- orchestration-native infrastructure
- AI-native compiler architecture
- graph-oriented backend runtime
- universal compile platform
- distributed semantic execution system
The compiler evolves into:
- operating system for builds
- orchestration runtime
- semantic execution graph
- distributed scheduler
- AI collaboration layer
The syntax is only the entry point.