gem-hunter

Zod is a small (let's say it's a medium sized), interpreted, dynamically typed with a first-class functions, closures, arrays, hashes, and more.

Prebuilt binaries for Linux, macOS, and Windows are attached to every GitHub Release.

curl -fsSL https://raw.githubusercontent.com/theawakener0/Zod/main/install.sh | sh

go install github.com/theawakener0/Zod@latest

Requires Go 1.27 or newer and installs the Zod executable into your Go bin directory.

import "std/..." resolves modules in this order:

1. $ZOD_STDLIB environment variable (explicit override — wins).
2. stdlib/ next to the zod executable (GitHub release tarballs ship this).
3. stdlib/ in the current working directory.
4. stdlib/ in up to 5 parent directories of the working directory/script.
5. The standard library embedded in the binary.

Users who maintain their own copy of the stdlib should set $ZOD_STDLIB; it takes priority over every other source.

• First-class functions and closures
• Data types: integers, floats, booleans, strings, arrays, hashes, matrices, and null
• if / elseif / else control flow
• C-style for loops, and infinite loop
• break and continue
• try(expr) for recoverable errors
• Standard library in stdlib/ (std/fmt, std/str, std/array, …) via import "std/fmt" as fmt
• The standard library is also embedded in the binary, so std/... imports resolve automatically without a stdlib/ directory
• Legacy core built-ins for I/O (println(), printf(), input(), etc.), arrays, and hashes (kept for compat)
• An interactive REPL

• Go 1.27 or newer

# if you installed manually run this
go build -o zod .

# if you installed using the script
zod

# if you installed using go install
Zod

Inside the REPL, type /clear to clear the screen and /exit to quit.

# if you installed using the script
zod file.zd

# if you installed using go install
Zod file.zd

println("Hello, World!")

More runnable examples live in examples/.

Index assignment works on arrays and hashes too: nums[0] = 10, user["age"] += 1.

Bindings are private by default. Prefix a top-level let or := with pub to export it.

// pub_lib.zd
pub let version = 1
let secret = "hidden"
pub greet := fn(name) { "hello, " + name }

from "examples/pub_lib.zd" import *      // all public bindings
from "examples/pub_lib.zd" import greet  // listed public bindings only
import "examples/pub_lib.zd" as m        // property access: m.version, m.greet("hi")

Importing or accessing a private binding is an error (e.g. secret is private). See docs/introduction.md (Modules & pub) and examples/modules_pub.zd for details.

New code should use the standard library in stdlib/ (25 modules) instead of the legacy core built-ins below. Each module is imported by path with an alias:

import "std/fmt" as fmt
fmt.println("Hello, World!")

• The __* names (about 50 intrinsics such as __print, __str_split, __read_file) are private implementation details backing std/*. Do not call them directly.
• New types: Bytes (type(x) returns "BYTES") and Error values (type(error("x")) returns "ERROR"). New globals are error(msg) (creates an error value) and is_error(x) (tests for one); string() also formats Array, Hash, Matrix, Bytes, null, and Error (string(error("x")) returns "Error: x").
• Capture errors with try(): let r = try(error("x")) returns [false, "x"]. A bare let e = error("x") halts evaluation by design, so always wrap error-producing expressions in try() (or nest them, e.g. string(error("x")), which the VM supports).
• An imported name shadows a same-named core built-in (e.g. array.push vs push) on the VM. Several modules export the same name (join in str/array/path, contains in str/array/hash), so always import with an alias and call through it.
• std/ lookup order and runnable examples are documented in docs.

The original 24 built-ins below still work, but new code should use std/* instead.

for more details. Go to the docs.

Inspired by Thorsten Ball's Writing an Interpreter in Go and Writing a Compiler in Go.

MIT License. See LICENSE.