Skip to content
TheChatArchiveThe Chat Archive
Mistralmistral-medium-2505· Mistral AIHugging Face LMArena Human Preference 140K

teach me some fundamentals in zig.

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with gpt-4.1-mini-2025-04-14’s answer.
  1. User

    teach me some fundamentals in zig.

  2. Mistral Assistant

    Zig is a modern, systems programming language designed for robustness, optimality, and clarity. Below are some fundamental concepts to get you started with Zig.


    1. Installation

    First, install Zig from the official website.

    # On Linux/macOS
    curl -L https://ziglang.org/builds/zig-linux-x86_64-0.11.0.tar.xz | tar -xJ
    export PATH="$PATH:$(pwd)/zig-linux-x86_64-0.11.0"
    

    Verify installation:

    zig version
    

    2. Hello World

    A simple Zig program:

    const std = @import("std");
    
    pub fn main() void {
        std.debug.print("Hello, World!\n", .{});
    }
    
    • const std = @import("std"); – Imports the standard library.
    • pub fn main() void – The entry point of the program.
    • std.debug.print – Prints to stderr (use std.io.getStdOut().writer().print for stdout).

    Compile and run:

    zig run hello.zig
    

    3. Variables and Types

    Zig is statically typed but has type inference.

    const x: i32 = 42; // Explicit type
    const y = 42;      // Type inferred as `comptime_int` (compile-time known)
    var z: u8 = 255;   // Mutable variable
    

    Common types:

    • i32, u32 – Signed/unsigned 32-bit integers.
    • f32, f64 – Floating-point numbers.
    • bool – Boolean (true/false).
    • []const u8 – Slice of bytes (like a string).
    • *T – Pointer to type T.

    4. Functions

    Functions can return values or be void.

    fn add(a: i32, b: i32) i32 {
        return a + b;
    }
    
    pub fn main() void {
        const sum = add(3, 5);
        std.debug.print("Sum: {}\n", .{sum});
    }
    
    • fn defines a function.
    • Parameters are explicitly typed.
    • Return type is specified after the parameters.

    5. Control Flow

    If-Else

    const age: u8 = 20;
    if (age >= 18) {
        std.debug.print("Adult\n", .{});
    } else {
        std.debug.print("Minor\n", .{});
    }
    

    Loops

    • while:
      var i: u8 = 0;
      while (i < 5) : (i += 1) {
          std.debug.print("i = {}\n", .{i});
      }
      
    • for:
      const nums = [_]i32{ 1, 2, 3 };
      for (nums) |num| {
          std.debug.print("{} ", .{num});
      }
      

    6. Pointers and Memory

    Zig gives fine-grained control over memory.

    var x: i32 = 10;
    const ptr: *i32 = &x; // Pointer to x
    ptr.* = 20; // Dereference and modify
    
    • &x – Takes the address of x.
    • ptr.* – Dereferences the pointer.

    7. Error Handling

    Zig uses explicit error handling with error types.

    fn divide(a: i32, b: i32) !i32 { // `!i32` means "returns i32 or an error"
        if (b == 0) return error.DivisionByZero;
        return a / b;
    }
    
    pub fn main() void {
        const result = divide(10, 0) catch |err| {
            std.debug.print("Error: {}\n", .{err});
            return;
        };
        std.debug.print("Result: {}\n", .{result});
    }
    
    • !T – A type that can return T or an error.
    • catch – Handles errors.

    8. Structs and Enums

    Structs

    const Person = struct {
        name: []const u8,
        age: u8,
    };
    
    pub fn main() void {
        const person = Person{ .name = "Alice", .age = 30 };
        std.debug.print("{s} is {} years old\n", .{ person.name, person.age });
    }
    

    Enums

    const Color = enum { Red, Green, Blue };
    
    pub fn main() void {
        const c = Color.Green;
        switch (c) {
            .Red => std.debug.print("Red\n", .{}),
            .Green => std.debug.print("Green\n", .{}),
            .Blue => std.debug.print("Blue\n", .{}),
        }
    }
    

    9. Memory Allocation

    Zig provides allocators for dynamic memory.

    const std = @import("std");
    
    pub fn main() !void {
        const allocator = std.heap.page_allocator;
        const ptr = try allocator.alloc(i32, 1); // Allocate space for 1 i32
        defer allocator.free(ptr); // Free memory when done
    
        ptr.* = 42;
        std.debug.print("Value: {}\n", .{ptr.*});
    }
    
    • try – Propagates errors.
    • defer – Ensures cleanup happens at scope exit.

    10. Compile-Time Execution

    Zig can run code at compile time.

    fn factorial(comptime n: u32) u32 {
        return if (n == 0) 1 else n * factorial(n - 1);
    }
    
    pub fn main() void {
        const fact5 = comptime factorial(5); // Computed at compile time
        std.debug.print("5! = {}\n", .{fact5});
    }
    
    • comptime – Forces evaluation at compile time.

    Next Steps

    • Read the Zig documentation.
    • Try small projects (e.g., a CLI tool, a simple game).
    • Explore the standard library (std).

    Zig is a powerful language with a strong focus on correctness and performance. Happy coding! 🚀

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.