mohitmishra786/low-level-dev-skills

zig-cross

Zig cross-compilation skill.

Zobacz źródło

Jak używać

  1. Skopiuj polecenie instalacji i sprawdź źródła przed instalacją we własnym środowisku agenta.
  2. W oryginale sprawdź wymagane narzędzia, dane dostępowe i obsługiwane środowiska.
  3. Opisz dane wejściowe i oczekiwany rezultat; porównaj wynik ze źródłami.
npx skills add https://github.com/mohitmishra786/low-level-dev-skills --skill zig-cross

Przed rozpoczęciem

  • Instalacja nie obejmuje subskrypcji modelu, limitu API ani uprawnień do plików.
  • Gwiazdki i instalacje pokazują aktywność, a nie niezależny test jakości lub bezpieczeństwa.
Oryginalny dokument Skill

Treść z repozytorium z zachowaniem nagłówków, przykładów, kodu, tabel, linków i obrazów.

Zig Cross-Compilation

Purpose

Guide agents through Zig's built-in cross-compilation: target triple selection, CPU feature targeting, zig cc for cross-compiling C projects, embedded bare-metal targets, and WASM output — all without requiring a system cross-toolchain.

Triggers

  • "How do I cross-compile a Zig program for ARM?"
  • "How do I build Zig for a different OS?"
  • "How do I use Zig to cross-compile C code for another platform?"
  • "How do I build Zig for embedded/bare-metal?"
  • "How do I target WebAssembly with Zig?"
  • "What Zig target triple do I use for Raspberry Pi?"

Workflow

1. Zig's native cross-compilation

Zig has cross-compilation built in — no cross-toolchain, no Docker, no sysroot needed for pure Zig code:

bash
# List all supported targets
zig targets | python3 -c "import sys,json; d=json.load(sys.stdin); [print(t) for t in d['libc']]"

# Build for a specific target
zig build-exe src/main.zig -target aarch64-linux-gnu -O ReleaseFast

# With build system (pass target as option)
zig build -Dtarget=aarch64-linux-gnu -Doptimize=ReleaseFast

# Cross-compile for Windows from Linux/macOS
zig build-exe src/main.zig -target x86_64-windows-gnu

# Cross-compile for macOS from Linux (requires macOS SDK)
zig build-exe src/main.zig -target aarch64-macos-none

2. Common target triples

Target triplePlatform
x86_64-linux-gnuLinux x86-64 (glibc)
x86_64-linux-muslLinux x86-64 (musl, static)
aarch64-linux-gnuARM64 Linux (Pi 4, AWS Graviton)
aarch64-linux-muslARM64 Linux static
armv7-linux-gnueabihfARM 32-bit Linux (Pi 2/3)
x86_64-windows-gnuWindows x86-64
aarch64-macos-nonemacOS Apple Silicon
x86_64-macos-nonemacOS Intel
wasm32-freestandingWASM (browser, no OS)
wasm32-wasiWASM with WASI
thumbv7m-freestanding-eabiCortex-M3 bare metal
thumbv7em-freestanding-eabihfCortex-M4/M7 with FPU
riscv32-freestandingRISC-V 32-bit bare metal

3. CPU feature targeting

bash
# Native CPU (auto-detect, only for native builds)
zig build-exe src/main.zig -mcpu native

# Baseline for architecture (most compatible)
zig build-exe src/main.zig -target x86_64-linux-gnu -mcpu baseline

# x86-64 with AVX2
zig build-exe src/main.zig -target x86_64-linux-gnu -mcpu x86_64+avx2+bmi2

# Raspberry Pi 4 (Cortex-A72)
zig build-exe src/main.zig -target aarch64-linux-gnu -mcpu cortex_a72

# Cortex-M4 with FPU
zig build-exe src/main.zig \
    -target thumbv7em-freestanding-eabihf \
    -mcpu cortex_m4+vfp4

# List CPU features for a target
zig targets | python3 -c "
import sys,json
d=json.load(sys.stdin)
for c in d['cpus']:
    if 'cortex' in c['name']:
        print(c['name'])
"

4. zig cc for C cross-compilation

zig cc cross-compiles C without a system cross-toolchain:

bash
# Cross-compile C for ARM64 Linux
zig cc -target aarch64-linux-gnu -O2 -o myapp-arm64 main.c

# Cross-compile C for Windows
zig cc -target x86_64-windows-gnu main.c -o myapp.exe

# Cross-compile C with static musl linking
zig cc -target x86_64-linux-musl -static main.c -o myapp-static

# Use in Makefile for all platforms
CC_LINUX_AMD64 = zig cc -target x86_64-linux-gnu
CC_LINUX_ARM64 = zig cc -target aarch64-linux-gnu
CC_WINDOWS     = zig cc -target x86_64-windows-gnu

5. Build system cross-compilation

zig
// build.zig — cross-build all targets
pub fn build(b: *std.Build) void {
    const targets = [_]std.Target.Query{
        .{ .cpu_arch = .x86_64, .os_tag = .linux, .abi = .gnu },
        .{ .cpu_arch = .aarch64, .os_tag = .linux, .abi = .gnu },
        .{ .cpu_arch = .x86_64, .os_tag = .windows, .abi = .gnu },
        .{ .cpu_arch = .aarch64, .os_tag = .macos },
    };

    for (targets) |t| {
        const target = b.resolveTargetQuery(t);
        const exe = b.addExecutable(.{
            .name = b.fmt("myapp-{s}", .{@tagName(t.cpu_arch.?)}),
            .root_source_file = b.path("src/main.zig"),
            .target = target,
            .optimize = .ReleaseFast,
        });
        b.installArtifact(exe);
    }
}
bash
# Build all targets
zig build
# Creates: zig-out/bin/myapp-x86_64, myapp-aarch64, myapp-x86_64.exe, myapp-aarch64

6. Embedded (bare-metal) targets

bash
# Cortex-M4 with FPU (STM32F4xx)
zig build-exe src/main.zig \
    -target thumbv7em-freestanding-eabihf \
    -mcpu cortex_m4+vfp4 \
    -O ReleaseSmall \
    --script linker.ld
zig
// src/main.zig — bare metal entry point
const std = @import("std");

// Custom panic handler for embedded (no OS)
pub fn panic(msg: []const u8, _: ?*std.builtin.StackTrace, _: ?usize) noreturn {
    // Toggle LED or halt
    while (true) {}
}

// Entry point (matches linker script)
export fn _start() void {
    main() catch |err| {
        _ = err;
        while (true) {}
    };
}

fn main() !void {
    // Hardware initialization...
}

7. WebAssembly

bash
# WASM freestanding (browser)
zig build-exe src/main.zig \
    -target wasm32-freestanding \
    -O ReleaseSmall \
    --export=init \
    --export=update \
    -fno-entry

# WASM WASI (wasmtime, wasmer)
zig build-exe src/main.zig \
    -target wasm32-wasi \
    -O ReleaseSafe
wasmtime myapp.wasm

# Optimize WASM size
wasm-opt -Oz myapp.wasm -o myapp.opt.wasm

For target triple reference and embedded linker script setup, see references/zig-target-triples.md.

Related skills

  • Use skills/zig/zig-compiler for single-file compilation flags
  • Use skills/zig/zig-build-system for multi-target build.zig configuration
  • Use skills/compilers/cross-gcc for system cross-toolchain setup when needed
  • Use skills/rust/rust-cross for Rust's cross-compilation approach comparison

Powiązane zadania

z tego samego repozytorium

Więcej Skills

Wszystkie Skills
mohitmishra786
Społeczność

low-power-embedded

Low-power embedded skill for sleep modes and energy optimization. Use when configuring MCU sleep/stop/standby, peripheral clock gating, wake-up sources, or measuring firmware current draw. Activates on queries about WFI, STOP mode, STM32 PWR, nRF sleep, wake-up EXTI, or reducing embedded power consumption.

Instalacje / 1h
1
GitHub Stars
296
Aktualizacja
20 lis
mohitmishra786
Społeczność

core-dumps

Core dump analysis skill for production crash triage. Use when loading core files in GDB or LLDB, enabling core dump generation on Linux/macOS, mapping symbols with debuginfo or debuginfod, or extracting backtraces from crashes without re-running the program. Activates on queries about core files, ulimit, coredumpctl, debuginfod, crash triage, or analyzing segfaults from production binaries.

Instalacje / 1h
2
GitHub Stars
267
Aktualizacja
27 cze
mohitmishra786
Społeczność

custom-allocators

Custom allocator skill for memory allocation strategies. Use when implementing pool/slab/arena allocators, tuning jemalloc/mimalloc, writing Rust GlobalAlloc, or benchmarking allocator performance. Activates on queries about jemalloc, mimalloc, tcmalloc, arena allocator, GlobalAlloc, or fragmentation.

Instalacje / 1h
2
GitHub Stars
267
Aktualizacja
27 cze
mohitmishra786
Społeczność

ebpf

eBPF skill for Linux observability and networking. Use when writing eBPF programs with libbpf or bpftrace, attaching kprobes/tracepoints/XDP hooks, debugging verifier errors, working with eBPF maps, or achieving CO-RE portability across kernel versions. Activates on queries about eBPF, bpftool, bpftrace, XDP programs, libbpf, verifier errors, eBPF maps, or kernel tracing with BPF.

Instalacje / 1h
2
GitHub Stars
267
Aktualizacja
27 cze