Language Proposals

Byte Literals

Add byte literal syntax `b'x'` for creating `byte` values directly, mirroring the existing `char` literal syntax `'x'`. Additionally, add `\xHH` hex escapes to both byte and char literals.

Byte-Level String Access

Add methods for accessing the raw UTF-8 bytes of a `str` value, and provide efficient byte-buffer types for byte-oriented processing like lexers and parsers.

Character and Byte Classification Methods

Define standard classification methods on `char` and `byte` types for character category testing. These are essential for text processing, lexers, parsers, and input validation.

Colon Syntax for Trait Implementations

Replace `impl Trait for Type` with `impl Type: Trait`, putting the subject before the predicate and unifying impl syntax with every other `:` conformance position in the language.

Intrinsics v2 — Generic SIMD API & Byte Operations

This proposal: 1. Redesigns the Intrinsics SIMD API from explicit-width functions to generic operations that monomorphize based on lane type and width 2. Adds byte-level SIMD operations — the foundati...

Labeled Block Early Exit

Allow `break:label value` to exit named blocks early with a value, providing early-exit ergonomics without adding a `return` keyword.

Mutable Self

Make `self` a mutable binding in method bodies, consistent with Ori's mutable-by-default philosophy. Methods that mutate `self` implicitly propagate the modified value back to the caller through desug...

Range Patterns on char and byte

Extend range patterns in `match` to work on `char` and `byte` types, enabling concise character classification in pattern matching.

Value Trait — ARC-Free Value Types

Introduce a `Value` marker trait that guarantees a type is always stored inline, copied by value, and completely bypasses ARC (automatic reference counting). Types declared with `Value` are never heap...

While Loop Expression

Add `while condition do body` loop syntax as sugar over `loop { if !condition then break; body }`.

Argument Punning

Allow omitting the value in a named function argument when the argument name matches the variable name being passed. `f(target: target)` can be written as `f(target:)`. This extends the existing struc...

Compound Assignment Operators

Add compound assignment operators (`+=`, `-=`, `*=`, `/=`, `%=`, `@=`, `&=`, `|=`, `^=`, `<<=`, `>>=`, `&&=`, `||=`) that desugar to `x = x op y`. This is pure syntactic sugar — no new traits, no new ...

Deep FFI — Higher-Level Foreign Function Interface

Deep FFI is a set of opt-in annotations and compiler features that layer on top of the existing `extern` declaration syntax. Five abstractions — declarative marshalling, ownership annotations, error p...

IsEmpty Trait for Collection Emptiness

`@` Matrix Multiplication Operator

Add `@` as a binary operator for matrix multiplication, following Python's PEP 465 convention. The operator desugars to the `MatMul` trait method `matrix_multiply()`, following the same pattern as all...

Pipe Operator

Add a pipe operator `|>` for left-to-right function composition. The piped value automatically fills the single unspecified parameter — no placeholder needed. This follows the same principle as delega...

`**` Power / Exponentiation Operator

Add `**` as a binary operator for exponentiation. The operator desugars to the `Pow` trait method `power()`, following the same pattern as all existing operator traits. `**` is right-associative and b...

Capability Unification & Generics Upgrade

Establish a consistent vocabulary for capabilities — **`:`** for structural capabilities (what types *have*) and **`uses`** for environmental capabilities (what functions *do*) — replacing the disconn...

Comma-Separated Match Arms

Change match arm separators from newlines to commas. Trailing commas are optional. This aligns match syntax with Rust, removes newline significance as a special case, and improves grammar consistency ...

Unsafe Semantics

Define `Unsafe` as a **marker capability** (like `Suspend`) that gates operations the compiler cannot verify. The `unsafe { }` block discharges the `Unsafe` capability locally — a programmer assertion...

Block Expression Syntax — `{ }` Replaces `run()` / `match()` / `try()`

Replace the parenthesized `function_seq` syntax with curly-brace block syntax. Move contracts from `run()` body-level to C++-style function-level declarations. Remove `run()` entirely.

Representation Optimization

Formalize the compiler's freedom to optimize the machine representation of types during lowering. The programmer writes `int`, `float`, and other high-level types; the compiler selects the most effici...

Compile-Time File Embedding (`embed`)

Add compile-time `embed` and `has_embed` expressions for embedding file contents into Ori programs. The `embed` expression is type-driven: the expected type determines whether the file is embedded as ...

Len Trait for Collection Length

Stateful Mock Testing in the Capability System

Ori's capability system uses `with...in` to provide mock implementations for testing. However, some tests require mocks that accumulate state across multiple calls (e.g., a counter that increments). B...

Index and Field Assignment via Copy-on-Write Desugaring

Named Capability Sets (`capset`)

This proposal introduces `capset`, a named capability set declaration that groups multiple capabilities under a single name. Capsets are transparent aliases — they expand to their constituent capabili...

Copy Semantics and Additional Reserved Keywords

Extend the low-level future-proofing proposal with:

Decimal Duration and Size Literals

Allow decimal syntax in duration and size literals as compile-time sugar that converts to exact integer values in the base unit.

Low-Level Future-Proofing

Reserve design space in Ori's type system and IR to enable future low-level programming features (stack-allocated types, borrowed views, arenas) without breaking ARC semantics or the high-level progra...

Repr Extensions

Extend the `#repr` attribute to support additional memory layout controls beyond `#repr("c")`. Add `#repr("packed")`, `#repr("transparent")`, and `#repr("aligned", N)` for fine-grained control over st...

Runtime Library Discovery

Define how the Ori compiler discovers `libori_rt.a` (the runtime library) during AOT compilation. Following rustc's sysroot pattern, discovery walks up from the compiler binary location rather than re...

AOT Test Backend

Add a new `Backend::AOT` test execution mode that compiles `.ori` tests through the full Ahead-of-Time compilation pipeline: LLVM IR generation → object file emission → linking → binary execution. Thi...

Multi-File AOT Compilation

Enable AOT compilation of Ori programs that use `use` statements to import functions from other files. Currently, `ori build` silently produces broken binaries when the source file imports from other ...

AOT Compilation

This proposal formalizes the Ahead-of-Time (AOT) compilation pipeline for Ori, covering object file generation, optimization passes, linking, debug information, and target configuration.

Associated Functions as a Language Feature

Implement associated functions as a general language feature that works for any type with an `impl` block, rather than hardcoding support for specific types like Duration and Size.

Associated Functions Proposal

Add support for associated functions (static methods) on types, enabling syntax like `Duration.from_seconds(s: 10)` and `Size.from_bytes(b: 1024)`.

Basic Const Generics

This proposal formalizes const generic parameters (`$N: int`), enabling compile-time values as type and function parameters. Const generics allow types like fixed-capacity lists to encode their capaci...

Default Associated Types

Allow associated types in traits to have default values, enabling `type Output = Self` where implementors can omit the associated type if the default is acceptable.

Default Type Parameters on Traits

Allow type parameters on traits to have default values, enabling `trait Add<Rhs = Self>` where `Rhs` defaults to `Self` if not specified.

Move Duration and Size to Standard Library

Remove Duration and Size as compiler built-in types and implement them as regular Ori types in the standard library prelude, using pure language features. Literal suffixes (`10s`, `5mb`) remain compil...

Existential Types (impl Trait)

This proposal formalizes the `impl Trait` syntax for existential types in Ori. Existential types allow functions to return opaque types that satisfy trait bounds without exposing the concrete type to ...

For-Do Expression

This proposal formalizes the `for...in...do` iteration expression syntax, including binding patterns, guard conditions, break/continue semantics, and interaction with labeled loops.

If Expression

This proposal formalizes the `if...then...else` conditional expression syntax, including type compatibility rules, branch evaluation, and interaction with the `Never` type.

Labeled Loops

This proposal formalizes labeled loop semantics, including label syntax, break/continue targeting, scope rules, and interaction with loop values.

Loop Expression

This proposal formalizes the `loop(...)` infinite loop expression syntax, including break/continue semantics, type inference from break values, and interaction with labeled loops.

LSP Implementation

This proposal formalizes the design and implementation decisions for Ori's Language Server Protocol (LSP) implementation, addressing architecture, integration, and design questions not covered in the ...

Match Expression Syntax

This proposal formalizes the syntax and semantics of match expressions in Ori. Match expressions provide pattern matching with exhaustiveness checking, enabling concise and safe destructuring of value...

Never Type Semantics

This proposal formalizes the `Never` type semantics, including its role as a bottom type, coercion rules, and use cases.

Newtype Pattern

This proposal formalizes newtype semantics, including type distinctness, conversions, trait inheritance, and use cases.

Operator Trait Method Naming

Rename operator trait methods to use full words instead of abbreviations for consistency and readability.

Operator Traits Proposal

Define traits for arithmetic, bitwise, and unary operators that user-defined types can implement to support operator syntax. The compiler desugars operators to trait method calls.

Ordering Type

This proposal formalizes the `Ordering` type, including its variants, use with `Comparable`, and common operations.

Package Version Resolution

Ori uses **exact version pinning** with a **single version policy**. No caret, no tilde, no ranges. Each package appears exactly once in the dependency graph at the version specified in `oripk.toml`.

App-Wide Panic Handler

Add an optional app-wide `@panic` handler function that executes before program termination when a panic occurs. This provides a hook for logging, error reporting, and cleanup without enabling local r...

Recurse Pattern

This proposal formalizes the `recurse` pattern semantics, including memoization, parallel options, termination guarantees, and the `self` keyword.

Reflection API

This proposal introduces a reflection API for Ori that enables runtime type introspection while maintaining the language's safety guarantees. The design centers on an opt-in `Reflect` trait with stati...

Standard Library Philosophy

Ori's standard library follows a "batteries included, independently versioned" philosophy. Official `std.*` packages cover common programming tasks, are maintained by the core team with long-term comm...

Timeout and Spawn Patterns

This proposal formalizes the `timeout` and `spawn` pattern semantics, including cancellation behavior, error handling, and relationship to other concurrency patterns.

Variadic Functions

Add variadic function parameters allowing functions to accept a variable number of arguments of the same type.

WASM Playground

This proposal formalizes the design and implementation decisions for Ori's browser-based WASM playground, which allows users to write, run, and format Ori code directly in the browser without any loca...

With Pattern (Resource Acquisition)

This proposal formalizes the `with` pattern semantics for resource acquisition, use, and guaranteed release.

Additional Built-in Functions and Types

This proposal formalizes three built-in functions and one type: `repeat`, `compile_error`, `PanicInfo`, and clarifies the null coalescing operator (`??`).

Additional Core Traits

This proposal formalizes three core traits: `Printable`, `Default`, and `Traceable`.

Cache Pattern

This proposal formalizes the `cache` pattern semantics, including TTL behavior, key requirements, cache invalidation, and capability interaction.

Closure Capture Semantics

This proposal specifies precise closure capture semantics, including when captures occur, how mutable bindings interact with captures, closure behavior across task boundaries, and memory implications....

Comparable and Hashable Traits

This proposal formalizes the `Comparable` and `Hashable` traits, including their definitions, invariants, standard implementations, and derivation rules.

Computed Map Keys

Formalize map literal key semantics: bare identifiers are literal string keys (like TypeScript/JSON), and `[expression]` syntax enables computed keys.

Conditional Compilation

Add conditional compilation support to Ori, allowing code to be included or excluded based on target platform, architecture, or custom build flags.

Const Evaluation Termination

This proposal specifies the termination guarantees and limits for compile-time constant evaluation, addressing what happens when const functions don't terminate, how long compilation can spend on cons...

Const Generic Bounds

This proposal formalizes const generic bounds (e.g., `where N > 0`), including allowed constraints, evaluation semantics, and error handling.

Custom Subscripting for User-Defined Types

Default Implementation Resolution

This proposal specifies the resolution rules for `def impl` (default implementations), including how conflicts between multiple defaults are resolved, interaction with `with...in` bindings, and initia...

Derived Traits

This proposal formalizes the `#derive` attribute semantics, including derivable traits, derivation rules, field constraints, and error handling.

Developer Convenience Functions

Add three built-in functions to the prelude for common development tasks:

Drop Trait

This proposal formalizes the `Drop` trait for custom destructors, including execution timing, constraints, and interaction with ARC.

Duration and Size Literal Types

This proposal formalizes the `Duration` and `Size` types, including literal syntax, arithmetic operations, conversions, and comparison semantics.

Error Trace Semantics with Async and Catch

This proposal specifies how error traces interact with async code, the `catch` pattern, and `try` blocks, addressing gaps around trace preservation across task boundaries and when traces can be lost.

Extension Methods

This proposal formalizes extension method semantics, including definition syntax, import mechanics, conflict resolution, and scoping rules.

Fixed-Capacity Lists

Introduce fixed-capacity lists — inline-allocated lists with a compile-time maximum size. Useful for embedded systems, performance-critical code, and bounded buffers.

For-Yield Comprehensions

This proposal formalizes `for...yield` comprehension semantics, including type inference, filtering, nesting, and interaction with break/continue.

Formattable Trait and Format Specs

This proposal formalizes the `Formattable` trait and format specification syntax for customized string formatting.

Grammar Synchronization Formalization

Formalize the relationship between the grammar specification (`grammar.ebnf`), the Rust compiler implementation, and Ori language tests. Establish `grammar.ebnf` as the single source of truth for synt...

Index Trait

This proposal formalizes the `Index` trait for custom subscripting, including return type variants, multiple key types, and error handling patterns.

Into Trait

This proposal formalizes the `Into` trait for type conversions, including its relationship to explicit conversion, standard implementations, and use patterns.

Intrinsics Capability

This proposal formalizes the `Intrinsics` capability for low-level, platform-specific operations including SIMD, bit manipulation, and hardware feature detection.

Iterator Performance and Semantics

This proposal formalizes the performance characteristics and precise semantics of Ori's functional iterator model, addressing the unusual `(Option<Item>, Self)` return type, state copying behavior, an...

Memory Model Edge Cases

This proposal addresses edge cases in Ori's memory model, including reference count atomicity across tasks, destructor guarantees, panic during destruction, and value representation rules. It also for...

Module System Details

This proposal specifies module system details including entry point files (`lib.ori` vs `mod.ori` vs `main.ori`), circular dependency detection and error reporting, re-export chains, nested module vis...

Nursery Cancellation Semantics

This proposal specifies the exact semantics of task cancellation within nurseries, addressing gaps in the current spec around what happens when tasks are cancelled due to errors, timeouts, or early te...

Object Safety Rules

This proposal formally specifies which traits can be used as trait objects, defining the object safety rules that the compiler enforces.

Parallel Execution Guarantees

This proposal specifies the execution guarantees for the `parallel` pattern, addressing ambiguity around ordering, concurrency limits, resource exhaustion, and partial completion semantics.

Pattern Matching Exhaustiveness

This proposal specifies the algorithm and rules for pattern matching exhaustiveness checking, including how the compiler determines if all cases are covered, when errors are issued, and how pattern fe...

Platform FFI (Native & WASM)

A unified foreign function interface supporting both native platforms (via C ABI) and WebAssembly (via JavaScript interop). The same Ori code can target either platform with appropriate FFI backends, ...

Rename Async Capability to Suspend

Rename the `Async` marker capability to `Suspend` to better reflect its semantics and avoid confusion with async/await patterns from other languages.

Sendable Trait and Interior Mutability Definition

This proposal clarifies the `Sendable` trait by defining what "interior mutability" means in Ori's context, specifying exactly which types are Sendable, and documenting verification rules for closures...

Simplified Doc Comment Syntax

Simplify doc comment syntax by removing the verbose `@param` and `@field` keywords. Use minimal markers that mirror familiar patterns:

std.crypto API Design

This proposal defines the API for `std.crypto`, providing cryptographic primitives for hashing, encryption, signatures, key exchange, and secure random number generation.

std.crypto FFI Implementation (Native)

This proposal adds native FFI implementation details to the approved `std.crypto` API. Cryptographic operations are backed by **libsodium** for modern algorithms and **OpenSSL** for RSA algorithms.

std.fs API Design (FFI Revision)

This revision adds FFI implementation details to the approved `std.fs` proposal. File system operations are backed by POSIX APIs on Unix platforms. Windows support is deferred to a separate proposal.

std.fs API Design

This proposal defines the API for `std.fs`, providing file system operations including reading, writing, directory manipulation, and file metadata.

std.json API Design (FFI Revision)

This revision adds FFI implementation details to the approved `std.json` proposal. JSON parsing/serialization uses **yyjson** on native platforms and **JavaScript's JSON API** on WASM, while keeping t...

std.json API Design

This proposal defines the API for `std.json`, providing JSON parsing, serialization, and manipulation capabilities.

std.time API Design

This proposal defines the API for `std.time`, providing date/time types, formatting, parsing, arithmetic, and timezone handling.

Formalize Test Terminology

Standardize test terminology across the specification and documentation:

Trait Resolution and Conflict Handling

This proposal specifies rules for resolving trait implementation conflicts, including the diamond problem in trait inheritance, conflicting default implementations, coherence rules (orphan rules), and...

Capability Composition Rules

This proposal specifies how capabilities compose, including partial provision with `with...in`, nested binding behavior, capability variance, and resolution rules when defaults and explicit bindings i...

Default Implementations (`def impl`)

Introduce `def impl` syntax to declare a default implementation for a trait. When a module exports both a trait and its `def impl`, importing the trait automatically binds the default implementation t...

Task and Async Context Definitions

This proposal formally defines what a "task" is in Ori and specifies async context semantics. Currently, the spec uses these terms without precise definitions, making it impossible to reason about con...

Test Execution Model

Define the complete test execution model for Ori: when tests run, which tests run, and how the compiler integrates test execution into the build process. This proposal consolidates and extends the app...

`as` Conversion Syntax

Replace the special-cased `int()`, `float()`, `str()`, `byte()` type conversion functions with a unified `as` keyword syntax, backed by traits for extensibility.

Pre/Post Checks for the `run` Pattern

Extend the `run` pattern with optional `pre_check:` and `post_check:` properties to support contract-style defensive programming without introducing new syntax or keywords.

Clone Trait

Define the `Clone` trait that enables explicit value duplication. This trait is already referenced in the prelude and derivable traits list but lacks a formal definition.

Debug Trait

Add a `Debug` trait separate from `Printable` for developer-facing structural representation of values. `Debug` is automatically derivable and shows the complete internal structure, while `Printable` ...

Default Parameter Values

Allow function parameters to specify default values, enabling callers to omit arguments.

Error Return Traces

Add automatic stack trace collection to `Result` error paths, enabling developers to see where errors originated, not just where they were caught.

Multiple Function Clauses

Allow functions to be defined with multiple clauses that pattern match on arguments, enabling cleaner recursive and conditional logic.

Incremental Test Execution and Explicit Floating Tests

Two related changes to Ori's testing system:

Iterator Traits

Formalize iteration in Ori with four core traits: `Iterator`, `DoubleEndedIterator`, `Iterable`, and `Collect`. These traits enable generic code over any iterable, allow user types to participate in `...

No Circular Imports

The Ori compiler must reject circular import dependencies between modules. Import cycles are a compile-time error.

Integer Overflow Behavior

Define integer overflow behavior in Ori: panic by default for safety, with explicit stdlib functions for alternative behaviors (saturation, wrapping).

Range with Step

Extend range syntax to support a step value for non-unit increments.

Remove Dot Prefix from Named Arguments

Remove the `.` prefix from named arguments. Use `name: value` syntax instead of `.name: value`.

Remove `dyn` Keyword for Trait Objects

Remove the `dyn` keyword for trait objects. Use the trait name directly as a type to indicate dynamic dispatch.

Sendable Trait and Role-Based Channels

Simplified Attribute Syntax

Simplify attribute syntax from `#[name(...)]` to `#name(...)` by removing the brackets. This reduces visual noise while maintaining clear attribute identification.

Simplified Bindings with `$` for Immutability

Simplify Ori's binding model to two forms:

Positional Lambdas for Single-Parameter Functions

When a function has exactly one parameter and the argument is a lambda, allow omitting the parameter name:

Spread Operator

Add a spread operator `...` for expanding collections and structs in literal contexts.

String Interpolation

Add string interpolation to Ori using **template strings** with backtick delimiters. Regular double-quoted strings remain unchanged (no interpolation).

Structured Diagnostics and Auto-Fix

Extend the compiler's diagnostic system to output structured, machine-readable diagnostics with actionable fix suggestions that can be automatically applied. This enables:

Causality Tracking (`ori impact` and `ori why`)

Expose Salsa's dependency tracking to users via two commands:

Dependency-Aware Test Execution

Implement reverse dependency closure for test execution. When a function changes, automatically run tests for that function AND tests for all functions that depend on it (callers up the dependency gra...

function_seq and function_exp Pattern Distinction

Two changes: