ZITH Language Specification

Draft v0.9 — 2026

Zith is a statically typed systems programming language with a small, composable core and a large toolbox for domain-specific work. It proves memory safety at compile time without a garbage collector or borrow checker.

Introduction

Zith gives you full control with a minimal & clean syntax — you don't have to choose between verbose but safe or readable but slow. Its memory model, Node Resource Analysis (NRA), proves ownership and lifetime safety using five keywords: lend, view, unique, share, and belong — plus a default (no keyword) modifier.

Beyond memory safety, Zith has a general-purpose core with a much larger toolbox: markers, contexts (DSLs), words (custom operators), comptime. You choose when to use them. Zith also follows the Rule of Three: "if a function needs more than three specialized tools, something went wrong."

This document is a draft of the language specification, currently v0.9. Not every feature described here is implemented in the compiler. For the exact picture of what works today, see Implementation Status. It serves three audiences: developers learning Zith for the first time, contributors working on the zithc compiler, and tooling authors building editors, linters, or other infrastructure around the language.

Notation used in this document

1. Overview & Design Philosophy

1.1 Who Zith Is For

If you are looking for just a 'new' language, clone or 'normal', so Zith is not for you. Zith was created for people starting to learn or open-minded, to discover new ways to think and structure your code, while having a powerful, readable, safe & expressive language.

1.2 Our Philosophy

Zith aims to be small and stable at its core — covering everyday needs — while offering a large kit that helps in specific domains where most languages need a lot of tricks to work. The compiler is a copilot: it gives you the tools, and you build the systems.

1.3 Design Goals

• Expressive, minimal syntax that favors readability without sacrificing power.
• Memory safety via Node Resource Analysis (NRA).
• Composable behavior through traits, capabilities, and interfaces.
• Static, zero-overhead error handling with rich recovery semantics.
• Compile-time computation (comptime) as a first-class feature.
• Low-level control — flow functions, markers — without sacrificing safety in everyday code.
• Extensibility through words and macros, ideally scoped inside contexts rather than polluting the global namespace.

1.4 Context-Bound Extensibility (Best Practice)

Macros and words should ideally live inside a context block. Activating them globally is possible but discouraged — the same code smell as using namespace std; in C++.

// Preferred
use SQL {
    // SQL words and macros active only here
}

// Discouraged
use SQL;   // pollutes the rest of the file

1.5 Compilation Pipeline

The zithc compiler follows a multi-stage pipeline:

source -> lex -> scan -> resolve(import/symbols) -> sema -> comptime/solve -> NTA/NRA -> HIR -> LLVM

Note: when you compile a library, after LLVM it outputs .zirl (Zith Intermediate Representation Library).

.zirl files serve as cache and distribution format for compiled libraries — no headers needed, OS-agnostic, and you choose static or dynamic linking at the client side. Distribute once, link however the consumer prefers.

Specification

Appendix — Keyword & Operator Reference

A.1 Keywords & Operators

A.2 Compiler Intrinsics

A.3 Attributes

Zith Language Specification — Draft v0.9 — Subject to change