Getting Started

Zap is a compiled systems programming language with an LLVM backend, ARC memory management, modern syntax, and explicit unsafe escape hatches. It targets developers who want predictable performance without GC pauses — and error handling that doesn’t look like noise.

Status: Early Alpha. The language is usable but not all features are finalized.

Installation

Option 1 — Build from source

You need clang 21+, llvm 21+, cmake 20+, and doxygen installed.

git clone https://github.com/thezaplang/zap.git
cd zap
chmod +x build.sh
./build.sh

The compiler will be at build/zapc. Add it to your PATH:

# bash / zsh
export PATH="$PATH:/absolute/path/to/zap/build"

Verify the installation:

zapc --version
zapc --help

Option 2 — Install script

curl -fsSL https://zaplang.xyz/install-latest.sh | bash

This downloads the latest pre-built binary and adds zapc to your PATH automatically.

---

Your first program

Create a file called hello.zp:

import "std/io" { println };

fun main() Int {
    println("Hello, Zap!");
    return 0;
}

Compile and run it:

zapc hello.zp -o hello
./hello

Output:

Hello, Zap!

What’s happening here

• import "std/io" { println } — imports the println function from the standard library’s I/O module.
• fun main() Int — the entry point. main must return Int.
• println("Hello, Zap!") — prints a string followed by a newline.
• return 0; — returns exit code 0 (success). Every statement ends with ;.

---

Compiler flags

Flag	Description
-o <name>	Set the output binary name
--allow-unsafe	Enable unsafe blocks and raw pointer operations
--help	Show all available flags

# Compile with a custom output name
zapc hello.zp -o hello

# Compile a program that uses unsafe features
zapc low_level.zp --allow-unsafe -o low_level

---

A slightly bigger example

Here’s a program that reads a name from stdin and greets the user:

import "std/io" { println, getLn };

fun greet(name: String) {
    println("Hello, " ~ name ~ "!");
}

fun main() Int {
    println("What's your name?");
    var name: String = getLn();
    greet(name);
    return 0;
}

Key things to notice:

• ~ is the string concatenation operator.
• var name: String declares a variable with an explicit type.
• Functions without a return type are Void — no return needed.
• getLn() reads a line from stdin (from std/io).

---

What’s in the docs

Section	What you’ll learn
Variables	Primitive types, var, const, global, alias
Functions	Declarations, ref params, overloads, varargs, generics
Control Flow	if, while, break, ternary ?:
Arrays	Fixed-size arrays, indexing, nested arrays
Structs & Records	Named data types, field access, generics
Enums & Aliases	Closed value sets, @error enums, alias
Classes	Heap-allocated types, init, deinit, inheritance
ARC & Weak Refs	Memory model, reference cycles, weak
Generics	Generic functions, types, constraints, iftype
Error Handling	Failable functions, fail, ?, or, or err
Modules & Imports	import, pub, folder modules, stdlib list
Unsafe	Raw pointers, ext fun, FFI, std/mem

Recommended learning path

If you’re new to Zap, follow this order:

1. Variables — types and declarations
2. Functions — the building blocks
3. Control Flow — conditionals and loops
4. Structs & Enums — data modeling
5. Classes — object-oriented features
6. Error Handling — Zap’s approach to failures
7. Modules — organizing code
8. Generics — reusable, type-safe code
9. Unsafe — when you need to go low-level

Doxygen reference

The full API reference is available at docs.zaplang.xyz.