{ "title": "", "subtitle": "A small, prototype-based programming language — now targeting WASM/WASI.", "topTitle": "Io", "content": [ { "type": "ContentText", "title": "About", "body": "

Io is a dynamic, prototype-based language built on a few simple ideas taken from Smalltalk (all values are objects), Self (prototypes, not classes), NewtonScript (differential inheritance), Act1 (actors and futures for concurrency), Lisp (code is a runtime-inspectable message tree), and Lua (small and embeddable).

Its guiding design principle is simplicity and power through conceptual unification — a handful of primitives stand in for features most languages keep separate:

concept	unifies
scopable blocks	functions, methods, closures
prototypes	objects, classes, namespaces, locals
messages	operators, calls, assigns, var access

The VM is written in portable C and now targets WebAssembly (WASI) by default. The same binary runs under wasmtime, Node.js, or directly in the browser via a bidirectional Io↔JavaScript bridge.

" }, { "type": "ContentText", "title": "Key Features", "body": "

Minimal Syntax — Expressions only. No keywords, no statements, no special forms. Every expression is a message send, including assignment, operators, and control flow.
Prototype-Based Objects — No classes. New objects are clones of existing ones, slots are created on write, and any object can be used as a prototype for any other.
Differential Inheritance — Clones inherit by reference until a slot is assigned, so most objects carry only the deltas that distinguish them from their parents.
Multiple Inheritance — Every object has a list of protos; lookup is depth-first with runtime loop detection.
Messages as Code — Messages form trees that can be inspected and rewritten at runtime. Argument evaluation can be deferred, so if, while, and for are implementable in Io itself.
Runtime Introspection — Slots, protos, message trees, and block source code are all inspectable and modifiable at runtime.
Actors and Futures — Any object can receive asyncSend or futureSend messages and run its own coroutine. Futures are transparent (they become their result) and detect deadlocks automatically.
Coroutines Everywhere — Concurrency uses cooperative user-level coroutines rather than OS threads, scaling to thousands of active tasks without thread-level overhead.
First-Class Continuations — the VM is callcc-capable: the current computation can be captured as a first-class value and later resumed, stored, or serialized.
Unified Sequences — Strings, buffers, and numeric vectors share one Sequence primitive, with multiple item types, text encodings, and SIMD acceleration on float vectors.
WASM/WASI Target — The default build produces a single WebAssembly module that runs under wasmtime, Node.js, or in browsers, with full access to the DOM when hosted in a page.
Io↔JS Bridge — Host integration on the browser target is bidirectional: Io can call JavaScript functions and JavaScript can call Io methods, replacing the native-addon model of earlier Io releases.
Embeddable Core — The VM ships as a single WebAssembly module under a BSD license, embeddable in any WASM host — browsers, Node.js, or native apps via wasmtime or wasmer.

" }, { "type": "ContentCards", "columns": 2, "items": [ { "title": "Documentation", "href": "docs/index.html", "subtitle": "Guides, tutorial, language reference, and design notes." }, "FAQ", { "title": "GitHub Repository", "href": "https://github.com/IoLanguage/io", "subtitle": "Source code, issues, and contributions." }, "Timeline" ] }, { "type": "ContentText", "body": "

For AI agents: llms.txt (curated index) and llms-full.txt (full content).

" } ] }

Reference

Objects