Repository navigation
Zeno 0.5.1
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 | shBoth 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/zenoWith 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.flatpakThe .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.pyhas an engine for the program written in each other
language (to-js,to-py,to-phpand so on), and the record of a
version keeps their times.bench/compare.pytimes 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.wasmbuilt 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.pyOn 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.