¿Qué es un zig build system script?

¿Qué es un zig build system script?

Zig se distingue por su enfoque minimalista y su propio sistema de construcción integrado, llamado Build System. Este sistema permite compilar proyectos, manejar dependencias, ejecutar pruebas y generar artefactos de manera sencilla y eficiente.

¿Qué es un Build Script en Zig?

Un build script es simplemente un archivo escrito en Zig que describe cómo debe construirse tu proyecto. Este archivo se llama típicamente build.zig y es ejecutado por el comando zig build. En él defines targets, lib, executable y otras configuraciones.

Estructura básica de un build.zig

El script suele comenzar importando el paquete std.build, que contiene todas las utilidades de construcción:

// build.zig
const std = @import("std");

pub fn build(b: *std.Build) void {
    // El cuerpo del build script va aquí
}
  • std : módulo estándar de Zig que incluye la funcionalidad de construcción.
  • b : puntero a la estructura std.Build que almacena el estado y configuraciones de la compilación.

Ejemplo 1: Compilar un ejecutable simple

A continuación se muestra un script que compila un programa que imprime “Hola, mundo”. Cada línea está comentada con detalle para que los principiantes comprendan el propósito de cada llamada.

// build.zig
// 1. Importamos el paquete estándar de Zig
const std = @import("std");

// 2. Exportamos la función build, que será llamada por zig build
pub fn build(b: *std.Build) void {
    // 3. Definimos la configuración del proyecto
    //    - .name: nombre del proyecto (se usará en el artefacto)
    //    - .target: plataforma objetivo, aquí dejamos que Zig elija la actual
    //    - .version: versión de la compilación
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});

    // 4. Creamos el ejecutable
    //    - addExecutable crea un target de tipo binario
    const exe = b.addExecutable("hello_world", "src/main.zig");
    exe.setTarget(target);
    exe.setBuildMode(optimize);

    // 5. Configuramos el output: se colocará en ./zig-out/bin
    exe.install();

    // 6. Añadimos el comando 'run' para ejecutar el binario directamente
    const run_cmd = exe.run();
    // 7. Si queremos que zig build --summary all muestre el tiempo de compilación
    run_cmd.step.dependOn(&b.step("install", "Install the binary"));
}

Este script realiza lo siguiente:

  • Define un objetivo de compilación estándar.
  • Agrega un ejecutable llamado hello_world cuyo código fuente está en src/main.zig.
  • Configura los modos de optimización y destino.
  • Instala el binario en el directorio de salida.
  • Permite ejecutar el binario con zig build run.

Ejemplo 2: Dependencia externa y librería

Supongamos que tu proyecto necesita usar una librería externa, como libcbor, y además quieres compilar una biblioteca compartida. El siguiente build.zig ilustra cómo hacerlo.

// build.zig
const std = @import("std");

pub fn build(b: *std.Build) void {
    // 1. Definimos opciones estándar de destino y optimización
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});

    // 2. Añadimos la dependencia de la librería externa
    //    - addExternalLibraryImport descarga y compila la dependencia
    const cbor = b.addExternalLibrary("cbor", .{
        .source_files = &[_][]const u8{ "deps/cbor/src/cbor.c" },
        .header_files = &[_][]const u8{ "deps/cbor/include/cbor.h" },
    });

    // 3. Creamos una biblioteca que utiliza la dependencia
    const lib = b.addSharedLibrary("my_lib", "src/lib.zig", .{
        .target = target,
        .optimize = optimize,
    });
    lib.addIncludePath("deps/cbor/include");  // Path al header
    lib.linkLibrary(cbor);  // Enlazar la dependencia

    // 4. Instalar la librería
    lib.install();

    // 5. Creamos un ejecutable que utiliza la librería
    const exe = b.addExecutable("app", "src/main.zig");
    exe.setTarget(target);
    exe.setBuildMode(optimize);
    exe.linkLibrary(lib);  // Enlazar nuestra librería

    // 6. Instalar el ejecutable
    exe.install();

    // 7. Agregamos pasos opcionales
    const run_cmd = exe.run();
    run_cmd.step.dependOn(&b.step("install", "Install app"));
}

En este script se realiza:

  • Descarga y compilación de una dependencia C (cbor).
  • Creación de una biblioteca compartida my_lib que incluye y enlaza la dependencia.
  • Compilación de un ejecutable app que usa la biblioteca.
  • Instalación de los artefactos en zig-out/bin y zig-out/lib.

Ventajas de usar el Build System de Zig

  • Sin herramientas externas: No necesitas CMake, Make o Ninja; Zig gestiona todo.
  • Tipado y seguridad: El build script está escrito en Zig, lo que garantiza tipado estático y detección temprana de errores.
  • Velocidad: Compilación incremental rápida gracias a la integración con el compilador Zig.
  • Portabilidad: Los scripts son multiplataforma; Zig decide el target adecuado.

Comandos útiles

  • zig build – Compila usando build.zig.
  • zig build run – Compila y ejecuta el binario por defecto.
  • zig build test – Ejecuta las pruebas definidas en el script.
  • zig build install – Copia los binarios y librerías en zig-out/bin y zig-out/lib.

Conclusión

El build system de Zig, aunque simple en apariencia, es una herramienta poderosa que combina la potencia del lenguaje con la conveniencia de un sistema de construcción nativo. Al aprender a escribir scripts build.zig, los desarrolladores obtienen un control total sobre la compilación, dependen menos de herramientas externas y pueden mantener sus proyectos más limpios y seguros.

Comments

No comments yet. Why don’t you start the discussion?

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *