Nikaia
Menu
Get started
Syntax
Specification
Decisions
Roadmap
Examples
Foundation
Issues
v0.0.1343
pre-alpha
System
Light
Dark
Sepia
GitHub
All pages
Nikaia
Home
Getting Started
A Tour of the Syntax
Nikaia: Philosophy & Origin
Changelog
Specification
The Nikaia Specification
Nikaia Language Specification
Nikaia Language Specification
Nikaia Language Specification
The Specification's Language Standard
Decisions
Architecture Decision Records
ADR-<topic>-<n>: <The decision, written as a statement>
ADR-001: A Scannerless Generated Parser, and a Staged Bootstrap
ADR-002: A Toolchain That Wraps Cargo, and Metaprogramming Without Proc-Macros
ADR-003: Two Programs — the Language, and the Machinery That Compiles It
ADR-004: One Lowering, and It Emits Rust Source Text
ADR-005: Ownership Without Annotations — the Borrow Model
ADR-010: Input Provenance — Trust Is a Property of Sources
ADR-013: Running the Flagship — std, Methods, and What Stage 0 Refuses to Infer
ADR-014: std in Nikaia, a Real Mapping, and a Parallel Driver
ADR-015: The Backend's Lazy Diagnostics
ADR-016: The UTF-8 Check Is Divided, Not Skipped
ADR-017: Escaping Is the Template's Contract, Not the Caller's Discipline
ADR-019: Standard Input Is a Stream, and It Is Read Like Everything Else
ADR-020: The Ledger Records What the Compiler Knows, and a Library Brings Its Own
ADR-021: The Build Cache Is Ours, and the Lockfile Is Its Key
ADR-023: Errors — What throws Declares, and What an Error Carries
ADR-024: The Type Checker Says Only What Is Written Down
ADR-025: A Loop Can Fail, and the Rule Was Already Written
ADR-037: Two Switches — Which Machine, and How Much of Your Code Runs at Once
ADR-042: A View Keeps the Type It Is a View Of, and a Transparent Container Is Seen Through
ADR-055: The Emitted Rust Is async Where a Function Can Pause
ADR-056: Every Substituted Name Is Put Back, and a Translation That Collapses a Distinction Is an Internal Error
ADR-080: An impl Owes Its trait, and a Write Through the Brackets Is Not an Index
ADR-081: A + Over Text Is a Call, and an Expression Gets a Span to Key It By
ADR-083: A Field of a Borrowed Subject May Not Be Handed Out by Value
ADR-094: The Caller Writes No & — Whether a Parameter Is Lent or Kept Is the Callee's, Inferred Into the Ledger
ADR-096: A Type Nothing Declares Is Refused Rather Than Lowered
ADR-100: A Consumer Reads a Dependency's Ledger, and Derives It Again Only Where Its Sources Changed
ADR-105: The Ledger Says Seq[T] for What Is Produced Step by Step, and Par[T] Where the Steps Run at Once
ADR-108: A Path Names Its Root at the Call — fs::Root, and Anywhere Is the One Visible Way Around the Check
ADR-118: with Is a Copy of a Value With Named Fields Changed
ADR-119: A Target Without an Operating System — What Stays, What Goes, and What the Compiler Can and Cannot Promise
ADR-121: The Ring's Park Hears the Bell, So Every Worker Operation Can Wake the Executor
ADR-123: crosses Says No as Well as Yes
ADR-132: else if Is an else Whose Block Is One if, and It Is Written Without the Braces
ADR-133: An Argument List of Options Alone Writes No ; — the Leading Semicolon Is Gone, and It Is Not Optional
ADR-135: A List Literal Is [1, 2, 3], the Empty One Takes Its Type From Its First Use, and a [ at the Start of a Line Begins a Literal
ADR-140: Five Places Where One Thing Had Two Spellings, and Which One Stays
ADR-141: Six Things the Specification Writes Are Corrections, and Three Are Constructs That Stay Unspecified
ADR-149: A Channel Is std's, and Only Bounded
ADR-150: A Duration Is std::time::Duration, and It Is Written 5.seconds()
ADR-152: A Fixed-Size Array Is Array[T, N]
ADR-166: Cargo's Target-Info Probe Is Given an Empty Standard Input
ADR-171: A Refusal From the Lowering Names Its Line
ADR-172: A for May Iterate Something Whose Step Pauses
ADR-177: A Grammar Runs While the Program Is Built by Compiling the Parser It Generates
ADR-178: Tier-1 Staging Is Withdrawn, and What Would Reopen It Is a Measured Crossover
ADR-179: &[T] Is a Type of This Language, and It Is What a Run Crosses As
ADR-182: A for Lends, and Everything Downstream of the Binding Has to Know It
ADR-184: A View Is Spelled ref X, and Text Has One Noun
ADR-185: A View Meets Two More Constructs That Were Never Told
ADR-186: A Parse Keeps The Text Its Record Views
ADR-188: The Escape Set Is The Language Below's, Written Down Once And Refused Here
ADR-203: An enum's Cases Are a Column of the Ledger, and a Unit-Only enum Compares
ADR-204: Whether a Type Compares Is a Question About Its Parts, and a Type That Does Not Is Refused Here
ADR-217: What the Specification Stated and the Compiler Did Not Build — T::variants, Kept Function Values, and Views Kept by a Parameter or a Result
ADR-218: Every unsafe Topic Is a Small Crate of Its Own
ADR-229: A Value Handed Over Inside an f"…" Hole Is Handed Over There
ADR-230: A Function Field Is Reached Through What Is Stored in It
ADR-231: A Value Read Through a View Is the Value
ADR-233: A Lambda That Pauses Is Handed to std's Pausing Counterpart
ADR-234: A Lazy Walk of io::lines() Carries Its Failure to the Walk
ADR-235: par_iter() Walks a List on Every Core, and Its Lambda Neither Pauses Nor Writes What Is Shared
ADR-243: std::process Starts a Program and Waits for It, and the Wait Gives the Thread Up
ADR-246: A Type That Holds Itself Holds Itself Through a Box the Compiler Writes
ADR-247: An Output Test Runs in a Directory of Its Own, Its Expectations Are Blessed, and a Test Gets a Scratch Root
ADR-251: The Ledger Is the Contract, What It Was Derived From Is Beside It, and It Speaks Nikaia Where Nikaia Can Say It
ADR-253: A List Has No +, and extend Is How Two Lists Join
ADR-258: Four Weights for a Design Question
ADR-260: A File Belongs to Its Project, and the Single-File Commands Are Verbs
ADR-263: A File Operation on an Idle Runtime Runs on the Calling Thread
ADR-269: An assert Is a Contract — Proved Where the Compiler Can, Checked Where It Cannot, Published Across Packages, and a Test Is a Block
ADR-270: The Prover's Solver — a Frontend, a Logic and a CDCL(T) Solver Written in Nikaia, with One Small Proof Format and a Committed Proof File
ADR-276: while true Is the Unconditional Loop; break and continue Leave the Innermost Loop and Carry Nothing; a Jump Is an Expression of the Never Type and May Carry Its Condition
ADR-277: A Lambda Is fn(name) { … } and Takes the Arguments It Names; a Parameter That Is Code Has the Type fn(A) -> R, and Its Shape Follows the Type and Whether the Body Keeps It
ADR-278: T? Is a Type the Compiler Wraps Into, and ?. Reaches a Member Through a View of Its Receiver
ADR-279: ?? Takes One Value as Its Fallback and Has No Postfix Form — and It Lends Its Left Side Where the Answer Is Read and Takes It Where It Is Kept
ADR-280: A Failure Travels as Its Error Type in a One-Word Envelope — the Site Is Free, a Trace Is Asked For, and the Failures That Joined It Are Shown, Not Read
ADR-281: Shared Mutable State Is SharedMut[T], Its Shape Is Chosen Per Value, It Opens Through Four Doors, and What Leaves It Is Stamped
ADR-282: Text Is One Type, String, Whose Representation Is Decided per Position by What Flows In — and a Copy Is Only the .clone() the Program Writes
ADR-283: A View That Escapes Is Tethered — Its Buffer Lives in the Keep of Whatever Keeps the View, the Compiler Decides Where, Nothing Is Written for It, and Bytes Is the Language's Buffer
ADR-284: A Nikaia Library for Other Languages Is One C Artifact — a Target That Is Safe at Its Boundary, Entry Points That Answer With a Status, the Caller's Memory, and Every Other Host a Generated File Over It
ADR-285: An Integer Is int or One of Five Fixed Widths, and Stops the Program Where It Does Not Fit; a Number Without an Annotation Is Typed by Its Uses
ADR-286: A Package Is a Directory and a Crate; use Names One and Brings No Name In; a Dependency Is Found by Path or by Version Through Cargo
ADR-287: A comptime Binding Must Be Evaluated While the Program Is Built — Where an Item or a Statement Stands, by a Body That Is sync and Touches at Most the Build's Parameters
ADR-288: sync Means a Function Never Pauses — Earned From the Body, Decided by a Lambda Where One Runs, Promised Across Packages Only Where Written
ADR-289: An HTTP Server Is the Application's Own — std Lends the Socket, the http Package Speaks the Protocol, and a Handler Is a Lambda Over the Request
ADR-290: A Rust Crate Is Described Before It Is Called, the Description Is Reviewed Like Code, and nikaia describe Drafts It as a Nikaia Program Reached From Rust as an Ordinary Module
ADR-291: A let Takes Names or a Flat Tuple, _ Ignores a Value That Arrived, and a match Takes Nested Patterns, Ends in else, Covers Every Case and Lends What an Arm Only Reads — With .. Inclusive and ..< Exclusive Everywhere
ADR-292: Statement Order Is the Written Order — a Program Asks for Concurrency with overlap, Which Keeps Every Result and Every Failure, or select, Which Keeps the First
ADR-293: A Map Read Is a T? and a Key Is Not a Position; a Sequence Says What It Is as a Whole; and What Is Handed Over Is Gone, Part by Part
ADR-294: Stage 1 Is Reached a Module at a Time, Leaves First — the Syntax Tree and the Checker's Types Move Whole, and the Toolchain's Nikaia Is One Package
ADR-295: A Generic Is Checked at Both Ends — a Type Parameter Is a Type in Its Body and a Variable at the Call, a Bound Names a Declared Trait, and the Ledger Carries the Trait, Each impl and the Bound
ADR-296: A Grammar Is Part of the Language — Scannerless, Entered by a Call to Any pub Rule, Cut in Parallel Only Where a Checked Frame Says So, Lowered Name for Name, and Its Actions Neither Pause Nor Fail Without a Name
ADR-297: A Cleanup Runs Where Ownership Says the Value Dies — Settled by the Compiler, Drained Under a Deadline, and a Cleanup Cut Off Is Exit 70
ADR-298: A Word This Language Uses Is Reserved and Only for a Construct, and a Word the Language Below Reserves Is Escaped Where It Is Written
ADR-299: A Database Statement Is SQL the Driver Checks at Build Time Against a Schema, and It Runs on a Connection Typed by That Schema
ADR-300: A Diagnostic Names the File the User Wrote — at Build Time Through a Source Map, at Run Time Through a Location Table
ADR-301: A Condition Is an Ordinary Expression — the Head of an if, a while and a for Parses the Body's Language Minus the Forms a { Begins, and Those Take Parentheses
ADR-302: A Call Into C Is Written Inside unsafe, and What Crosses Is a View for the Call or an Opaque Handle That May Be Absent — Never a Raw Pointer
ADR-303: The Runtime Is Nikaia's Own — It Starts Before main, Is Tuned When the Program Starts, Completes Files and Registers Every Readiness Wait; the HTTP Server Is Ours and TLS Is rustls
ADR-304: Reflection Is Data, Not a Syntax Tree — T::fields Is a List a Bound Makes Exist, and the Loop Over It Is Unrolled Once per Type Used
ADR-305: The Language Below Is Rust 1.88 or Newer at Edition 2024 — One Measured Floor, for the Compiler, std and the Emitted Code Alike
ADR-306: An Index or Overflow Check a Proof Shows Unneeded Is Not Emitted, at the Level the Build Asks For — --optimization=remove-bounds-checks and remove-overflow-checks
ADR-307: A Comment Is // or a Nesting / … /, and a Run of /// Before an Item Is Its Documentation — Prose the Parser Keeps and the Contract Does Not Carry
ADR-308: What the Compiler Says About a catch — an Unread Error Is Bound as _error, a catch Over What Cannot Fail Is Refused, and an Error That Newly Reaches One Is Named Once
ADR-309: Only an f"…" Has Holes, the Grammar Parses Them as Code, and Every Analysis Sees Them
ADR-310: A Build Reads a File Only When the Code, a Committed List and the Invocation All Name It — the Code Says asset("…"), the Path Stays in the Project, and from Is a Name
ADR-311: A Build-Time Value Crosses Into the Program in Its View Form — a List as an Array or a ref Array[T], a Map as a Fixed Table Written as Pairs, a Declared Row Held as a View, and the Lookup Is the Compiler's
ADR-312: A Handle on a Shared Value Is Duplicated, Never Moved; It May Go Into a Task of Our Own and Not Into Code Nothing Describes; and at One User Thread Its Count Is Plain
ADR-313: The Prelude Is a Written List, Small and Closed — What Is the Language's Needs No use, Everything Else Is Written With Its Module, and Each Spelling of the Other Is Refused
ADR-314: What a Grammar Matched and What a Callee Promises Are Facts of the Walk
ADR-315: Arithmetic and a Conversion That May Not Fit Can Be Asked Whether They Do — checked_ Names, With the Answer Optional
ADR-316: A Map's Hasher Follows Its Keys' Trust and Shape, Is Reported, and the Program May Name Its Own
ADR-317: A Call's ( Is on the Line of What It Calls — a ( That Begins a Line Begins What Is Written There
ADR-318: An Option's Default Is a Build-Time Value — Evaluated Once Where the Function Is Declared, Recorded as Its Value, and Handed to the Call in the Form a comptime Crosses In; a std Type the Compiler Cannot See Into Crosses Through the Parts Its Ledger Entry Names
ADR-319: A File Name Is fs::Path, the Platform's Own Bytes — Text Stands Wherever One Is Asked, an f"…" Builds One Where the Use Asks, and Only a Name the System Handed Over May Fail to Be Text
ADR-320: Text Is UTF-8 and Is Read Through a View That Names Its Unit — Bytes, Scalars or Graphemes; There Is No char
ADR-321: Build-Time Code Is Compiled and Run, Not Interpreted — Against the Package's Dependencies, Linked Dynamically, One Crate per Package, With a Step Budget
ADR-322: A Whole Number May Carry a Scale — K M G T P Decimal, Ki Mi Gi Ti Pi Binary — and an Exponent Is Written e
ADR-323: A Grammar Describes a Type as Data — meta::Type, From Which the Compiler Writes a Block's Parameters and Result
ADR-324: A Package Links a C Library by Name, as Data the Compiler Acts On — There Is No Build Script, and a Package Brings No C Sources Yet
ADR-325: The Tools Below Nikaia Read No Configuration From the Project — Cargo and rustc Start in the Compiler's Own Directory, With a Configuration the Compiler Writes
ADR-326: Many Connections at Once — net::serve Below Every Protocol, Admission by an Exchangeable Strategy, and a Panic That Ends Only Its Task
ADR-327: Shared State After a Panic Is Never Read Half-Changed — Rebuilt Where It Says How — and Every Task and Shared Value Has a Memory Budget in Memory Nikaia Allocates Itself
ADR-328: Supervision — supervisor::run Runs a Supervisor Until It Gives Up, Children in Dependency Order, Restarts by an Exchangeable Policy, and a Child Keeps No Changeable State Across a Restart
ADR-329: A Reflected Field Also Answers Its Type as meta::Type and Its Documentation — What an API Description Is Built From, Without Annotations
ADR-330: A Type Is Passed Where a Function Asks for One, Answers Its Kind as a meta::Type That Carries Types, and a match on the Kind Checks Each Arm Under the Kind It Names
ADR-331: Attributes Are Values of Ordinary Structs, Written With @ Before a Declaration, Marked by @meta::Attribute, and Read as Members; a Struct Field May Have a Default
ADR-332: A Handler Gets Only What Its Signature Declares — Path and Query by Name, Everything Else by a Type That Extracts Itself From Declared Inputs; a Function Answers Its Parameters While the Program Is Built
ADR-333: A Type Declares comptime Value Parameters in Its Brackets, as Array[T, N] Does, and a Function Takes a comptime Parameter Its Call Writes as Any Other
ADR-334: A Tree of Routes Is a comptime Value — Handlers Capture Nothing, Shared State Comes In as State[T] — So the Whole Tree Is Checked and Its Matcher Built While the Program Is Built
ADR-335: A Layer Is a Declared Value With Fixed Phases — before, after, observe — and No Layer Ever Runs the Handler; It Runs at Most Once, Under the Runtime Alone
ADR-336: Before 0.1 Nikaia Is Installed With cargo install From the Repository; 0.1 Publishes to crates.io; GitHub Releases Begin at 0.2, With the Binary and a Container Image; a .deb Waits for 1.0
ADR-337: nikaia fmt Writes One Style With No Options, Keeps Every Comment, and Never Changes What a Program Means
ADR-338: std Is the Core the Language Stands On; Formats and Protocols Are Official Packages, Versioned on Their Own and Taken in by Their First use
ADR-339: A Grammar Can Say Where a Match Was (span(p), here) and Whether a Line Break Precedes It (same_line); /// Is a Rule, and No Grammar Declares a State or an extern rule
ADR-340: Every Expression Node Carries an Id Given Right After the Parse, Fixed for the Life of the Tree
ADR-341: Eq and Ord Are Traits of the Language, a Bound on Them Gives the Operators, and a Program Writes impl Eq and impl Ord for the Types It Declares
ADR-342: A Chain Over a List Runs Element by Element, With No List Between Its Steps; Where Its Lambdas Touch Nothing, the Order They Run In and Where an Overflow Stops It Are Not Fixed
ADR-343: process::exit(code) Ends main Now, With That Code, the Way main Ends; in a Task It Is Refused
ADR-344: json Reads Into the Type the Caller Names, by the Database's Rules; a Schema Is a Build-Time Input
ADR-345: Fatal Errors; exit Is One
ADR-346: Every Task Error Has a Receiver
ADR-347: An Enum of One Variant Is Written by Its Type's Name
ADR-348: The Memory main Still Holds Is Freed, Unless an Optimization Leaves It to the OS
ADR-349: E::V(..) Matches All of a Variant's Values
ADR-351: A Function Value Keeps the Error Set Inferred for It
ADR-352: null Is a Pattern in a match Over a T?
ADR-355: List Patterns, and .. as the Rest of Positional Values
ADR-356: A let and a for Head Take a Nested Tuple of Names — No Variant
ADR-357: A catch That Names Every Error Type Arriving Is Complete
ADR-358: A Parameter May Take a Tuple Apart, in a Function and in a Lambda; the Ledger Names the Parts
ADR-359: Within Its Package, a Callee's Body Answers a Claim That Needs It; a Call With Known Arguments Is Run; a Quotient by a Known Number Is a Term; Across a Package, a Hint
ADR-360: main's Parameters Are the Command Line; Its Preconditions, Carried Back as Any Function's Are, Are Checked Where the Words Arrive, a Breach Ending the Program With Status 2
ADR-361: A Loop Is a Problem in Horn Clauses; the Compiler Finds Its Invariant With a Growing Portfolio of Strategies, Checks Every One, and Takes Proposals From Outside Programs, an LLM Among Them, Only to Check Them
ADR-362: [v; n] Is a List Literal of n Copies of a Value That Copies, Typed by Its Use as Every List Literal Is; a List Literal of One Range Is Warned
ADR-363: The Toolchain's Own Nikaia Package Is Lowered at user_parallelism = yes; std's Modules Still Lower the Same at Both Settings
ADR-364: A Tuple May Be Nullable: (A, B)? Is Written as Any T? Is
ADR-365: Standard Input and Every File Read While the Program Runs Are Untrusted Unless Marked trusted: true; Only the Project's Own Assets Are Trusted
ADR-366: A Grammar Reads Bytes as Readily as Text; What Becomes Text Is Checked Where It Becomes Text
ADR-367: A Fold Over a Grammar's Input Takes No More Steps Than the Input Has Room For; Its Counters Are Proved From That, Only Where the Input's Length Is Known
ADR-368: A Program Can Measure Time and What Another Program Used: time::now(), a Duration's Readers, and What process::run Reports Beyond the Output
ADR-369: A Type's Invariant — Written as an assert in the Struct, and Found Where None Is Written
ADR-370: A Function Asks to Be Inlined With @inline; the Compiler Adds the Hint Itself Only Where It Knows Better
ADR-371: Vector Lanes, crc32c and Prefetch Are Portable std; an Instruction of One Architecture Is a Safe Function of Its Backend Module
ADR-372: Parallel Folding Without a Grammar - task::cores(), Par::fold, Pieces of Bytes; Pieces Are Claimed While the Work Runs, and Order Is Kept Unless the Program Says order: par::Order::Any
ADR-373: A Bytes Carries What Owns Its Memory; a ref Bytes That Is Only Read Takes Any Run of Bytes
ADR-374: A Position in a Text Is a text::Pos, Not a Number; a Text Is Cut by Name and a Position Moves Only in a Named Unit
ADR-375: A Bytes Searches for a Set of Bytes by What the Program Wants, Not by How Wide It Looks
ADR-376: unsafe { assume(claim) } - a Claim the Program Vouches For, a Fact Without a Proof
ADR-377: Vectors a Program Holds - simd::Lanes[T] at the Build's Width, simd::Fixed[T, N] Where an Algorithm Demands a Width
ADR-378: The Emitted Code Is unsafe Only Where a Switch or the Program Says So
ADR-379: An Unconditional Write Is Emitted Before the ifs Beside It That Cannot Tell
ADR-380: An assert the Compiler Does Not Prove Is Refused, Unless the Build Says warn
ADR-381: A Named Property of a Value Is a Fact - assert(is_sorted(xs)) Is Proved by Name, Carried to the Caller and Checked Once
ADR-382: A Test That Proves a T? Is Not null Makes It a T - for a Name and for a Path of Fields from It
ADR-383: A Parsed File's Nodes Are Numbered by a Pass of Their Own, in Input Order, Right After the Parse; the Grammar Gives No Ids
ADR-384: Entry::or_default and Seq::cloned Are in std
ADR-385: A Length Is an i64, and std States How Many Items a Sequence Yields
ADR-386: drain() Is on Every Map and Set, as on Vec and HashMap
ADR-387: A View of a Type That Copies Is Copied Where the Value Is Wanted
ADR-388: The Table a Grammar Interns Into Is the Caller's, Handed to the Entry as words:
ADR-389: immutable Binds a Value Nothing Reachable From It Ever Changes; at Item Level It Is Evaluated Once, on First Use
ADR-async-5: Every Task Is Started by async in a Group It Does Not Outlive; async e Is Waited For Where Its Value Is First Needed, a Handle Is Asked For by an Option, and Fan-Out Over a Collection Is the par_iter Chain
ADR-catch-1: A catch Block That Begins With an Arm Is a match Over error; Every Other catch Block Means What It Means Today
ADR-collections-1: The Ordered Collections Offer What the Hashed Ones Offer, Apart from Hashing: Every Map Has entry, Every List and Set Has extend
ADR-collections-2: An Array Is Read as a List Is: Array[T, N] and Its Run Have iter(), and the Sequence That Starts There; So Has Every Set
ADR-decision-records-1: A Record Is Named by Its Topic and a Number, ADR-<topic>-<n>; the Numbered Records Keep Their Numbers Until a Consolidation Replaces Them
ADR-error-sets-1: A Code Parameter the Body Does Not Keep Fails, at Each Call, with What That Call Hands It
ADR-grammar-1: A Grammar Takes Values - Rule Parameters and Options, Bounds and Guards - and an Action Stands After ->
ADR-grammar-2: A Grammar Entry May Take a Type, and the Compiler Builds a Parser per Type; members[S] Fills a Struct by the Compiler's Rules, So a Typed Read Is a Grammar and Not a Library Walk
ADR-lambdas-1: A Lambda That Runs at Most Once May Give Away What It Captures; for std the Contract Says So, for User Code It Is Inferred
ADR-regex-1: std::regex Is the RE2 Dialect; a Regular Expression Is Typed by Its Engine, a Pattern the Build Knows Is Compiled Down a Ladder of Engines and Run by std's Code Specialised for It, a Pattern That Arrives at Run Time Runs on Rust's Automata Crates
ADR-specialization-1: A Function Is Emitted per Build-Time Value Where Its Signature Asks: comptime? on a Parameter, @unroll on a Loop, Branches on Known Values Decided While Building, a Result Type Computed From a comptime Parameter
ADR-views-1: A Part Taken out of a let mut View of a Place Is Given Back Before the View Ends, as out of a mut Parameter
ADR-views-2: mut on a for Binding Means What It Means on a let: the Element of a Place Writes Through, an Owned Element Is the Loop's Own
ADR-views-3: A Parameter That Keeps Its Argument Says keep, ref Leaves the Language, and a Result's Source Is Inferred or Written from
ADR-yaml-1: yaml Is an Official Package in packages/yaml/: a Grammar Over Bytes Builds a Zero-Copy Tree With Spans, YAML 1.2 Core Schema, Limits On by Default; the serde_yaml Facade and stream Come Later
Notes
The documentation, and what belongs in each part
Why an automatic clone is not a convenience
The bootstrap: the compiler in Nikaia
Builder facts
CI: what a run spends, and what a cache can save
The consultant
Decision basis: text moved into a struct while a view of it lives (#942, step 1)
The error corpus
Facts about data: sorted lists, valid trees. Decision basis
A formal semantics of Nikaia? Decision basis
A formally verified compiler? Decision basis
Handoff — the parser backend: how to work on it, and what was already tried
The language, reviewed — where the syntax is weak, where people will curse, where data is at risk
What a compare-and-swap loop would buy, and the defect finding it uncovered
Long jobs: who runs them, how often, how long
Measuring performance
A modular compiler: decision basis
What an always-Mutex floor for Locked costs
How the supervisor chooses the next topic
Nikaia: status and roadmap
Self-hosting plan: the core of emit and check (#125, #558)
What the solver is asked, and where its time goes
What the specification promised, and what the compiler answers
Speed from round to round
A view kept past its call: what was built, and what a full answer would need
What the rustc subprocess costs — and what skipping it would have bought
The main session (supervisor)
Token saver strategy (agents)
Token speed: what the self-hosting agents cost against what they moved
Nikaia Toolchain Architecture
Unique ownership: a door with no lock in it
Writing for readers outside the project
Examples
Nikaia Examples
1brc.nika
fortunes.nika
access-log/src/
access-log/src/main.nika
c-library
c-library/src/
c-library/src/main.nika
calc/src/
calc/src/main.nika
config/src/
config/src/main.nika
crate-ledger/src/
crate-ledger/src/main.nika
escaping/src/
escaping/src/main.nika
A Rust crate that brings its own runtime — the ADR-303 D7 experiment
foreign-runtime/overlaps.nika
foreign-runtime/crossing/src/
foreign-runtime/crossing/src/main.nika
foreign-runtime/serve/src/
foreign-runtime/serve/src/main.nika
foreign-runtime/smuggled/src/
foreign-runtime/smuggled/src/main.nika
hello-http/src/
hello-http/src/main.nika
http/src/
http/src/main.nika
inventory/src/
inventory/src/main.nika
inventory/src/page.nika
inventory/src/stock.nika
json/src/
json/src/main.nika
k-nucleotide/src/
k-nucleotide/src/main.nika
n-body/src/
n-body/src/main.nika
report/src/
report/src/main.nika
sqlite/src/
sqlite/src/main.nika
tally/src/
tally/src/main.nika
trend/src/
trend/src/main.nika
trend/src/
main.nika
This site is open source.
Improve this page
.
