DEV Community: Toby Inkster

ZuzuScript 0.6.x released

Toby Inkster — Thu, 18 Jun 2026 23:00:00 +0000

New releases for Perl, Rust, JS, and Android

New releases of ZuzuScript are available for Perl, Rust, JS, and Android. This release is mostly about bringing implementation behaviour back into line with the language documentation, improving cross-runtime parity, and tightening temporary-file cleanup in the standard library.

Important changes include:

The ?: operator now follows its documented semantics across all three main runtimes. a ?: b returns a when a is non-null, and returns b only when a is null. Older implementations accidentally treated it like a value-preserving or, so false, 0, and empty-string values could fall through to the right-hand side. This release is intended to correct the implementations, not to redefine the language.
ZPath and ZZPath ?: expressions now use the same definedness check as ZuzuScript itself, so path expressions no longer have separate truthiness behaviour for this operator.
Path.tempfile() and Path.tempdir() now attach lifecycle cleanup to the returned Path object in zuzu.pl, zuzu-rust, and zuzu-js. Temporary files are deleted, and temporary directories are recursively deleted, when the object would run __demolish__.
Temporary Path cleanup now respects object reachability. A temporary path is not removed while a script still retains a reference to the Path object, including when it is returned from a block, returned from a function, or kept inside a returned collection.
Zuzuzoo install and metadata tests now keep their temporary Path objects alive for as long as the underlying files are needed, matching the intended lifecycle model.

zuzu.pl

Zuzu-0.006000

zuzu-rust

zuzu-js

Android

Zuzu REPL APK

ZuzuScript 0.5.x released

Toby Inkster — Wed, 17 Jun 2026 23:00:00 +0000

New releases for Perl, Rust, JS, Android, and syntax highlighting packages

New releases of ZuzuScript are available for Perl, Rust, JS, and Android, alongside fresh browser highlighter, VS Code, and Pulsar syntax packages. This release is mostly about filling out the logical operator family, improving cross-runtime parity, and making the newer language operators available inside ZZPath expressions too.

Major new features include:

switch case values can now override the switch comparator with a comparison operator prefix, such as case ~ /^Rob/ or case eqi "Bob". The Rust implementation also optimizes literal-string eq/eqi switch dispatch tables and literal-integer numeric equality dispatch tables.
New logical operators: nor/⊽, xnor/↔, onlyif/⊨, and butnot/⊭.
New value-preserving logical operators: and?/⋀?, or?/⋁?, xor?/⊻?, xnor?/↔?, nand?/⊼?, nor?/⊽?, onlyif?/⊨?, and butnot?/⊭?.
std/path/zz ZZPath expressions now recognise and evaluate the newer language operators for bit shifts, divisibility, logical combinations, and value-preserving logical combinations.
Dynamic method calls have better shared conformance coverage, including cases where the method expression evaluates to a method name or a Method value, named arguments, and std/eval.
Collection APIs are more consistent across runtimes. The release includes fixes for Array.join(), negative indexes in get()/set()/set_weak(), sample()/shuffle(), Bag removal, PairList enumeration, weak collection aliases, and several is_empty()/contains() parity gaps.
The JS browser runtime now supports ZuzuBrowser.addModule(moduleName, url), allowing whitelisted remote ZuzuScript modules to be fetched, parsed, imported, and cached on first use.
The JS implementation now matches the language-defined precedence for logical operators, and the JS lexer accepts the ⊤ and ⊥ Boolean literals.
The Rust --lint mode now warns about chained uses of the less intuitive nand, nor, xnor?, nand?, and nor? operators.
The browser highlighter, VS Code extension, and Pulsar package have been repackaged for the 0.5.0 release cycle.

zuzu.pl

Zuzu-0.005000

zuzu-rust

zuzu-js

Android

Zuzu REPL APK

Syntax Highlighting and Editor Packages

Building GUIs with Zuzu-Designer

Toby Inkster — Mon, 15 Jun 2026 23:00:00 +0000

This tool makes it so easy

This tutorial assumes you have:

zuzu-designer 0.1.0
zuzu-rust 0.4.0
ZuzuScript standalone browser bundle 0.4.0

All of these are available on the downloads page.

Designing the GUI

Just run zuzu-designer and a window will pop up allowing you to design a GUI. On the left side there is a tree view showing how the GUI controls are nested within each other, from the top level Window object, through to containers like VBox and HBox that allow you to arrange controls, down to individual widgets like buttons and text labels.

For our example, we’re just creating a Window with one VBox that contains a Label and a Button. Double clicking on anything within the tree view allows you to change that widget’s properties. You can drag and drop items in the tree view to change their order or nesting. In the top right you can see a preview of the GUI and in the bottom right, you can see the Zuzu GUI XML.

Adding some code

We can take that XML and insert it into a small ZuzuScript.

Here we’ve attached a “click” handler to the button. This is just a function which increments a variable i then sets the label’s text to show how many times the button has been clicked. If i > 3 then we will close the window. Note we’re providing the string “Done” when we close the window. Remember that for later.

Windows start off hidden, so after attaching the click handler, we call w.call() to show the window.

Running the script.

At the command line we run:

zuzu-rust gui-demo.zzs

It works!

We click the button a couple of times.

Click it a couple more times and i should reach 4 and the window should close.

You’ll note that the word “Done” is printed out on the terminal. This is because our w.call() doesn’t just show the window, but waits for the window to be closed and returns the result (that string “Done”), so this is what the say command prints.

Moving to the browser

Now let’s embed this script in HTML.

Loading the standalone browser bundle (line 1) allows <script type="text/x-zuzuscript"> scripts to be recognized as ZuzuScript and executed.

The only other change we’ve made is replacing the say w.call with w.show. This is because w.call waits for the window to be closed before the script continues running but the in-browser environment is designed for asynchronous scripting and doesn’t like code that blocks, waiting for a long time. The w.show method shows the window without waiting for it to close.

Viewing the web page

And just like that, the GUI appears in the browser:

And we can interact with it just like before:

The std/gui toolkit is not always the most powerful nor the most attractive GUI toolkit, but it’s very easy to work with, and being able to easily move between desktop apps and the browser is an awesome feature.

Introducing Rowquill

Toby Inkster — Sat, 13 Jun 2026 23:00:00 +0000

Brand new ORM for Zuzu just dropped!

Rowquill is an ORM for ZuzuScript, allowing you to declare classes for your database tables, and perform searches, inserts, updates, and deletes in an object-oriented manner. It takes inspiration from Perl’s DBIx::Class and other popular ORMs.

Features

create, find, search, all, first, count, exists, find_or_create, create_or_update, insert, update, insert_or_update, and delete.
Generated column accessors with optional alternate names.
Primary key lookup by scalar, array, or dictionary.
Dirty tracking so update only writes changed non-primary-key fields, plus is_dirty, dirty_fields, mark_clean, and reload.
Raw column storage in column_data.
Inflate and deflate callbacks for structured values such as JSON.
length, pattern, validate, required, default, readonly, unique, and exists_in column checks.
search supports equality, common comparison operators, LIKE, NOT LIKE, ILIKE, IN, NOT IN, BETWEEN, AND, OR, and NOT.
has_one and has_many relationships with multi-column joins and optional search-style where filters.
Assigning has_one relationships with relationship(set: row).
Custom row helper methods and static table-class methods.
Lifecycle hooks for insert, update, and delete.
Schema registry helpers: has_table and table_names.
Schema-level create, find, search, and insert shortcuts for dynamic table names.
Schema.transaction with nested transaction savepoints.

Example

from db/rowquill import Schema;
from std/db import DB;

let schema := new Schema( dbh: DB.temp() );

schema.get_dbh().prepare("""
    CREATE TABLE department (
        id int,
        name varchar(200),
        PRIMARY KEY (id, company)
    );
""").execute();

schema.add_table( "department", function ( tab ) {
    tab.add_column( "id", "int", primary: true );
    tab.add_column( "name", "varchar", required: true );
    tab.has_many(
        accessor: "employees",
        table: "employee",
        join: { id: "dept" },
        where: { is_deleted: false },
    );
} );

schema.get_dbh().prepare("""
    CREATE TABLE employee (
        id int PRIMARY KEY,
        fullname varchar(200),
        dept int,
        is_deleted bool
    );
""").execute();

schema.add_table( "employee", function ( tab ) {
    tab.add_column( "id", "int", primary: true );
    tab.add_column(
        "fullname",
        "varchar",
        required: true,
        accessor: "name",
    );
    tab.add_column( "dept", "int" );
    tab.add_column( "is_deleted", "bool" );
    tab.has_one(
        accessor: "department",
        table: "department",
        join: { dept: "id" },
    );
    tab.add_helper( "is_accountant", function ( employee ) {
        return employee.department().name() eq "Accounts";
    } );
} );

let accounts := schema.table("department").create(
    id: 3,
    name: "Accounts",
);
accounts.insert();

let bob := schema.table("employee").create(
    id: 42,
    name: "Bob",
    dept: 3,
    is_deleted: false,
);
bob.insert();

say( bob.department().name() ); // Accounts
say( accounts.employees()[0].name() ); // Bob
say( bob.is_accountant() ); // true

Get Rowquill 0.0.2

ZuzuScript 0.4.x released

Toby Inkster — Thu, 11 Jun 2026 23:00:00 +0000

New releases for Perl, Rust, JS, and Android

Major new features include:

std/string/encode module for dealing with text encodings. UTF-8, UTF-16, UTF-32, and Latin-1 encodings are supported across all runtimes. The Perl runtime additionally supports all encodings supported by the Encode Perl module including EBCDIC, Shift-JIS, etc.
Major updates to the std/net/url module to fully support RFC 6570 URI Templates.
Major bug fixes to std/time on the Rust and JS runtimes adding missing functionality that previously only worked in the Perl runtime.
Major bug fixes to std/math/bignum on the Rust and JS runtimes.
Allow alternative ways to write numeric literals such as 1E3 (E-notation), 0xDEADBEEF (hexadecimal), 0b11001100 (binary), and 0o377 (octal).
Bit shift numeric/binarystring operators » and «.
Divides and does-not-divide numeric operators ∣ and ∤.
The for loop is now able to iterate over strings character by character, or binarystrings byte by byte.
Rust runtime: correct stringifications for true and false when printing them via say.
Perl runtime: now comes with a README.md.

zuzu.pl

Zuzu-0.004000

zuzu-rust

0.4.0 amd64 deb cargo crate

zuzu-js

zuzu-js@0.4.0 node package browser bundle

ZuzuScript 0.3.x released

Toby Inkster — Tue, 09 Jun 2026 23:00:00 +0000

New releases for Perl, Rust, JS, and Android

zuzu.pl

Zuzu-0.003000

zuzu-rust

0.3.0 amd64 deb cargo crate

zuzu-js

zuzu-js@0.3.0 node package browser bundle

ZuzuScript 0.2.x released

Toby Inkster — Sun, 07 Jun 2026 23:00:00 +0000

New releases for Perl, Rust, and JS

New releases of ZuzuScript are available, mostly aimed at fixing bugs. In addition to implementation-specific bug fixes for each runtime, they all update the languagetests component to version 20260608 (which includes improved tests for semicolon placement after statements) and update stdlib to version 20260608 (which includes better support in Zuzuzoo for test cases that are deliberately skipped; they should not cause the distribution to fail install).

zuzu.pl

Zuzu-0.002000

zuzu-rust

0.2.0 amd64 deb cargo crate

zuzu-js

zuzu-js@0.2.0 node package browser bundle

zuzu.pl 0.001004

Toby Inkster — Thu, 04 Jun 2026 23:00:00 +0000

New version of the Perl runtime released

Changed

Raised the required versions of Path::Tiny and Sub::Quote.
Marked the std/clib integration test as author-only.
Excluded blib from distribution manifests.

Fixed

Fixed the marshal golden fixture test to parse on older supported Perl versions.

https://metacpan.org/release/TOBYINK/Zuzu-0.001004

Golfing with Zia

Toby Inkster — Sun, 31 May 2026 23:00:00 +0000

code.golf has experimental ZuzuScript support

code.golf now allows you to submit solutions in ZuzuScript.

It uses zuzu-rust 0.1.0 to evaluate solutions.

Introducing ZuzuScript

Toby Inkster — Sun, 31 May 2026 20:57:22 +0000

So I’ve created a programming language which blends a fairly JavaScript-like syntax with fairly Perl-like semantics, and a few other features that I haven’t really seen in many programming languages.

This Perl:

use Path::Tiny;

my $str = uc(substr(Path::Tiny->new("myfile.txt")->slurp_utf8, 0, 80));

Becomes this in ZuzuScript:

from std/path import Path;

let str := new Path("myfile.txt")
  ▷ ^^.slurp_utf8
  ▷ ^^[0:80]
  ▷ uc ^^;

The ▷ operator means “evaluate the left side, then evaluate the right side with ^^ set to the result of the left side”. It’s conceptually similar to | in shells and seems to make a lot of expressions so much easier to understand.

Other features I like:

Path/query operators for XPath/JSONPath-like deep access to nested objects.
Built-in async/await.
OO including roles/traits.
Runs in the browser!
PairLists (like hashes, but with ordered keys that allow duplicate keys)
for/else

Familiar things from Perl: documentation uses pod, variables are lexical (actually almost everything is lexical), there’s a topic variable (but it’s called ^^ instead of $_), different operators for different data types (> for numbers but gt for strings), weak typing, keywords like say and warn, first class regexps, and a CPAN-like site for sharing modules.

The primary implementation is in Perl, but there are alternative implementations in Rust and JavaScript. Yes, this is coded with AI assistance.

More info: https://zuzulang.org/.

Zuzu JavaScript Runtime Released

Toby Inkster — Sat, 30 May 2026 23:00:00 +0000

zuzu-js 0.1.0 is now available through npm.

The JavaScript runtime is now available on npmjs.com.

https://www.npmjs.com/package/zuzu-js

You can install it using npm install -g zuzu-js.

Run simple inline code:

zuzu-js -e 'say("Hello, world");'

Run a full script:

zuzu-js path/to/script.zzs

Compile from ZuzuScript into JavaScript:

zuzu-js-compile path/to/script.zzs -o script.js
node script.js

(The resulting JS file will be very large as it bundles the entire ZuzuScript runtime. But it should work.)

zuzu-rust Released

Toby Inkster — Fri, 29 May 2026 23:00:00 +0000

zuzu-rust 0.1.0 is now available through cargo.

The Rust runtime is now available on crates.io.

https://crates.io/crates/zuzu-rust

You can install it using npm install -g zuzu-js.

Run simple inline code:

zuzu-rust -e 'say("Hello, world");'

Run a full script:

zuzu-rust path/to/script.zzs