zenc README

The project's README from github.com/zenc-lang/zenc. As one markdown file: README.md.

English • Deutsch • Русский • 简体中文 • 繁體中文 • Español • Italiano • Português Brasileiro

Zen C

Modern Ergonomics. Zero Overhead. Pure C.


Build Status License Version Platform

Write like a high-level language, run like C.

Overview • Community • Quick Start • Ecosystem • Language Reference • Standard Library • Toolchain

Overview

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.

Community

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

Ecosystem

The Zen C project consists of several repositories. Below you can find the primary ones:

Repository Description Status
zenc The core Zen C compiler (zc), CLI, and Standard Library. Active Development
docs The official documentation and language specification. Active
rfcs The Request for Comments (RFC) repository. Shape the future of the language. Active
vscode-zenc Official VS Code extension (Syntax Highlighting, Snippets). Alpha
www Source code for zenc-lang.org. Active
awesome-zenc A curated list of awesome Zen C examples Growing
zenc.vim Official Vim/Neovim plugin (Syntax, Indentation). Active

Showcase

Check out these projects built with Zen C:

Index

General Language Reference

Browse the Language Reference

Quick Start

Installation

git clone https://github.com/zenc-lang/zenc.git
cd zenc
make clean # remove old build files
make
sudo make install

Development Targets

make format       # Auto-format all source files with clang-format
make format-check # Verify formatting without changing files
make lint         # Run format-check + shellcheck on test scripts
make bench        # Run performance benchmarks
make WERROR=1     # Build with -Werror (warnings as errors)

Windows

Zen C has full native support for Windows (x86_64). You can build using the provided batch script with GCC (MinGW):

build.bat

This will build the compiler (zc.exe). Networking, Filesystem, and Process operations are fully supported via the Platform Abstraction Layer (PAL).

Alternatively, you can use make if you have a Unix-like environment (MSYS2, Cygwin, git-bash).

Portable Build (APE)

Zen C can be compiled as an Actually Portable Executable (APE) using Cosmopolitan Libc. This produces a single binary (.com) that runs natively on Linux, macOS, Windows, FreeBSD, OpenBSD, and NetBSD on both x86_64 and aarch64 architectures.

Prerequisites:

Build & Install:

make ape
sudo env "PATH=$PATH" make install-ape

Artifacts:

Usage:

# Run on any supported OS
./out/bin/zc.com build hello.zc -o hello

Usage

# Compile and run
zc run hello.zc

# Build executable
zc build hello.zc -o hello

# Interactive Shell
zc-repl

# Documentation (Recursive)
zc-doc main.zc

# Documentation (Single file, no check)
zc-doc --no-recursive-doc main.zc

Environment Variables

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

export ZC_ROOT=/path/to/Zen-C

Language Reference

See the official Language Reference for more details.

Standard Library

Zen C includes a standard library (std) covering essential functionality.

Browse the Standard Library Documentation

Key Modules

Click to see all Standard Library modules
Module Description Docs
std/bigfloat.zc Arbitrary-precision floating-point arithmetic. Docs
std/bigint.zc Arbitrary-precision integer BigInt. Docs
std/bits.zc Low-level bitwise operations (rotl, rotr). Docs
std/complex.zc Complex Number Arithmetic Complex. Docs
std/vec.zc Growable dynamic array Vec<T>. Docs
std/string.zc Heap-allocated String type with UTF-8 support. Docs
std/queue.zc FIFO queue (Ring Buffer). Docs
std/map.zc Generic Hash Map Map<V>. Docs
std/fs.zc File system operations. Docs
std/io.zc Standard Input/Output (print/println). Docs
std/option.zc Optional values (Some/None). Docs
std/result.zc Error handling (Ok/Err). Docs
std/path.zc Cross-platform path manipulation. Docs
std/env.zc Process environment variables. Docs
std/net/ TCP, UDP, HTTP, DNS, URL. Docs
std/thread.zc Threads and Synchronization. Docs
std/time.zc Time measurement and sleep. Docs
std/json.zc JSON parsing and serialization. Docs
std/stack.zc LIFO Stack Stack<T>. Docs
std/set.zc Generic Hash Set Set<T>. Docs
std/process.zc Process execution and management. Docs
std/regex.zc Regular Expressions (TRE based). Docs
std/simd.zc Native SIMD vector types. Docs

18. Unit Testing Framework

Zen C features a built-in testing framework with per-test isolation, named output, and non-fatal assertions.

Syntax

A test block contains a descriptive name and a body of code to execute. Tests do not require a main function to run.

test "descriptive name" {
    let a = 3;
    assert(a > 0, "a should be positive");
}

Running Tests

zc run my_file.zc

Output shows each test by name:

  TEST: descriptive name ... OK
  TEST: another test ... FAIL

1 test(s) failed

Assertions

Function Behavior
assert(cond, msg) Records failure, continues to next test (no longer aborts)
expect(cond, msg) Non-fatal — records failure but continues within the same test

Use assert for critical checks that should stop the current test, and expect when you want to verify multiple conditions without short-circuiting:

test "example" {
    expect(result != null, "result should not be null");
    expect(result.code == 200, "status should be 200");
    // both run even if the first fails
}

Exit Code

The binary exits with the number of failed tests (0 = all passed).

Tooling

Zen C provides a built-in Language Server and REPL to enhance the development experience. It is also debuggable with LLDB.

Language Server (LSP)

The Zen C Language Server (LSP) supports standard LSP features for editor integration, providing:

To start the language server (typically configured in your editor's LSP settings):

zc-lsp

It communicates via standard I/O (JSON-RPC 2.0).

REPL

The Read-Eval-Print Loop allows you to experiment with Zen C code interactively using modern In-Process JIT Compilation (powered by LibTCC).

zc-repl

Features

Commands

Command Description
:help Show available commands.
:reset Clear current session history (variables/functions).
:vars Show active variables.
:funcs Show user-defined functions.
:structs Show user-defined structs.
:imports Show active imports.
:history Show session input history.
:type <expr> Show the type of an expression.
:c <stmt> Show the generated C code for a statement.
:time <expr> Benchmark an expression (runs 1000 iterations).
:edit [n] Edit command n (default: last) in $EDITOR.
:save <file> Save the current session to a .zc file.
:load <file> Load and execute a .zc file into the session.
:watch <expr> Watch an expression (re-evaluated after every entry).
:unwatch <n> Remove a watch.
:undo Remove the last command from the session.
:delete <n> Remove command at index n.
:clear Clear the screen.
:quit Exit the REPL.
! <cmd> Run a shell command (e.g. !ls).

Language Server Protocol (LSP)

Zen C includes a built-in Language Server for editor integration.

Use zc-lsp to start the server.

Debugging Zen C

Zen C programs can be debugged using standard C debuggers like LLDB or GDB.

Visual Studio Code

For the best experience in VS Code, install the official Zen C extension. For debugging, you can use the C/C++ (by Microsoft) or CodeLLDB extension.

Add these configurations to your .vscode directory to enable one-click debugging:

tasks.json (Build Task):

{
    "label": "Zen C: Build Debug",
    "type": "shell",
    "command": "zc",
    "args": [ "${file}", "-g", "-o", "${fileDirname}/app", "-O0" ],
    "group": { "kind": "build", "isDefault": true }
}

launch.json (Debugger):

{
    "name": "Zen C: Debug (LLDB)",
    "type": "lldb",
    "request": "launch",
    "program": "${fileDirname}/app",
    "preLaunchTask": "Zen C: Build Debug"
}

Compiler Support & Compatibility

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

Test Suite Status

Click to view Compiler Support details
Compiler Pass Rate Supported Features Known Limitations
GCC 100% (Full) All Features None.
Clang 100% (Full) All Features None.
Zig 100% (Full) All Features None. Uses zig cc as a drop-in C compiler.
TCC 98% (High) Structs, Generics, Traits, Pattern Matching No Intel ASM, No __attribute__((constructor)).

[!WARNING] COMPILER BUILD WARNING: While Zig CC works excellently as a backend for your Zen C programs, building the Zen C compiler itself with it may verify but produce an unstable binary that fails tests. We recommend building the compiler with GCC or Clang and using Zig only as a backend for your operational code.

MISRA C:2012 Compliance Testing

The Zen C test suite includes verification against MISRA C:2012 guidelines.

[!IMPORTANT] MISRA Disclaimer This project is completely independent and holds no affiliation, official endorsement, or corporate connection with MISRA (Motor Industry Software Reliability Association).

Due to strict copyright restrictions, test cases only list directives by their numeric identifiers and avoid publishing internal specifications. Users needing primary documentation are encouraged to acquire authentic guideline materials from the Official MISRA portal.

Building with Zig

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

Output Backends

Zen C supports multiple output backends via the --backend flag. Each backend produces a different target format:

Backend Flag Extension Description
C --backend c .c Default — GNU C11
C++ --backend cpp .cpp C++11 compatible (also available as --cpp)
CUDA --backend cuda .cu NVIDIA CUDA C++ (also available as --cuda)
Objective-C --backend objc .m Objective-C (also available as --objc)
JSON --backend json .json Machine-readable AST for tooling
AST dump --backend ast-dump .ast Human-readable AST tree (debugging)
Lisp --backend lisp .lisp Transpile to Common Lisp (sbcl --script)
Graphviz --backend dot .dot Visual AST graph (dot -Tpng ast.dot -o ast.png)

Backend-specific options can be set with --backend-opt:

# Pretty-print JSON output
zc transpile file.zc --backend json --backend-opt pretty

# Show full raw content (no truncation)
zc transpile file.zc --backend lisp --backend-opt full-content

# OR use convenience aliases:
zc transpile file.zc --backend json --json-pretty
zc transpile file.zc --backend lisp --backend-full-content

All backend options are self-documented — unknown -- flags are checked against registered backend aliases automatically.

C++ Interop

Zen C can generate C++-compatible code with the --backend cpp flag (--cpp for short), allowing seamless integration with C++ libraries.

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

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

Using C++ in Zen C

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() {
    let 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*).

CUDA Interop

Zen C supports GPU programming by transpiling to CUDA C++ via the --backend cuda flag (--cuda for short). This allows you to leverage powerful C++ features (templates, constexpr) within your kernels while maintaining Zen C's ergonomic syntax.

# Direct compilation with nvcc
zc run app.zc --backend cuda

# Or transpile for manual build
zc transpile app.zc --backend cuda -o app.cu
nvcc app.cu -o app

CUDA-Specific Attributes

Attribute CUDA Equivalent Description
@global __global__ Kernel function (runs on GPU, called from host)
@device __device__ Device function (runs on GPU, called from GPU)
@host __host__ Host function (explicit CPU-only)

Kernel Launch Syntax

Zen C provides a clean launch statement for invoking CUDA kernels:

launch kernel_name(args) with {
    grid: num_blocks,
    block: threads_per_block,
    shared_mem: 1024,  // Optional
    stream: my_stream   // Optional
};

This transpiles to: kernel_name<<<grid, block, shared, stream>>>(args);

Writing CUDA Kernels

Use Zen C function syntax with @global and the launch statement:

import "std/cuda.zc"

@global
fn add_kernel(a: float*, b: float*, c: float*, n: int) {
    let i = thread_id();
    if i < n {
        c[i] = a[i] + b[i];
    }
}

fn main() {
    def N = 1024;
    let d_a = cuda_alloc<float>(N);
    let d_b = cuda_alloc<float>(N); 
    let d_c = cuda_alloc<float>(N);
    defer cuda_free(d_a);
    defer cuda_free(d_b);
    defer cuda_free(d_c);

    // ... init data ...
    
    launch add_kernel(d_a, d_b, d_c, N) with {
        grid: (N + 255) / 256,
        block: 256

zenc (zenc-lang/zenc)

Searching Database…

4.3K ·GitHub
Zenc
这是什么？Zen C 是一门现代系统编程语言，具备高层级的易用性（类型推断、模式匹配、泛型、trait、async/await），可编译为人类可读的 GNU C/C11，同时保持 100% 的 C ABI 兼容性。
这是一门自带编译器的独立语言，还是我加到现有 C 代码里的库？它是一门自带编译器（zc）的独立语言，把 Zen C 源码转译为 C（或 C++、CUDA、Objective-C 等其他后端），而不是导入现有项目的库。
如何构建和运行 Zen C 编译器？在 Windows 上，用 GCC（MinGW）运行附带的批处理脚本来构建 zc.exe；在类 Unix 系统（包括 MSYS2/Cygwin/git-bash）上则运行 make。你还可以使用 cosmocc 工具链构建单个可移植二进制文件（zc.com），它可在 Linux、macOS、Windows 和各 BSD 上原生运行。
要真正运行 Zen C 程序，我需要什么 C 编译器后端？Zen C 以任何支持 C11 的编译器为目标——GCC、Clang、Zig（通过 zig cc）或 TCC 都是经过测试的后端，可用 --cc 标志选择；要构建可移植的 APE 版本，你还需要把 cosmocc 工具链加入 PATH。
我可以用 Zig 构建 Zen C 编译器本身吗？不可靠——用 zig cc 构建编译器可能产生不稳定、通不过自身测试的二进制文件，因此建议用 GCC 或 Clang 构建编译器，Zig 只用作你自己 Zen C 程序的后端。TCC 虽然快，但不支持 Intel ASM 和 attribute((constructor))。
Zen C 只能在 Linux 上运行，还是也能在 Windows 和 macOS 上运行？它对 Windows x86_64 有完整的原生支持，其可移植的 APE 构建可在 x86_64 和 aarch64 架构的 Linux、macOS、Windows、FreeBSD、OpenBSD 和 NetBSD 上原生运行。
内置的 REPL 提供了什么？它使用由 LibTCC 驱动的进程内 JIT 编译实现即时反馈，提供 :c 显示生成的 C 代码、:time 对表达式进行基准测试等命令，历史记录持久化保存到 ~/.zenchistory。
除了纯 C，编译器还能生成哪些输出格式？通过 --backend 标志，它可以输出 C++、CUDA C++、Objective-C、机器可读的 JSON AST、人类可读的 AST 转储、Common Lisp 以及 AST 的 Graphviz dot 图。
我可以用 Zen C 写 GPU 代码吗？可以——--backend cuda 标志把 Zen C 转译为 CUDA C++，提供 @global/@device/@host 属性和简洁的启动语句，可直接在 NVIDIA GPU 上调用内核。
如何调试和测试 Zen C 程序？由于 Zen C 编译为 C，你可以用 LLDB 或 GDB 等标准工具调试（VS Code 用户可使用 CodeLLDB），该语言还内置单元测试框架，提供逐测试隔离和非致命的 assert/expect 检查，退出码为失败测试的数量。
What are similar projects?libuv, coost, taskflow, YouCompleteMe, htn_planner, ava, vim-go, goose
Which topics is it in?programming-languages, test-framework, gdb, repl, regex, udp, simd, transpiler, jit, tcp, debugger, lsp
Creator
zenc-lang
Size
6 MB
Stars
4.3K
Updated
CommitOct 15Releasev0.4.4Mar 20
Age
9mo
Commits · 90 Days