¿Qué es un zig build source file?

En Zig el flujo de trabajo de compilación está guiado por un archivo especial llamado build.zig. Este archivo no es simplemente código Zig ordinario; actúa como un pequeño intérprete que le dice al sistema de construcción cómo debe compilar los distintos módulos de tu proyecto, qué dependencias usar y qué opciones de compilación aplicar.

Estructura básica de build.zig

• Importar la biblioteca estándar: const std = @import("std");
• Definir la función de entrada: pub fn build(b: *std.build.Builder) void { ... }
• Crear un objetivo: const exe = b.addExecutable("app", "src/main.zig");
• Configurar el objetivo: exe.setTarget(target); y exe.setBuildMode(mode);
• Instalar artefactos: b.installArtifact(exe);

Ejemplo completo de build.zig con comentarios

// Importamos la biblioteca estándar de Zig, que contiene herramientas de compilación
const std = @import("std");

// Esta es la función que zig build invocará para generar el proceso de construcción
pub fn build(b: *std.build.Builder) void {
    // Obtenemos opciones de destino estándar (CPU, sistema operativo, etc.)
    const target = b.standardTargetOptions(.{});

    // Seleccionamos el modo de compilación (Debug, ReleaseSafe, ReleaseFast, ReleaseSafe)
    const mode = b.standardReleaseOptions();

    // Creamos un nuevo ejecutable llamado "mi_app" con el origen principal en src/main.zig
    const exe = b.addExecutable("mi_app", "src/main.zig");
    // Indicamos al compilador cuál es el objetivo de destino
    exe.setTarget(target);
    // Indicamos el modo de compilación (depurador, optimización, etc.)
    exe.setBuildMode(mode);

    // Añadimos una opción para que zig build instale el ejecutable en la ruta de salida
    b.installArtifact(exe);
}

Crear un proyecto sencillo

Para comenzar, crea la siguiente estructura de carpetas:

mi-proyecto/
├── build.zig
├── src/
│   └── main.zig
└── zig-out/

Contenido de src/main.zig con explicación línea a línea

// Importamos la biblioteca estándar para acceder a funciones de depuración y otras utilidades
const std = @import("std");

// La función principal del programa, es la entrada de ejecución
pub fn main() void {
    // Imprimimos un mensaje en la consola, usando la función print de std.debug
    std.debug.print("¡Hola, mundo desde Zig!\n", .{});
}

Compilar con zig build

Con los archivos build.zig y src/main.zig listos, simplemente ejecuta en la raíz del proyecto:

• zig build — compila el proyecto y coloca el ejecutable en zig-out/bin.
• zig build run — compila y ejecuta el binario inmediatamente.

Añadiendo dependencias externas

Si tu proyecto necesita una librería externa, puedes usar el gestor de paquetes integrado de Zig: zig mod o declarar la dependencia directamente en build.zig. A continuación, un ejemplo que añade la librería zig-lib como dependencia.

Ejemplo avanzado de build.zig con dependencia

// Importamos la biblioteca estándar
const std = @import("std");

// Función de construcción
pub fn build(b: *std.build.Builder) void {
    // Definimos opciones de destino estándar
    const target = b.standardTargetOptions(.{});
    // Seleccionamos modo de compilación
    const mode = b.standardReleaseOptions();

    // Creamos el ejecutable
    const exe = b.addExecutable("con_dep", "src/main.zig");
    exe.setTarget(target);
    exe.setBuildMode(mode);

    // Agregamos la dependencia "zig-lib" desde GitHub
    const lib = b.addExternalDependency(
        .{ .url = "https://github.com/ziglang/zig-lib/archive/refs/heads/main.zip" },
        .{ .name = "zig-lib", .build_name = "lib" }
    );

    // Enlazamos la librería al ejecutable
    exe.linkLibrary(lib);

    // Instalamos el artefacto
    b.installArtifact(exe);
}

Actualización de src/main.zig para usar la librería

// Importamos la librería estándar
const std = @import("std");

// Importamos la librería externa "zig-lib" bajo el alias "lib"
const lib = @import("zig-lib");

// Función principal
pub fn main() void {
    // Usamos una función de la librería externa (ejemplo ficticio)
    const resultado = lib.someFunction();

    // Imprimimos el resultado
    std.debug.print("Resultado de lib.someFunction(): {d}\n", .{resultado});
}

Resumen rápido

• build.zig es el motor que guía la compilación en Zig.
• Define objetivos, dependencias y opciones de compilación.
• Se ejecuta mediante zig build y su sintaxis está basada en la propia sintaxis de Zig.
• La modularidad de Zig permite que build.zig sea tan simple o tan complejo como lo requiera el proyecto.

Con esta base, puedes comenzar a explorar proyectos más grandes, integrar librerías externas y experimentar con