History

How Zeno was built

440 commits and 10 releases so far, from the first file to what is on main today.

This page lists every commit in the Zeno repository, oldest first, under the release it went into. Read from the top, it is the story of how the language was built, from an empty folder on 14 November 2026 to what is on main today.

Each line says in plain words what one commit changed. The letters and digits at its start are the commit's short name, and they open the commit on GitHub, with its full message and every line of code it touched. A release is a heading, with a few words under it on what the release brought. The last heading, Unreleased, is what is on main and in no release yet.

Two other files go with this one. The reason for every choice in the language is in docs/decisions.md, and what is still to be built is in docs/missing.md.

The releases

  • Zeno 0.1.0, 15 November 2026, 156 commits: the whole language, a book, and builds for ten kinds of machine
  • Zeno 0.2.0, 16 November 2026, 19 commits: a program in a web page, installers and packages
  • Zeno 0.3.0, 16 November 2026, 32 commits: speed, and a choice of how memory is freed
  • Zeno 0.4.0, 16 November 2026, 18 commits: a build as fast as C and Rust
  • Zeno 0.5.0, 17 November 2026, 12 commits: the program written in another language
  • Zeno 0.5.1, 17 November 2026, 6 commits: the VM as fast as it was
  • Zeno 0.5.2, 18 November 2026, 41 commits: four more targets, a registry, and the libraries of other languages
  • Zeno 0.6.0, 19 November 2026, 33 commits: the release for firmware, and the libraries of five more languages
  • Zeno 0.7.0, 19 November 2026, 18 commits: from a .zeno file to a chip in one step
  • Zeno 0.8.0, 20 November 2026, 103 commits: several values, generic enums, and a block that puts back what it opened
  • Unreleased, on main now, 2 commits: what has come since 0.8.0

Zeno 0.1.0

Released 15 November 2026 · 156 commits · the release on GitHub

The first release is the largest part of the story: the whole language was built on 14 and 15 November 2026. It begins with a README and a sketch of the syntax, and then goes stage by stage. A lexer, a parser, an interpreter and a type checker come first, then a compiler to C and a garbage collector, then builds for firmware that have no collector at all, a second engine (a bytecode VM) and a second backend (LLVM). After that come the library, programs in several files, packages, a formatter, a language server for editors, and tests written in Zeno.

Most stages are three commits: the code, a walkthrough of it in docs/, and the reasons in docs/decisions.md. The release ends with The Zeno Book and with a workflow that builds zeno for ten kinds of machine. Writing the book and trying the release on a Mac and on Windows each found mistakes, and the mends are here too.

A name, a sketch and a syntax

14 November 2026

  • de07d57The first commit: a README, an empty command-line program in Rust, and hello.zeno.
  • 8e8ea36The syntax is made to look like Python first, and the README lists what the language should be able to do.
  • 8e5cda9The syntax changes to the one Zeno kept: braces, let and var, and whole words for keywords.

Reading a program: the lexer and the parser

14 November 2026

  • 33669d7The lexer: it cuts a file into tokens and decides where a line ends, with tests.
  • 9fea775zeno tokens prints the tokens of a file, and an error points at its place with a caret.
  • 0ee6898A walkthrough of how the lexer works.
  • 861e3b6Every stage shares one kind of error, and a message names a token in words.
  • 37b02f5The parser: it turns the tokens into a syntax tree, and zeno parse prints the tree.
  • 7e99c93A walkthrough of how the parser works.
  • 15f52e4Comparisons chain as in Python (0 < x < 10), // divides whole numbers, and is is kept for none.

Running a program: the interpreter

14 November 2026

  • 8c90b90The interpreter: zeno run runs a program for the first time.
  • 52e8edcdocs/decisions.md begins, the file that holds the reason for every choice, with a walkthrough of the interpreter.
  • 8fc07ffFunctions can be used as values, map, filter and reduce arrive, and the type of a field may be left out.
  • 7a1956bThe reasons for allowing several styles and optional types are written down, with an example.

Checking a program before it runs: the type checker

14 November 2026

  • d30c750The type checker: zeno check finds mistakes before a program runs, and strict mode asks for every type to be written.
  • 45eb543Tests for the checker, and a list that is written out is checked item by item.
  • a39031aA walkthrough of the checker, and its reasons.
  • 7873651A type can be a function (function(int) -> int), a file can begin with strict, and units come from a fixed table, so a misspelt unit is caught.
  • 273b260The checker works out the types of parameters and fields that have none written, by going over the program until nothing changes.
  • 0f32d01The docs for function types, unit types, the strict line and worked-out types.

Compiling to C

14 November 2026

  • 26eb7ebThe checker hands what it learned about each function to the stages after it.
  • 7ea2462zeno build: numbers, text, functions and control flow are compiled to C. The tests compare a compiled program's output with the interpreter's, byte for byte.
  • 505e4fcA walkthrough of the C backend, and its reasons.
  • f470cb3An error caused by a worked-out type says which call the type came from, and units of one kind work together: 1 s + 500 ms is 1500 ms.
  • 6b5c1c5The checker hands the types of classes, enums and lists to the compiler.
  • e38aaaeClasses, lists, enums and match compile to C.
  • cb32725The docs for how classes, enums, match and lists compile.
  • 252e4b4The interpreter is tightened so that a compiled program can agree with it: a function value sees only what was in view where it was written, a raised object is caught by its class, and text methods know plain letters only.
  • be1f7ccnone, errors (try and raise) and functions as values compile to C. The tour of the language now builds.
  • c4c718bThe docs for how none, errors and function values compile.

Memory: a collector, a firmware build, and owned values

14 November 2026

  • a199025Compiled programs free their memory with a mark-and-sweep garbage collector, and --memory reports what was used.
  • feef6dfA walkthrough of the collector, and a plan to carry errors as plain values for firmware.
  • a31c589The plan for the next two stages: owned values with borrows, and a firmware build with no collector.
  • 44f6cc8zeno build --firmware: an error travels as a returned value, with no setjmp, as firmware rules such as MISRA C ask.
  • 83e3a58A walkthrough of the firmware build, and its reasons.
  • 672487eOwned values: a value marked owned has one owner and is freed the moment its owner's block ends. A borrow parameter only looks.
  • 23fa3f5A walkthrough of owned values, and decision 5.8.
  • 2747119The README and the older pages point at owned values.
  • 91fde19zeno build --no-collector: a firmware build with no garbage collector in it. Anything that would take memory nobody gives back is refused when the program is built.
  • bc5f77cA walkthrough of the build with no collector, and decision 5.9.
  • 393c071The README and the older pages point at the build with no collector.

A second engine: bytecode and a VM

14 November 2026

  • 216e852What each operator does moves to a file of its own, so that a second engine can share it.
  • b2ce242A function sees what is declared above it and nothing below: a mistake in scoping, found while building the VM, is mended.
  • e7e94c0Bytecode: a program as a flat list of small instructions, and a compiler from the syntax tree to it. zeno bytecode prints it.
  • 9ff462cThe VM: zeno run --vm runs the bytecode, two to three times as fast as the interpreter. Every test now runs on both engines and must give the same output.
  • 9a6e6aeThe bytecode listing names two hidden slots, and the help text lines up.
  • 1eadeceA walkthrough of the bytecode VM, and its reasons.
  • 6d108a8The checker refuses a function that is called before a variable it needs is declared.

A second backend: LLVM

14 November 2026

  • 00513e1The C backend's code for reading an f-string format is split off, so that another backend can use it.
  • 4a4f1dezeno build --llvm: numbers, text, functions and control flow are written as LLVM IR, as plain text and with no dependency.
  • 2049bc3A walkthrough of the LLVM backend, and its reasons.
  • 798e928//, % and / are written in IR and no longer call the runtime, which makes a loop of them more than twice as fast.
  • 384b5d6The LLVM backend compiles the rest of the language: classes, enums, match, lists, none, errors, function values and units.
  • e524554The walkthrough of the LLVM backend is rewritten for the whole language.

For firmware: a board, bits, sized numbers and generics

14 November 2026

  • fa3961aThe board and time modules: pins, sleep and now. blink.zeno runs on a simulated board and builds for a real one.
  • 7f10b84The bit operators &, |, ^, ~, << and >>.
  • c1f941bWhole numbers with a size: u8, u16, u32, i8, i16 and i32. A number that does not fit is an error and never a wrong answer.
  • 2840eb6The docs for the bit operators and the sized numbers.
  • 1ff13eczeno tokens, parse and bytecode end quietly when their output goes to a program that stops reading.
  • 0c3ee4dGenerics: function first[T](...) and class Stack[T]. The checker works the type out from the call.
  • 01a8585The docs for generics.
  • a90e33f--llvm --firmware: the LLVM backend carries errors as values too.
  • 66410c0The docs for --llvm --firmware.
  • 268c392--llvm with --no-collector and --memory: the LLVM backend frees owned values and can leave the collector out.
  • b330867The docs for --llvm with --no-collector and --memory.

No collector: a pool, text that is kept, and one owner for every value

14 to 15 November 2026

  • 2788a33With no collector, memory comes from one fixed pool and not from malloc. Taking a block and giving it back take constant time, and the pool cannot break up.
  • 0e89346The docs for the memory pool.
  • e07dc43With no collector, text can be kept: whatever stores a text has a copy of its own and frees it.
  • 54031adThe docs for text that is kept, with an example.
  • ce6bf6aA value made in the middle of a statement and given to nobody belongs to the statement, which frees it. So split, map, filter and + on lists work with no collector.
  • 418337aThe docs for what a statement owns.
  • 51ebc9bWith no collector, every list and object has one owner without the word owned, and a list owns its items.
  • ac76f2fA list cannot fill a type parameter where it has one owner, and the message for it is put right.
  • 96abe6bA walkthrough of one owner.
  • a06f534Decision 5.15: whoever receives a value owns it.
  • 00cb81cThe older pages are brought up to date with one owner.
  • d01a741An owner cannot be given a new value while a loop walks its list: a way to read freed memory is closed.
  • 49c97d8With no collector, enum values and values that may be none have one owner too.
  • f3b8effThe docs for enums and none with one owner.
  • 082126bThe checker gives errors and function values one owner with no collector. They were the last two kinds of value without one.
  • 2cd94d1Both backends free errors and function values through their owner.
  • a626e31The docs for functions and errors with one owner.
  • 914cc99The older pages and the README are brought up to date.

Memory by hand

15 November 2026

  • 9efd0f8Memory by hand: unsafe blocks, raw pointers, allocate and free, and registers at a fixed address. zeno run checks every use; a compiled program, like C, checks none.
  • d8e411aAn unsafe block that ends in return ends the function: the C backend wrote a second return after it.
  • c3a1d12A walkthrough of memory by hand, and its reasons.

The audit: is every rule unambiguous and intuitive?

15 November 2026

  • 0714358A plain parameter only looks at a value, and take marks the one that takes it over. borrow is gone.
  • a4c2d5fThe docs follow that change, and docs/audit.md begins.
  • 41cef08Messages count in words: "1 argument", "2 arguments", and never "argument(s)".
  • cc2853a[1] + ["two"] is refused, as append already refused it.
  • 40258d2After case none, the later cases of a match know the value is there.
  • eb5e05bWith no collector, every function can look at a let at the top of the file, which is how firmware keeps a table.
  • 8d232e1A method can take out what its own object holds, as a queue does with pop.
  • a0e4a6cA var that holds a function of the program can be given another function.
  • d9e6c8bA firmware build refuses a raises it cannot honour, and the audit is written up.

The library

15 November 2026

  • f4bf63aText and lists get the methods every program reaches for: find, slice, insert, reverse, sort, join and more.
  • 26830bdThe docs for the first part of the library.
  • 92c2197Programs read and write: files, the keyboard (input), and the arguments they were started with.
  • 5163d9eThe docs for reading and writing.
  • 36a4e17More of math: angles with units (30 deg), logarithms, exp and rounding.
  • 683df64The docs for the new math, with an example of five instruments.
  • 689e9cfA dictionary type: ["Ada": 36], [:] for an empty one, and the type dict[str, int].
  • 8fb13a3The docs for the dictionary.

Bigger programs: modules, packages, a formatter and a language server

15 November 2026

  • 5275c4dPrograms in several files: import shapes reads shapes.zeno as a module.
  • 65b4bd5The docs for programs in several files.
  • 54d4554Packages: a zeno.package file says what a program needs, and zeno fetch gets it from git.
  • e235d96The docs for packages.
  • 49209cbzeno format: one layout for every Zeno file. It changes white space only, and checks that the program still means the same.
  • bc6727eThe docs for the formatter.
  • d2a1eddzeno lsp: a language server, so that an editor shows mistakes as you type, with setup for VS Code, Vim, Neovim and Helix.
  • 580e838The docs for the language server.
  • 3d651dfThe language server answers "go to declaration" and hover, from what the checker knows.
  • 1040b8eThe docs for how the server knows what a name means.

The finish line for 0.1

15 November 2026

  • 1acd4f0private: a declaration at the top of a file can be kept to that file.
  • c1cbf21private fields and functions of a class.
  • 9f9ae5dAn example for private: a queue of a fixed size.
  • 20f0423The docs for private, and the list of what is left for version 0.1.
  • dcaef4eInterfaces: interface Shape { ... } and class Circle is Shape.
  • 04e9189The docs for interfaces.
  • d93b0b5A dict can hold any kind of value, and a loop can have two names: for key, value in ages.
  • e9fc668The docs for both.
  • be3c6a6zeno test: the tests of a program are written in Zeno, with test "name" { ... } and assert.
  • 6d3c3a3The docs for tests.
  • 0f8d365zeno new makes a new program or package in one command.
  • 6f353bbThe docs for zeno new.
  • 34078deThe last gaps: += on a sized number, a format on a quantity ({angle:.1f}), the operators //=, %= and **=, and two mistakes in the order of x += f() mended.
  • eb9c706The docs for the last gaps.
  • 0700a2eThe version is 0.1.0: the list for it is done. Also a clearer message for as after an import.
  • 702a6deEvery decision once marked provisional is read again and settled, and docs/version-0.1.md says what 0.1 is.

The Zeno Book, and a release for ten kinds of machine

15 November 2026

  • 08d0d83The Zeno Book begins: its LaTeX source, its build, and the first chapters.
  • c531678Book: values, numbers, text, control flow, functions, lists and dicts.
  • e2d3ec3Book: classes, enums, none, errors and functions as values.
  • f5807d4Book: types, units, sized numbers and bits.
  • 0b2272fBook: generics, interfaces, modules and packages.
  • 4ca6d11Book: reading and writing, and mathematics.
  • cdfed0cBook: testing and the tools.
  • 4443627Book: the board and compiling.
  • 0322055Book: memory, ownership and firmware.
  • 3762242Book: building with no collector, and unsafe code.
  • f831a99The release workflow: a tag builds zeno for ten kinds of machine (Linux, macOS and Windows, on several processors each) and checks every build.
  • 4e090ebBook: Inside Zeno, and why Zeno is as it is.
  • ddf739eThe first trial of the release found that a compiled program rounded floats differently on a Mac. Compiled programs now round as zeno run does on every processor.
  • 903a7ddBook: the appendices, and the first full build: 226 pages of PDF and a page of HTML for each chapter, with all 300 samples run by the compiler.
  • 3751da3Release workflow: the C build and the LLVM build are each checked in a step of their own.
  • ee19a64Release workflow: what a trial finds is written on the summary page of the run.
  • 814b967The docs for how a release is made and how to install one.
  • c07f157Release workflow: a release can be made from the Actions page on GitHub.
  • 642c040Writing the book found programs that zeno check accepted and that failed later. The checker now refuses them, and several messages say more.
  • 797556bBook: the samples follow the checker's new refusals.
  • 1213f69Windows: a compiled program sleeps and reads the clock the Windows way, so --llvm builds there.
  • da45a66A path that Zeno makes is written with / on every system.
  • 6b3ed16Windows: arguments arrive whole in any script (a word in Tamil had come out as ?????), and a fetched package keeps its line ends.
  • 9385ec0The mend for Windows arguments is done again without the heap, so that a build with no collector stays without one.
  • 7cc9fe9The docs for what Windows found. Every test passes there now.
  • be2248eThree clearer messages that the book asked for.
  • 446d355Book: Zeno builds on Windows too. This commit is Zeno 0.1.0.

Zeno 0.2.0

Released 16 November 2026 · 19 commits · the release on GitHub

A Zeno program can be a web page, and Zeno gets installers. zeno build --web puts a program, its page and Zeno itself (built as WebAssembly) into one HTML file that a browser opens. The same days brought a setup program for Windows and one line to paste for macOS and Linux, packages for apt, pacman, snap, flatpak, Homebrew and winget, a json module, the first playground, and the MIT licence. With this release the repository became public.

A program in a web page

15 November 2026

  • 64e8f27The web module and zeno build --web: a Zeno program becomes one HTML file that a browser opens. Zeno itself runs in the page, built as WebAssembly.
  • 90cc566The version moves to 0.2.0, with its release notes.
  • 5a2f9e2Book: install steps for ten machines, and a new chapter on web pages.

Installers, packages, JSON and a playground

16 November 2026

  • e3a17a1Installers: a setup program for Windows, and one line to paste for macOS and Linux. zeno build finds the C compiler by itself.
  • 6b9361fA page can do more: events, styles, drawing on a canvas, text kept between visits, and the network. zeno playground writes a page in which programs are written and run in a browser.
  • c0a3563What 0.1 left: min and max of quantities, hover on a field in an editor, and zeno test --only to run tests by name.
  • a0a1254A workflow adds installers to a version that is already released, and 0.1.0 gets both.
  • b200af8The json module: json.parse and json.write.
  • d60f0bdBook: the bigger web module, JSON, the installers, and tests by name.
  • be32a88Packages: a .deb, a snap, a flatpak, a pacman package, and recipes for Homebrew and winget.
  • 4581bd7Packages: the PKGBUILD goes into its folder and not into the archive beside it.
  • 0fe0238A release now makes the packages and tries each one. Their walkthrough and their reasons.
  • 051062bA timer that can be stopped: web.after and web.every give a Timer.
  • 66a1d5eThe Homebrew, pacman and winget recipes for 0.1.0, with its checksums.
  • 1c8fce9Book: the timer, and the whole web module in the library appendix.
  • 39d70e6Book: installing with apt, pacman, snap, flatpak, Homebrew and winget.
  • f998247The playground is made ready for zeno-lang.org: an endless loop is stopped after 5 seconds, errors show under the output, and it fits a phone.

A licence, and a public repository

16 November 2026

  • db80267Zeno gets the MIT licence, in the repository and in everything a release carries.
  • 2367c89The repository is made public, and the docs no longer say that the install line cannot download. This commit is Zeno 0.2.0.

Zeno 0.3.0

Released 16 November 2026 · 32 commits · the release on GitHub

This release is about speed. The garbage collector is rebuilt around pages and then given two generations, a program can ask for memory owned and have no collector, --release drops the overflow checks, and the VM gets faster. Six benchmarks against C, Rust and Python are added to measure all of it. Also here: sort with a function, a new playground with a real editor, and the groundwork for the package stores.

The rehearsal of the release hung on macOS, so 0.3.0 went out with the two generations on Linux only. The cause was found in 0.4.0.

After 0.2.0: sort with a function, a new playground, and the package stores

16 November 2026

  • 9a48258The Homebrew, pacman and winget recipes for 0.2.0, with its checksums.
  • 8581065Book: 0.2.0 is released, and chapter 1 installs it.
  • 6b54f7dsort with a function: people.sort(age_of) orders a list of anything by a key. A crash in map, filter and reduce is mended.
  • 9741037Book: sort with a function.
  • 4cea297A new playground: an editor in colour that checks as you write, a Format button, problems that jump to their line, and fifteen examples.
  • 9c9a488The stores workflow: signed lists for apt, the files for the AUR, and winget files in the current form.
  • bad5ee2The sketch example can be drawn with a finger on a phone.
  • 3ad0c5eOn Arch Linux the package is named zeno-lang-bin, because the AUR already has another program called zeno.
  • 90558ceThe docs for the stores: where each package manager looks for Zeno, and what is left to do for each.
  • 6640134Book: the AUR name, and no Flathub.
  • a9ba762Book: a line that ran into the margin is mended.

Speed: a faster collector, a choice of memory, and benchmarks

16 November 2026

  • 8d205deA faster collector: blocks live in 64 KB pages that are found through a hash table. One benchmark went from 57.8 seconds to 12.0.
  • 9219ac5A program chooses how its memory is freed: memory owned (one owner for each value, no collector) or memory collector. A --release build drops the overflow checks on whole numbers.
  • d11af73Benchmarks: six programs in Zeno, C, Rust and Python, and a script that runs and checks them. A walkthrough of the memory modes.
  • 1321033winget: the recipe files in the newer form that Microsoft's list asks for.
  • 8fc4af8Book: memory owned, --owned, --collector, --release and the paged collector.
  • 3d1c6dbBenchmark results after those changes.
  • dca4974for ch in text walks the text and no longer makes a list of its characters first.
  • 79252adA field that a function never writes is read once, and math.sqrt is inlined in the LLVM build.
  • 8fba764Benchmark results after those two.
  • 9f0f67amemory owned at the top of a file makes the classes of that file owned, also in a program with a collector.
  • e15264eThe playground shows the C that zeno build writes for the program, in a tab of its own.
  • 49fb9dcThe collector gets two generations, so that it need not go over old blocks at every collection. A leak in lists is ended on the way.
  • 54c9758Benchmark results after generations, and a script that keeps the times of each version.
  • 09fe44cThe VM gets faster: instructions joined into one, quick paths for int and float arithmetic, and fields found by their place.
  • 9a04d9fThe playground takes the one accent colour of the website, blue.
  • 40cfa4eBenchmark records for 0.1.0 and 0.2.0, to compare later versions with.

Releasing 0.3.0, and a hang on macOS

16 November 2026

  • 06d0195Release notes for 0.3.0.
  • 1ff51bfThe rehearsal of 0.3.0 hung in the tests on macOS. Every workflow job gets a time limit, and a probe workflow is added to look into the hang.
  • 9630500Until the hang is understood, the two generations are used on Linux only.
  • c920cd8The probe runs the test suite under a clock on macOS and says where a hung program is.
  • ca486cdThe release notes say what 0.3.0 has: generations on Linux, and the paged collector on every system. This commit is Zeno 0.3.0.

Zeno 0.4.0

Released 16 November 2026 · 18 commits · the release on GitHub

zeno build --fast is a build that runs as fast as C and Rust on the benchmarks. The release also ends the hunt for the hang on macOS that held 0.3.0 back. It was a try that jumped with two C functions that do not match on a Mac. Once that was mended, the collector's two generations came back on macOS.

Finding the hang on macOS

16 November 2026

  • 354aea1The Homebrew, pacman and winget recipes for 0.3.0, with its checksums.
  • ba8aa27The benchmark record of 0.3.0.
  • 393212aThe release had left the AUR's .SRCINFO file at 0.2.0, because a workflow drops files whose names begin with a dot. Mended.
  • 514613aThe probe asks three questions of the runtime on macOS, to narrow the hang down.
  • 9e28b91The probe runs the two hung tests with a runtime that writes what it does, and looks at a hung program with a debugger.
  • aae13f0The probe tries the cause it suspects: an LLVM build enters a try with _setjmp and raise leaves it with longjmp, and on macOS the two do not match.
  • e548e7eThe mend: a try jumps with the matched pair _setjmp and _longjmp. The mismatch had left blocked the signal that the collector's two generations rely on.
  • 8744490The probe checks that the whole suite passes on macOS with two generations.
  • 3c270a3The two generations are back on macOS.
  • c57afedDecision 22.11 records that.
  • 2a2aaefmain becomes 0.3.1, with notes on what was mended.

zeno build --fast

16 November 2026

  • 6132e28zeno build --fast: a build with no checks on indexes, float division or square roots, compiled with -O3. Numbers become text without snprintf, and big owned lists grow with realloc.
  • b04f80fBenchmarks with --fast.
  • 3e492d1The next version is named 0.4.0, since a new way to build is more than a mend.
  • 1aa503b--fast uses C's own whole-number arithmetic, so the loop benchmark compiles to the same instructions as C. In every build, // and % by a power of two are a shift and a mask.
  • af7a738The benchmark script can count instructions, which is steadier than a clock, and timed runs go in rounds.
  • 5b44520Decision 23.9: the overflow rule of --fast stays, with what dropping it would cost, measured.
  • d6b3debRelease notes for 0.4.0, and the README and the docs name its files. This commit is Zeno 0.4.0.

Zeno 0.5.0

Released 17 November 2026 · 12 commits · the release on GitHub

Zeno writes your program in another language. zeno build --target gives the same program in JavaScript, TypeScript, Python, PHP, Go, Java, C#, C++ or Rust, as a web page, or as WebAssembly, and each prints what zeno run prints. A review of every target found about thirty corners where a language did what is usual there and not what Zeno does. Each got a rule, and a test program that holds every target to it.

Eleven targets

16 to 17 November 2026

  • 79cf832The Homebrew, pacman and winget recipes for 0.4.0, with its checksums.
  • e043682The benchmark record of 0.4.0.
  • 52c030ezeno build --target js, html and py: Zeno writes the program in JavaScript or Python, and a script holds every target to what zeno run prints.
  • 2a96152Targets: Go, Java and C#.
  • 90d713bTargets: C++.
  • 8939c1dTargets: Rust and WebAssembly, and a weekly check of every target against the newest version of its language.
  • 925d162Book: rebuilt with a section on zeno build --target.
  • 98c6603Book: other languages are marked as new in 0.5.
  • 60c5416A review of every target found about thirty corners where a target did what its own language does and not what zeno run does: order, large numbers, text, JSON, names. Each now has a rule and a program that tests it.
  • 52796d2Targets: TypeScript and PHP.
  • 5e88303The version moves to 0.5.0, with its release notes.
  • 878afd3The benchmarks can time the program written in each other language. The notes of 0.5.0 say how its speed compares with 0.4.0. This commit is Zeno 0.5.0.

Zeno 0.5.1

Released 17 November 2026 · 6 commits · the release on GitHub

A small release with one purpose. In 0.5.0, zeno run --vm had become a few percent slower, although no line of the VM had changed: with more code in the program, the Rust compiler had laid it out differently. 0.5.1 is 0.5.0 built as one piece, and the VM is as fast as it was in 0.4.0.

  • 655d4b7The Homebrew, pacman and winget recipes for 0.5.0, with its checksums.
  • 662d727Benchmarks: a program that stops without a word is reported as that, and the script no longer falls over.
  • ffbed00The benchmark record of 0.5.0, with the times of the program in nine other languages.
  • 8f3da1dzeno run --vm was 1 to 9 % slower in 0.5.0 with no line of it changed: the Rust compiler had cut the program up differently. A release is now built as one piece, and the version moves to 0.5.1.
  • e19e4f7Release notes for 0.5.1.
  • 4acd512The README and the docs name the files of 0.5.1. This commit is Zeno 0.5.1.

Zeno 0.5.2

Released 18 November 2026 · 41 commits · the release on GitHub

This release adds to what is around the language and leaves the language as it was. There are four more target languages (Lua, Ruby, Dart and Kotlin), and a registry, so that a package is found by its name. import python, import node and import java let a Zeno program use the libraries of those languages. zeno build --minimal writes the least C that runs a program, program.run starts another program, and the first part of the library is written in Zeno itself.

The repository moved to the zeno-src organization on GitHub. Two mistakes were mended: a float % that the C++ target got wrong, and a caught error that could stop a program built on Windows.

After 0.5.1: records, the book, and where to write

17 November 2026

  • bfae8a9The Homebrew, pacman and winget recipes for 0.5.1, with its checksums.
  • e23b2b7The benchmark record of 0.5.1. A run that its host crashed is run again.
  • 441f348Book: rebuilt for Zeno 0.5, with eleven target languages.
  • 7817c2eBook: the title page names the version the book is for.
  • d027849The install and release pages still named the files of old versions. They name 0.5.1 now.
  • 139f757SECURITY.md: where to report a security problem in private.
  • 1380d3cAn address at zeno-lang.org for each kind of mail: help, issues, security and contact.
  • 1f8a079Book: a section on where to write when you are stuck.

Starting another program, and a new home on GitHub

17 November 2026

  • 4d1a392program.run(name, words) starts another program and waits for it.
  • fae846cAn example that saves a video with yt-dlp through program.run, with the walkthrough and the reasons.
  • f7611fdThe repository moved to the zeno-src organization on GitHub, and every link points there.

Four more target languages

17 November 2026

  • 3e2c68fzeno build --target lua and --target ruby.
  • ab67e56zeno build --target dart.
  • 76aff9bzeno build --target kotlin, and a test program of awkward names for the four new languages.
  • 966a2adThe docs for Lua, Ruby, Dart and Kotlin.
  • dc82309Book: Lua, Ruby, Dart and Kotlin are on their way.
  • 17959ffHow fast the four new targets run.
  • c66ef68With a new compiler the C++ target printed a wrong float for 7.0 % 0.1, and Go could do the same. Both are mended. The weekly check had stayed green with that failure in it, and now fails when a program differs.

A registry, and the libraries of Python, JavaScript and Java

18 November 2026

  • ce5760dA registry: a package is found by its name (needs units at "v1.2.0"), with zeno search and zeno publish.
  • 11eef17import python: a Zeno program uses the libraries of Python, which runs beside it.
  • 6257ea6An example that uses yt-dlp as a library through import python, with the walkthrough and the plan for other languages.
  • 3998c64The docs for the registry, and the book's chapter on packages.
  • a3fa4bdBook: rebuilt with the registry.
  • 0b680e8import node: a Zeno program uses the libraries of JavaScript.
  • 32732c6import java: a Zeno program uses the classes and jars of Java.

The least C

18 November 2026

  • 8db60a7zeno build --minimal: the least C that runs the program, with no checks and only the parts of the runtime the program uses.
  • 1832b7bA script builds every test program with and without --minimal and compares the two.
  • 4652734The docs for --minimal.
  • 4aabf71Book: the least C, in the chapter on compiling.
  • 9d15172Book: rebuilt with it.
  • 028e557The --minimal comparison leaves out one sample whose result C does not define (memory given back twice).
  • 49b0e49A field may have the name of a class or an enum: the C that zeno build wrote for it did not compile.
  • 1b87690A --minimal test failed on Windows without a word. The trial workflow now builds such programs there and reports where one stops.
  • 2f4fbacThe trial also reports how the program ended, at each level of the C compiler's optimising.

A list of what is missing, a mend for Windows, and a library written in Zeno

18 November 2026

  • f907a95docs/missing.md: what Zeno does not have yet, in the order to build it, firmware first.
  • b1b4d82Adding import java had made a sort on the VM a tenth slower, with no line of the VM changed. The code of the bridge is kept apart from the functions every program runs, and the speed is back.
  • fbf4affThe failure on Windows is found and mended: a caught error could stop a program built there with gcc. A try is now a plain jump.
  • 3e677b4Part of the library is now written in Zeno itself: math.hypot, sinh, cosh, tanh, gcd and clamp, and a random module. Only the functions a program uses are added to it.
  • 265c21dThe docs for the library written in Zeno, with an example.
  • 0c48e5fBook: the functions written in Zeno, in the appendices.
  • 596a800The version is 0.5.2, with its release notes. Its speed was compared with 0.5.1 first. This commit is Zeno 0.5.2.

Zeno 0.6.0

Released 19 November 2026 · 33 commits · the release on GitHub

The release for firmware. The work follows docs/missing.md, the list of what Zeno still lacks, with firmware first. A program can now read a board: a button on an input pin, bytes on a serial port, a voltage on an analog pin. It has the numbers firmware works in: f32, u64, lists of a fixed length, bytes, enums that stand for numbers, and units made of units. Beside that, a Zeno program can use the libraries of Ruby, PHP, Lua, .NET and C, and through C those of Go and Rust, and it can end with a number for the shell.

The last hours before the release went on trying all of it on Windows and macOS, and on making sure that a program which uses none of the new things runs as fast as it did in 0.5.2.

Ending a program, enums as numbers, and bytes

18 November 2026

  • 5135b88The Homebrew, pacman and winget recipes for 0.5.2, with its checksums.
  • d7c378aprogram.exit, program.environment and program.warn. A case of an enum can stand for a number: enum Reply { Ack = 6 Nak = 21 }.
  • c1715a8Bytes from and to a file: files.read_bytes and files.write_bytes.
  • 446c228A list[u8] is stored one byte to an item. An 8 MB file read and written back takes 13 MB of memory where it took 64.

The libraries of Ruby, PHP, Lua and .NET

18 November 2026

  • 0f38b05import ruby: the library of Ruby and its gems.
  • 216f9b0import php: what comes with PHP, and Composer packages.
  • efc5668import lua: the library of Lua and its rocks.
  • e84a926import csharp: the types of .NET and the packages of NuGet.
  • 6c5b61dThe decisions for those four become chapters 37 to 40, since main had taken 34 to 36.

Numbers for firmware: fixed lists, f32, u64, and units made of units

18 November 2026

  • dacdeefThe benchmark record of 0.5.2.
  • 670f4a6A list of a fixed length, list[u8, 64], and [0] * 64 to fill one.
  • b2f8ad4docs/targets.md records the last check of the targets: 349 programs in each language.
  • 778b502f32, a float of 32 bits, as C's float.
  • 399d7afBook: a chapter on the libraries of Python, JavaScript and Java.
  • 222068fu64, a whole number of 64 bits with no sign, and .max and .min on every whole type (u8.max).
  • dab0d00Units made of units: voltage times current is power, so 3.3 V * 20 mA is 0.066 W.

The libraries of C, and of Go and Rust through C

18 November 2026

  • b747791import c: a Zeno program calls libraries of C, and of Go and Rust through their C interface.
  • 564dae0zeno build calls C directly: import c works in every C build, and the checker reads the declarations, so a wrong argument is found before the program runs.

On a board: inputs, a serial port, and a voltage

18 November 2026

  • 9665982Inputs on a board: input_pin(2, pull_up) makes a pin that the program reads.
  • d21a4a3The WebAssembly and Rust targets could wake from sleep a fraction of a millisecond early. They now wait until the time has passed.
  • 0635fbaA serial port on a board: serial(1, 115200 baud), with write, read_byte and has_byte.
  • a2447a7Reading a voltage on a board: analog_pin(0) gives a pin whose voltage() is a quantity in volts.

Ready for 0.6.0: Windows, macOS, and the speed of 0.5.2

18 to 19 November 2026

  • d41ce8aimport c on Windows and macOS: a file of C beside the program is found on Windows, and on macOS a library that is missing is named in the error.
  • 9c4ae25Adding program.exit had made the VM run 1 to 3 % more instructions on every benchmark. The exit is carried another way now, and the VM is as fast as in 0.5.2.
  • 14b9d1bOn Windows and macOS a function that a library of C does not have is named, as on Linux. On Windows a built program reads its environment whole in any script.
  • 032ced2The trial workflow reports what Ruby said when it stopped.
  • 4a6b559import ruby did not start on Windows, where Ruby cut its command line short. The helper is handed over as a file there.
  • 92db930== and the tests for f32 and u64 are made cheap again, so the new numbers cost older programs nothing.
  • 2af235cWith no collector, a list that is the default of a field (items: list[str] = []) was freed while the new object still pointed at it. It now belongs to the object.
  • f11a77aThe VM keeps the output, the board, the page and the keyboard behind one pointer, so that adding to them cannot slow its loop. One benchmark had become 6 % slower by the clock.
  • bc8a2a1Sums of two ints or two floats take a short path in the interpreter too, which now runs fewer instructions than in 0.5.2.
  • 4268b08The version is 0.6.0, with its release notes.
  • 356e780Book: rebuilt for Zeno 0.6. This commit is Zeno 0.6.0.

Zeno 0.7.0

Released 19 November 2026 · 18 commits · the release on GitHub

0.7.0 is the second release for firmware. The board module gets the three things it lacked: a PWM signal, a steady beat, and edges counted by an interrupt. zeno build --board runs the board's own compiler, a board can print and stop by itself with no C library under the program, a float is made into text by Zeno's own runtime, and the C of a build can be read by a C compiler that is neither GCC nor Clang. hello takes 936 bytes of flash on an ARM Cortex-M3. All of it was tried on two boards that QEMU emulates, and none of it on a real one yet. The book has a new chapter on libraries of C. This ends the eighth of the fourteen items of docs/missing.md.

  • 8d44bb1The Homebrew, pacman and winget recipes for 0.6.0, with its checksums.
  • 40ae73aHISTORY.md, this page: every commit under its release, written by tools/history.py from git and a file of notes. The website shows it at /history/.

A PWM signal, a steady beat, and interrupts

18 November 2026

  • 7703e47A PWM signal on a board: pwm_pin(9, 1 kHz) makes a pin that goes on and off at a frequency, and duty(0.25) says for how much of each turn it is on.
  • 3889409A steady beat on a board: ticker(10 ms).wait() waits for the next beat, so a loop keeps its pace however long its work took.
  • fb95f78Interrupts on a board: button.interrupt(falling) counts the edges of an input as they happen, and wait() sleeps until one comes.

One step to a board

18 to 19 November 2026

  • fc034c1zeno build --board boards/qemu-cortex-m3 blink.zeno runs the board's own compiler. A board is a folder with a zeno.board file, and every example is run on an emulated ARM Cortex-M3.
  • ec52d5eA board that prints, reads and stops by itself: its header says #define ZENO_BOARD_PRINTS and brings four functions, and nothing of the program goes through the C library. A second board, boards/lm3s6965evb, drives the chip's own registers.
  • 85e8b0cThe README says that the five stages since 0.6.0 came after it.
  • 906865cTwo chapters of the decisions had the number 49. The history's is now 54.

A float with no C library, and plain C

19 November 2026

  • 767b985A float is made into text, and text into a float, by the runtime itself, with whole numbers and exactly. On a Cortex-M3 that is 4 KB of flash where snprintf and strtod were 28.
  • e4bac94The benchmark figures of 0.6.0.
  • eeea2b4The C++ and Lua targets printed 46 powers of two with 17 digits. They print 16, as zeno run does.
  • d0bd086The version on main is 0.7.0, and its release notes are begun.
  • eb3c486Every check that asked GCC or Clang for a built-in is written a second time in plain C, so a C compiler that is neither can build a program. tcc builds every example.
  • 39cef6aThe table of sizes on the page about minimal builds, measured again.

Ready for 0.7.0

19 November 2026

  • 4d2fd31The book for 0.7: Ruby, PHP, Lua and C# in the chapter on the libraries of other languages, and a new chapter on libraries of C.
  • 951c666The version is 0.7.0, with its release notes. GCC and Clang get the top of the program as 0.6.0 gave it to them, so a built program runs the instructions it ran before, and the interpreter keeps the board behind a pointer, as the VM does.
  • 17453fdThree tests of the last two stages failed in a debug build or on Windows, by their own arithmetic and line ends. They are mended. Nothing of Zeno itself changed. This commit is Zeno 0.7.0.

Zeno 0.8.0

Released 20 November 2026 · 103 commits · the release on GitHub

0.8.0 is a release for the language itself. A function can give several values, an enum and an interface can leave a type open, and a type parameter can say what it asks of its type. An owned class that is Resource is put back on every way out of its block, a file can be read and written in pieces, a program can list and make folders, an assert can say why it matters, and zeno test --build runs a program's tests in the program C or LLVM makes of it. Most of what a build with no collector refused is now built. Every new feature is asked for by a word or a flag: a program that writes none of them is built as 0.7.0 built it, to the byte. It ends items 9 to 12 of docs/missing.md and two tools of item 13; the rest of item 13 and item 14 are put off. The engines were not timed for it, and nothing of it has run on a real board.

  • fdf8c23The Homebrew, pacman and winget recipes for 0.7.0, with its checksums.
  • d4f3faaThe benchmark figures of 0.7.0.
  • 3a1ee8cThe version on main is 0.8.0, and the notes of 0.8.0 are begun.
  • 14ce321docs/plan-9-14.md: the plan for items 9 to 14 of what Zeno lacks, with the design of each part, the ways weighed, the tests, and how each is shown to cost nothing.
  • d6673ectools/same.py builds every program each way a build can be asked for with two zeno programs, and shows that the C, the IR, the joined program and the bytecode they write are the same: the same C means the same speed.
  • 60dba12Python's compiled files are kept out of the repository.
  • ea5d687The plan: raises after a result belongs to the function it ends, a type ends at a comma, and an ordinary build holds what a function value raises against a type neither way.
  • e1d726draises in a function type: function(str) -> int raises ValueError. A call through such a value is checked as raising, and a firmware build and a build with no collector now take a raising function as a value, which they refused (decision 56).
  • 4c2b97dThe plan: what the review of raises in a function type settled, and what the first half of 9.2 asked.
  • 909ca90The plan: the tests leave out the same firmware builds as before.
  • a24bb55Giving a value away is one function in the checker, so that a function that is kept can give away what it uses by the same rule as let b = a. Nothing changes.
  • 80be701A function that is kept takes what it uses: compose(f, g) builds with no collector (decision 56.8). With it, four fixes from the review of raises in a function type, and a function called straight from the call that made it is freed with no collector, which 0.7.0 left.
  • 36b2d90The plan: a function that is kept cannot take a var, in any build.
  • dc322b6A function that is kept cannot take a var, in any build: with a collector one that said owned was taken, and the program stopped with a fault of memory. self gets a message that can be followed (decision 56.8).
  • e1079ccA method used as a value builds every way: let m = counter.bump is the function that calls the method, bound to the object of that line, and it looks or takes by the rule of a kept function (decision 56.9).
  • 31a0593A method of an object that no variable holds is refused with words that say what to write, and chapter 56 counts what tools/same.py found.
  • 0ff7d7etake slot.task and take tasks[i] give what is there and leave none, in every engine and build, so an object with one owner can hand on what it holds (decision 56.10).
  • 2f7ec0bThe plan: items 9 to 12 are built in full, and of item 13 the tests of a compiled program and a message on assert. The other tools of item 13 and the whole of item 14 are put off, with their designs kept.
  • 5fba04dThe plan: no benchmarks for these parts, and every feature is asked for by a word or a flag, so that a program that does not ask builds and runs as before.
  • 4a66de7The plan: which tests of 0.7.0 changed, said exactly.
  • 052ea30With no collector a list or an object can fill a type parameter: Stack[Frame], Box([1, 2]) and same(frame) build, and take T says that a generic keeps what it is given (decision 56.11).
  • 74091cdThe engines count what 0.7.0 counted again: the kind after raises in a type is boxed, and the VM's two arms for take call a cold function of their own.
  • bd717a7A function that tests a parameter that may be none and then reads a field of it reads the field after the test, in C and LLVM. 0.7.0 read it before, and so read through NULL when given none.
  • 697b4bcWith no collector a dict of lists or of objects builds, and the dict owns its values as a list owns its items: d[key] looks, a store frees the value that was there, pop hands it over (decision 56.12).
  • 2666f98The two instructions of take come after the superinstructions, and the interpreter's take is in a cold function of its own.
  • 9bd9566What was known of the speed of items 9.1 to 9.4 when the benchmarks stopped (decision 56.13).
  • 2b90f07What Zeno lacks: item 9 says which of its parts are done.
  • 59be546The plan: a list of numbers that may be none with no collector owns a block of the pool for each number, since flags beside the list would change the C of every program.
  • 9dc71d6With no collector a list of numbers that may be none builds, and the list owns a block of the pool for each number, as it owns its copy of each text (decision 56.14).
  • ac6518dThe size of the pool and of the text room on the command line, --pool and --text-room, and with --memory a write to a block after it was given back stops the program (decision 56.15).
  • fae3563A function with a name inside a function, and a default that is more than a literal, build through C and LLVM, with or without a collector: one that uses nothing around it is a function of the file, one that does is a closure made after the last thing it uses (decision 56.16).
  • e9a4346What a build still refuses is one table for a build with no collector, all by design, and one for every build, each with its reason, and a test holds both compilers to them (decision 56.17).
  • cab1573The plan: item 9 is accepted, with what its sweep of the code missed.
  • f10c24bThe plan: the count of builds whose C differs from 0.7.0, set right (114 and 128).
  • a7a31abThe plan: two builders at once, who builds what, and a review that holds nobody up.
  • 0ddcb6ain on a list of values that may be none builds through C as through LLVM, and range(...) used as a value is the list zeno run makes, in every build (decision 56.19).
  • 5d8b280tools/refused.py tries one operation on each type six ways and fails on a refusal no table lists; what it and the review of item 9 found builds now or is a row with its reason, and a default is shared so the compilers see what the checker saw (decision 56.19).
  • a0ce9dcThe plan: the follow-up of item 9 is accepted, and the runtime grows only for a program that asks.
  • 56d31acA message on assert: assert c, "text" prints the text on a line of its own above what was false, and the text is worked out only when the assert fails (decision 60.1).
  • 30a1223The plan: three builders, and item 11 with a builder of its own.
  • ba2817aThe plan: five things the code asked about the tests of a compiled program.
  • 2440fabThe plan: the numbers inside chapter 58 of the decisions, and how a generic enum is built.
  • 6b04ce3The plan: three things the code asked about interfaces, and owned interface.
  • 43c17bfThe runtime grows only for a program that uses what is added: each new part of runtime.c is a piece, written in only when the program uses it, so a program that uses nothing new gets 0.7.0's runtime to the byte in every build (decision 56.19).
  • 8f0b647The plan: the runtime in pieces is accepted, and several values where no type is written.
  • 0c6e6f8Several values from one function: -> (int, str), return a, b, let q, r = f() and a, b = b, a, in every engine, every build and every target; several values are never one value, and are shown as <2 values: ...> where no type is written (decision 57).
  • 1e245bfThe plan: item 10 is accepted, with one fault and four small things to mend.
  • 3a7b737Tests of a compiled program: zeno test --build compiles each file with its tests as zeno build would, in C or LLVM, with or without a collector, for a computer or a board, and the program prints what zeno test prints, line for line (decision 60.2).
  • e2c9d2cSeveral values received, swapped and raised past in a test of a compiled program, in every build: where items 10 and 13 meet.
  • b20ed7dThe plan: a message on assert and the tests of a compiled program are accepted.
  • 4390fa8Folders: files.list gives a folder's names sorted by the numbers of their characters, the same in every engine, build and target; files.make_folder makes a folder and those above it; files.join is written in Zeno (decisions 59.20 to 59.23).
  • b57c0f8Folders in the docs: docs/folders.md, decisions 59.20 to 59.23, and the notes of 0.8.0.
  • 510336bSeveral values: with no collector, values written out free what an earlier one made when a later one raises; the same name twice on the left, and _ where it is a variable, are refused (decision 57).
  • e2d317bThe book: several values from one function, in the chapter on functions.
  • d69b592The plan: folders are accepted, and three things a resource asked.
  • 0c01265Folders: what files.join does at the ends of its parts, and Java's names where the language setting is not UTF-8.
  • f5d4e01A parameter of an interface's function may have a default: a plain value (a number, text, true, false, none, a quantity, or a case that carries nothing) that each class writes the same, and a call through the interface may leave it out (decision 58.20).
  • a038f09A function that takes out what its object owns can stand for one of an interface: a call through the interface is held to the guards of taking out, found over the checker's rounds, so a call read before the class is held as one read after it (decision 58.21).
  • ec5cd10owned interface: each object that is one has one owner, with a collector too; only an owned class can be one, and an owned class can only be one (decision 58.22).
  • 0a50a71What interfaces left out, in the decisions (58.20 to 58.23), docs/interfaces.md, what Zeno lacks, and the notes of 0.8.0.
  • 3c28ca2A default, a function that takes out and an owned interface, each with two results, in every build: where 11.4 meets several values.
  • 532ac68The plan: the mending of item 10 and what interfaces left out are accepted.
  • a1be903The book: what items 9 and 10 change, in the chapters on functions as values, compiling, ownership, firmware and no collector, and in the list of limits.
  • 2f2504bThe book: a message on assert, zeno test --build, folders, and a default, taking out and owned interface in the chapter on interfaces.
  • b0a22b2Generic enums: enum Maybe[T] and Result[T, E], a copy for each set of types, Nothing typed by the place it goes, in every engine and build; with no collector a look at a copy of a generic goes to a parameter of a generic that looks (decisions 58.1 and 58.2).
  • 0052fc0The plan: a Reader and a Writer are written in Zeno, over five small built-ins.
  • 7357805Bounds: function largest[T is Ordered] and [S is Shape] on a function, a class and an enum, refused at the call when a type lacks them; Ordered comes with Zeno unless the program has its own, and a bound makes no code (decisions 58.3 to 58.5).
  • 144f4f6Generic interfaces: interface Source[T], and a class that says which copy it is, is Source[int] or is Source[T]; each copy is an interface of its own, in every build (decision 58.6).
  • d7ca291The book: bounds, generic enums and generic interfaces in the chapter on generics; the limits and the design chapter say what is left.
  • a0ca116The plan: generic enums, bounds and generic interfaces are accepted.
  • ba41819A method with a type parameter of its own stays refused, with a message that shows the function of the file to write instead (decision 58.7); a generic given a list of two types, as first([200 ms, 1 s]), says in a build why and what to write (58.8).
  • 5ec9077The book: in what generics leave out, a function of the file in place of a method with a type of its own (58.7), and a list of two units given to a generic (58.8).
  • d063941The plan: a method with a type parameter of its own stays refused, and item 11 is accepted.
  • 3dab71bA method with a type parameter of its own is refused on its own line, not on the first line of its class (58.7).
  • 117c236Cleaning up when a block ends: owned class Selected is Resource, whose release runs when the owner of the object ends, on every way out of its block, last made first, and not when it was given away, in every engine, build and target; a resource lives in a let or a parameter, and every other place is refused with a message (decisions 59.1 to 59.3).
  • 9fb78a8Decisions 59.1 to 59.5 and docs/resource.md: what a resource is, where it can be, the top of a file under zeno test, how each engine releases it, and what it still leaves out.
  • 63c7f27The plan: cleaning up when a block ends is accepted, with one fault to mend.
  • 5365b64The book: is Resource and release, when it runs and where a resource may live, in the chapter on ownership, and its limit in the appendix.
  • ab9fdc7A resource written out among several values is refused as one a call gives, a default cannot make a resource, and the refusal of several values says only to give the resource back alone (the mending of 59.1).
  • 615a32bThe Lua target jumps to the next round of a loop from a try only when the body holds a continue, so a while whose try holds only a break runs.
  • 0d12e31A file in pieces: files.read_from gives a Reader with read_line, read_bytes and for line in reader, files.write_to and files.append_to give a Writer, closed when the owner ends, written in Zeno over six built-ins, in every engine, build and target (decisions 59.6 and 59.7).
  • 9645274Decisions 59.6 and 59.7 and docs/files-in-pieces.md: a file read and written in pieces, and what a program cannot touch.
  • 7a69bc2The plan: a file in pieces is sent back with two faults; the mend of cleaning up is accepted.
  • fe23d35files.list("") raises in the WebAssembly target too, where WASI took an empty path for the current folder.
  • 0e08020The plan: the last check of where the items meet, and a crash in LLVM builds to mend.
  • 6c93f7aA named function given to a function that gives several values is called with the places for the later ones in every LLVM build (the last check of where the items meet).
  • 870164eThe plan: the crash of several values through LLVM is mended and accepted.
  • 53c24beA reader reads on when the file has grown since it met the end, in every engine, build and target, and zeno test --build --llvm takes the pieces of the runtime a test uses.
  • c1b5897Decision 59.6 and docs/files-in-pieces.md: a file that grows, a long line with no collector, and the line an uncaught error names.
  • e393ca1The plan: a file in pieces is accepted, and with it every item; the release waits only for a green run of the targets.
  • 2e6e036The book: a file read and written in pieces, in the chapter on reading and writing; the limits and the design chapter say what is left of it.
  • c81708dThe plan: folders on Windows and macOS, found by the trial; the tag waits for them.
  • ffab0c6The book for Zeno 0.8: rebuilt as a PDF and HTML, 323 pages, with its 378 programs and 103 commands run by this version.
  • dc369ebIn a C or LLVM build on Windows, files.list and files.make_folder take names through the code page as fopen does, so a listed name opens; the folder tests hold on disks that ignore case.
  • 132e3a1A comment in the runtime's folder piece no longer holds a slash and a star.
  • 728f562The folder test makes a name that is not UTF-8 only where the disk allows one.
  • f65f31eThe folder test in every build takes away the files each engine made.
  • 799b443The plan: folders on Windows and macOS are mended and accepted.
  • 5a7c8beWhat Zeno lacks: in a C or LLVM build on Windows a file name goes through the code page, not UTF-8, and why that waits (59.20).
  • 0dcf295The book: a file's name on Windows, among the limits.
  • 09ccc64The plan: the run of the targets is green, and what the tag may hold.
  • facfa27The notes of 0.8.0 are finished, the install lines name 0.8.0, and the page on targets gives the counts of this version.
  • bc9f25bThe notes of 0.8.0 say how many tests ran on each system. This commit is Zeno 0.8.0.

Unreleased

Not in a release yet · 2 commits · 20 November 2026

What is on main since 0.8.0 was released.

  • 68e021cThe Homebrew, pacman and winget recipes for 0.8.0, with its checksums.
  • 3ae9202The plan: 0.8.0 is out, and the plan for items 9 to 13 is closed.

This file is written by tools/history.py from the commits themselves and the notes in tools/history-notes.txt. It lists 440 commits, up to 3ae9202 of 20 November 2026. A commit that only brings this file or its notes up to date is not listed.

This page is HISTORY.md in the language repository.