ferrule language specification

this is the specification for ferrule α1. it describes what the language is and what it will be. each document has front matter that tells you what's implemented, what's planned, and what's been deferred to future versions.

the spec is the single source of truth. if something isn't in here, it's not part of the language yet.

how to read this

each document has yaml front matter at the top:

---
title: some feature
status: α1          # α1, α2, β, or rfc
implemented:        # sections that work right now
  - basic-stuff
  - other-thing
pending:            # sections planned for this phase
  - advanced-stuff
deferred:           # pushed to later phase or rfc
  - complex-thing
---

status meanings:

• α1 means it's part of the current milestone
• α2 means next milestone
• β means later
• rfc means it's a proposal, not committed

conventions:

• code for syntax and identifiers
• [link](path) references the canonical definition
• examples are runnable unless marked otherwise

design pillars

these are the core ideas that guide decisions:

1. immutability first - const by default, var when you need mutation, inout for explicit by-reference
2. errors as values - no exceptions, typed error domains, lightweight propagation
3. explicit effects - functions declare what they do, async is just another effect
4. scoped ownership - views can't escape their scope, no borrow checker, no gc
5. capability security - no ambient authority, fs/net/clock/rng are values you pass
6. strict nominal types - types with the same shape aren't compatible
7. no implicit coercions - booleans, numbers, nullability all explicit
8. explicit polymorphism - records + generics, no traits or oop

what's in α1

the core language that you can actually use:

what's deferred

these features are designed but not part of α1:

looking for future features? check out the rfcs for proposed additions to the language.

specification index

core language

functions and effects

error handling

memory model

modules and capabilities

unsafe

concurrency (β)

advanced (α2+)

reference

key decisions

these are the choices that define ferrule:

to be defined

these decisions are still open:

language identity

ferrule is a systems language where effects and capabilities are first-class. you get low-level control with safety guarantees about what code can do, not just what memory it touches.

target users:

• embedded developers who want more safety than c
• security-critical systems where capability audit trails matter
• developers who want rust-style safety without fighting the borrow checker

what it's not:

• not rust (no borrow checker, simpler generics)
• not zig (effects and capabilities are language features)
• not go (no gc, explicit error handling)