Release Notes

← Home
Io

Notable changes in Io over the past twelve months.

Io uses date-based versioning. This page collects the notable changes of the last twelve months — a period in which the VM was rewritten around a stackless evaluator and re-targeted from native binaries to WebAssembly. Entries marked tagged correspond to release tags in the repository; the rest are development milestones on the road between them. For the longer arc, see the Timeline.

2026.11.19 — Backtraces and exit status

Tagged 2026.11.19. Errors now say where they came from, and a failing script reports failure to the shell.

  • Backtraces are back — an uncaught error prints the calls that led to it, with file and line, instead of “nothing on stack”. An exception records its trace when it is raised: Exception stackTraceLines returns it as a list, and pass keeps the original.
  • Failing scripts exit non-zero — a script or -e expression that ends with an uncaught exception exits with status 1, so shell scripts and CI can tell it failed. It exited 0 because the CLI looked for the exception on the wrong coroutine.
  • Build — make rebuilds the objects that include a changed header; a clean build is no longer needed after editing one (#515).

2026.11.18 — Long-running programs stop growing

Tagged 2026.11.18. A memory fix for programs that never return to the top level: servers, actors, and long-lived coroutines.

  • Loops release their temporaries — while, loop, for and foreach kept every value a loop body created until the enclosing method returned, so a top-level script or an actor that loops forever grew without bound. A 300,000-iteration loop used to leave 300,000 objects behind; it now leaves two (#513).
  • Coroutine switches no longer leak — each yield, pause or resume left a stray marker on the retain stack that kept a few objects alive per switch.
  • A possible crash in for and foreach — loops counting through small integers released the wrong retain-stack entries on each iteration, which could corrupt the stack.

2026.11.17 — Io on npm, and inside the JS event loop

Tagged 2026.11.17. The first release since the WASM merge, and the first on npm.

  • npm package — npm install @iolanguage/io runs the VM from JavaScript in Node and browsers (@iolanguage/io). Releases publish to npm from the release workflow with provenance.
  • Io inside the JS event loop — in the browser and Node build, Io coroutines, actors, wait and await on JS Promises run without blocking JavaScript; an eval that waits resolves when it finishes, and callbacks JS calls later can wait too (#509).
  • ES module — the browser bridge is an ES module with a small API: Io.load(), eval, lobby, onOutput, dispose (#507).
  • Syntax errors no longer crash the VM — unfinished source such as x := ( raises a catchable compile error; it used to trap the VM and end a REPL session (#511).
  • Closures over method locals — a block created inside a method keeps its scope after the method returns; the locals used to be recycled while the block still used them.
  • Fixes found along the way — a message chain sent to an actor future ran more than once; then/catch/finally ran the rest of the statement twice; JS Promises stopped resolving after about a thousand; List_removeLast_ never removed anything, so retained objects were never released.
  • WASI 0.2 component build — make component builds the VM as a WebAssembly component (wasm32-wasip2) alongside the core WASI module.
  • Cooperative scheduler timer queue — wait parks the calling coroutine on a timer queue instead of busy-spinning; timed coroutines run concurrently and the VM idles in a single host wait until the next deadline.
  • Live Interpreter — an in-browser REPL running the full VM, linked from the home page.
  • Performance tracking — a benchmark page recording interpreter, shootout, and SIMD results over time.
  • WASI 0.3 notes — design notes on adopting native-async components (future/stream) once host and toolchain support land.

2026.04.20 — WASM becomes the default target

Tagged 2026.04.20-native-final. The WASM branch merged to master (#495); WebAssembly/WASI is now the default and only build target. The final native build — CMake, Eerie, and DynLib — is frozen at this tag, with ongoing native work on the native branch.

  • SIMD128 Vector backend — the Vector primitive gains a WebAssembly SIMD128 backend, restoring AltiVec-era vector acceleration on modern hardware and in the browser.
  • 64-bit integer literals — integer literals no longer truncate to 32 bits (#420).
  • Map equality — Map implements comparison for equality (#28).
  • JSON singletons — asJson added to nil, true, and false (#27).
  • isKindOf fix — ancestor checks use identity comparison (#201).
  • Site and Book restructured for the WASM era; continuous integration rewritten for the WASM toolchain.

2026.03.06 — Stackless alpha, WASM port, and the JS bridge

Tagged 2026.03.06-stackless-alpha. The first alpha of the stackless VM, together with the initial WebAssembly port and a new JavaScript integration model.

  • WASM/WASI cross-compilation — the VM compiles to a single portable WebAssembly module that runs under wasmtime, Node.js, or the browser.
  • Bidirectional Io↔JavaScript bridge — Io can call JavaScript functions and JavaScript can call Io methods, replacing the native addon model. DynLib, AddonLoader, and the Eerie addon infrastructure were removed.
  • Async/await across the bridge — futures integrate with JavaScript Promises: the eval loop yields and resumes across the JS boundary, and an unrecognized message sent to a pending future implicitly awaits its result.
  • BigInt — arbitrary-precision integers with transparent round-tripping across the Io↔JS bridge.
  • Browser REPL — an interactive interpreter hosted in a web page, with demos for the bridge, DOM access, async, and callbacks.
  • Strings default to UTF-8.

2026.02 — Stackless evaluator

The recursive, C-stack-based evaluator was replaced with a heap-allocated frame state machine — the foundation the WASM port builds on. With no native C stack to switch, the platform-specific coroutine assembly is no longer needed.

  • Iterative eval loop — evaluation runs on a frame state machine instead of C recursion.
  • First-class continuations — the current computation can be captured, resumed, stored, or serialized (callcc, behind the IO_CALLCC build flag).
  • Tail-call optimization — including through if branches.
  • Robust exception unwinding — Io-level exceptions are unwound by the eval loop rather than C setjmp/longjmp.
  • Resumable exceptions — Common Lisp–style signal / withHandler: a handler can resume at the signal site, fall through, or unwind.
  • GC-managed eval frames — frames are pooled, garbage-collected objects; coroutines became frame-based and the old platform-specific coroutine library was removed.

2025.07 — ARM64 coroutines

Native ARM64 coroutine support for Apple Silicon and modern Linux (#476) — the last major addition to the native-era coroutine implementation before the stackless rewrite made platform-specific coroutine code unnecessary.