Skip to content

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.