Zenth on Zenth Programming Language

Getting Started

Mon, 01 Jan 0001 00:00:00 +0000

#Getting Started

#Prerequisites

Zenth compiles to native binaries through Go, so you need:

Go 1.26 or later
just command runner (optional, for convenience)

#Installation

Clone the repository and build the compiler:

git clone https://github.com/mkaz/zenth.git
cd zenth
just build

This produces a zenth binary in the current directory. To install it to your $GOPATH/bin:

just install

#Your First Program

Create a file called hello.zn:

fn main() {
 Println("Hello, World!");
}

Every Zenth program needs a main function as its entry point.

Read and Process a File

Mon, 01 Jan 0001 00:00:00 +0000

#Read and Process a File

This guide shows how to read a file, process its contents line by line, and write the results to another file.

#Read an entire file as a string

fn main() {
 let content = File("input.txt").read();
 Println(content);
}

#Read a file line by line

Use .lines() to get an array of strings, one per line:

fn main() {
 let lines = File("input.txt").lines();
 for i, line in lines {
 Println("{i}: {line}");
 }
}

#Check if a file exists first

fn main() {
 let f = File("input.txt");
 if !f.exists() {
 Println("file not found: " + f.name());
 Exit(1);
 }
 let lines = f.lines();
 Println("Read {lines.length()} lines");
}

#Process and write results to a new file

Read lines, transform them, and write the output:

Variables

Mon, 01 Jan 0001 00:00:00 +0000

Zenth has three ways to declare variables: let, var, and const. All declarations use = for assignment – there is no := operator.

#Immutable Variables with `let`

let declares an immutable binding. Once assigned, its value cannot change:

let name = "Zenth";
let year = 2026;
let pi = 3.14159;
let active = true;

Attempting to reassign a let variable is a compile-time error:

let x = 5;
x = 10; // error: cannot assign to immutable variable 'x'

#Mutable Variables with `var`

var declares a mutable binding that can be reassigned:

Parse Puzzle Input

Mon, 01 Jan 0001 00:00:00 +0000

#Parse Puzzle Input

This guide shows common parsing patterns for structured text input: one number per line, comma-separated values, blank-line sections, coordinates, key/value fields, and mixed text. These are the kinds of transformations that come up constantly in Advent of Code problems.

#Read a whole file and trim it

Use .read() when the input is one block of text, then .strip() to remove the trailing newline:

fn main() {
 let raw = File("input.txt").read().strip();
 Println(raw);
}

This is useful for single-line inputs like 389125467 or target area: x=20..30, y=-10..-5.

Types

Mon, 01 Jan 0001 00:00:00 +0000

Zenth is strongly typed with type inference for local variables. Function signatures always require explicit types.

#Integer Types

Zenth has a single integer type: Int (64-bit signed).

let x = 42; // Int (inferred)
let big: Int = 999;

Integer literals can use underscores for readability:

let million = 1_000_000;

#Built-in Integer Constants

Zenth provides built-in constants for the integer range limits:

Constant	Value	Description
`INT_MAX`	9223372036854775807	Maximum `Int` value (2^63-1)
`INT_MIN`	-9223372036854775808	Minimum `Int` value (-2^63)

These are true constants and cannot be reassigned:

Functions

Mon, 01 Jan 0001 00:00:00 +0000

Functions are declared with the fn keyword. Every program needs a main function as its entry point.

#Declaring Functions

fn greet(name: Str) {
 Println("Hello, {name}!");
}

Parameters require explicit type annotations using the name: Type syntax.

#Return Types

Specify a return type with ->:

fn add(a: Int, b: Int) -> Int {
 return a + b;
}

Functions without a -> return type return nothing (void).

#Calling Functions

fn main() {
 greet("World");
 let result = add(3, 4);
 Println(result); // 7
}

#Multiple Parameters

fn clamp(value: Int, low: Int, high: Int) -> Int {
 if value < low {
 return low;
 }
 if value > high {
 return high;
 }
 return value;
}

#Multi-Return Functions

Functions can return multiple values using a parenthesized return type. The caller unpacks the result with tuple destructuring:

Design Philosophy

Mon, 01 Jan 0001 00:00:00 +0000

#Design Philosophy

Zenth is an attempt to combine a few traits that are often split across different languages. Python is easy to read and write, but it trades away static types and native binaries. Go has both, but its syntax can feel heavier than I want for day-to-day code. Zenth takes ideas from each and aims for a smaller, more regular surface area.

#Simplicity first

Each feature should have one primary way to use it. There is one loop keyword (for) that covers counting, iteration, and while-style loops. There is one way to define a type (obj). There are no alternate spellings for the same construct.

Strings

Mon, 01 Jan 0001 00:00:00 +0000

Zenth has two kinds of string literals: double-quoted strings with interpolation, and single-quoted raw strings.

#Double-Quoted Strings

Double-quoted strings ("...") support interpolation with {expression}:

let name = "World";
Println("Hello, {name}!"); // Hello, World!

Any expression can go inside the braces – variables, arithmetic, method calls:

let a = 3;
let b = 4;
Println("{a} + {b} = {a + b}"); // 3 + 4 = 7

Values are automatically converted to strings, so you don’t need to call Str() inside interpolation:

Control Flow

Mon, 01 Jan 0001 00:00:00 +0000

#If / Else

if x > 10 {
 Println("big");
} else if x > 5 {
 Println("medium");
} else {
 Println("small");
}

Conditions must be Bool – there is no truthy/falsy coercion. Parentheses around the condition are not required.

#For Loops

for is the only loop keyword in Zenth. It supports five styles.

#C-Style For

The classic three-part loop with init, condition, and post:

for var i = 0; i < 10; i++ {
 Println(i);
}

The init clause can declare a variable with var or let:

Enums

Mon, 01 Jan 0001 00:00:00 +0000

Enums define a type with a fixed set of named variants. Each variant is backed by a string value — by default the variant name itself.

#Declaring Enums

enum Color {
 Red;
 Green;
 Blue;
}

Without explicit values, each variant’s string value is its name: "Red", "Green", "Blue".

#Explicit String Values

You can assign explicit string values to variants:

enum HexColor {
 Red = "#FF0000";
 Green = "#00FF00";
 Blue = "#0000FF";
}

enum Stoplight {
 Red = "red";
 Yellow = "yellow";
 Green = "green";
}

#Using Enums

Access variants with EnumName.Variant syntax:

Objects

Mon, 01 Jan 0001 00:00:00 +0000

Objects are user-defined types with named fields. Methods are defined inside the object body using self to access fields.

#Declaring an Object

obj Point {
 x: Float;
 y: Float;
}

Fields are declared with name: Type; syntax.

#Default Field Values

Fields can have default values. If a default is provided, the field becomes optional in the constructor:

obj Account {
 balance: Int = 0;
 interest: Float = 2.5;
}

#Creating Instances

Use constructor syntax with named arguments Name(field=value):

Arrays

Mon, 01 Jan 0001 00:00:00 +0000

Arrays are dynamically-sized sequences of elements, all of the same type.

#Creating Arrays

Use bracket syntax for array literals:

let numbers = [1, 2, 3, 4, 5];
let names = ["Alice", "Bob", "Charlie"];

With an explicit type annotation:

let scores: Array(Int) = [100, 95, 87];

An empty slice can use a type annotation:

var points: Array(Point) = [];
points.add(Point(x=1, y=2));

Use .repeat(n) to create an array by repeating elements:

var zeros = [0].repeat(10); // [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
let dashes = ["-"].repeat(5); // ["-", "-", "-", "-", "-"]
let pattern = [1, 2].repeat(6); // [1, 2, 1, 2, 1, 2]

When the source array has multiple elements, they tile to fill the requested count.

Tuples

Mon, 01 Jan 0001 00:00:00 +0000

Tuples are fixed-size ordered values that can hold mixed types. They come in two forms: positional and named.

#Positional Tuples

Use Tuple(...) to create a tuple with values accessed by numeric index:

let t = Tuple("hello", 42);
Println(t.0); // "hello"
Println(t.1); // "42"

With a type annotation:

let pair: Tuple(Str,Int) = Tuple("age", 30);

#Named Tuples

Named tuples add field names so you can access elements by name. Use = for values and : for types:

Hashmaps

Mon, 01 Jan 0001 00:00:00 +0000

Hashmaps are unordered collections of key-value pairs.

#Creating Hashmaps

You can create a hashmap using the Hashmap(KeyType, ValueType) built-in:

var scores = Hashmap(Str,Int);

#Assigning and Accessing

Use bracket syntax [key] to assign and access values:

scores["Alice"] = 100;
scores["Bob"] = 95;

let aliceScore = scores["Alice"];
Println(aliceScore);

#Hashmap Length

Use Len() to get the number of key-value pairs in the hashmap:

Println(Len(scores));

#Default Values

You can provide a default value for missing keys using the default named argument:

Sets

Mon, 01 Jan 0001 00:00:00 +0000

Sets are unordered collections of unique values.

#Creating Sets

Create an empty set with Set(Type):

var visited = Set(Str);
visited.add("start");
visited.add("middle");

You can also convert an array into a set with Set(items):

let letters = ["a", "b", "a"];
let unique = Set(letters);
Println(Len(unique)); // 2

#Core Operations

Use .add(value) to insert an item, .exists(value) to test membership, and .remove(value) to delete an item:

var nums = Set(Int);
nums.add(1);
nums.add(2);
nums.add(2); // duplicate, ignored

Println(nums.exists(1)); // true
nums.remove(1);
Println(Len(nums)); // 1

Sets also expose .length() when you prefer method syntax:

Dates

Mon, 01 Jan 0001 00:00:00 +0000

Zenth has a built-in Date type for working with calendar dates. Dates are created using static constructors and support formatting, addition, and subtraction.

#Creating Dates

#Today’s date

let d = Date.today();

Returns a Date object representing the current date (time portion is midnight UTC).

#From a string

let epoch = Date.from("1970-01-01");

Parses a date string using the default format %Y-%m-%d (year-month-day).

#From a string with custom format

let jan13 = Date.from("01/13/2007", "%m/%d/%Y");

The second argument is a Python-style format string. Available format specifiers:

Files

Mon, 01 Jan 0001 00:00:00 +0000

The File() built-in creates a file object for reading and writing files and inspecting file paths. File objects are value types – there are no open handles and nothing to close.

#Creating a File Object

let f = File("/path/to/data.txt");

#Methods

#exists

Returns true if the file exists on disk:

let f = File("config.txt");
if f.exists() {
 Println("found it");
}

#read

Returns the full file contents as a string. Exits with an error if the file cannot be read:

Imports

Mon, 01 Jan 0001 00:00:00 +0000

Zenth provides access to standard library functionality through imports. Under the hood, these map to Go standard library packages.

#Basic Import

import "fmt";

#Aliased Import

Use as to give an import a shorter name:

import "math" as m;

Then call functions through the alias:

let root = m.sqrt(16.0);

#Available Modules

Zenth module	Maps to	Common functions
`fmt`	Go `fmt`	`println`, `printf`, `sprintf`
`math`	Go `math`	`sqrt`, `abs`, `pow`, `min`, `max`
`os`	Go `os`	`exit`, `args`
`strings` or `Str`	Go `strings`	`split`, `join`, `contains`, `replace`, `trim`

#Calling Module Functions

import "math";

fn main() {
 let x = math.sqrt(144.0);
 Println(x); // 12

 let y = math.pow(2.0, 10.0);
 Println(y); // 1024
}

#Example with String Operations

import "strings";

fn main() {
 let csv = "apple,banana,cherry";
 let parts = strings.split(csv, ",");
 for part in parts {
 Println(part);
 }
}

#External Go Package Imports

Use import_go to import any Go package — including third-party libraries. The Zenth toolchain automatically fetches the package using go get before compiling.

Modules

Mon, 01 Jan 0001 00:00:00 +0000

Zenth supports splitting programs across multiple files using local modules. A module is simply a .zn File (or a directory of .zn files) that you import into your program.

#Importing a Local Module

Use a path starting with ./ or ../ to import a local module:

import "./utils";
import "./math/geometry";
import "../shared/helpers";

The module name is derived from the filename stem (the last path component without .zn). Use as to give it a custom alias:

Testing

Mon, 01 Jan 0001 00:00:00 +0000

Zenth has a built-in test runner that discovers and runs test functions. Test files live in a tests/ directory and use the _test.zn suffix.

#Writing Tests

Create a file ending with _test.zn in a tests/ directory. Define test functions that start with test_:

// tests/math_test.zn

fn test_addition() {
 AssertEq(2 + 3, 5);
}

fn test_negative_numbers() {
 AssertEq(-3 + 3, 0);
 Assert(-1 < 0);
}

Test files do not need a fn main() – the test runner generates one automatically.

Zenth on Zenth Programming Language

Getting Started

#Getting Started

#Prerequisites

#Installation

#Your First Program

Read and Process a File

#Read and Process a File

#Read an entire file as a string

#Read a file line by line

#Check if a file exists first

#Process and write results to a new file

Variables

#Immutable Variables with let

#Mutable Variables with var

Parse Puzzle Input

#Parse Puzzle Input

#Read a whole file and trim it

Types

#Integer Types

#Built-in Integer Constants

Functions

#Declaring Functions

#Return Types

#Calling Functions

#Multiple Parameters

#Multi-Return Functions

Design Philosophy

#Design Philosophy

#Simplicity first

Strings

#Double-Quoted Strings

Control Flow

#If / Else

#For Loops

#C-Style For

Enums

#Declaring Enums

#Explicit String Values

#Using Enums

Objects

#Declaring an Object

#Default Field Values

#Creating Instances

Arrays

#Creating Arrays

Tuples

#Positional Tuples

#Named Tuples

Hashmaps

#Creating Hashmaps

#Assigning and Accessing

#Hashmap Length

#Default Values

Sets

#Creating Sets

#Core Operations

Dates

#Creating Dates

#Today’s date

#From a string

#From a string with custom format

Files

#Creating a File Object

#Methods

#exists

#read

Imports

#Basic Import

#Aliased Import

#Available Modules

#Calling Module Functions

#Example with String Operations

#External Go Package Imports

Modules

#Importing a Local Module

Testing

#Writing Tests

#Immutable Variables with `let`

#Mutable Variables with `var`