Skip to content

Releases

Zeno 0.5.1

Choose a tag to compare

@github-actions github-actions released this 17 Nov 03:31

Zeno 0.5.1 puts zeno run --vm back to the speed it had in 0.4.0.
Nothing else changes: it is 0.5.0, built another way.

Installing

Windows: download zeno-0.5.1-windows-setup.exe below and run it.
It is not signed, so Windows warns the first time: "More info", then
"Run anyway".

macOS and Linux:

curl -fsSL https://github.com/partham20/zeno-lang/releases/download/v0.5.1/install.sh | sh

Both put zeno on the PATH and offer to install a C compiler and git
if the machine has none.
docs/install.md
says what they do. The archives further down are for installing by
hand.

Homebrew, on macOS and Linux:

brew tap partham20/zeno-lang https://github.com/partham20/zeno-lang
brew install partham20/zeno-lang/zeno

With another package manager. There is a package for apt, pacman,
snap and flatpak, installed from its file:

sudo apt install ./zeno_0.5.1_amd64.deb                         # Debian, Ubuntu, Raspberry Pi OS
sudo pacman -U zeno-lang-bin-0.5.1-1-x86_64.pkg.tar.zst         # Arch
sudo snap install --classic --dangerous zeno_0.5.1_amd64.snap
flatpak install --user zeno-0.5.1-x86_64.flatpak

The .deb is also there for arm64, armhf (every Raspberry Pi with
a 32-bit system) and i386, the snap for arm64 and armhf, and the
flatpak for aarch64. apt installs a C compiler and git along with
Zeno if the machine has none.

docs/stores.md
says where each manager finds Zeno by itself, with no file, and what is
still to be done for the ones that do not yet.

zeno run --vm as fast as in 0.4.0

0.5.0 added zeno build --target, and its notes said that Zeno itself
was as fast as before. That was measured by counting instructions, and
the count was right: the VM ran the same instructions as in 0.4.0. But
timed in rounds on a quiet machine it was slower on every benchmark,
by 1 to 9 %. The Rust compiler cuts a program into pieces and works on
each alone, and with more code in the program it had cut Zeno up
differently: the same instructions, placed worse.

Zeno is now built as one piece (codegen-units = 1), so code that is
added elsewhere cannot move the VM about. Against 0.4.0, in seconds,
the best of four rounds:

0.4.0 0.5.0 0.5.1
fib 0.56 0.60 0.58
loop 6.15 6.45 6.01
sort 2.63 2.86 2.60
strings 1.27 1.27 1.24
trees 7.09 7.34 7.05
nbody 12.06 12.56 11.95

Counted, it runs 1 to 2 % fewer instructions than 0.4.0. Programs
built with zeno build were never slower: their C is the same in
0.4.0, 0.5.0 and 0.5.1. Plain zeno run was not slower either.
Decision 24.29 has the whole of it.

Also

  • bench/run.py has an engine for the program written in each other
    language (to-js, to-py, to-php and so on), and the record of a
    version keeps their times. bench/compare.py times two builds of
    Zeno against each other.
  • A known limit is written down: Node 22 can stop with a fault of its
    own while it runs a big .wasm built with --target wasm. Node 24
    does not (docs/targets.md, "Known limits").

The archives

Machine File
Linux, x86-64: most PCs and servers zeno-0.5.1-linux-x86_64.tar.gz
Linux, ARM64: a Raspberry Pi 3, 4 or 5 with a 64-bit system, ARM servers zeno-0.5.1-linux-arm64.tar.gz
Linux, 32-bit ARMv7: a Raspberry Pi 2 or later with a 32-bit system zeno-0.5.1-linux-armv7.tar.gz
Linux, 32-bit ARMv6: a Raspberry Pi 1 or Zero zeno-0.5.1-linux-armv6.tar.gz
Linux, 32-bit x86 zeno-0.5.1-linux-x86.tar.gz
macOS, Apple silicon zeno-0.5.1-macos-arm64.tar.gz
macOS, Intel zeno-0.5.1-macos-x86_64.tar.gz
Windows, x86-64 zeno-0.5.1-windows-x86_64.zip
Windows, 32-bit x86 zeno-0.5.1-windows-x86.zip
Windows, ARM64 zeno-0.5.1-windows-arm64.zip

Unpack it and put zeno (zeno.exe on Windows) somewhere on your
PATH. To build web pages, put zeno.wasm from the same folder
beside it. The folder also holds the docs, the examples and the editor
setup.

tar -xzf zeno-0.5.1-linux-x86_64.tar.gz
cd zeno-0.5.1-linux-x86_64
./zeno --version
./zeno build --release examples/hello.zeno && ./hello
./zeno build --target py examples/hello.zeno && python3 hello.py

On macOS, a program downloaded with a browser is held back because
Apple has not signed it. xattr -d com.apple.quarantine zeno lets it
run.

zeno build hands the C it writes to a C compiler, so it needs one:
cc, gcc or clang, whichever it finds first, or the one CC
names. zeno build --llvm needs clang. zeno fetch needs git. zeno build --target needs nothing to write the file (but wasm, which
needs Rust), and the language to run it. zeno build --web and
everything else need nothing.

What was checked

As for 0.5.0, every build but the Windows one for ARM64 was run before
it was released, and each one that was run also built the page of
examples/todo.zeno and wrote examples/hello.zeno in ten languages.
The whole test suite, 519 tests, passes on Linux x86-64, on macOS on
Apple silicon and on Windows x86-64.

The speed was compared with 0.4.0 and 0.5.0 on one machine, Linux on
x86-64, counted and timed. The builds for the other systems are made
the same way, as one piece, but were not timed.

The setup program for Windows was installed, run and uninstalled on a
Windows machine, and install.sh the same on Linux and on macOS. Each
package was installed, run and removed: the .deb, the snap and the
flatpak on Ubuntu, the pacman package in Arch, and the Homebrew
formula on macOS.

Zeno 0.5.0

Choose a tag to compare

@github-actions github-actions released this 17 Nov 01:44

Zeno 0.5 writes your program in another language. zeno build --target <language> gives a file in JavaScript, TypeScript, Python,
PHP, Go, Java, C#, C++ or Rust, a web page, or a WebAssembly file, that
prints what zeno run prints. Nothing else about Zeno moves: zeno run and zeno build are as fast as in 0.4.

Installing

Windows: download zeno-0.5.0-windows-setup.exe below and run it.
It is not signed, so Windows warns the first time: "More info", then
"Run anyway".

macOS and Linux:

curl -fsSL https://github.com/partham20/zeno-lang/releases/download/v0.5.0/install.sh | sh

Both put zeno on the PATH and offer to install a C compiler and git
if the machine has none.
docs/install.md
says what they do. The archives further down are for installing by
hand.

Homebrew, on macOS and Linux:

brew tap partham20/zeno-lang https://github.com/partham20/zeno-lang
brew install partham20/zeno-lang/zeno

With another package manager. There is a package for apt, pacman,
snap and flatpak, installed from its file:

sudo apt install ./zeno_0.5.0_amd64.deb                         # Debian, Ubuntu, Raspberry Pi OS
sudo pacman -U zeno-lang-bin-0.5.0-1-x86_64.pkg.tar.zst         # Arch
sudo snap install --classic --dangerous zeno_0.5.0_amd64.snap
flatpak install --user zeno-0.5.0-x86_64.flatpak

The .deb is also there for arm64, armhf (every Raspberry Pi with
a 32-bit system) and i386, the snap for arm64 and armhf, and the
flatpak for aarch64. apt installs a C compiler and git along with
Zeno if the machine has none.

docs/stores.md
says where each manager finds Zeno by itself, with no file, and what is
still to be done for the ones that do not yet.

zeno build --target: the program in another language

$ zeno build --target py examples/hello.zeno
Wrote hello.py. Run it with `python3 hello.py`
$ python3 hello.py
Hello, Zeno!
--target Writes Run it with
js hello.js node hello.js
ts hello.ts, TypeScript node hello.ts (Node 22.18 or later), or tsc, Bun, Deno
html hello.html, a page that runs the program a browser
py hello.py python3 hello.py
php hello.php php hello.php (PHP 8.0 or later, no extension needed)
go hello.go go run hello.go
java hello.java java hello.java (JDK 11 or later)
cs hello.cs dotnet run hello.cs (.NET 10 or later)
cpp hello.cpp g++ -std=c++17 -O2 hello.cpp -o hello && ./hello
rust hello.rs rustc -O --edition 2021 hello.rs -o hello && ./hello
wasm hello.wasm, built by rustc wasmtime hello.wasm, or any WebAssembly host with WASI

It is one file, with nothing to install beside the language itself.
The file is written by fixed rules: the same program gives the same
file, letter for letter.

It does what zeno run does. The file carries Zeno's rules with
it, so a whole number that overflows is an error in the Python and the
JavaScript too, a float prints with the same digits, a list index out
of range stops the program with the same message at the same line, and
text in Tamil is counted and cut the same way. A tool holds every
target to that: tools/targets.py runs 337 programs (every example,
every sample of the book, and 22 written to try the corners) with
zeno run and in each language, and compares what is printed and the
error a program stops with. All eleven targets print the same on all of
them.

It is only a flag. Without --target, nothing of this runs. zeno run, zeno build, --release, --fast and --web do what they did
in 0.4, at the same speed. The C that zeno build writes for the six
benchmarks is the C that 0.4.0 wrote, but for one function that quotes
a text, and the built programs run the same count of instructions, to
one part in ten thousand, on five of the six. On the sixth, nbody, the
two builds with --owned run half a percent more (three or four
instructions a step), because the C compiler placed the same loop at
another address. zeno run --vm, whose code was not touched, is within
about two in a hundred either way (fewer on loop and nbody, more on fib
and trees), which is the Rust compiler laying the same code out
differently.

What it cannot write. A program for a board (import board), a
page made with import web, and unsafe memory belong to zeno build; --target says so and writes nothing.

docs/targets.md
shows what each language's file looks like, how it is made, how fast
it is, and its known limits.

One rule where there were two

Writing eleven other ways to run a program showed where zeno run did
whatever the Rust it is built with does. Each such corner now has a
rule, which zeno run, zeno build and every target keep. A program
only sees a difference from 0.4 in these corners:

  • Text in quotes. A text shown inside a list or a dict, or named in
    an error, is written as it is. ["தமிழ்"] printed as
    ["தமிழ\u{bcd}"]; now it prints as written. Only control
    characters are shown as codes (decision 24.20).
  • A float exactly between two shortest texts prints the one whose
    last digit is even, as zeno build already did. It can only happen
    to a float of 16 or 17 digits (24.21).
  • lines() and input(). A \r belongs to the end of a line
    only just before the \n, whatever version of Rust built Zeno
    (24.24).

Mended

  • range with a step that goes past the last int ended in a wrong,
    endless list. It ends the range.
  • json.parse took \u+041 as a character. The four after \u must
    be hex digits, and the second half of a pair must be one.

The archives

Machine File
Linux, x86-64: most PCs and servers zeno-0.5.0-linux-x86_64.tar.gz
Linux, ARM64: a Raspberry Pi 3, 4 or 5 with a 64-bit system, ARM servers zeno-0.5.0-linux-arm64.tar.gz
Linux, 32-bit ARMv7: a Raspberry Pi 2 or later with a 32-bit system zeno-0.5.0-linux-armv7.tar.gz
Linux, 32-bit ARMv6: a Raspberry Pi 1 or Zero zeno-0.5.0-linux-armv6.tar.gz
Linux, 32-bit x86 zeno-0.5.0-linux-x86.tar.gz
macOS, Apple silicon zeno-0.5.0-macos-arm64.tar.gz
macOS, Intel zeno-0.5.0-macos-x86_64.tar.gz
Windows, x86-64 zeno-0.5.0-windows-x86_64.zip
Windows, 32-bit x86 zeno-0.5.0-windows-x86.zip
Windows, ARM64 zeno-0.5.0-windows-arm64.zip

Unpack it and put zeno (zeno.exe on Windows) somewhere on your
PATH. To build web pages, put zeno.wasm from the same folder
beside it. The folder also holds the docs, the examples and the editor
setup.

tar -xzf zeno-0.5.0-linux-x86_64.tar.gz
cd zeno-0.5.0-linux-x86_64
./zeno --version
./zeno build --release examples/hello.zeno && ./hello
./zeno build --target py examples/hello.zeno && python3 hello.py

On macOS, a program downloaded with a browser is held back because
Apple has not signed it. xattr -d com.apple.quarantine zeno lets it
run.

zeno build hands the C it writes to a C compiler, so it needs one:
cc, gcc or clang, whichever it finds first, or the one CC
names. zeno build --llvm needs clang. zeno fetch needs git. zeno build --target needs nothing to write the file (but wasm, which
needs Rust), and the language to run it. zeno build --web and
everything else need nothing.

What was checked

As for 0.4.0, every build but the Windows one for ARM64 was run before
it was released, and each one that was run also built the page of
examples/todo.zeno and wrote examples/hello.zeno in ten languages. The whole test suite, 519 tests, passes on Linux
x86-64, on macOS on Apple silicon and on Windows x86-64.

The eleven targets were checked on Linux x86-64, on GitHub's machine,
with the newest Node, TypeScript, Python, PHP, Go, Java, .NET, g++ and
Rust: 337 of 337 programs each, and 328 of 328 for the page, which is
opened in Chromium. The file written is the same on every system, but
it was run on Linux only.

The setup program for Windows was installed, run and uninstalled on a
Windows machine, and install.sh the same on Linux and on macOS. Each
package was installed, run and removed: the .deb, the snap and the
flatpak on Ubuntu, the pacman package in Arch, and the Homebrew
formula on macOS.

The speed of 0.5.0 was compared with 0.4.0 on one machine, Linux on
x86-64, by counting instructions (bench/run.py --count).

Zeno 0.4.0

Choose a tag to compare

@github-actions github-actions released this 16 Nov 19:57

Zeno 0.4 has a way to build that is as fast as C and Rust,
zeno build --fast, and it mends what the release of 0.3.0 found on
macOS.

Installing

Windows: download zeno-0.4.0-windows-setup.exe below and run it.
It is not signed, so Windows warns the first time: "More info", then
"Run anyway".

macOS and Linux:

curl -fsSL https://github.com/partham20/zeno-lang/releases/download/v0.4.0/install.sh | sh

Both put zeno on the PATH and offer to install a C compiler and git
if the machine has none.
docs/install.md
says what they do. The archives further down are for installing by
hand.

Homebrew, on macOS and Linux:

brew tap partham20/zeno-lang https://github.com/partham20/zeno-lang
brew install partham20/zeno-lang/zeno

With another package manager. There is a package for apt, pacman,
snap and flatpak, installed from its file:

sudo apt install ./zeno_0.4.0_amd64.deb                         # Debian, Ubuntu, Raspberry Pi OS
sudo pacman -U zeno-lang-bin-0.4.0-1-x86_64.pkg.tar.zst         # Arch
sudo snap install --classic --dangerous zeno_0.4.0_amd64.snap
flatpak install --user zeno-0.4.0-x86_64.flatpak

The .deb is also there for arm64, armhf (every Raspberry Pi with
a 32-bit system) and i386, the snap for arm64 and armhf, and the
flatpak for aarch64. apt installs a C compiler and git along with
Zeno if the machine has none.

docs/stores.md
says where each manager finds Zeno by itself, with no file, and what is
still to be done for the ones that do not yet.

zeno build --fast

A new way to build, for a program whose tests pass, when every last bit
of speed matters. It leaves out the checks a correct program never
fails, as C does: a list index out of range, a float divided by zero,
the square root of a number below zero, and the overflow of a whole
number. The C compiler is asked for -O3. Every other build keeps all
its checks.

Overflow is where it differs from --release. With --release a sum
that overflows wraps round. With --fast it has no defined result, as
in C, and the C compiler builds on its not happening. That is what
makes a loop of whole numbers the same instructions a C program gets:
on the loop benchmark --fast runs 300.27 million instructions where C
runs 300.26 million. An overflow is an error in Zeno, so a program that
runs clean under zeno run has none (docs/memory-modes.md, decision
23.6).

On the six benchmarks, counted in instructions, --fast --owned runs
no more than C on five of the six, far fewer on two of them, and 6%
more on the sixth (fib, where the time is the same); the times are in
bench/README.md. Rust is ahead on one, nbody, because its compiler
knows there are exactly five bodies; with the number hidden from it,
it is behind both C and Zeno (decision 23.4).

Faster in every build

  • A number becomes text (str(n), {n}) several times faster, without
    snprintf.
  • In an owned program, a big list grows with realloc, as a C array
    does, instead of being copied each time it doubles.
  • x // 8 and x % 8, by 2, 4, 8 and so on written as a number, are
    one shift and one mask, with nothing to check. % and // by any
    other number take fewer instructions than they did (decision 23.5).
  • xs.append(x) is a compare, a store and a count in the loop that
    appends, not a call (decision 23.8).

Benchmarks that can be trusted to one in a hundred

python3 bench/run.py --count counts the instructions each program
runs, under valgrind. The count is the same on every run, where a time
on a busy machine moves by a tenth. Timed runs now go in rounds, each
engine once per round. Both sets of numbers are in bench/README.md
(decision 23.7).

The two generations of the collector, on macOS too

0.3.0 had the collector's two generations on Linux only: on macOS they
made programs built with zeno build --llvm hang. The cause is found
and mended (see below), so a program built on macOS now has them too,
and most of its collections look only at the blocks made since the
last one. On Windows every collection still looks at everything.

Mended

  • On macOS, in a program built with zeno build --llvm, catching an
    error with try could leave signals held back from then on: Ctrl-C
    no longer stopped the program. A try remembered its place in one
    way and raise went back to it in another, and the two did not
    agree about signals. This was in 0.2.0 and 0.3.0. Programs built
    with plain zeno build were right.
  • The release of 0.3.0 left packaging/arch/.SRCINFO in the
    repository at 0.2.0, beside a PKGBUILD of 0.3.0. A release now
    keeps both.

The archives

Machine File
Linux, x86-64: most PCs and servers zeno-0.4.0-linux-x86_64.tar.gz
Linux, ARM64: a Raspberry Pi 3, 4 or 5 with a 64-bit system, ARM servers zeno-0.4.0-linux-arm64.tar.gz
Linux, 32-bit ARMv7: a Raspberry Pi 2 or later with a 32-bit system zeno-0.4.0-linux-armv7.tar.gz
Linux, 32-bit ARMv6: a Raspberry Pi 1 or Zero zeno-0.4.0-linux-armv6.tar.gz
Linux, 32-bit x86 zeno-0.4.0-linux-x86.tar.gz
macOS, Apple silicon zeno-0.4.0-macos-arm64.tar.gz
macOS, Intel zeno-0.4.0-macos-x86_64.tar.gz
Windows, x86-64 zeno-0.4.0-windows-x86_64.zip
Windows, 32-bit x86 zeno-0.4.0-windows-x86.zip
Windows, ARM64 zeno-0.4.0-windows-arm64.zip

Unpack it and put zeno (zeno.exe on Windows) somewhere on your
PATH. To build web pages, put zeno.wasm from the same folder
beside it. The folder also holds the docs, the examples and the editor
setup.

tar -xzf zeno-0.4.0-linux-x86_64.tar.gz
cd zeno-0.4.0-linux-x86_64
./zeno --version
./zeno build --release examples/hello.zeno && ./hello

On macOS, a program downloaded with a browser is held back because
Apple has not signed it. xattr -d com.apple.quarantine zeno lets it
run.

zeno build hands the C it writes to a C compiler, so it needs one:
cc, gcc or clang, whichever it finds first, or the one CC
names. zeno build --llvm needs clang. zeno fetch needs git. zeno build --web and everything else need nothing.

What was checked

As for 0.3.0, every build but the Windows one for ARM64 was run before
it was released, and each one that was run also built the page of
examples/todo.zeno. The whole test suite, 514 tests, passes on Linux
x86-64, on macOS on Apple silicon and on Windows x86-64.

The setup program for Windows was installed, run and uninstalled on a
Windows machine, and install.sh the same on Linux and on macOS. Each
package was installed, run and removed: the .deb, the snap and the
flatpak on Ubuntu, the pacman package in Arch, and the Homebrew
formula on macOS.

The benchmarks were timed and counted on one machine, Linux on x86-64.
The two generations of the collector are on Linux and macOS. On
Windows, and on a chip, every collection looks at everything.

Zeno 0.3.0

Choose a tag to compare

@github-actions github-actions released this 16 Nov 09:05

Zeno 0.3 is about speed, and about choosing how memory is freed. On
six benchmarks a compiled program now runs within about a quarter of
the same program in C, and a program can say that it wants no
collector at all.

Installing

Windows: download zeno-0.3.0-windows-setup.exe below and run it.
It is not signed, so Windows warns the first time: "More info", then
"Run anyway".

macOS and Linux:

curl -fsSL https://github.com/partham20/zeno-lang/releases/download/v0.3.0/install.sh | sh

Both put zeno on the PATH and offer to install a C compiler and git
if the machine has none.
docs/install.md
says what they do. The archives further down are for installing by
hand.

Homebrew, on macOS and Linux:

brew tap partham20/zeno-lang https://github.com/partham20/zeno-lang
brew install partham20/zeno-lang/zeno

With another package manager. There is a package for apt, pacman,
snap and flatpak, installed from its file:

sudo apt install ./zeno_0.3.0_amd64.deb                         # Debian, Ubuntu, Raspberry Pi OS
sudo pacman -U zeno-lang-bin-0.3.0-1-x86_64.pkg.tar.zst         # Arch
sudo snap install --classic --dangerous zeno_0.3.0_amd64.snap
flatpak install --user zeno-0.3.0-x86_64.flatpak

The .deb is also there for arm64, armhf (every Raspberry Pi with
a 32-bit system) and i386, the snap for arm64 and armhf, and the
flatpak for aarch64. apt installs a C compiler and git along with
Zeno if the machine has none.

On Arch the package is now called zeno-lang-bin. It was zeno-bin,
and the AUR has a zeno that is another program. pacman offers to
put the new one in place of the old.

docs/stores.md
says where each manager finds Zeno by itself, with no file, and what is
still to be done for the ones that do not yet.

Choosing how memory is freed

A program that makes lists, objects and text has to give their memory
back. Until now a compiled program had a garbage collector, unless it
was built for a chip. Now a program chooses, and says so in one line of
zeno.package:

package server
memory owned

With memory owned there is no collector. Every list and object has
one owner and is freed on the line its owner ends, as in Rust, and the
program asks the system for more memory as it needs it. zeno check
and zeno run hold the program to the same rules, so a mistake about
who owns what is found before the build.

Where it is said What it covers
memory owned in zeno.package the program
zeno build --owned, or --collector one build, over what the file says
memory owned at the top of a file the classes of that file, also in a program with a collector
owned class, owned list[int] one value, as before

So a program can keep the collector for most of its code and free the
objects of one busy file exactly.
docs/memory-modes.md
walks through it.

--release

zeno build --release main.zeno

--release leaves out the check for overflow: +, - and * of
whole numbers wrap round, as the processor does, and do not stop the
program with an OverflowError. Everything else is still checked: an
index past the end, // by zero, u8(300). zeno run checks
everything, as it always did. It is what a release build of Rust does,
and for the same reason: the check costs a little on every step of a
tight loop.

A faster collector

The collector was rebuilt, twice over.

  • Blocks live in pages. It used to sort its table of every block
    at each collection. Now blocks of one size share a page of 64 KB, and
    a page keeps one bit for each block.
  • Two generations. Most blocks are garbage soon after they are
    made, and one that has lived through a collection usually lives
    through many. So most collections look only at the blocks made since
    the last one. The system's own protection of memory tells the
    collector which old pages were written to since, so nothing in the
    compiled code had to change. This is on Linux only for now. On macOS
    and Windows every collection still looks at everything.

A program that makes millions of small objects ran nine times slower
than the same program in C when built with 0.2. With 0.3 it is a
quarter slower, with the collector still doing all the freeing.

How fast it is now

Six small programs, each written in Zeno, C, Rust and Python, each
checked to print what the C one prints. Seconds, on a 4-core Xeon at
2.1 GHz, best of three:

Program C Rust Zeno 0.2.0 zeno build --release --release --owned
fib 40 0.156 0.249 0.468 0.480 0.121 0.138
loop 10⁹ 0.920 0.880 1.43 1.258 1.010 0.947
sort 10⁷ 1.09 1.14 1.33 1.43 1.44 1.35
strings 10⁷ 0.919 0.704 28.3 1.157 1.337 1.285
trees 20 6.14 7.49 59.8 7.70 6.66 3.98
nbody 10⁷ 0.488 0.368 1.37 0.511 0.479 0.515

The column for 0.2.0 is zeno build of that version, timed in a run
of its own on the same machine. Times move by about a tenth from run
to run there, so a smaller difference means nothing. The programs, the
script that runs them and the numbers are in
bench.

zeno run --vm is faster too: it runs a tight loop of whole numbers
quicker than Python 3.13 does, and is two to four times slower than
Python on objects, calls and text. zeno run and the VM are there to
check a program and to try it, and zeno build is the fast way.

Besides the collector and the two options, three smaller things made
the difference:

  • for item in items walks the list in place when the body cannot
    change it, where it used to walk a copy.
  • for ch in text walks the text, and makes no list of its characters.
  • A field that a function never writes is read once, not at each use.

sort with a function

people.sort(function(person: Person) -> int { return person.age })

sort takes a function that says what each item is ordered by, a
number or text, so a list of anything can be put in order. Items
with the same key stay as they were. It is the same in zeno run,
the VM and both compilers, and with --no-collector it leaves
nothing behind.
docs/library.md
walks through it.

The playground

zeno-lang.org/playground runs Zeno
in a browser, with nothing installed. It has a new editor: the program
is in colour, it is checked as you write, a mistake is shown at its
line, and there is a button to format it. It has fifteen examples and
fits a phone.

It also has a C tab, which shows the program as zeno build
writes it in C, made again as you write, for each of the three builds:
zeno build, --firmware and --no-collector. It is the plainest
answer to "what does this line cost?".

A page that draws now works with a finger as well as a mouse:
examples/sketch.zeno uses pointer events, and a canvas says where an
event was in its own pixels, however wide it is shown.

Mended

  • A function given to map, filter or reduce that changed the
    list it was walking crashed zeno run. Built programs were right.
  • A built program could hold far more memory than it used: a block
    that was still in use kept the block before it from being freed,
    and that one the one before it. One benchmark held 2.3 GB where it
    needed 130 MB.

The archives

Machine File
Linux, x86-64: most PCs and servers zeno-0.3.0-linux-x86_64.tar.gz
Linux, ARM64: a Raspberry Pi 3, 4 or 5 with a 64-bit system, ARM servers zeno-0.3.0-linux-arm64.tar.gz
Linux, 32-bit ARMv7: a Raspberry Pi 2 or later with a 32-bit system zeno-0.3.0-linux-armv7.tar.gz
Linux, 32-bit ARMv6: a Raspberry Pi 1 or Zero zeno-0.3.0-linux-armv6.tar.gz
Linux, 32-bit x86 zeno-0.3.0-linux-x86.tar.gz
macOS, Apple silicon zeno-0.3.0-macos-arm64.tar.gz
macOS, Intel zeno-0.3.0-macos-x86_64.tar.gz
Windows, x86-64 zeno-0.3.0-windows-x86_64.zip
Windows, 32-bit x86 zeno-0.3.0-windows-x86.zip
Windows, ARM64 zeno-0.3.0-windows-arm64.zip

Unpack it and put zeno (zeno.exe on Windows) somewhere on your
PATH. To build web pages, put zeno.wasm from the same folder
beside it. The folder also holds the docs, the examples and the editor
setup.

tar -xzf zeno-0.3.0-linux-x86_64.tar.gz
cd zeno-0.3.0-linux-x86_64
./zeno --version
./zeno build --release examples/hello.zeno && ./hello

On macOS, a program downloaded with a browser is held back because
Apple has not signed it. xattr -d com.apple.quarantine zeno lets it
run.

zeno build hands the C it writes to a C compiler, so it needs one:
cc, gcc or clang, whichever it finds first, or the one CC
names. zeno build --llvm needs clang. zeno fetch needs git. zeno build --web and everything else need nothing.

What was checked

As for 0.2.0, every build but the Windows one for ARM64 was run before
it was released, and each one that was run also built the page of
examples/todo.zeno. The whole test suite, 506 tests, passes on
Linux x86-64.

The setup program for Windows was installed, run and uninstalled on a
Windows machine, and install.sh the same on Linux and on macOS. Each
package was installed, run and removed: the .deb, the snap and the
flatpak on Ubuntu, the pacman package in Arch, and the Homebrew
formula on macOS.

The benchmarks were timed on one machine, Linux on x86-64. The two
generations of the collector are on Linux only. On macOS they made
compiled programs hang when the release was rehearsed, so there, as on
Windows and on a chip, every collection looks ...

Read more

Zeno 0.2.0

Choose a tag to compare

@github-actions github-actions released this 16 Nov 02:38

Zeno 0.2 adds two things: a Zeno program can be a web page, and Zeno
has installers.

Installing

Windows: download zeno-0.2.0-windows-setup.exe below and run it.
It is not signed, so Windows warns the first time: "More info", then
"Run anyway".

macOS and Linux:

curl -fsSL https://github.com/partham20/zeno-lang/releases/download/v0.2.0/install.sh | sh

Both put zeno on the PATH and offer to install a C compiler and git
if the machine has none.
docs/install.md
says what they do. The archives further down are for installing by
hand.

With a package manager. There is a package for apt, pacman, snap
and flatpak, installed from its file:

sudo apt install ./zeno_0.2.0_amd64.deb                         # Debian, Ubuntu, Raspberry Pi OS
sudo pacman -U zeno-bin-0.2.0-1-x86_64.pkg.tar.zst              # Arch
sudo snap install --classic --dangerous zeno_0.2.0_amd64.snap
flatpak install --user zeno-0.2.0-x86_64.flatpak

The .deb is also there for arm64, armhf (every Raspberry Pi with
a 32-bit system) and i386, the snap for arm64 and armhf, and the
flatpak for aarch64. apt installs a C compiler and git along with
Zeno if the machine has none.

Homebrew, on macOS and Linux:

brew tap partham20/zeno-lang https://github.com/partham20/zeno-lang
brew install partham20/zeno-lang/zeno

For winget there are three files in
packaging/winget,
which are what Microsoft's collection of packages takes.
docs/packages.md
says what each package is, and what is still to be done before
apt install zeno and the rest work with one word.

A program in a web page

import web

let count = web.element("#count")
var presses = 0

function pressed() {
    presses += 1
    count.text = f"{presses} presses"
}

web.element("#press").on("click", pressed)

zeno build --web counter.zeno writes counter.web.html, one file
that a browser opens from the disk or from a web server. It holds the
page (counter.html beside the program, or an empty page that shows
what the program prints), the program, and Zeno itself built for
WebAssembly, so the browser checks and runs the program as zeno run
does.

zeno run and zeno test run the same program on a simulated page
that prints each change somebody would see, so what a page does can be
tested without a browser.

docs/web.md
walks through it. examples/todo.zeno is a list of things to do, and
examples/sketch.zeno a sheet to draw on with the mouse.

zeno playground writes playground.html: a page in which Zeno
programs are written and run in a browser, with nothing installed
(docs/playground.md).

Nothing that ran under 0.1 changes.

What the web module has

  • web.element("#count"), web.elements("li"), web.create("li", "Buy milk")
  • web.after(500 ms, tick), web.every(1 s, tick) and web.on_key(pressed)
  • web.save, web.load and web.forget: text kept between visits
  • web.fetch(address, done) and web.post(address, text, done): the
    network. done is called with the status and the text of the answer
  • An Element has text and value, and on, fire, append,
    remove, clear, get, set, add_class, remove_class,
    has_class, show, hide, set_style and get_style
  • On a <canvas>: draw_rect, draw_circle, draw_line, draw_text
    and erase
  • A function given to on may take an Event, which has kind,
    target, x, y and key

If todo.html is beside todo.zeno, zeno run and zeno test read
it, so asking for an element the page does not have is an error on a
desk as it is in a browser.

import json reads and writes JSON, in a page and everywhere else
zeno run goes: json.parse(text) gives the value the text
describes, and json.write(value) the text of a value. It is how a
page reads what a server answers.

web.after and web.every give a Timer, and timer.stop() calls
off what it was waiting to do.

What it does not have yet: images and curves on a canvas. A built
page carries the whole of Zeno, 0.4 MB, runs at the speed of zeno run, and needs a browser from 2023 or later.

Smaller things

  • min and max take quantities in one unit: max(readings) of a
    list[V] is in volts.
  • zeno test --only "empty" runs the tests with that text in their
    name.
  • In an editor, resting the mouse on a field (p.x) says its type.
  • For let x: str = first([1]) the mistake is said at x.

The licence

Zeno is under the MIT licence from this version: use it, change it and
pass it on, and keep the notice. The file LICENSE is in every
archive, in what the installers install, and in every package.

The archives

Machine File
Linux, x86-64: most PCs and servers zeno-0.2.0-linux-x86_64.tar.gz
Linux, ARM64: a Raspberry Pi 3, 4 or 5 with a 64-bit system, ARM servers zeno-0.2.0-linux-arm64.tar.gz
Linux, 32-bit ARMv7: a Raspberry Pi 2 or later with a 32-bit system zeno-0.2.0-linux-armv7.tar.gz
Linux, 32-bit ARMv6: a Raspberry Pi 1 or Zero zeno-0.2.0-linux-armv6.tar.gz
Linux, 32-bit x86 zeno-0.2.0-linux-x86.tar.gz
macOS, Apple silicon zeno-0.2.0-macos-arm64.tar.gz
macOS, Intel zeno-0.2.0-macos-x86_64.tar.gz
Windows, x86-64 zeno-0.2.0-windows-x86_64.zip
Windows, 32-bit x86 zeno-0.2.0-windows-x86.zip
Windows, ARM64 zeno-0.2.0-windows-arm64.zip

Unpack it and put zeno (zeno.exe on Windows) somewhere on your
PATH. To build web pages, put zeno.wasm from the same folder
beside it. The folder also holds the docs, the examples and the editor
setup.

tar -xzf zeno-0.2.0-linux-x86_64.tar.gz
cd zeno-0.2.0-linux-x86_64
./zeno --version
./zeno build --web examples/todo.zeno     # then open todo.web.html

On macOS, a program downloaded with a browser is held back because
Apple has not signed it. xattr -d com.apple.quarantine zeno lets it
run.

zeno build hands the C it writes to a C compiler, so it needs one:
cc, gcc or clang, whichever it finds first, or the one CC
names. On Windows it no longer needs set CC=gcc.
zeno build --llvm needs clang. zeno fetch needs git. zeno build --web and everything else need nothing.

What was checked

As for 0.1.0, every build but the Windows one for ARM64 was run before
it was released, and each one that was run also built the page of
examples/todo.zeno. The whole test suite, 492 tests, passes on
Linux x86-64.

The pages themselves were tried in one browser, Chromium: clicks,
keys, timers, a form, text in Tamil, a program in several files with
a package, an error in a function that a timer called, drawing with
the mouse, a colour kept between visits, the network from a page on
a web server, and the playground. Other browsers have not been
tried.

The setup program for Windows was installed, run and uninstalled on a
Windows machine before it was released, and install.sh the same on
Linux and on macOS. The step of the setup program that installs a C
compiler and Git with winget was not run by any test.

Zeno 0.1.0

Choose a tag to compare

@github-actions github-actions released this 15 Nov 20:44

The first release of Zeno: a small, readable, statically typed language
for firmware and for everything around it. One zeno checks a program,
runs it, tests it, formats it, and compiles it to C or to LLVM IR.

Version 0.1 is the whole language as it was set out. What is in it, and
what it leaves out, is in
docs/version-0.1.md.

Installing

Two installers were added to this release on 16 November 2026. They
install the files of the archives below, which are as they were.

On Windows, download zeno-0.1.0-windows-setup.exe and run it. It
is the same file for x86-64, 32-bit x86 and ARM64. It installs Zeno
for you alone, with no administrator's password, adds it to the PATH,
and offers to install a C compiler and Git if the machine has none.
The first time, Windows says "Windows protected your PC", because the
program is not signed: "More info", then "Run anyway".

On macOS and Linux, one line in a terminal:

curl -fsSL https://github.com/partham20/zeno-lang/releases/download/v0.1.0/install.sh | sh

It works out which archive the machine needs, checks the download
against SHA256SUMS.txt, installs into ~/.zeno, and adds that to
the PATH. sh install.sh --uninstall takes it off again. While the
repository is private the line cannot download anything: put
install.sh, SHA256SUMS.txt and the archive for the machine in one
folder, and run ZENO_FROM=. sh install.sh there.

How both work is in
docs/install.md.

With a package manager. Packages were added the same day, made
from the same archives. For apt, pacman, snap and flatpak there is a
file to install:

sudo apt install ./zeno_0.1.0_amd64.deb                         # Debian, Ubuntu, Raspberry Pi OS
sudo pacman -U zeno-bin-0.1.0-1-x86_64.pkg.tar.zst              # Arch
sudo snap install --classic --dangerous zeno_0.1.0_amd64.snap
flatpak install --user zeno-0.1.0-x86_64.flatpak

The .deb is also there for arm64, armhf (every Raspberry Pi with
a 32-bit system) and i386, the snap for arm64 and armhf, and the
flatpak for aarch64. apt installs a C compiler and git along with
Zeno if the machine has none.

Homebrew, on macOS and Linux:

brew tap partham20/zeno-lang https://github.com/partham20/zeno-lang
brew install partham20/zeno-lang/zeno

For winget there are three files in
packaging/winget,
which are what Microsoft's collection of packages takes.
docs/packages.md
says what each package is, and what is still to be done before
apt install zeno and the rest work with one word.

Download

To do it by hand instead:

Machine File
Linux, x86-64: most PCs and servers zeno-0.1.0-linux-x86_64.tar.gz
Linux, ARM64: a Raspberry Pi 3, 4 or 5 with a 64-bit system, ARM servers zeno-0.1.0-linux-arm64.tar.gz
Linux, 32-bit ARMv7: a Raspberry Pi 2 or later with a 32-bit system zeno-0.1.0-linux-armv7.tar.gz
Linux, 32-bit ARMv6: a Raspberry Pi 1 or Zero zeno-0.1.0-linux-armv6.tar.gz
Linux, 32-bit x86 zeno-0.1.0-linux-x86.tar.gz
macOS, Apple silicon zeno-0.1.0-macos-arm64.tar.gz
macOS, Intel zeno-0.1.0-macos-x86_64.tar.gz
Windows, x86-64 zeno-0.1.0-windows-x86_64.zip
Windows, 32-bit x86 zeno-0.1.0-windows-x86.zip
Windows, ARM64 zeno-0.1.0-windows-arm64.zip

Unpack it and put zeno (zeno.exe on Windows) somewhere on your
PATH. It is one file and needs nothing else installed. The folder
also holds the docs, the examples and the editor setup.

tar -xzf zeno-0.1.0-linux-x86_64.tar.gz
cd zeno-0.1.0-linux-x86_64
./zeno --version
./zeno run examples/hello.zeno

On macOS, a program downloaded with a browser is held back because
Apple has not signed it. xattr -d com.apple.quarantine zeno lets it
run.

zeno build hands the C it writes to a C compiler, so it needs one
(cc, or the one CC names; on Windows, set CC=gcc with MinGW).
zeno build --llvm needs clang.
zeno fetch needs git. Everything else needs nothing.

What was checked

Every build but one was run before it was released: it ran all the
examples through the interpreter and the virtual machine, ran their
tests, formatted them and made a new program with zeno new. The ARM
builds for Linux ran under an emulator and the Intel build for macOS
under Apple's translation. The Windows build for ARM64 was built and
not run, because there was no machine to run it on.

The whole test suite (more than 450 tests), which also compiles every test
program to C and to LLVM IR and runs the result, passes on Linux
x86-64, on macOS on Apple silicon and on Windows x86-64.

On Windows, zeno build was checked on three examples with MinGW's
gcc, and zeno build --llvm with the clang that comes with Visual
Studio. Each prints exactly what zeno run prints. Compiling with
Microsoft's own C compiler (cl) has not been tried.