Zen C is a modern systems programming language that compiles to human-readable GNU C/C11. It provides a rich feature set including type inference, pattern matching, generics, traits, async/await, and manual memory management with RAII capabilities, all while maintaining 100% C ABI compatibility.

Join the discussion, share demos, ask questions, or report bugs in the official Zen C Discord server!

• Discord: Join here

git clone https://github.com/z-libs/Zen-C.git
cd Zen-C
make
sudo make install

# Compile and run
zc run hello.zc

# Build executable
zc build hello.zc -o hello

# Interactive Shell
zc repl

You can set ZC_ROOT to specify the location of the Standard Library (standard imports like import "std/vector.zc"). This allows you to run zc from any directory.

export ZC_ROOT=/path/to/Zen-C

Zen C uses type inference by default.

var x = 42;                 // Inferred as int
const PI = 3.14159;         // Compile-time constant
var explicit: float = 1.0;  // Explicit type

Fixed-size arrays with value semantics.

var ints: int[5] = {1, 2, 3, 4, 5};
var zeros: [int; 5]; // Zero-initialized

Group multiple values together.

var pair = (1, "Hello");
var x = pair.0;
var s = pair.1;

Data structures with optional bitfields.

struct Point {
    x: int;
    y: int;
}

// Struct initialization
var p = Point { x: 10, y: 20 };

// Bitfields
struct Flags {
    valid: U8 : 1;
    mode:  U8 : 3;
}

Tagged unions (Sum types) capable of holding data.

enum Shape {
    Circle(float),      // Holds radius
    Rect(float, float), // Holds width, height
    Point               // No data
}

Standard C unions (unsafe access).

union Data {
    i: int;
    f: float;
}

#### Type Aliases
Create a new name for an existing type.
```zc
alias ID = int;
alias PointMap = Map<string, Point>;

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

// Named arguments supported in calls
add(a: 10, b: 20);

Anonymous functions that can capture their environment.

var factor = 2;
var double = x -> x * factor;  // Arrow syntax
var full = fn(x: int) -> int { return x * factor; }; // Block syntax

if x > 10 {
    print("Large");
} else if x > 5 {
    print("Medium");
} else {
    print("Small");
}

// Ternary
var y = x > 10 ? 1 : 0;

Powerful alternative to switch.

match val {
    1 => print("One"),
    2 | 3 => print("Two or Three"),
    4..10 => print("Range"),
    _ => print("Other")
}

// Destructuring Enums
match shape {
    Circle(r) => print(f"Radius: {r}"),
    Rect(w, h) => print(f"Area: {w*h}"),
    Point => print("Point")
}

// Range
for i in 0..10 { ... }      // Exclusive (0 to 9)
for i in 0..=10 { ... }     // Inclusive (0 to 10)
for i in 0..10 step 2 { ... }

// Iterator/Collection
for item in vec { ... }

// While
while x < 10 { ... }

// Infinite with label
outer: loop {
    if done { break outer; }
}

// Repeat
repeat 5 { ... }

// Guard: Execute else and return if condition is false
guard ptr != NULL else { return; }

// Unless: If not true
unless is_valid { return; }

Zen C provides versatile options for printing to the console, including keywords and concise shorthands.

• print "text": Prints to stdout without a trailing newline.
• println "text": Prints to stdout with a trailing newline.
• eprint "text": Prints to stderr without a trailing newline.
• eprintln "text": Prints to stderr with a trailing newline.

Zen C allows you to use string literals directly as statements for quick printing:

• "Hello World": Equivalent to println "Hello World". (Implicitly adds newline)
• "Hello World"..: Equivalent to print "Hello World". (No trailing newline)
• !"Error": Equivalent to eprintln "Error". (Output to stderr)
• !"Error"..: Equivalent to eprint "Error". (Output to stderr, no newline)

You can embed expressions directly into string literals using {} syntax. This works with all printing methods and string shorthands.

var x = 42;
var name = "Zen";
println "Value: {x}, Name: {name}";
"Value: {x}, Name: {name}"; // shorthand println

Zen C supports a shorthand for prompting user input using the ? prefix.

• ? "Prompt text": Prints the prompt (without newline) and waits for input (reads a line).
• ? "Enter age: " (age): Prints prompt and scans input into the variable age.
  • Format specifiers are automatically inferred based on variable type.

var age = "How old are you? ";
println "You are {age} years old.";

Zen C allows manual memory management with ergonomic aids.

Execute code when the current scope exits.

var f = fopen("file.txt", "r");
defer fclose(f);

Automatically free the variable when scope exits.

autofree var types = malloc(1024);

Implement Drop to run cleanup logic automatically.

impl Drop for MyStruct {
    fn drop(mut self) {
        free(self.data);
    }
}

Define methods on types using impl.

impl Point {
    // Static method (constructor convention)
    fn new(x: int, y: int) -> Point {
        return Point{x: x, y: y};
    }

    // Instance method
    fn dist(self) -> float {
        return sqrt(self.x * self.x + self.y * self.y);
    }
}

Define shared behavior.

trait Drawable {
    fn draw(self);
}

impl Drawable for Circle {
    fn draw(self) { ... }
}

Use use to mixin fields from another struct.

struct Entity { id: int; }
struct Player {
    use Entity; // Adds 'id' field
    name: string;
}

Type-safe templates for Structs and Functions.

// Generic Struct
struct Box<T> {
    item: T;
}

// Generic Function
fn identity<T>(val: T) -> T {
    return val;
}

// Multi-parameter Generics
struct Pair<K, V> {
    key: K;
    value: V;
}

Built on pthreads.

async fn fetch_data() -> string {
    // Runs in background
    return "Data";
}

fn main() {
    var future = fetch_data();
    var result = await future;
}

Run code at compile-time to generate source or print messages.

comptime {
    // Generate code at compile-time (written to stdout)
    println "var build_date = \"2024-01-01\";";
}

println "Build Date: {build_date}";

Embed files as byte arrays.

var png = embed "assets/logo.png";

Import compiler plugins to extend syntax.

import plugin "regex"
var re = regex! { ^[a-z]+$ };

Pass preprocessor macros through to C.

#define MAX_BUFFER 1024

Decorate functions and structs to modify compiler behavior.

Zen C provides first-class support for inline assembly, transpiling directly to GCC-style extended asm.

Write raw assembly within asm blocks. Strings are concatenated automatically.

asm {
    "nop"
    "mfence"
}

Prevent the compiler from optimizing away assembly that has side effects.

asm volatile {
    "rdtsc"
}

Zen C simplifies the complex GCC constraint syntax with named bindings.

// Syntax: : out(var) : in(var) : clobber(reg)
// Uses {var} placeholder syntax for readability

fn add(a: int, b: int) -> int {
    var result: int;
    asm {
        "add {result}, {a}, {b}"
        : out(result)
        : in(a), in(b)
        : clobber("cc")
    }
    return result;
}

Note: When using Intel syntax (via -masm=intel), you must ensure your build is configured correctly (for example, //> cflags: -masm=intel). TCC does not support Intel syntax assembly.

Zen C supports special comments at the top of your source file to configure the build process without needing a complex build system or Makefile.

//> include: ./include
//> lib: ./libs
//> link: -lraylib -lm
//> cflags: -Ofast
//> pkg-config: gtk+-3.0

import "raylib.h"

fn main() { ... }

Zen C is designed to work with most C11 compilers. Some features rely on GNU C extensions, but these often work in other compilers. Use the --cc flag to switch backends.

zc run app.zc --cc clang
zc run app.zc --cc zig

Recommendation: Use GCC, Clang, or Zig for production builds. TCC is excellent for rapid prototyping due to its compilation speed but misses some advanced C extensions Zen C relies on for full feature support.

Zig's zig cc command provides a drop-in replacement for GCC/Clang with excellent cross-compilation support. To use Zig:

# Compile and run a Zen C program with Zig
zc run app.zc --cc zig

# Build the Zen C compiler itself with Zig
make zig

Zen C can generate C++-compatible code with the --cpp flag, allowing seamless integration with C++ libraries.

# Direct compilation with g++
zc app.zc --cpp

# Or transpile for manual build
zc transpile app.zc --cpp
g++ out.c my_cpp_lib.o -o app

Include C++ headers and use raw blocks for C++ code:

include <vector>
include <iostream>

raw {
    std::vector<int> make_vec(int a, int b) {
        return {a, b};
    }
}

fn main() {
    var v = make_vec(1, 2);
    raw { std::cout << "Size: " << v.size() << std::endl; }
}

Note: The --cpp flag switches the backend to g++ and emits C++-compatible code (uses auto instead of __auto_type, function overloads instead of _Generic, and explicit casts for void*).

We welcome contributions! Whether it's fixing bugs, adding documentation, or proposing new features.

1. Fork the Repository: standard GitHub workflow.
2. Create a Feature Branch: git checkout -b feature/NewThing.
3. Code Guidelines:
   • Follow the existing C style.
   • Ensure all tests pass: make test.
   • Add new tests for your feature in tests/.
4. Submit a Pull Request: Describe your changes clearly.

The test suite is your best friend.

# Run all tests (GCC)
make test

# Run specific test
./zc run tests/test_match.zc

# Run with different compiler
./tests/run_tests.sh --cc clang
./tests/run_tests.sh --cc zig
./tests/run_tests.sh --cc tcc

• Parser: src/parser/ - Recursive descent parser.
• Codegen: src/codegen/ - Transpiler logic (Zen C -> GNU C/C11).
• Standard Library: std/ - Written in Zen C itself.