The changelog
Shipped, so far.
The first language milestone runs real programs with checked types and console input and output. Every entry below renders the roadmap's Done section — 56 milestones in 29 groups — straight from ROADMAP.md, the single source. Where it goes next: the roadmap.
Shipped
WebAssembly compiler
1 shipped.
- WebAssembly compiler:
zhex compileships with browser and WASI targets, byte-identical to the interpreter across the examples corpus (#7).
Shipped
Numbers
1 shipped.
- Numbers:
Intwidened to signed 128-bit — literals, arithmetic, comparisons, parsing, printing, JSON and XML integers, and map keys all carry the new width, with overflow a language error at the 128-bit bounds;zhex compilebuilds keep 64-bit Ints and fence wider values (#167).
Shipped
Interpreter
1 shipped.
- Interpreter: typed words, inferred locals, conditions, bounded loops, and checked flows. Mutation words return their receiver —
list.append,array.resize,map.remove,buffer.add-line, andbuffer.set-linereturn the collection they mutated, making mutation flows chain (#156).
Shipped
Working examples
1 shipped.
- Working examples: composition, console input, FizzBuzz, Fibonacci, factorial, palindrome checking, a recursive GCD, and a times table.
Shipped
Executable specification
1 shipped.
- Executable specification: tests cover syntax, types, scope, arithmetic boundaries, Unicode, and failure paths.
Shipped
Getting started
1 shipped.
- Getting started: documentation, a public examples website, just recipes for development, and local highlighting packages for Vim/Neovim, VS Code, and Zed.
Shipped
Website
7 shipped.
- Website: Astro-powered topic documentation and an editorial redesign with a new logo, syntax-highlighted examples, and a published design system with a concept archive.
- Website: in-browser examples ship — the site build compiles the 22 in-subset examples to browser WebAssembly artifacts (about 111 KB raw, 38 KB gzipped each; WebAssembly garbage collection, roughly Chrome 119+, Firefox 120+, and Safari 18.2+), the examples page runs them in the visitor's browser through a small shim, the 14 examples outside the compiler subset stay fenced with notes naming the construct the compiler does not cover yet, and a build-embedded differential gate re-runs every artifact and fails the site build unless each stdout matches the Go interpreter byte-for-byte (#106).
- Website: the Game of Life demo — the compiled example runs in the browser with play, pause, and step over its parsed generations, byte-checked against the interpreter on every build (#90).
- Website: one shared artifact fetch and lazy demo init on the examples page — no double downloads, demos load when scrolled into view (#113).
- Website: the demos move to their own page — a 25 by 25 Game of Life (glider plus toad, blinker, and beacon) runs 54 generations as the first demoSpecs manifest row with its browser artifact and derived verify pins, playback loops with an end-of-run beat and no dead controls, and the examples page links to the page from its top (#115).
- Website: the demos grow to four evolving Game of Life runs — the Gosper glider gun (54 by 54, 120 generations of streaming gliders), the acorn (60 by 60, the methuselah's first 150 generations), and diehard (24 by 24, all 130 generations to its extinction) join the patterns intro, each with its own board, title, and blurb, per-demo verify pins (board size, frame count, stdout size cap, artifact-oracle byte match), and a stage that adapts per board with cells never below 12px (#116).
- Website: the browser playground ships — the full Go interpreter compiles to a WebAssembly engine (
cmd/zhex/engine, built byjust engineintosite/public/) that runs source strings with the interpreter's own diagnostics and holds REPL sessions with the terminal's entry laws; the playground page lazy-loads it behind its cover click, run and REPL modes share a stdin box and caret diagnostics rendered from the report envelope, examples cards open in it with their module maps resolved, share links carry source, input, and mode in the URL fragment, and an interactive read-line seam wakes the paused engine on browser input (#91 engine, #88 playground, #122 seam).
Shipped
Licensing
1 shipped.
- Licensing: the repository is public and published under the MIT license.
Shipped
Editors
1 shipped.
- Editors: syntax highlighting for Vim/Neovim, VS Code, and Zed, with installation and usage documented on the website's docs page.
Shipped
Agents
1 shipped.
- Agents: AGENTS.md, an llms.txt site index, and agent-readable examples make Zhex easy for humans to review and AI agents to write.
Shipped
Errors
1 shipped.
- Errors: built-in diagnostics point at the source, carry stable cataloged codes, and can report as JSON; user words declare success types and infer a single escaping Result family through
try, then callers propagate withtryor recover lazily withcatch. Multiple uncaught families are rejected; explicitResult<T, E>signatures remain supported. Results cannot be silently discarded. Structured Error values expose code, origin, details, and causes; a named reporter can observe explicit handled reports and each unhandled terminal failure without external delivery by default.console.exitprovides deliberate statuses from 0 to 255;console.failwrites a message to stderr and exits with status 1. Both close activefile.streamloops on termination.
Shipped
Input
1 shipped.
- Input:
read-line,text.to-int, file, buffer, and argument reads return explicit Results. Callers choose a fallback withcatch, propagate through compatible fallible words withtry, or let the program boundary report an unhandled failure.
Shipped
Insight
1 shipped.
- Insight:
zhex run --tracestreams JSONL step events — word calls, bindings, flow steps, returns — so people and agents can watch a program run; the event vocabulary is documented in llms.txt.
Shipped
REPL
1 shipped.
- REPL:
zhex replkeeps words and values across entries, enters multiline blocks and delimited expressions with editable terminal auto-indentation, four-space Tab and bracketed paste support, echoes expression values, redefines words with a note, lists signatures withwords, recovers from errors, and traces with--trace.
Shipped
Vocabulary
15 shipped.
- Vocabulary: rich text work ships — sixteen
textwords, with literal split, join, and prefix/suffix checks added by the first standard-library story (#57),BufferandFiletypes, guaranteed-closefile.streamloops, whole-file reads throughfile.read, checked report output throughfile.writewith the first built-in trailing constant default (#58), and program arguments viaconsole.arg. - Vocabulary: collection composition ships —
list.map,list.filter, andlist.foldrun ordinary function-value callbacks (explicit or word-name partials, no lambda syntax) once per element left to right, with fresh outer lists, shared elements, an unchanged source, and the traversal guard held throughout (#60), andlist.find,list.any, andlist.allshort-circuit over the same callback contract, withfindreturningOption.SomeorOption.None(#61); Result-returning callbacks and Result fold accumulators are rejected, and the registeredscore-reportexample demonstrates all six words. - Vocabulary: deterministic ordering ships —
list.sortreturns a stable ascending copy ofList<Int>/List<String>values in code-point string order, andlist.sort-byranks any list by an Int or String key callback evaluated once per element in source order under the traversal guard (#62); both return fresh outer lists with shared elements and unchanged sources, equal keys keep source order, and the registeredsortingexample demonstrates both words. - Vocabulary: file inspection ships —
file.list(folder)returns one level of a folder's bare entry names, dot entries included, as a fresh sortedList<String>inside aResultunder the shared million-element limit,file.exists(path)answers existence as a plainBoolwhere a missing path isfalse(postfixtry/catchselects the checkedResult<Bool, FileError>form), andfile.size(path)andfile.free-space(path)report a regular file's bytes and the bytes available on a path's volume inside Results (#73); failures carry the stable codesfile-list,file-exists,file-size, andfile-free-space, and the executable example was deferred untilfile.make-foldermade a deterministic one possible. - Vocabulary: lexical path words ship —
file.join(base, child)concatenates with the native separator and cleans, with an absolute child replacing the base (file.join("a/b", "/c")→/c) so untrusted absolute components never nest under a base;file.base(path),file.extension(path), andfile.directory-of(path)decompose a path into its final element, final-dot suffix (dot included,.bashrcfor the dotfile), and everything but the final element (#74); all four are pureStringwords with no filesystem access, and the registeredpathsexample demonstrates them. - Vocabulary: destructive file operations ship —
file.make-folder(path, parents = false)creates one folder level or, withparents = true, every missing ancestor while tolerating an existing folder,file.delete(path)removes a file or an empty folder and refuses a nonempty one,file.delete-folder(path, recursive = false)removes an empty folder or, with a deliberaterecursive = true, the whole tree best-effort (part may be gone before the first failure), andfile.move(source, target, overwrite = false)renames files and folders, replaces an existing file only withoverwrite = true, refuses folder targets in both modes, and fails cross-device moves with the platform's error (#75); the mode arguments are built-in trailing constant defaults, failures carry the stable codesfile-make-folder,file-delete,file-delete-folder, andfile-move, and the registeredfile-workexample pays #73's deferred-example debt with a deterministic make-folder → write → list → size → free-space → delete round trip. - Vocabulary: JSON heterogeneous trees ship —
json.parse(raw)returnsResult<Json, Error>overJson, a host-predeclared recursive choice (Null,Bool,Text,Number(literal),List,Object) that programs never declare; trees are ordinary data — constructible, storable in records, matched with plainmatch— while recursion stays host-only (#76).json.encodeaccepts trees:encode(parse(raw))preserves key order and number literals byte-for-byte and normalizes whitespace to compact;Json.Numberliterals are validated against the JSON number grammar at encode, strictness (duplicate keys, depth 256, the million-element cap, UTF-8/surrogates, JSON Pointer paths) is shared withjson.decodewith no new codes, and JSON depth 256 plus word-call depth 256 put a recursive word over a maximally deep tree exactly at the call-depth edge. The registeredjson-treeexample counts a heterogeneous payload recursively and round-trips it. - Vocabulary: predicate selection ships —
list.select(values, predicate)keeps the elements a(T) -> Boolpredicate accepts, unmodified, andarray.select(values, predicate)keeps whole rows of a rank-2 array, passing each row to the predicate as a freshList<T>and preserving the rectangle (#70); both follow the #60 callback contract, visit every element or row without short-circuiting, return fresh outer collections with shared elements and unchanged sources, reject Result-returning predicates at check time, and arrays of any rank besides 2 reportarray.select requires a rank-2 arrayat runtime; the updatedcollectionsexample demonstrates both words. - Vocabulary: typed XML decode ships —
xml.decode(text, defaults)returnsResult<T, Error>, schema-directed exactly likejson.decodeover the same supported types on the stdlib encoding/xml tokenizer (#79); attributes map onto record fields verbatim with a collision failing the decode, repeated same-named elements collect intoList<T>, absent elements use defaults orOption<T>(no null marker), text-only elements decode asString/exact-integerInt/true|falseBool, and strictness rejects unknown elements and attributes, mixed content, namespace-prefixed orxmlns-resolved names, DTD/entity declarations, and undefined entities, with predefined and numeric entities decoded and no network ever; limits mirror JSON (depth 256, one million elements) and failures carryxml-syntax,xml-type,xml-field,xml-range, andxml-depthwith element paths. The registeredxml-configexample decodes an embedded service configuration. - Vocabulary: environment configuration ships —
env.get(name)answers the process environment as a totalOption<String>(an unset name isOption.None, a set-but-empty name isOption.Some("")) andenv.load(path = ".env")reads KEY=VALUE lines into the environment insideResult<Unit, Error>, common-Error family likejson.parse, with first assignment wins — a key already in the environment, or set by an earlier line of the same file, is never overridden (#64, the environment half; the path words shipped as #74); blank lines and whole-line#comments are skipped after leading trim, one matching pair of surrounding single or double quotes on the value is stripped,KEY=sets the empty string, a malformed line failsenv-parsenaming the line number and a read failureenv-readwith lines before a malformed one staying applied, the.envtrailing constant default stays deferred for partials likefile.write'sappend, andenvjoins the reserved module names; the registeredenv-configexample demonstrates both words. - Vocabulary: text code points as numbers ship —
text.to-code-points(text)returns a string's code points (the unittext.lengthalready counts) as a freshList<Int>in order andtext.from-code-points(list)rebuilds text, so character classification becomes ordinary Int arithmetic instead of the slice/text.to-int/trydance the AoC days carried, the #157 review's top finding (#160); a code point that is not valid Unicode — negative, above U+10FFFF, or a surrogate half — fails the stabletext-code-pointcode, and to-code-points past one million elements failscollection-limitbefore materializing; noChartype, the values areInts, and no example was registered (the motivating programs are the AoC working areas, and the wasm-subset examples cannot take new host words yet). - Vocabulary: floored modulo ships —
int.mod-floor(value, modulus)gives wrap-around-correct modulo where a nonzero result has the modulus's sign, so dials, circular buffers, and grids need no hand-rolled fix-up of%'s truncation (the silent-wrong-answer trap 2025 day 1 carried as a permanent helper, #161);%keeps its documented truncation toward zero, a zero modulus fails the existingdivision-zerocode, and the sign adjustment cannot overflow. - Vocabulary: map extraction ships —
map.keys(map)returns a freshList<K>andmap.values(map)a freshList<V>, both in documented insertion order (the orderfor k, v in maptraverses), so a map's data flows into thelistcomposition words without a hand loop (2025 day 8's three-line workaround, #162); both hold the one-million-elementcollection-limitbefore materializing, extraction is a read with no traversal-guard interaction, and String, Int, and Bool keys extract alike. No new codes. - Vocabulary: list membership ships —
list.contains(values, item)answers "is this present" in one word overList<Int>/List<String>, ridinglist.sort's constrained overloads so the third collection namespace matchestext.containsandmap.containswithout generic equality (#163); the scan is linear, stops at the first equal element with the traversal guard held, an empty list isfalse, other element types fail at check time with alist.any-and-a-predicate hint, andList<Bool>stays out (weak demand — the overload set stays closed wherelist.sortdrew it). No new codes. - Vocabulary: positional insert ships —
list.insert(values, index, value)places a value at the zero-based insertion point, chosen over a comparator sort becauselist.sort-byalready ranks by key and the missing primitive was insertion, so rule-based ordering stays a user-side insertion sort (the 2024 day 5 shape, #164); valid indices run0through the length inclusive (index == length appends; a strict element-index law would forbid inserting into an empty list), out of range fails the stablelist-rangecode at runtime with the family's plain/checked split — plain calls diagnose,try/catchselectResult<List<T>, Error>— and the mutation-receiver, iteration-guard, and element-limit rules matchlist.appendexactly. No new codes.
Shipped
Language
6 shipped.
- Language: indefinite iteration and distinguishable EOF ship —
while conditionrepeats an indented body while itsBoolcondition holds, evaluated before each pass; it is a statement of typeUnit, is rejected as a binding or assignment right-hand side, has nobreak/continue, and may run forever by design with no iteration limit, andread-linekeeps itsResult<String, InputError>shape while its end-of-input failure carries areasondetail ofend-of-fileversusread-failedfor a read failure, read witherror.detail(#72); both land as #65's prerequisites, and the registeredcollatzexample demonstrates the loop. - Language: the string-context Int exception ships —
+concatenates when exactly one operand isIntand the other isString(the Int renders asint.to-stringdoes, chains associate left to right, and twoIntoperands still add numerically), andprintaccepts anIntdirectly (#83);Booland every other type stay strict in these positions, and the no-implicit-conversions law keeps every other position strict. - Language: the reserved zero-argument
mainentry word ships — a file whose top level has no statements may defineword main, andzhex runandzhex compileinvoke it as the entry point, with a failing Result inside reporting like a top-leveltryand parameters failing themain-parameterscode (#134); imports stay words-only, and beside top-level statements, in a module, or in the REPLmainstays an ordinary word, so one file can both run and be imported by its test (collapsing the AoC day splits is the separate follow-up). - Language: with blocks ship —
with <namespace>directly under aflowseed line fixes the seed: every step receives the original seed as its first argument (never the previous step's result), bare step names resolve through the namespace first (appendunderwith listislist.append) and then as ordinary words with the seed, the last step's value is the block's value, and the namespace may be built-in or a used module (#153); theflowkeyword may be dropped exactly on the expression line abovewith— same indentation, no blank or comment line between — fusing that line (including alet/var/assignment right-hand side, which then receives the block's value) while a naked expression anywhere else keeps its discarded no-op meaning (#154); a step resolving nowhere fails the newwith-stepcode naming both tries, aResultseed must be handled first (mirroringflow), a Unit seed failswith-seedat the first step with a hint naming the seed line, an unfusablewithline failswith-location,withjoins the reserved keywords,--traceemits awith-stepevent per step, the wasm compiler learns no new node kind (a flow cursor that never updates), and the registeredwith-blocksexample demonstrates both forms. - Language: word doc comments ship — a contiguous block of full-line
##comments at column 1 directly above aworddeclaration becomes that word's doc, with one optional leading space stripped per line, lines joined with newlines, and a blank line or plain#comment detaching the block while##anywhere else stays a plain comment (#93);wordsprints the doc indented four spaces beneath the signature (a blank doc line renders empty, module words qualified), docs live on the word so a redefinition replaces or clears one without affecting signature compatibility, user words only — records, choices, and built-ins get none — and a REPL comment-only line now joins the next line's entry, so a doc block shares its entry with the word it documents whilewordstyped after a comment line still runs. - Language: the three #166 expression-grammar gaps close. Postfix
catchbinds beyond statements (#181) — the one-line fallback also lands on assignment right-hand sides and inside call arguments at expression boundaries (parenthesized, short-form, or grouped), the fallback extending to the argument's boundary, with a trailing ungrouped catch on a short-form call's last argument guarding the whole call exactly as trailingtrydoes, while the block handler and lone-name binding stay statement forms. Postfix chains mix indexed and field reads freely (#182) —space.bytes[i].xmeans exactly what naming the intermediate means, field-then-index staying open as before, with the named-intermediate diagnostics unchanged. Arrays gain rank 1 (#183) — one-dimensional tables create, read, write, resize, and iterate like any other rank, rank 0 still failsarray-rankwithmin_rank1,array.selectkeeps its rank-2-only rule, and day 19's one-column workaround fell away with byte-identical output.
Shipped
Diagnostics
1 shipped.
- Diagnostics: the mutation-receiver branch-tail trip hints its fix — when an
ifarm ends in a mutation call and the other arm isUnit, the stablebranch result types must matchfirst line gainshint: <word> returns the <kind> it changed; bind it aslet stored = <word>(...)or give both branches the same type(#165, the ergonomics remainder after #156 made every mutation word return its receiver and statement position kept discarding non-Result values); the message, position, and caret are unchanged, plain value mismatches stay hintless, and the rule is written into the contract's branching section and AGENTS.md's hint list.
Shipped
Tooling
1 shipped.
- Tooling: doctests ship — a doc line of the form
## > expressionis a doctest whose expected output is the doc lines that follow until a blank doc line, the next## >line, or the doc's end (a blank line returns the doc to prose; prose directly after an example reads as output and mismatches), andzhex doctests <file.zhex> [--report=text|json]compiles the file like a run without executing its body, then checks and evaluates each documented word's examples in the owning module's scope (bare calls resolve inside the module), comparing the REPL echo of the value with the expected lines (#94); a mismatch or an expression that fails to check or evaluate is a diagnostic pointing at the doc line with the stable codesdoctest-mismatchanddoctest-checkin the catalog and--report=json, any failure exits nonzero, a bareResultstays rejected so fallible examples usetry, passing runs print nothing, and plainzhex runnever executes docs;just doctestssweeps every example with one built binary as part ofjust test, seeded on every public word ofexamples/modules/math.zhex(md and html deferred);zhex test [path]runs every*.test.zhexfile as its own process plus every other.zhexfile's doctests (#97) — per-file PASS/FAIL lines with the captured failure line, a summary (N files: X passed, Y failed), exit 1 on any failure,--report=jsonfailures in the diagnostic envelope (test-failedfor a plain failed check), and--gapslisting public words referenced by no doctest and no test file — seeded byexamples/modules/math.test.zhexover the one-word siblingtestmodule'scheck(condition, label), andjust doctestsnow runsbin/zhex test examples.
Shipped
Rich values
1 shipped.
- Rich values: explicit binding annotations, nominal records with named constructor arguments and optional field defaults, block-valued bindings, transparent type aliases, and one-parameter choices with exhaustive matching, homogeneous shared
List<T>and shapedArray<T>collections, inferredMap<K, V>with built-inOption<V>lookup, plain list/array reads and mutations with optional checked forms, insertion-ordered map operations, and collection traversal with bindings and mutation guards. Typed JSON decoding with explicit record defaults and encoding for the supported value subset is also available. Dates, times, durations, instants, and named zones support calendar and elapsed-time operations.
Shipped
Text utility
1 shipped.
- Text utility:
text-statsreads a file two ways — whole-buffer counts and a streamed uppercased echo — with program arguments, streamed lines, and guaranteed close, all through the new vocabulary (#28) — and becomes the workload for measurements (#4).
Shipped
Measurements
1 shipped.
- Measurements: the interpreter runs text-stats at 8-9 ms per pass with stable allocation profiles by mode (docs/measurements.md); readability review recommends a line-filter tool as the next application, with number-to-text ceremony flagged for a future language story.
Shipped
Tools
1 shipped.
- Tools: the line-filter tool ships as the first end-to-end application —
zhex run examples/filter.zhex <pattern> <file>prints matching lines verbatim, streaming the file; wrong arguments fail with a usage line and a missing file reports its natural FileError (#81).
Shipped
Modules
3 shipped.
- Modules:
use mathloads sibling files, words are importable unless underscore-private, calls are qualified, cycles and reserved names diagnose with paths, and the REPL adopts modules per session — with a two-file corpus example and docs sections to match. - Modules: the pure-Zhex
mdMarkdown report module ships as a validated sibling module beside a two-filemd-reportexample (#77) — fragment-returning words (heading, paragraph, bullet/ordered lists, link, fenced code block, tables added by owner decision), per-position escaping withmax(3, longest run + 1)fences, percent-encoded link targets that neutralizejavascript:/data:schemes, strict header-width table rows, and verbatim paragraphs; the example composes records and lists into a buffer and prints, with no host words or editor changes. - Modules: the html composition module ships (#78) — a pure-Zhex sibling module with the guarantee "escaped unless raw":
html.escape-textpins Gohtml.EscapeStringsemantics over&,<,>,',"(stays in the module; no second workload justified host promotion),html.attr(name, value)builds one pre-escaped attribute andhtml.element(tag, attributes: List<String>, content)joins them with text escaping left toescape-text,html.pageemits the doctype document with an escaped title,html.rawis the identity bypass documented against every escaping property, andhtml.linkallows only relative,http,https, andmailtotargets, rejecting every other scheme (includingjavascript:anddata:) with thehtml-url-schemecode; the registeredmodules/html-pageexample composes a page and one rejected link.
Shipped
Advent of Code 2025
1 shipped.
- Advent of Code 2025: all twelve days solved in Zhex under
aoc/2025/— one main-based file per day (words plus themainentry word, #176) with its*.test.zhexsuite, sample inputs undersamples/— published as doors on the year-general advent-of-code page (year tabs, honest per-door status labels, per-day outlines from theaocSpecsrows, and browser run panels on the compiled days, re-run byte-for-byte against the interpreter by the build's verify-wasm gate); the whole suite runs green withbin/zhex test aoc(37 files), and the closing verification sweep re-ran all twelve days clean (12/12 PASS) on a fresh tree (#123 epic).
Shipped
Advent of Code 2023 and 2024
1 shipped.
- Advent of Code 2023 and 2024: the two archive years solved under
aoc/2023/andaoc/2024/— 25 days each in the 2025 idiom (one main-based file per day with its test file, sample inputs only, every part-2 answer carried by two independent community references recorded per day in the findings logs) — published as doors on the advent-of-code page's year tabs with honest statuses (2023 day 25 prints the year's completion star; 2024 day 24 stands at part 1 with its part-2 solver honestly pending as #168); the verification sweeps re-ran every day — 2023's sweep passed 23 of 25 days and its two latent input-shape flags were fixed and regression-pinned (#169 day 10, #170 day 14), 2024's sweep passed all 25 — and the whole three-year suite runs green withbin/zhex test aoc(189 files), 61 doors solved in full plus the one honest part-1 door (#136 epic).
Shipped
Dogfooding
1 shipped.
- Dogfooding: the bounded REPL front end investigation ships — a Zhex-written driver (
tools/dogfood/repl.zhex) owns prompts, dispatch, and EOF policy over the per-runrepl.*seam words, a transcript matrix diffs both binaries across 29 scripted cases plus 350 generated entries with the two accepted divergences pinned, and the design note lives indocs/repl-dogfood-note.md(#65); full interpreter self-hosting stays out of scope.
Shipped
Compiler
1 shipped.
- Compiler: the native Go target ships —
zhex compile <file.zhex> --target=nativeemits a self-contained program directory (readablemain.go,go.mod, thezhexrtruntime sources) and builds it with the Go toolchain, or writes the sources with the onego buildinstruction when Go is absent; native keeps the interpreter's full 128-bit Ints, runtime failures render aszhex run's diagnostics through a source-position table, cross-compilation follows GOOS/GOARCH, the corpus differential gate injust testholds every in-subset example byte-identical (stdout, stderr, exit status) while generic choices,json.decode/xml.decode, the temporal words,file.free-space,error.set-reporter, constructor partials, checked indexed writes, and fallible callbacks fencenot-available-in-build, and the measured speedup is a 10.6× geometric mean over the interpreter, 3.9–70× per workload (#185, four phases; data on #6).
Shipped
WebAssembly
1 shipped.
- WebAssembly: the prelude grows lists and buffers amortized and WASI line I/O is buffered (#187) — list and buffer headers carry a capacity with doubling appends (floor 4) with every len-is-capacity consumer switched,
buffer.to-textjoins in two passes, stdout batches in a 32KB adapter buffer flushed on fill, before stderr, before stdin reads, and at exit, and read-line drains a persistent stdin buffer — so text counts go from 115× slower than the interpreter to 4.6× faster, the 100k-line growth case that did not finish runs in 109 ms, and the factory benchmark's BFS drops from 947 ms to 19 ms (before/after on #6); the residual flow-chain and network losses are the prelude insertion sort and map.put grow-by-one, filed as #188.
Shipped
Performance
1 shipped.
- Performance: the cross-language benchmark suite ships under
performance/— six benchmarks (fibrec, intloop, stringbuild, wordcount, gridsim, filterstream), one file per engine with the same algorithm and byte-verified identical output (Zhex interpreted and native, hand-written Go, C, JavaScript under Node and Bun, Ruby, Python, PHP sources shipped);run.shdiscovers engines at run time, compares every output before any timing, and reports warm-up + median-of-five wall times with versions pinned and absent engines marked NOT INSTALLED under the fairness law in its README (#190, extending #184;just perf, deliberately outsidejust test; the recorded run puts native's geomean with the Node/Bun engines at 48.6 ms and the interpreter 3.5–69× above native).
Where Zhex goes next → · View the roadmap source · Try what shipped →