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.
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 replZen 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
By default, variables are mutable. You can enable Immutable by Default mode using a directive.
//> immutable-by-default
var x = 10;
// x = 20; // Error: x is immutable
var mut y = 10;
y = 20; // OK
| Type | C Equivalent | Description |
|---|---|---|
int, uint |
int, unsigned int |
Platform standard integer |
I8 .. I128 |
int8_t .. __int128_t |
Signed fixed-width integers |
U8 .. U128 |
uint8_t .. __uint128_t |
Unsigned fixed-width integers |
isize, usize |
ptrdiff_t, size_t |
Pointer-sized integers |
byte |
uint8_t |
Alias for U8 |
F32, F64 |
float, double |
Floating point numbers |
bool |
bool |
true or false |
char |
char |
Single character |
string |
char* |
C-string (null-terminated) |
U0, void |
void |
Empty 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;
}
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 = if 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 { ... }
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; }
| Operator | Description | Function Mapping |
|---|---|---|
+, -, *, /, % |
Arithmetic | add, sub, mul, div, rem |
==, !=, <, > |
Comparison | eq, neq, lt, gt |
[] |
Indexing | get, set |
?? |
Null Coalescing (val ?? default) |
- |
??= |
Null Assignment (val ??= init) |
- |
?. |
Safe Navigation (ptr?.field) |
- |
? |
Try Operator (res? returns error if present) |
- |
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;
}
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 {
print("Compiling...");
}
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.
Decorate functions and structs to modify compiler behavior.
| Attribute | Scope | Description |
|---|---|---|
@must_use |
Fn | Warn if return value is ignored. |
@deprecated("msg") |
Fn/Struct | Warn on usage with message. |
@inline |
Fn | Hint compiler to inline. |
@noinline |
Fn | Prevent inlining. |
@packed |
Struct | Remove padding between fields. |
@align(N) |
Struct | Force alignment to N bytes. |
@constructor |
Fn | Run before main. |
@destructor |
Fn | Run after main exits. |
@unused |
Fn/Var | Suppress unused variable warnings. |
@weak |
Fn | Weak symbol linkage. |
@section("name") |
Fn | Place code in specific section. |
@noreturn |
Fn | Function does not return (e.g. exit). |
@derived(...) |
Struct | Auto-implement traits (e.g. Debug). |
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.
Prevent the compiler from optimizing away assembly that has side effects.
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;
}
| Type | Syntax | GCC Equivalent |
|---|---|---|
| Output | : out(var) |
"=r"(var) |
| Input | : in(var) |
"r"(var) |
| Clobber | : clobber("rax") |
"rax" |
| Memory | : clobber("memory") |
"memory" |
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 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.
| Compiler | Pass Rate | Supported Features | Known Limitations |
|---|---|---|---|
| GCC | 100% | All Features | None. |
| Clang | 100% | All Features | None. |
| TCC | ~70% | Basic Syntax, Generics, Traits | No __auto_type, No Intel ASM, No Nested Functions. |
Recommendation: Use GCC or Clang 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.
We welcome contributions! Whether it's fixing bugs, adding documentation, or proposing new features.
- Fork the Repository: standard GitHub workflow.
- Create a Feature Branch:
git checkout -b feature/NewThing. - Code Guidelines:
- Follow the existing C style.
- Ensure all tests pass:
make test. - Add new tests for your feature in
tests/.
- 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- Parser:
src/parser/- Recursive descent parser. - Codegen:
src/codegen/- Transpiler logic (Zen C -> GNU C/C11). - Standard Library:
std/- Written in Zen C itself.