Zig

Paradigms	Multi-paradigm: imperative, concurrent, procedural, functional
Designed by	Andrew Kelley
First appeared	8 February 2016; 6 years ago (2016-02-08)[1]
Preview release	0.10.1[2]  / 19 January 2023; 14 days ago (19 January 2023)
Typing discipline	Static, strong, inferred, structural, generic
Platform	x86-64, ARM64, WebAssembly Tier 2: ARM, IA-32, RISC-V, MIPS64, POWERPC64, IA-32, SPARC64, some tier-2 platforms have tier-1 support when "freestanding"
OS	Cross-platform: Linux, FreeBSD, Windows
License	MIT
Filename extensions	.zig, .zir
Website	ziglang.org
Influenced by
C, C++, LLVM IR, Go, Rust, JavaScript[citation needed]

Zig is an imperative, general-purpose, statically typed, compiled system programming language designed by Andrew Kelley.^[3][4] The language is designed for "robustness, optimality and maintainability",^[5][6] supporting compile-time generics, reflection and evaluation, cross-compilation, and manual memory management.^[7] A major goal of the language is to improve upon the C language,^[8][9] while also taking inspiration from Rust,^[10][5] among others. Zig has many features for low-level programming, notably packed structs (structs without padding between fields), arbitrary-width integers^[11] and multiple pointer types.^[12]

Zig is not a new language only. It also includes a C/C++ compiler, and Zig can be used with either or both languages.

Since version 0.10 the (new default) Zig compiler is written in Zig, i.e., it is a self-hosting compiler, and that is a major new feature of that release (the older legacy bootstrapping compiler, written in C++, is still an option but will not be in 0.11). The default backend (i.e. the optimizer) is still LLVM (now version 15, legacy uses version 13), and LLVM is written in C++. Zig (i.e. the compiler, not generated code from it) with LLVM is 169 MiB, vs without LLVM 4.4 MiB. When compiling with the new Zig compiler much less memory is used (the older, now legacy, compiler uses 3.5x more memory), and it compiles a bit faster. Faster executable code is usually complied with the new compiler (i.e. its LLVM code generation is better), and it fixes many bugs, but there are also improvements for the older legacy compiler in version 0.10. The self-hosted linker is tightly coupled with the self-hosted compiler. The new version also adds some experimental (tier-3) support for AMD GPUs (there's also some lesser support for Nvidia GPUs and for PlayStation 4 and 5).

The older bootstrapping ("stage1") compiler is written in Zig and C++, using LLVM 13^[13] as a back-end,^[14][15] supporting many of its native targets.^[16] The compiler is free and open-source software released under an MIT License.^[17] The Zig compiler exposes the ability to compile C and C++ similarly to Clang with the commands "zig cc" and "zig c++",^[18] providing many headers including libc and libcxx for many different platforms, allowing Zig's cc and c++ sub-commands to act as cross compilers out of the box.^[19][20]

Plus the operating systems (mostly desktop ones) officially supported (and documented), (minimal) applications can and have been made for Android (with Android NDK, and programming for iOS also possible).

Zig doesn't have its own official package manager (non-official ones exist), but a standard one has a milestone for 0.12.

Zig development is funded by the Zig Software Foundation (ZSF), a non-profit corporation with Andrew Kelley as president, which takes in donations and hires multiple full-time employees.^[21][22][23]

Examples

Hello World

const std = @import("std");

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    try stdout.print("Hello, {s}!\n", .{"world"});
}

Generic linked list

pub fn main() void {
    var node = LinkedList(i32).Node {
        .prev = null,
        .next = null,
        .data = 1234,
    };

    var list = LinkedList(i32) {
        .first = &node,
        .last = &node,
        .len = 1,
    };
}

fn LinkedList(comptime T: type) type {
    return struct {
        pub const Node = struct {
            prev: ?*Node,
            next: ?*Node,
            data: T,
        };

        first: ?*Node,
        last:  ?*Node,
        len:   usize,
    };
}

Projects

• Bun is a JavaScript and TypeScript runtime written in Zig, using Safari's JavaScriptCore virtual machine.

See also

• C
• C++
• Nim
• Rust
• D

References

External links

• Official website
• Zig on GitHub
• Movie: Introducing Zig
• Movie: The Road to 1.0
• Zig Weekly