---
title: "Inicio rápido — Docs de zenit Zig UI"
description: "Crea una app nativa de macOS que vive fuera del repo de zenit y se compila y ejecuta por sí sola."
url: https://zenit.z.express/es/docs/guide/getting-started
language: es
alternate_en: https://zenit.z.express/docs/guide/getting-started.md
alternate_zh: https://zenit.z.express/zh/docs/guide/getting-started.md
alternate_ja: https://zenit.z.express/ja/docs/guide/getting-started.md
alternate_ko: https://zenit.z.express/ko/docs/guide/getting-started.md
alternate_fr: https://zenit.z.express/fr/docs/guide/getting-started.md
alternate_de: https://zenit.z.express/de/docs/guide/getting-started.md
project: zenit v0.1.0-alpha (Zig 0.15.2, macOS)
source: https://github.com/version-next/zenit
---

# Inicio rápido

Crea una app nativa de macOS que vive fuera del repo de zenit y se compila y ejecuta por sí sola.

¿Desarrollas con Claude Code u otro agente? Instala primero la zenit UI dev Skill.

Empaqueta este manual, la tabla de decisión de componentes y las trampas de proyectos reales en instrucciones que tu agente carga cuando las necesita, para que el código que escribe siga las convenciones de zenit.

[Descargar la Skill.zip · 54 KB](https://zenit.z.express/downloads/zenit-ui-dev.zip)[Guía de instalación](https://zenit.z.express/es/docs/guide/ai-skill)

## Requisitos previos

Esta versión apunta a macOS, con Apple Silicon verificado de forma continua. Asegúrate de tener Zig 0.15.2 y las Xcode Command Line Tools; Bun solo hace falta para las pruebas end-to-end.

```sh
zig version
xcode-select -p
```

> WARNING
> 
> **Las versiones deben coincidir.** La plantilla declara `minimum_zig_version = "0.15.2"` en `build.zig.zon`; otras versiones pueden fallar de formas confusas en las APIs de build o en las huellas de paquete.

## Crear un proyecto

Parte de `templates/minimal-app` en el repo. Es un proyecto downstream completo:

`templates/minimal-app`

```
minimal-app/
├── README.md
├── build.zig          # zenit.attach() + run / app steps
├── build.zig.zon      # declares the zenit dependency
├── e2e/
│   └── record-demo.ts # drives and records the app through the Harness
└── src/
    └── main.zig       # counter-button app
```

1.  **Copia la plantilla**
    
    Copia templates/minimal-app a un directorio nuevo fuera del repo de zenit.
    
2.  **Ajusta la ruta de la dependencia**
    
    La plantilla usa por defecto `.path = "../../"`, que solo se resuelve dentro del repo. Tras copiarla, apúntala a tu checkout de zenit de forma relativa a build.zig.zon, o fija una revisión publicada con `zig fetch --save=zenit <url>`.
    
3.  **Genera una huella**
    
    No conserves el .fingerprint de la plantilla: dos proyectos que lo compartan chocan en la caché de paquetes de Zig. Borra la línea, ejecuta zig build una vez y pega el valor que indica el error. De paso, cambia .name = .myapp.
    

```sh
git clone https://github.com/version-next/zenit.git
cp -R zenit/templates/minimal-app ./myapp
cd myapp   # then set .zenit = .{ .path = "../zenit" } in build.zig.zon
zig build
```

## Conectar zenit

`build.zig.zon` declara la dependencia; `build.zig` obtiene la API de build propia de zenit mediante `@import("zenit")`.

`build.zig.zon`

```zig
.{
    .name = .myapp,
    .version = "0.1.0",
    .fingerprint = 0x8798022a7f8e220e, // replace: delete this line, run zig build once
    .minimum_zig_version = "0.15.2",

    .dependencies = .{
        // Relative to this file. Absolute paths are rejected by Zig 0.15.2.
        .zenit = .{ .path = "../zenit" },
    },

    .paths = .{
        "README.md",
        "build.zig",
        "build.zig.zon",
        "e2e",
        "src",
    },
}
```

Este es el build.zig de la plantilla tal cual. Es más que una llamada a attach: reenvía los flags de test, instala el cliente del Harness y define el paso run y el empaquetado .app:

`build.zig`

```zig
const std = @import("std");
const zenit = @import("zenit");

pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});
    const test_mode = b.option(bool, "test-mode", "Enable the Zenit automation harness") orelse false;
    const e2e_port = b.option(u16, "e2e-port", "Zenit Harness RPC directory suffix") orelse 19816;

    const zenit_dep = b.dependency("zenit", .{
        .target = target,
        .optimize = optimize,
        // Dependency build options are isolated in Zig. Forward these
        // explicitly so `zig build -Dtest-mode=true` reaches Zenit.
        .@"test-mode" = test_mode,
        .@"e2e-port" = e2e_port,
    });

    const exe = b.addExecutable(.{
        .name = "myapp",
        .root_module = b.createModule(.{
            .root_source_file = b.path("src/main.zig"),
            .target = target,
            .optimize = optimize,
        }),
    });

    zenit.attach(zenit_dep, exe);
    zenit.installHarnessClient(b, zenit_dep);

    b.installArtifact(exe);

    const run_cmd = b.addRunArtifact(exe);
    run_cmd.step.dependOn(b.getInstallStep());
    const run_step = b.step("run", "Run the app");
    run_step.dependOn(&run_cmd.step);

    // Optional: `zig build app` packages a double-clickable .app bundle.
    if (target.result.os.tag == .macos) {
        const bundled = zenit.bundleApp(b, .{
            .exe = exe,
            .display_name = "My App",
            .bundle_id = "com.example.myapp",
            .version = "0.1.0",
            .signing = .ad_hoc,
        });
        const app_step = b.step("app", "Build the .app bundle");
        app_step.dependOn(bundled.final_step);
    }
}
```

| Llamada | Qué hace |
| --- | --- |
| `zenit.attach(zenit_dep, exe)` | Añade los imports de módulo ui y zenit\_app, compila los cinco puentes ObjC de macOS y enlaza Cocoa, Metal, CoreText y los demás frameworks |
| `.@"test-mode" / .@"e2e-port"` | En Zig las opciones de dependencia están aisladas; reenvíalas explícitamente para que zig build -Dtest-mode=true llegue a zenit |
| `zenit.installHarnessClient(b, zenit_dep)` | Instala el cliente tipado del Harness en zig-out/share/zenit/harness/client.ts para e2e/record-demo.ts |
| `zenit.bundleApp(b, .{ ... })` | Genera un zig-out/<display\_name>.app que se abre con doble clic, aquí con firma ad-hoc |

## Monta tu primer árbol de UI

`App.runWith` crea el Scope raíz, llama una vez a tu función de montaje y toma el control del bucle de eventos. La función de montaje debe tener la firma `fn (cx: *ui.Cx, scope: *ui.Scope) anyerror!*ui.Node`; tu app solo devuelve el nodo raíz.

`src/main.zig`

```zig
const std = @import("std");
const ui = @import("ui");
const App = @import("zenit_app").App;

const Counter = struct {
    n: u32 = 0,
    label: ?*ui.Node = null,
    buf: [32]u8 = undefined,

    pub fn increment(self: *Counter) void {
        self.n += 1;
        const node = self.label orelse return;
        const content = std.fmt.bufPrint(&self.buf, "Clicked {d} times", .{self.n}) catch return;
        if (node.getText()) |old| {
            var t = old;
            t.content = content;
            node.setText(t);
        }
        node.markRenderDirty();
    }
};

fn mountUi(cx: *ui.Cx, scope: *ui.Scope) anyerror!*ui.Node {
    const allocator = cx.allocator;

    const counter = try cx.bindState(Counter, .{});
    const click = cx.on(Counter, counter, Counter.increment);

    const root = try ui.box(cx, .{
        .width = .fill(),
        .height = .fill(),
        .direction = .column,
        .gap = 16,
        .padding = ui.Padding.all(40),
        .background = cx.tokens.color.bg_primary,
        .align_items = .center,
        .justify = .center,
    }, .{});

    try root.appendChild(allocator, try ui.text(cx, "Hello, zenit!", .{
        .font_size = 24,
        .font_weight = 600,
        .color = cx.tokens.color.fg_primary,
    }));

    const button = try ui.widgets.Button(.{
        .label = "Click me",
        .variant = .primary,
        .on_click = click,
    }).mount(scope, cx);
    button.meta.ownership.meta.test_id = "counter.increment";
    try root.appendChild(allocator, button);

    const label = try ui.text(cx, "Clicked 0 times", .{
        .font_size = 14,
        .color = cx.tokens.color.fg_secondary,
    });
    try root.appendChild(allocator, label);
    counter.label = label;

    return root;
}

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();

    const app = try App.init(gpa.allocator(), .{
        .window = .{ .width = 640, .height = 480, .title = "Hello, zenit" },
    });
    defer app.deinit();

    try app.runWith(mountUi);
}
```

`cx.bindState` entrega `Counter` al Cx, y `cx.on` convierte uno de sus métodos en el callback del botón; `test_id` permite que los scripts E2E encuentren el botón por su significado.

> NOTE
> 
> **La plantilla actualiza el texto a mano para ser mínima.** El búfer vive dentro de `Counter` en una dirección estable, así que prestarlo a `setText` es seguro. Las apps reales suelen guardar la cuenta en un Signal y dejar que `ui.textFmt` actualice la etiqueta; consulta [Reactividad](https://zenit.z.express/es/docs/guide/reactivity).

## Compilar y ejecutar

```sh
zig build run   # build and run the unbundled executable
zig build app   # package zig-out/My App.app (macOS)
```

[Video](https://zenit.z.express/media/hello-button.mp4?v=b4d2b8f8a0)

La Hello Button.app real lanzada desde la salida del build (examples/hello\_button, el mismo botón contador que la plantilla): el harness hace clic tres veces con el cursor de mano y la etiqueta muestra “Clicked 3 times”. Ventana, widget y respuesta vienen de la API pública de arriba.

La plantilla también incluye un script de grabación: compila con `zig build -Dtest-mode=true`, arranca la app y ejecuta `e2e/record-demo.ts` para obtener un clip similar; consulta [E2E harness](https://zenit.z.express/es/docs/advanced/e2e).

> TIP
> 
> **Siguiente.** Cuando aparezca la ventana, lee a continuación Estructura del proyecto y el árbol de UI. No te apresures a crear tu propia capa de componentes: zenit ya incluye widgets, temas y primitivas reactivas.