What Zeno does not have yet, and what to do about each
This page builds nothing. It is the whole list of what Zeno is still
missing, in the order it should be built, with a recommendation for
each item. It was written on 2026-11-18, against main after 0.5.1.
The list comes from three places:
- The limits Zeno wrote down itself. Chapter 11 of
decisions.mdand appendix G of the book, "What Zeno Does Not Have Yet". Each one was tried again on today's compiler for this page. - What the README promises and has not delivered. The table "One
language, every job" names C in both directions,
asyncandawait, fast arrays, operator overloading, and mobile. - What C, C++, Python, JavaScript, Java, Rust and Go have that neither of the first two mentions. Each was tried as a small program, to see what Zeno says today.
Zeno is for firmware first, so what a board needs is weighed above what a server needs.
Will adding these change what works today?
No. Every item below is refused today with a message, or is a name that does not exist yet. No program that is accepted now uses any of them, so allowing one later changes the meaning of no program. That was the test for putting a limit on the list in the first place (11.6).
What each one costs is work, and the work is wide. A new built-in
function is written for the interpreter, the VM, the C runtime, the
LLVM build and fifteen targets. That is why the first item below is
the one that makes the others cheap. And nothing may make a program
that does not use it slower or larger: speed is compared before every
release (release.md).
The order to build them in
| What | Size | Why here | |
|---|---|---|---|
| 1 | A library written in Zeno. Done (library-in-zeno.md) |
medium | Every later library function is then written once, and not once for each engine and each target |
| 2 | The small library gaps. Done: hypot, sinh, cosh, tanh, gcd, clamp, random numbers, and program.exit, program.environment and program.warn (ending-a-program.md) |
small | First use of 1. Every one is asked for by ordinary programs |
| 3 | An enum case with a number: Ack = 6. Done (enum-numbers.md); a loop over the cases is left |
medium | Every protocol and every register field is a number with a name |
| 4 | Bytes: bytes from and to a file (done, bytes.md), a packed list[u8] (done, decision 36.2), a list of a fixed length (done, fixed-lists.md, decision 36.4; kept off the pool is left) |
large | "The first thing a real driver will ask for" (5.13a) |
| 5 | u64 and f32. Done (f32.md, chapter 41; u64.md, chapter 42) |
medium | Counters and timestamps; a board whose float unit is 32 bits |
| 6 | Units made of units: V * A is W. Done (units-made.md, chapter 43) |
medium | Units are what Zeno has that C does not. Power, resistance and frequency are the firmware's daily sums |
| 7 | Inputs on a board (done, inputs.md, chapter 45), a serial port (done, serial.md, chapter 46), an ADC (done, analog.md, chapter 47), PWM (done, pwm.md, chapter 48), a timer (done as a ticker, ticker.md, chapter 49), interrupts (done as edges the board counts, interrupts.md, chapter 50). No done part has been tried on a real board |
large, wants a board | The one thing that keeps Zeno off real hardware |
| 8 | One step from a .zeno file to a board: the board's compiler run by zeno build --board (done, board-build.md, chapter 51), a runtime with no printf and no exit (done for a board that brings four functions, chapter 52), a float made into text and read with no snprintf and no strtod (done, chapter 53), checks without GCC built-ins (done, plain-c.md, chapter 55). No part has been tried on a real board, or with a compiler that is neither GCC nor Clang but tcc |
large | The same |
| 9 | What a build with no collector still refuses, and raises in a function type. Parts 9.1 to 9.9 done (chapter 56): raises in a function type (raises-in-types.md), a function that is kept (kept-functions.md), a method as a value (method-values.md), take in front of a place (take.md), a value with one owner in a generic (generic-owned.md), a dict that owns its values (dict-owned.md), a list of numbers that may be none (none-list.md), the size of the pool on the command line (pool-size.md), a function inside a function and a default that is worked out, in every build (inner-functions.md), and what a build still refuses, in one table for a build with no collector (no-collector.md) and one for every build (compiler.md), all held by a test. Left: what those tables list, each with its reason, and 56.18 |
medium | Firmware builds should take every program zeno run takes |
| 10 | Several values from one function. Done (several-values.md, chapter 57): -> (int, str), let q, r = f(), a, b = b, a, in every engine, build and target. Left: swapping two items a list owns with no collector, several names in a for, a default for one of several results |
medium | Go, Python and Rust all have it, and a driver's read wants a value and a status |
| 11 | Generic enums, generic interfaces, and bounds. Done (chapter 58, generics.md) |
large | A Maybe[T] and a sort that asks for an order |
| 12 | Cleaning up when a block ends (done, resource.md, decisions 59.1 to 59.5: owned class X is Resource, in a let or a parameter), folders (done, folders.md, 59.20 to 59.23), and files read and written in pieces (done, files-in-pieces.md, 59.6 and 59.7) |
medium | An open file, a lock and an interrupt mask all need "and put it back" |
| 13 | Tools: tests of a compiled program (done, zeno test --build, testing.md, decision 60.2) and a message on assert (done, decision 60.1); step through a .zeno file in gdb, completion and rename in the editor, a REPL (put off, 2026-11-19) |
medium, in pieces | Each is small by itself |
| 14 | More than one thing at a time: tasks, threads, async (put off, 2026-11-19; designed in the plan) |
very large | Last, because it touches memory, errors and every engine |
Items 1 to 8 are built, and went out in 0.7.0. How items 9 to 14 are
to be built, part by part, with the ways of writing each that were
weighed, is in plan-9-14.md. Items 9 to 12 are
being built in full, and of item 13 the tests of a compiled program
and the message on assert. The other tools of item 13 and the whole
of item 14 are put off: their designs are in the plan, ready for when
they are taken up.
Calling C from Zeno belongs between 7 and 8. It is being built
elsewhere, as the third version of the bridges to other languages, so
it is not on this list. What matters for firmware is that it works in
zeno build --firmware, and not only in zeno run: a vendor's HAL is
C.
1. On a board
| Missing | What the others have | Recommendation |
|---|---|---|
| ~~Inputs: reading a pin, saying a pin is an input, a pull-up (3.15b)~~ | C through the vendor's header. Rust: embedded-hal |
Done (chapter 45, inputs.md): input_pin(2, pull_up), is_high(), is_low(), a fifth board function. Left: pressing a button under zeno run, and trying it on one real board |
| A serial port, an ADC, PWM, a hardware timer | The same | The serial port is done (chapter 46, serial.md): serial(1, 115200 baud), write, write_bytes, read_byte, has_byte. The ADC is done (chapter 47, analog.md): analog_pin(0), voltage() in volts, count(). PWM is done (chapter 48, pwm.md): pwm_pin(9, 1 kHz), duty(0.25), pulse(1500 us). The timer is done as a ticker (chapter 49, ticker.md): ticker(10 ms), wait(), ticks(), restart(). Left: a function a tick runs, which is an interrupt |
| Interrupts: a function that runs when a pin or a timer says so, and a safe way to share a variable with it | C: a vector table and volatile. Rust: #[interrupt] and a critical section |
The safe half is done (chapter 50, interrupts.md): button.interrupt(falling), wait(), edges(). The rule is one sentence: the program's own code never runs inside an interrupt; the board counts, and the program asks. Left, with item 14: a function of the program run at each edge |
~~A runtime for a board: the firmware C still calls printf and exit~~ |
C and Rust build with no library at all | Done (chapter 52, board.md): a board's header says #define ZENO_BOARD_PRINTS and brings four functions, and print, input, a warning, an error's message and the end of the program go through them. hello takes 936 bytes of flash on a Cortex-M3. A number with a fraction is made into text, written with decimals and read by the runtime itself, with whole numbers (chapter 53): 4 KB where snprintf and strtod were 28. Left: --memory on such a board |
| ~~Another processor in one step: a build writes C, and compiling it for a board is a second command (5.12c)~~ | Rust: --target thumbv7em-none-eabihf. Go: GOARCH |
Done (chapter 51, board-build.md): zeno build --board <folder>. The folder's zeno.board names the compiler, the flags, the start-up files and the linker script, because they are the board's and not the program's. Left: a board by name, loading the program in the same step, a collector for a chip |
| ~~Checks without GCC and Clang built-ins (5.5e)~~ | Done (chapter 55, plain-c.md): each thing asked of GCC and Clang by name is written a second time in plain C, behind one mark, ZENO_PLAIN_C. tcc builds every example and each does what it does built by gcc. Left: a trial with IAR's, Keil's or a chip maker's compiler, none of which can be run where Zeno is made, and Microsoft's compiler |
|
MISRA: variable argument lists in the runtime, printf, a forward goto (firmware.md) |
Take them one rule at a time after the board runtime, which removes two of them | |
time.now() is a float of milliseconds |
C: a uint32_t of ticks |
Give a whole number of ticks beside it, after u64 |
Never run on hardware. The STM32 header in board.md was written and not tried. Since chapter 51 every example runs on an ARM Cortex-M3 that QEMU emulates, which tries the C on a real processor's instructions, and since chapter 52 a second board folder drives that chip's own pin, timer and UART registers as far as QEMU emulates them. Neither is a real board |
This needs a board on a desk. It is the only item on this page that needs hands |
2. Numbers and memory
| Missing | What the others have | Recommendation |
|---|---|---|
~~A packed list[u8]: an item takes eight bytes (5.13a)~~ |
C: uint8_t buf[64]. Rust: Vec<u8>, [u8; 64]. Go: []byte |
Done (36.2): a list[u8] takes one byte an item. Lists of the other sized numbers still take eight |
| ~~A list of a fixed length~~, whose size is known when the program is built | C, C++, Rust and Go arrays | Done (36.4): list[u8, 64], with [0] * 64 to fill one (36.3). Left: keeping its items in the object or on the stack, with no block from the pool (36.5) |
| ~~Bytes from and to a file~~ (6.16) | All seven | Done (chapter 36): files.read_bytes gives a list[u8], files.write_bytes takes one |
~~u64~~ (2.8d), and i64 as a name |
All but JavaScript and Python, which have big numbers | Done (chapter 42): an operator between two u64s gives a u64, checked, and it meets an int only when the number is written. i64 is not added: it would be a second name for int (42.1) |
~~f32~~ |
C, C++, Java, Rust, Go | Done (chapter 41): sums in 32 bits, an f32 goes where a float is wanted, and an f32 beside a float is refused. Left: math in 32 bits (41.9) |
~~u8.max and u8.min~~ |
Rust: u8::MAX |
Done (42.7): .max and .min on every whole type, from u8 to u64. Left: float.max |
| Small variables and parameters: only a field of a class is stored at its size | C | Leave. The C compiler keeps them in registers either way |
| The layout of an object: no promise of the order or the gaps between fields, and no fields of a few bits | C: structs and bit fields. Rust: repr(C) |
Build after bytes, as a word on the class. A frame or a register block is then a class |
Pointers to more than numbers, the address of a variable, p - q, a 64-bit register (unsafe.md) |
C, C++, Rust | Build as drivers ask. A pointer to an object first, since that is what a C library hands back |
| ~~Units made of units~~, and a unit a program names itself (1.15) | None of the seven have units at all. F# does | Done (chapter 43): V * A is W, V / A is ohm, W * h is J, 1 / s is Hz, from a closed list. Left: charge (mAh), speed, and a program's own units |
| Numbers of a fixed number of decimals, for a processor with no float unit | None as part of the language | Leave for a package |
| Code that is built only for one board | C: #if. Rust: cfg. Go: build tags |
A const and an if that the compiler drops when it can never be true. No second language inside the language |
3. The language
| Missing | What the others have | Recommendation |
|---|---|---|
| ~~An enum case with a number, an enum from a number~~, a loop over the cases | C, C++, Java, Rust, Go (iota) |
Done (chapter 35): Ack = 6, int(Ack), Reply(6) gives a Reply or none. The loop over the cases is next |
~~Several values from one function, and a, b = b, a~~ |
Python, Go, Rust, C++ | Done in 0.8.0 as two or more results and not as a new kind of value: -> (int, str), taken apart where it is received (several-values.md, chapter 57). A tuple that is kept in a list is a class |
| ~~Generic enums~~ (3.16e) | Rust, Java, C++ | Done (58.1): enum Maybe[T], Result[T, E] |
| ~~Bounds~~ (3.16d) | Rust traits, Java, Go, C++ concepts | Done (58.3): function largest[T is Ordered] moves the error from inside the generic to the call. Ordered comes with Zeno |
| ~~Generic interfaces~~ (10.10) | Rust traits, Java, Go | Done (58.6): interface Source[T], class Countdown is Source[int] |
| A method with a type parameter of its own, type arguments written at a call | Rust, Java, C++, Go | Left for later after item 11 (58.7): a function of the file that takes the object first does the same work, and the message says so. Types at a call stay unwritten (3.16b) |
| ~~Something that runs when a block ends~~ | C++ destructors, Rust Drop, Go defer, Python with, Java try with resources |
Done in 0.8.0 (59.1): owned class X is Resource, whose release the owner's end calls. Left: a resource in a field or a list |
finally |
Python, Java, JavaScript | Leave. The item above does its work, and one way is the rule |
A value chosen by a condition in one line (x if c else y) |
All but Go | Decide once. There is one way to write an if today, and it is a statement |
Operators for a class (a + b for two vectors) |
C++, Python, Rust | Build it late, as an interface the class says it is: class Vector is Addable. The README promises it for numerics |
Unions other than or none (1.13) |
Python, TypeScript | Leave. An enum that carries data is the one way |
Text over several lines, text that repeats ("-" * 20), an item counted from the end (xs[-1]) |
Python, mostly | Small. Text over several lines is worth having. The other two have a way already (slice, len) |
| A set | Python, Java, Rust, C++, JavaScript | A dict of true does the work. Write it in Zeno once item 1 is done |
| A key of a dict that is not a str or an int: an enum case, a float | All | Enum cases, once they can be numbers. Floats: leave |
A second name for a type (type Volts = float) |
C, C++, Rust, Go | Leave. Units do this job better |
| ~~A named function inside a function, in a build; a method as a value; a default that is not written out~~ | Done in 0.8.0: inner-functions.md, method-values.md. Two functions inside that call each other and use variables around them are left (56.18) |
|
More than one thing at a time: threads, tasks, async and await, channels |
All seven, each its own way | Last and largest. Choose one model, and choose the one a board can run: tasks that take turns, with a queue between them. The README's async row waits for this |
Something that gives its values one at a time (yield) |
Python, JavaScript, Rust, Go | Leave until a program asks |
| Code that writes code: macros, reflection, running at build time | C, C++, Rust | Leave. It is the hardest thing to keep unambiguous |
Inheritance, a second way to write a function, import x as y |
Decided, and not limits (version-0.1.md) |
4. The library
| Missing | Recommendation |
|---|---|
| ~~A library written in Zeno~~ (6.10) | Done (chapter 33). A module that comes with Zeno may have a part that is a .zeno file kept inside the zeno program, joined in only when a program names something from it |
~~hypot, sinh, cosh, tanh, gcd, clamp~~ (6.21) |
Done, as the first functions written in Zeno |
| ~~Random numbers~~ (6.21) | Done: the module random. What is left is a seed from the machine, which waits for the time of day |
| The methods of text and lists in Zeno (6.10) | Leave. They are called as xs.insert(...) and take items out of a list they were lent, which a function written in Zeno may not |
~~program.exit(code) and the environment~~ (6.19) |
Done (chapter 34): program.exit and program.environment, in every engine and target |
| ~~Writing to the error stream~~ | Done: program.warn(text) (34.3) |
| ~~A file read in pieces~~ (6.12, 6.20) | Done in 0.8.0 (59.6): files.read_from, files.write_to, files.append_to, closed when the owner ends (files-in-pieces.md) |
| An uncaught error of a library function written in Zeno names the library's line (59.6, 33.2) | Leave for now. files.read_from of a missing file, uncaught, points at library/files.zeno:86, not the program's line. Naming the caller's line too wants a line for each call a library makes, in every engine |
| In a C or LLVM build on Windows a file name goes through the code page, not UTF-8 (59.20) | A later version. A build opens a file with fopen, which takes a name through the machine's code page, and files.list takes names the same way so that what it lists opens; a name the code page cannot hold, made by another program, comes back with question marks. Taking names as UTF-8 there changes how every file function opens a path, in the runtime of every program, so it waits for a version that decides it |
| ~~Folders: what is in one, making one, joining the parts of a path~~ | Done in 0.8.0 (59.20 to 59.22, folders.md). Removing one is left |
| The date and the time of day | Build: time has only a stopwatch today |
| The network outside a page: a socket, an HTTP request | After tasks, for a server. web.fetch in a page is there |
| Patterns in text (regular expressions) | Leave for a package, or use import python |
| Capital letters outside plain English (3.14) | Settled for the language. A package for programs with the room |
| JSON in a compiled program, and straight into a class (18.5) | Build the first once the library can be written in Zeno. The second waits for generic bounds |
program.run in a build (25.6) |
Build as programs ask |
| A queue, a heap, a search in a sorted list | Write in Zeno once item 1 is done |
5. Tools
| Missing | What the others have | Recommendation |
|---|---|---|
A debugger. The C that a build writes has no #line, so gdb steps through the C and not the .zeno file |
All seven | Build the #line marks, in a --debug build only. It is small, and gdb, lldb and every probe for a board then work as they are |
| A REPL. The README names one | Python, JavaScript, Java | Small with the interpreter. Build it |
Tests of a compiled program, a message on assert, something run before each test (10.21) |
Rust, Go | Build the first two. A firmware program should be tested as it is built |
| How much of a program its tests ran, and timing a function | Go, Rust | Later |
| In the editor: completion, rename, every use of a name, going to a field (9.11, 17.4) | All | Completion first. It is what people notice is missing |
| The VS Code extension is a folder to copy, and not in the Marketplace | Needs an account, like the stores in stores.md |
|
| Pages made from the comments of a program | Rust, Go, Java, Python | Later, when packages exist that need them |
| Compiling one file at a time (7.11) | C, C++, Rust, Go, Java | Leave until a program is large enough to wait for |
| The registry is empty, and no package has been published through its form | Publish the first one. examples/filters is ready-made |
6. Where a program can run
| Missing | Recommendation |
|---|---|
| A real board. See part 1 | The first platform to add |
A page that is compiled and has import web. --web carries the interpreter (14.1). --target html is compiled and small, and has no web module |
Give the JavaScript target the web module. The book's line on this is half out of date: the compiled page exists since 0.5 |
| Canvas images and curves, more than one finger, the address bar (16.13) | As pages ask |
| The playground: one file, no colours, no Stop button (16.12) | Small. Build with the next change to the playground |
| A window on a desktop, a phone | Far off. The Kotlin and Dart targets are the way to a phone, and neither has a screen module |
7. Firmware builds and builds with no collector
Each of these runs under zeno run and is refused by one kind of
build. They are item 9 in the order. What a build with no collector
still refuses, all by design, is the table in
no-collector.md; what every build still refuses
is the table in compiler.md.
| Refused | Recommendation |
|---|---|
~~A function that says raises, used as a value in a firmware build (5.5l)~~ |
Done in 0.8.0: function(str) -> int raises ValueError (raises-in-types.md, chapter 56) |
~~list[int or none] with no collector (5.16h)~~ |
Done in 0.8.0: the list owns a block of the pool for each number, as it owns its copy of each text (none-list.md). The number and a flag side by side, with no block, is left for later (56.18) |
| ~~A dict of lists or objects with no collector (10.14)~~ | Done in 0.8.0: the dict owns its values, as a list owns its items (dict-owned.md) |
| ~~A list or an object as what a type parameter stands for, with no collector (5.16i, 5.19f)~~ | Done in 0.8.0: Stack[Frame], and take T (generic-owned.md) |
~~A few moves of an owned value (5.8i, 5.15e, 5.17d), and raise e (5.9d)~~ |
Done, or kept by design: a function that is kept takes what it uses (5.17d, kept-functions.md); take slot.task moves out of a field (5.8i, take.md); raise e builds. Taking an item out of a list while a for walks it stays refused by design (5.15e): the loop is still looking at the items |
| ~~The pool's size on the compiler's line (5.9j); spare blocks not filled with a pattern (5.9k)~~ | Done in 0.8.0: zeno build --pool 4096, and with --memory a block given back is checked (pool-size.md) |
| ~~A function of an interface with a default; an owned class as an interface (10.5, 10.10)~~ | Done in 0.8.0: a plain value that each class writes the same, a function that takes out standing for one of an interface, and owned interface (interfaces.md, 58.20 to 58.22) |
| A function of an interface with a type of its own (10.5) | With generic interfaces |
How Zeno compares, feature by feature
"Yes" means the language has it as part of itself or of the library that comes with it.
| C | C++ | Python | JS | Java | Rust | Go | Zeno | |
|---|---|---|---|---|---|---|---|---|
| Sized whole numbers to 64 bits | yes | yes | no | no | yes | yes | yes | yes |
| A 32-bit float | yes | yes | no | no | yes | yes | yes | yes |
| A list of a fixed length | yes | yes | no | no | yes | yes | yes | yes |
| Bytes packed one to a byte | yes | yes | yes | yes | yes | yes | yes | yes |
| Registers and raw pointers | yes | yes | no | no | no | yes | some | yes |
| Interrupts | yes | yes | no | no | no | yes | no | counted, no handler |
| Builds with no library under it | yes | yes | no | no | no | yes | no | nearly |
| Numbers with units | no | no | no | no | no | no | no | yes |
| Overflow checked | no | no | no need | no | no | in debug | no | yes |
none checked before use |
no | no | no | no | no | yes | no | yes |
| Errors a function must declare | no | no | no | no | yes | yes | no | yes |
| Enums that carry data | no | some | no | no | some | yes | no | yes |
| An enum case with a number | yes | yes | yes | no | yes | yes | yes | yes |
| Generics | no | yes | no | no | yes | yes | yes | yes, with bounds |
| Several results from a function | no | yes | yes | yes | no | yes | yes | yes |
| Cleaning up at the end of a block | no | yes | yes | yes | yes | yes | yes | freeing only |
| Operators for a class | no | yes | yes | no | no | yes | no | no |
| Threads or tasks | yes | yes | yes | yes | yes | yes | yes | no |
| Modules and packages | no | some | yes | yes | yes | yes | yes | yes |
| A formatter with the language | no | no | no | no | no | yes | yes | yes |
| A test runner with the language | no | no | yes | yes | no | yes | yes | yes |
| A language server | yes | yes | yes | yes | yes | yes | yes | yes, no completion |
| A debugger that shows the source | yes | yes | yes | yes | yes | yes | yes | no |
| A REPL | no | no | yes | yes | yes | no | no | no |
| Calls C | is C | yes | yes | yes | yes | yes | yes | being built |
What was tried for this page
These were run on the compiler built from main on 2026-11-18, and
each was refused as the list says: u64, f32, int or str, 3 V *
2 A, program.exit, the environment, math.hypot, math.sinh,
math.clamp, import random, assert outside a test,
files.read_bytes, enum Maybe[T], interface Ordered[T], a named
function inside a function in a build, import json in a build,
list[int or none] and a dict of lists with --no-collector, a
tuple, -> (int, str), a, b = b, a, an enum case with = 1,
defer, finally, async, a set, u8.max, the address of a
variable, an enum case as a key, "ab" * 3, xs[-1], text between
three quotes, x if c else y.
Since this page was written, math.hypot, math.sinh, math.clamp
and import random are no longer refused: see part 4. With
--no-collector, a dict of lists and list[int or none] build since
0.8.0: see part 9.
Two lines of the book's appendix are no longer the whole story.
sort by a function came in 0.3. And a compiled page exists since
0.5 as --target html, without the web module.
The rest of the appendix was taken from the documents and not run
again: the moves of an owned value, raise e with no collector, the
functions of an interface, and the web items.
This page is docs/missing.md in the language repository.