# Io

> A small, prototype-based programming language — now targeting WASM/WASI.

## Documentation

- [Documentation](/docs/): Guides, tutorial, language reference, and design notes.
- [Book](/docs/Book/): The original Io book, organized by chapter.
- [Appendix](/docs/Book/Appendix/): Grammar reference and citations.
- [Concurrency](/docs/Book/Concurrency/): Coroutines, actors, futures, and Io's concurrency model.
- [Control Flow](/docs/Book/Control%20Flow/): Branching, loops, exceptions, and scope.
- [Introduction](/docs/Book/Introduction/): The origins, philosophy, and influences behind Io.
- [Objects](/docs/Book/Objects/): Slots, prototypes, cloning, and differential inheritance.
- [Primitives](/docs/Book/Primitives/): Built-in objects: numbers, strings, lists, maps, files, and more.
- [Syntax](/docs/Book/Syntax/): Io's minimal grammar: expressions, messages, and operators.
- [Guide](/docs/Guide/): Comprehensive language guide: syntax, messages, objects, control flow, concurrency, and more.
- [Implementation](/docs/Implementation/): How the Io VM is put together, and how to extend it from C.
- [How to Write C Bindings](/docs/Implementation/How%20to%20Write%20C%20Bindings/): How to write Io-visible primitives in C — the macros, the argument-extraction API, proto registration, and GC-safe slot updates.
- [Overview](/docs/Implementation/Overview/): A tour of the Io VM source tree — object representation, the message tree, the evaluator, the standard library loader, and the garbage collector.
- [Reference](/docs/Implementation/Reference/): C-internal implementation details extracted from cdoc and cmetadoc comments.
- [BigInt](/docs/Implementation/Reference/BigInt/): C implementation of arbitrary-precision integers. Each BigInt is an IoObject whose dataPointer is an IoBigIntData that owns a libtommath mp_int (variable-size digit array on the heap). Unlike Number, BigInt has a real payload: rawClone allocates and mp_init's a fresh mp_int, and the tag's freeFunc must call mp_clear before freeing the wrapper. Operands must both be BigInts — there is no silent coercion from Number (matching JavaScript's BigInt rules), which is enforced by the IoBigInt_argData helper that raises an error on non-BigInt args. Every arithmetic method follows the same mp_init/op/mp_copy-into-new- BigInt/mp_clear pattern to keep libtommath's ownership discipline correct even in the face of GC-driven allocation.
- [Block](/docs/Implementation/Reference/Block/): C implementation of Io blocks and methods (they share the same struct; block() binds a lexical scope, method() leaves scope NULL so activation uses the message target). IoBlockData carries the message tree, an argNames List, the optional captured scope, passStops (whether return/continue/break propagate to the caller), and profiler timing. Activation happens via IoBlock_activate, which is installed as the tag's activateFunc — any getSlot of an activatable Block thus runs the block without explicit message dispatch. IoBlock_activate builds a fresh locals object (cloned from state->localsProto), populates it with call/self/updateSlot plus the named arguments, and recursively evaluates the body via IoMessage_locals_performOn_. With frame-based coroutines and the iterative evaluator, that inner perform will usually redirect into the eval loop rather than recurse on the C stack. The optional profiler wraps IoBlock_activate with clock() bookkeeping.
- [Call](/docs/Implementation/Reference/Call/): C implementation of the Call object created once per block/method activation. IoCallData captures the activation's sender (caller's locals), the target receiver, the triggering message, the slotContext (where the slot was found during lookup — can differ from target when the slot lives on a proto), the activated Block/CFunction itself, the coroutine that is running, and the stopStatus used to signal return/continue/break. Each Call is exposed through the block's locals as the "call" slot so Io code can read sender, message argAt, etc. IoCall_rawStopStatus is the primary C-level read path; the iterative evaluator (IoState_iterative.c) and IoBlock_activate both poke the status here when an early exit is requested.
- [CFunction](/docs/Implementation/Reference/CFunction/): C implementation of the CFunction primitive. An IoCFunctionData holds a C function pointer (IoUserFunction: target/locals/message -> result), an optional typeTag gate (only activate if target's tag matches, else raise a typed error), a uniqueName symbol for introspection, and profiler timing. Like Block, CFunction is self-activating: the tag's activateFunc is IoCFunction_activate, so fetching a CFunction from an activatable slot calls through immediately. This is how every C-backed Io method (List append, Number +, Object if/while/for, etc.) is installed — IoObject_addMethodTable_ creates one CFunction per entry and stores it in the target proto. CFunctions do not pre-evaluate their arguments; the recipient uses IoMessage_locals_valueArgAt_ or the pre-eval fast path (IoState_preEvalArgAt_) to fetch them lazily.
- [Collector](/docs/Implementation/Reference/Collector/): Thin Io-facing wrapper around the underlying C Collector (see basekit/source/Collector.c). There is no dedicated IoCollector struct — the proto is just an IoObject carrying a method table; every method forwards to Collector_* on IOSTATE->collector. Because of that, the file has no tag/newTag/rawClone/free/mark functions: lifecycle of the collector itself is owned by IoState. The Io-level methods exposed here (collect, setMarksPerAlloc, allObjects, dirtyObjects, etc.) let scripts tune and inspect the incremental tri-color mark-sweep at runtime. COLLECTOR_FOREACH iterates every live marker and is used by the introspection methods.
- [Compiler](/docs/Implementation/Reference/Compiler/): Thin Io-facing facade over the C lexer (IoLexer) and the C recursive- descent parser (IoMessage_parser). Exposes three Io-visible entry points — tokensForString, messageForString, messageForString2 — that run a source string through IoLexer_lex, surface any errorToken as an Io "compile error" Exception, and either hand back a list of token description objects or the root IoMessage of the parsed chain. The Compiler proto itself is just a slot-holder; there is no compiled bytecode representation in Io, so "compiling" means producing a message tree.
- [Continuation](/docs/Implementation/Reference/Continuation/): C implementation of first-class continuations. A continuation owns a deep copy of the IoEvalFrame chain that was current at `callcc` time, plus the locals of the capturing block. Invocation is one-shot and destructive: the stored chain is installed as `state->currentFrame`, the continuation's pointer is nulled, and `state->continuationInvoked` tells the eval loop to restart from the new top. `copy` makes a fresh deep copy so the same point can be re-entered more than once. Deep copy is required because popped frames are zeroed by the pool in IoState_iterative_fast.c — a grab-pointer capture would see empty frames by the time `callcc` returns. Frames stay GC-reachable through IoEvalFrame's own mark walk of the parent chain; `capturedLocals` is marked here. `asMap` / `fromMap` serialize a continuation to a plain Map (state enum name, message source text, primitive fields, per-state controlFlow payload) so continuations can cross process or network boundaries and be rebuilt from text — the design target that motivated the stackless rewrite.
- [Coroutine](/docs/Implementation/Reference/Coroutine/): C implementation of Io coroutines built on the heap-allocated IoEvalFrame chain instead of platform C-stack switching (no ucontext, fibers, setjmp, or assembly). A coroutine owns its own IoEvalFrame parent chain (DATA(self)->frameStack), a retain stack (ioStack), and bookkeeping for stop status, return value, and frame depth. Switching coroutines is a pure pointer swap: IoCoroutine_saveState_ parks state->currentFrame and friends into the outgoing coro, then IoCoroutine_restoreState_ pulls the incoming coro's saved frame chain back into the live IoState. The same single eval loop (IoState_evalLoop_) keeps running on the main C stack and simply resumes iterating on whichever frame chain is now current. The GC walks each coroutine's saved frame chain via IoCoroutine_mark so suspended coroutines stay alive and reachable.
- [Date](/docs/Implementation/Reference/Date/): IoObject wrapper around the plain-C Date struct (a timeval plus a timezone). All real calendar math — year/month/day/hour/minute/second decomposition, strftime-style formatting, strptime-style parsing, UTC/local/zone conversion — lives in Date.c and PortableStrptime.c; this file just bridges Io message sends to those C routines, manages lifecycle (tag, clone, free, compare), and handles arithmetic with IoDuration (Date + Duration -> Date, Date - Date -> Duration). A "format" slot on the proto holds the default strftime pattern ("%Y-%m-%d %H:%M:%S %Z") that asString falls back to when no explicit format argument is supplied.
- [Debugger](/docs/Implementation/Reference/Debugger/): C side of the Debugger object is intentionally tiny — it is a plain Io object with only a "type" slot stamped here; all stepping logic lives in Io-level code. The real wire-up happens in IoCoroutine.c: when a coroutine has debuggingOn, IoObject_performWithDebugger populates slots like message, messageSelf, messageLocals, messageCoroutine on this proto and resumes the coroutine stored in the Io-level `debuggerCoroutine` slot. That makes the debugger a regular Io coroutine paused in a receive loop, woken once per message send of the target coroutine.
- [Directory](/docs/Implementation/Reference/Directory/): C implementation of Directory — a thin Io wrapper around POSIX opendir/readdir/closedir. IoDirectoryData holds a single symbol (the path); each items/at/size call reopens the directory rather than keeping a persistent DIR* open, which keeps clone semantics trivial and avoids leaking descriptors on GC. Under WASI the evaluator must have been started with --dir= for any path to be openable; otherwise opendir fails and Io sees an "unable to open directory" exception. isDirectory prefers the d_type fast path when the host dirent exposes it, falling back to a stat call otherwise.
- [Duration](/docs/Implementation/Reference/Duration/): Thin IoObject wrapper around the plain-C Duration struct (years, days, hours, minutes, seconds). All arithmetic and formatting live in Duration.c; this file only bridges Io message sends to the C API, manages lifecycle (tag / clone / free / compare), and registers the proto. Durations interoperate with IoDate for +/- arithmetic — see IoDate_add / IoDate_subtract, which read the C Duration via IoDuration_duration — and with IoNumber through asNumber / fromNumber, treating seconds as the canonical scalar form.
- [Error](/docs/Implementation/Reference/Error/): Minimal C scaffolding for the Error proto. The object carries no C payload of its own — error information lives entirely in Io-level slots such as "message" — so this file only supplies the tag, proto registration, and a pair of convenience constructors used by C code that wants to hand an Error up through the VM. The richer exception flow (raise, catch, pass) is implemented in Io on top of Exception; IoError is the lightweight structural representative returned by primitives that report failure without raising.
- [EvalFrame](/docs/Implementation/Reference/EvalFrame/): Heap-allocated frame state machine that replaces C-stack recursion in the evaluator. Each frame is a GC-managed IoObject carrying an IoEvalFrameData payload: the message being evaluated, its target/locals, an evaluation state (see IoFrameState), evaluated-argument storage with a 4-slot inline buffer, and a discriminated-union of control-flow continuations (if/while/ for/foreach/callcc/coroutine/await) live only for the states that use them. Frames form a parent chain rooted at the coroutine's bottom frame; the GC walks that chain via the tag's markFunc. This module owns frame lifecycle (alloc, clone, reset, free) and state-name ↔ enum conversion; the actual step-by-step state transitions live in IoState_iterative.c.
- [File](/docs/Implementation/Reference/File/): Stat-related methods for File — split out from IoFile.c so the stat(2) surface can be built out (or stubbed) independently of the core stream API. IoFile_statInit is called from IoFile_proto and bolts these methods onto the File proto. The struct stat buffer is lazily allocated and cached in IoFileData->info on first use, then shared by every subsequent protectionMode / userId / size / isDirectory query until the file is freed. The S_ISLNK and S_ISSOCK macros are stubbed to 0 under WASI, where the type bits are unavailable; lstat falls back to stat for the same reason.
- [Lexer](/docs/Implementation/Reference/Lexer/): Hand-written UTF-8 aware tokenizer that turns an Io source string into a List of IoTokens. The lexer is driven by IoLexer_lex which kicks off a recursive IoLexer_readMessage loop; each sub-reader (readIdentifier, readOperator, readNumber, readQuote, readComment, ...) uses a position-saving pushPos / popPos / popPosBack convention to implement try-then-backtrack parsing without a separate parse state. Emitted tokens are appended both to the flat tokenStream List (parallel consumption order by the parser) and chained via nextToken links inside IoToken itself. Nested `/*...*\/` comments, triple-quoted strings, hex and decimal literals with exponents, backslash line continuations, and synthesised group-name tokens for `[...]` and `{...}` are all handled here. The parser in IoMessage_parser.c pops tokens off the stream and routes them through IoMessage_ifPossibleCache Token_.
- [List](/docs/Implementation/Reference/List/): Thin IoObject wrapper around the shared basekit List container (DATA(self) is a plain List*). The tag installs clone/mark/free/compare function pointers; marking walks every element so the GC keeps contained objects alive. Iteration primitives (each, foreach, reverseForeach) have two execution paths: when state->currentFrame is set they stamp the frame's controlFlow.foreachInfo union and return immediately so the iterative eval loop drives the iteration (see FRAME_STATE_FOREACH_* in IoState_iterative.c); otherwise a LIST_SAFEFOREACH recursive fallback is used, which is exercised during VM bootstrap before the eval loop starts. Mutation methods set IoObject_isDirty_ so Store/persistence layers can notice change. asEncodedList / fromEncodedList implement a compact binary round-trip used by the object serialization machinery.
- [Map](/docs/Implementation/Reference/Map/): Thin IoObject wrapper around basekit's PHash (cuckoo hash). DATA(self) is the PHash*; mark walks every key and value so contained IoObjects remain live. Unlike Io's own Object slots (which are stored in a PHash owned by the Object), Map is a separate user-visible collection with ordering-free semantics and symbol keys. The foreach implementation has two paths: on the iterative evaluator it materializes keys via IoMap_rawKeys and hands the List off to the foreach frame state machine (controlFlow.foreachInfo.mapSource carries the original Map so the loop can look the value up per iteration). The recursive fallback PHASH_FOREACH is used only during VM bootstrap before state->currentFrame exists.
- [Message](/docs/Implementation/Reference/Message/): C implementation of Io's first-class Message. An IoMessage is the AST node and the runtime perform record rolled into one: it holds a name (IoSymbol), an args List of sub-message trees, an optional cachedResult (literal or inline-cache value), a `next` pointer to the rest of the chain, an inline slot-lookup cache (inlineCacheValue / inlineCacheContext, marked with the containing tag version), and source-location fields (label, lineNumber). Evaluation goes through IoMessage_locals_performOn_, which delegates to the iterative evaluator in IoState_iterative.c whenever a frame exists; a bootstrap-only recursive fallback handles the short window before the first eval loop starts. Most Io-visible getters/setters are thin wrappers around IoMessage_raw*_ helpers; the raw helpers are also how IoMessage_parser and IoMessage_opShuffle build and rewrite trees without running the perform machinery.
- [Number](/docs/Implementation/Reference/Number/): C implementation of Io's Number proto. A Number is an IoObject whose inline data union stores a double — no separate heap payload, no dataPointer. The CNUMBER / DATA macros just reinterpret the inline slot, and IoNumber_free is a no-op because there is nothing to release. Most arithmetic methods are thin shims that read the double out of self (and any operand), compute, and return a freshly minted Number via IONUMBER. Number is registered as a primitive proto on the state so IONUMBER can clone without going through the message machinery. Bitwise and character-class methods cast the double to long / int on the fly; the limits methods expose the host's / constants.
- [Object](/docs/Implementation/Reference/Object/): C implementation of the root Object prototype — the ancestor of every Io value. An IoObject is a CollectorMarker whose `object` field points to an IoObjectData carrying the tag (vtable), a PHash of slots, an inline-or-heap-allocated protos array, and a small data union used by primitive subtypes. This file owns allocation (IoObject_justAlloc / _alloc / _proto), cloning (raw / primitive / IOCLONE with init), proto chain manipulation (rawAppendProto_, rawPrependProto_, rawRemoveProto_ with inline-or-realloc'd storage), slot read/write, lookup loop detection, the whole Io-visible method table installed by IoObject_protoFinish, and the localsProto variant used for block locals. Most of the `IO_METHOD(IoObject, ...)` functions here already carry doc blocks and are part of the Io-visible API; only the internal C helpers (raw*, alloc/dealloc, activateFunc, lookup primitives) are annotated below.
- [Profiler](/docs/Implementation/Reference/Profiler/): C implementation of Profiler — walks the full heap via the collector to reset or report per-Block timing data. Profiler owns no state of its own; the profiler timings live on individual IoBlocks (IoBlock_rawProfilerTime / IoBlock_rawResetProfilerTime). This module just provides the bulk reset and bulk query entry points. A commented-out CFunction branch is kept as a placeholder for extending profiling to native functions.
- [Sandbox](/docs/Implementation/Reference/Sandbox/): C implementation of Sandbox — a wrapper that lazily spins up an entire nested IoState and runs strings of Io code inside it. The inner IoState is stored in the IoObject's data pointer (see DATA(self)) and created lazily by IoSandbox_boxState so empty Sandbox clones stay cheap. Quota-style protection (messageCountLimit, timeLimit) is enforced by the inner IoState's evaluator, not by this module; setters here just poke those fields. Output from code run in the sandbox is intercepted via IoState_printCallback_ and re-sent as a printCallback message back to the outer VM, so the host can decide what to do with sandboxed stdout.
- [Sequence](/docs/Implementation/Reference/Sequence/): C implementation of the Sequence / String / Symbol proto. A Sequence is an IoObject whose dataPointer is a UArray — a typed, resizable byte array from the basekit runtime that tracks itemType, encoding, and item size in addition to raw bytes. A single proto serves three roles: mutable Sequence, immutable Symbol (interned; pointer-equality for equal strings), and typed numeric vector (uint8, int32, float32, etc.) used by the fast math methods. The split across IoSeq.c, IoSeq_immutable.c, IoSeq_mutable.c, and IoSeq_vector.c is purely a code-organization partition: this file owns lifecycle (clone/free/ compare), the constructor API, and cross-partition helpers; IoSeq_immutable.c holds read-only methods also usable on Symbols; IoSeq_mutable.c holds the in-place-mutating methods; IoSeq_vector.c holds the SIMD/vector math. Symbols are detected via IoObject_isSymbol; rawClone short-circuits on them (returning the original) so every "clone" of a Symbol is the same interned object.
- [State](/docs/Implementation/Reference/State/): Top-level entry points for evaluating Io source from C. Every "run some code" path embedders expose eventually funnels through IoState_tryToPerform, which spawns a fresh try-coroutine so uncaught exceptions are captured instead of reaching the host. Sandbox-mode state (message count limit, deadline endTime) is reset here before the evaluation starts so the iterative evaluator can enforce the limits per-run. This file is intentionally small — the actual step machinery lives in IoState_iterative.c.
- [System](/docs/Implementation/Reference/System/): C implementation of Io's System object — a slot-only object (no dedicated data pointer or tag) that exposes VM- and environment-level hooks: process exit, errno string, env var get/set, platform name, sleep, symbol table, lobby root, and GC recycler tuning. Under WASI the host-provided surface is minimal: daemon and system() raise errors, thisProcessPid is always 1, activeCpus is 1, and platform/ platformVersion return "wasm"/"wasi-0.1". IO_VERSION_STRING and INSTALL_PREFIX are stamped onto System as slots in IoSystem_proto so Io code can query the build identity.
- [Tag](/docs/Implementation/Reference/Tag/): Per-type vtable shared by every IoObject of a given primitive class. An IoTag carries the type's name, a set of function pointers (clone, free, mark, activate, compare, perform, write/read, notification, cleanup) and is reference-counted across the proto and all its clones. Each IoObject_new... constructor attaches exactly one tag (installed by the corresponding IoXxx_newTag helper) and the collector calls markFunc / freeFunc through the tag rather than switching on type. Keeping the dispatch here lets IoObject stay a fixed-size marker regardless of how many primitive subtypes the VM defines.
- [Token](/docs/Implementation/Reference/Token/): Plain-C token node produced by IoLexer as it scans source text. A token carries its spelling (name/length), an IoTokenType classification, a lineNumber/charNumber for diagnostics, an optional error string, and a forward-link `nextToken` that the lexer uses to splice tokens into a singly-linked chain parallel to the per-frame List tokenStream. Tokens are owned by the lexer and freed via IoToken_free; they are not IoObjects and are not GC-managed — the parser in IoMessage_parser.c consumes them one at a time and translates each into an IoMessage.
- [WeakLink](/docs/Implementation/Reference/WeakLink/): C implementation of WeakLink. Holds a single non-owning pointer (DATA(self)->link) that is deliberately NOT marked by the GC, so the referent can be collected even while a WeakLink names it. The mechanism for notification is the IoObject listener list plus the tag's notificationFunc: on setLink, the WeakLink registers as a listener on the target via IoObject_addListener_; when the target is freed, the collector fires IoWeakLink_notification which clears the pointer back to NULL. There is no markFunc registered — that is the whole point. The commented-out writeToStream/readFromStream pair persists WeakLinks by PID (IoObject_pid) so they can be rehydrated through IoState_objectWithPid_.
- [Reference](/docs/Reference/): Browse every built-in object and method in Io's standard library.
- [Block](/docs/Reference/Block/): An anonymous function (method or block) that captures messages and arguments. Activated by sending it a message.
- [Call](/docs/Reference/Call/): Call stores slots related to activation.
- [CFunction](/docs/Reference/CFunction/): A wrapper around a C function exposed to Io as an activatable slot.
- [Collector](/docs/Reference/Collector/): A singleton containing methods related to Io's garbage collector. Io currently uses a incremental, non-moving, generational collector based on the tri-color (black/gray/white) algorithm with a write-barrier. Every N number of object allocs, the collector will walk some of the objects marked as gray, marking their connected white objects as gray and turning themselves black. Every M allocs, it will pause for a sweep where it makes sure all grays are marked black and io_frees all whites. If the sweepsPerGeneration is set to zero, it will immediately mark all blacks as white again and mark the root objects as gray. Otherwise, it will wait until the sweepsPerGeneration count is reached to do this. By adjusting the allocsPerSweep and sweepsPerGeneration appropriately, the collector can be tuned efficiently for various usage cases. Generally, the more objects in your heap, the larger you'll want this number.
- [Compiler](/docs/Reference/Compiler/): Contains methods related to the compiling code.
- [Continuation](/docs/Reference/Continuation/): A first-class continuation captured by `callcc`. Represents a resumable snapshot of execution state; invoking it re-enters the captured context.
- [Coroutine](/docs/Reference/Coroutine/): Coroutine is an primitive for Io's lightweight cooperative C-stack based threads.
- [Date](/docs/Reference/Date/): An absolute point in time, represented as seconds since the epoch.
- [Debugger](/docs/Reference/Debugger/): Contains methods related to the IoVM debugger.
- [Directory](/docs/Reference/Directory/): A handle to a directory on disk. Lists contents, creates subdirectories, and walks file trees.
- [DirectoryCollector](/docs/Reference/DirectoryCollector/): An object to collect multiple UnitTests defined in *Test.io files within a given directory (System launchPath directory by default).
- [Duration](/docs/Reference/Duration/): A container for a duration of time.
- [Error](/docs/Reference/Error/): Error-handling helpers for returning error values from methods instead of raising exceptions.
- [EvalFrame](/docs/Reference/EvalFrame/)
- [Exception](/docs/Reference/Exception/): The Exception proto is used for raising exceptions; instances hold exception-related info. Raise An exception can be raised by calling raise() on an exception proto. Exception raise("generic foo exception") Try and Catch To catch an exception, the try() method of the Object proto is used. try() will catch any exceptions that occur within it and return the caught exception or nil if no exception is caught. e := try() To catch a particular exception, the Exception catch() method can be used. Example: e := try( // ... ) e catch(Exception, writeln(e coroutine backtraceString) ) The first argument to catch indicates which types of exceptions will be caught. catch() returns the exception if it doesn't match and nil if it does. Pass To re-raise an exception caught by try(), use the pass method. This is useful to pass the exception up to the next outer exception handler, usually after all catches failed to match the type of the current exception: e := try( // ... ) e catch(Error, // ... ) catch(Exception, // ... ) pass Custom Exceptions Custom exception types can be implemented by simply cloning an existing Exception type: MyErrorType := Error clone
- [false](/docs/Reference/false/): The false singleton — Io's representation of boolean falsity.
- [File](/docs/Reference/File/): A handle to a file on disk. Supports reading, writing, seeking, and metadata queries.
- [FileCollector](/docs/Reference/FileCollector/): An object to collect multiple UnitTests defined in the current file.
- [FileImporter](/docs/Reference/FileImporter/): An Importer for local source files.
- [Importer](/docs/Reference/Importer/): A simple search path based auto-importer.
- [List](/docs/Reference/List/): A mutable, ordered collection of values indexed by integer position.
- [Map](/docs/Reference/Map/): A mutable dictionary mapping Sequence keys to arbitrary values.
- [Message](/docs/Reference/Message/): A parsed message in Io's AST. Carries a name, argument messages, the next message in the chain, and cached values for evaluation.
- [MutableSequence](/docs/Reference/MutableSequence/): A Sequence whose contents can be modified in place. MutableSequence is the receiver for the mutating methods of Sequence (append, insert, remove, etc.).
- [nil](/docs/Reference/nil/): nil is a singleton object that is used as a placeholder and to mean false in Io.
- [Number](/docs/Reference/Number/): A double-precision floating-point value. All numeric literals are Numbers.
- [Object](/docs/Reference/Object/): The root proto. All other protos clone from Object; it provides core slot management, message dispatch, introspection, and control flow primitives.
- [Path](/docs/Reference/Path/): Path manipulation: joining, splitting, absolute/relative conversion, and tilde expansion.
- [Profiler](/docs/Reference/Profiler/): A sampling profiler for timing message execution.
- [Sandbox](/docs/Reference/Sandbox/): Runs Io code in an isolated child state with restricted resource limits.
- [Scheduler](/docs/Reference/Scheduler/): Io's coroutine scheduler.
- [Sequence](/docs/Reference/Sequence/): An ordered, homogeneous collection of bytes or numbers. Strings are Sequences with a character encoding.
- [State](/docs/Reference/State/): High-performance iterative evaluator with aggressive optimizations: - Frame pooling (no malloc/free in hot path) - Computed gotos (faster than switch) - Inline fast paths for common cases - Local variable caching
- [System](/docs/Reference/System/): Process-level operations: command-line arguments, environment variables, platform info, and exit.
- [TestRunner](/docs/Reference/TestRunner/): Core testing object responsible for running tests, collected by UnitTests and TestSuites.
- [true](/docs/Reference/true/): The true singleton — Io's representation of boolean truth.
- [UnitTest](/docs/Reference/UnitTest/): An object for organizing and running unit tests validated by assertions.
- [WeakLink](/docs/Reference/WeakLink/): A WeakLink is a primitive that can hold a reference to an object without preventing the garbage collector from collecting it. The link reference is set with the setLink() method. After the garbage collector collects an object, it informs any (uncollected) WeakLink objects whose link value pointed to that object by calling their "collectedLink" method.
- [Style Guide](/docs/Style%20Guide/): How to write idiomatic Io — naming, formatting, comments, and the patterns used throughout the standard library.
- [Technical Notes](/docs/Technical%20Notes/): Design docs on WASM targeting, stackless evaluation, and future work.
- [Future Work](/docs/Technical%20Notes/Future%20Work/): Design notes and proposals for upcoming changes.
- [Exceptions](/docs/Technical%20Notes/Future%20Work/Exceptions/): Design notes on the current exception system and proposed improvements.
- [Stackless](/docs/Technical%20Notes/Stackless/): Io's iterative evaluator, continuations, and coroutines.
- [Stackless VM Examples](/docs/Technical%20Notes/Stackless/Examples/): Patterns enabled by the heap-allocated frame-based evaluator: portable coroutines, TCO, frame introspection, and robust exception handling.
- [Stackless Evaluator Report](/docs/Technical%20Notes/Stackless/Report/): Design and status notes on the heap-allocated frame-based evaluator.
- [WASM](/docs/Technical%20Notes/WASM/): Running Io in the browser via WebAssembly.
- [Browser Target](/docs/Technical%20Notes/WASM/Browser%20Target/): Io runs in the browser as a WebAssembly module. The browser build compiles the full VM into a WASM reactor module that JS loads and drives via exported functions.
- [DOM Interop](/docs/Technical%20Notes/WASM/DOM%20Interop/): Io code running in the browser can query, create, and manipulate HTML elements through the DOM object and Element instances.
- [Tutorial](/docs/Tutorial/): A short, example-driven tour of Io for folks who already know how to program. Each section is a quick REPL session.

## FAQ

- [FAQ](/FAQ/): Common questions about Io — its origins, philosophy, and practical use.

## Timeline

- [Timeline](/Timeline/): Milestones in Io's history, from 2002 to today.