From 257b352a01724d2946a3805418dbb312c4b6feeb Mon Sep 17 00:00:00 2001 From: Steve Dekorte Date: Tue, 17 Nov 2026 11:22:49 -0800 Subject: [PATCH] Release notes for 2026.11.18 Co-Authored-By: Claude Fable 5.2 Claude-Session: https://claude.ai/code/session_011WETVfgtbJ5chDp7AeZUe9 --- Release Notes/_index.json | 5 +++++ Release Notes/index.html | 4 ++-- index.html | 4 ++-- llms-full.txt | 10 +++++++++- llms.txt | 2 +- 5 files changed, 19 insertions(+), 6 deletions(-) diff --git a/Release Notes/_index.json b/Release Notes/_index.json index 10b990c76..1178faa5f 100644 --- a/Release Notes/_index.json +++ b/Release Notes/_index.json @@ -6,6 +6,11 @@ "type": "ContentText", "body": "

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.

" }, + { + "type": "ContentText", + "title": "2026.11.18 — Long-running programs stop growing", + "body": "

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

" + }, { "type": "ContentText", "title": "2026.11.17 — Io on npm, and inside the JS event loop", diff --git a/Release Notes/index.html b/Release Notes/index.html index cbf79c3d3..69ef43fe0 100644 --- a/Release Notes/index.html +++ b/Release Notes/index.html @@ -11,8 +11,8 @@ -

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.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.

+

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.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.

- + diff --git a/index.html b/index.html index 200109dad..d9af493c0 100644 --- a/index.html +++ b/index.html @@ -23,8 +23,8 @@ -
Io

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

About

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:

conceptunifies
scopable blocksfunctions, methods, closures
prototypesobjects, classes, namespaces, locals
messagesoperators, 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.

Key Features

  • 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.
+
Io

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

About

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:

conceptunifies
scopable blocksfunctions, methods, closures
prototypesobjects, classes, namespaces, locals
messagesoperators, 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.

Key Features

  • 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.
- + diff --git a/llms-full.txt b/llms-full.txt index 6004d7ec3..42ddcc117 100644 --- a/llms-full.txt +++ b/llms-full.txt @@ -1,6 +1,6 @@ # Io — Full Documentation -Site build: Io · 2026-11-13 · e76a3f5c +Site build: Io · 2026-11-16 · 6db971fd 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). @@ -7044,6 +7044,14 @@ 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](https://github.com/IoLanguage/io); the rest are development milestones on the road between them. For the longer arc, see the [Timeline](../Timeline/index.html). +## 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](https://github.com/IoLanguage/io/pull/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. diff --git a/llms.txt b/llms.txt index 7b53fd15d..04fdc7e7b 100644 --- a/llms.txt +++ b/llms.txt @@ -2,7 +2,7 @@ > A small, prototype-based programming language — now targeting WASM/WASI. -Site build: Io · 2026-11-13 · e76a3f5c +Site build: Io · 2026-11-16 · 6db971fd ## Documentation