Zod

README

Zod Programming Language

Zod is a small, interpreted, dynamically typed with a first-class functions, closures, arrays, hashes, and more.

Install

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

Option 1: Download script

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

Option 2: go install

go install github.com/theawakener0/Zod@latest

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

Option 3: Manual download

Grab the tarball for your OS/architecture from the Releases page, extract it, and put the zod binary on your PATH.

Features

• First-class functions and closures
• Data types: integers, booleans, strings, arrays, hashes, and null
• if / else if / else control flow
• C-style for loops, and infinite loop
• break and continue
• Built-in functions for I/O (println(), printf(), input(), etc.), arrays, and hashes
• An interactive REPL

Getting Started

Prerequisites

• Go 1.22 or newer

Build

go build -o zod .
# if you installed using the script or go install you can just run zod

Run the REPL

./zod

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

Run a script

./zod file.zd

Run the examples

./zod examples/hello.zd
./zod examples/guess_the_number.zd

Examples

Hello, World!

println("Hello, World!")

Variables and data types

let name = "Zod"
version := 1
let isAwesome = true
 scores := [10, 20, 30]
let config = {"lang": "Zod", "year": 2026}
nothing := null

Functions and closures

let add = fn(x, y) { x + y }
println(add(2, 3))  // 5

makeAdder := fn(x) {
    fn(y) { x + y }
}
let addFive = makeAdder(5)
println(addFive(10))  // 15

Control flow

let grade = fn(score) {
    if (score >= 90) {
        "A"
    } elseif (score >= 80) {
        "B"
    } else {
        "C"
    }
}

println(grade(95))  // A

Loops

// C-style for loop
for (i := 0; i < 5; i++) {
    println(i)  
/*
    0
    1
    2
    3
    4
*/
}

// While-style for loop
let x = 0
for (x < 3) { x++ }
println(x)  // 3

// Infinite loop with break / continue
let i = 0
loop {
    i++
    if (i == 3) { continue }
    if (i == 6) { break }
}

More runnable examples live in examples/.

Language Reference

Data types

Type	Example
Integer	42, -7, 0
Boolean	true, false
String	"Hello, World!"
Array	[1, 2, 3], []
Hash	{"name": "Zod"}, {}
Null	null

[!NOTE] The Hash type is implemented as a Go map, so it's not a true Hashmap and does not preserve order.

Operators

Category	Operators
Arithmetic	+ - * /
Comparison	== != < > <= >=
Logical	&& || !
Increment	++ -- (prefix and postfix)

Assignment

Operator	Meaning
let	Declare a new variable: let x = 5
:=	Assign (declares if needed): x := 5

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

Built-in Functions

Function	Description
len(x)	Length of a string, array, or hash
println(...)	Print each argument on its own line
printf(fmt, ...)	Formatted output (Go-style verbs)
input(prompt)	Read a line of input from the user
int(x)	Convert a string/bool to an integer
string(x)	Convert an int/bool to a string
type(x)	Return the type name of x
first(arr)	First element of an array
last(arr)	Last element of an array
push(arr, x)	New array with x appended
pop(arr)	New array without its last element
insert(hash, k, v)	New hash with k: v added
remove(hash, k)	New hash without key k
keys(hash)	Array of keys in a hash
vals(hash)	Array of values in a hash
contains(hash, k)	Whether a hash contains key k
random(x)	Random integer between 0 and x
matrix(r, c, data)	Create a 2D array with r rows and c cols
make(size) / make(size, value)	Create a new array with size elements, and value
color(color, text)	Change the color of text to color
exp(x)	e^x
pi()	π

[!NOTE] The matrix function is still under development so don't expect to use it in real appliction. The color function is still under development so it doesn't have many colors.

Acknowledgments

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

License

MIT License. See LICENSE.