Mach Engine: Game Engine em Zig com Vulkan, DirectX 12 e Metal

O Mach Engine é uma game engine de código aberto escrita em Zig pela Hexops, com renderização baseada em WebGPU que roda sobre Vulkan, DirectX 12, Metal e WebGPU no navegador. Nesta página você encontra a arquitetura (Mach Core, ECS, módulos), exemplos de código, como instalar com zig build e um comparativo com Raylib-Zig, SDL2 e Godot.

Status do projeto: o Mach está em desenvolvimento ativo e ainda não chegou à versão 1.0 — APIs e módulos podem mudar entre releases. Ele é uma das melhores formas de estudar Zig aplicado a gráficos e jogos; para um projeto comercial com prazo, pondere também a maturidade das alternativas do comparativo abaixo.

Visão Geral do Mach

O Mach Engine não é apenas uma game engine — é um ecossistema de ferramentas gráficas projetado para aproveitar ao máximo as capacidades do Zig, mantido pela Hexops com o engenheiro Stephen Gutekanst (slimsag) como principal mantenedor. É um dos projetos mais populares do ecossistema Zig.

Princípios Fundamentais

• Performance previsível: Sem garbage collector, sem runtime surpresa
• Composabilidade: Arquitetura modular baseada em ECS (Entity Component System)
• Compilação cruzada: Compile para Windows, Linux, macOS e web (WASM) a partir de qualquer plataforma
• Zero overhead: Abstrações que compilam para código nativo otimizado
• Interoperabilidade C: Use qualquer biblioteca C de gamedev existente

Arquitetura do Engine

O Mach é organizado em camadas que podem ser usadas independentemente:

Mach Core

A camada mais baixa, que fornece uma abstração multiplataforma sobre as APIs gráficas nativas:

const mach = @import("mach");
const gpu = mach.gpu;

pub const App = @This();

pub fn init(app: *App) !void {
    // Inicialização da aplicação gráfica
    const device = try gpu.Device.create(.{
        .power_preference = .high_performance,
    });
    _ = device;
    _ = app;
}

pub fn update(app: *App) !bool {
    // Loop principal de atualização
    _ = app;
    return true; // continuar rodando
}

pub fn deinit(app: *App) void {
    // Limpeza de recursos
    _ = app;
}

pub fn main() !void {
    try mach.run(App);
}

Sistema de Renderização

O Mach abstrai as diferenças entre APIs gráficas com uma camada unificada baseada em WebGPU:

• Vulkan no Linux e Windows
• DirectX 12 no Windows
• Metal no macOS e iOS
• WebGPU no navegador (via WASM)

Essa abstração permite escrever código uma vez e renderizar em qualquer plataforma com performance nativa.

ECS (Entity Component System)

O Mach implementa um sistema de entidades e componentes otimizado para cache:

const World = mach.World;

// Definir componentes
const Position = struct { x: f32, y: f32, z: f32 };
const Velocity = struct { dx: f32, dy: f32, dz: f32 };
const Sprite = struct { texture_id: u32, width: u32, height: u32 };

// Criar entidade
var world = World.init(allocator);
const entity = try world.spawn(.{
    Position{ .x = 0, .y = 0, .z = 0 },
    Velocity{ .dx = 1, .dy = 0, .dz = 0 },
    Sprite{ .texture_id = 0, .width = 64, .height = 64 },
});
_ = entity;

// Iterar sobre entidades com Position e Velocity
var iter = world.query(struct { pos: *Position, vel: *const Velocity });
while (iter.next()) |item| {
    item.pos.x += item.vel.dx;
    item.pos.y += item.vel.dy;
    item.pos.z += item.vel.dz;
}

O ECS do Mach é projetado para ser cache-friendly, organizando dados em Arrays of Structs (AoS) que maximizam a localidade de cache durante iterações.

Módulos do Ecossistema Mach

O Mach inclui diversos módulos especializados:

mach-glfw

Binding Zig para GLFW, oferecendo gerenciamento de janelas e input:

const glfw = @import("mach-glfw");

const window = try glfw.Window.create(800, 600, "Meu Jogo", null, null, .{});
defer window.destroy();

while (!window.shouldClose()) {
    glfw.pollEvents();
    // Renderizar frame
    window.swapBuffers();
}

mach-freetype

Renderização de fontes de alta qualidade usando FreeType:

const freetype = @import("mach-freetype");

var library = try freetype.Library.init();
defer library.deinit();

var face = try library.createFace("fonts/roboto.ttf", 0);
try face.setPixelSizes(0, 48);

mach-sysaudio

API de áudio multiplataforma para jogos:

const sysaudio = @import("mach-sysaudio");

var audio = try sysaudio.Context.init(allocator);
defer audio.deinit();

var device = try audio.openDefaultDevice(.playback);
defer device.close();

Recursos Gráficos

Pipeline de Renderização

O Mach oferece um pipeline gráfico flexível:

• Render passes customizáveis
• Compute shaders para processamento paralelo na GPU
• Instanced rendering para objetos repetidos
• Shadow mapping para iluminação realista
• Post-processing com efeitos de tela cheia

Suporte a Shaders

O Mach usa shaders WGSL (WebGPU Shading Language) que são compilados para o formato nativo de cada plataforma:

@vertex
fn vs_main(@builtin(vertex_index) in_vertex_index: u32) -> @builtin(position) vec4<f32> {
    let x = f32(1 - i32(in_vertex_index)) * 0.5;
    let y = f32(i32(in_vertex_index & 1u) * 2 - 1) * 0.5;
    return vec4<f32>(x, y, 0.0, 1.0);
}

@fragment
fn fs_main() -> @location(0) vec4<f32> {
    return vec4<f32>(1.0, 0.0, 0.0, 1.0);
}

Começando com o Mach

Instalação

# Clonar o template de projeto
git clone https://github.com/hexops/mach-example
cd mach-example

# Compilar e executar
zig build run

Estrutura de Projeto

meu-jogo/
├── build.zig
├── build.zig.zon
├── src/
│   ├── main.zig
│   ├── game.zig
│   ├── renderer.zig
│   └── assets/
│       ├── shaders/
│       ├── textures/
│       └── models/
└── tests/

build.zig.zon

.{
    .name = "meu-jogo",
    .version = "0.1.0",
    .dependencies = .{
        .mach = .{
            .url = "https://github.com/hexops/mach/archive/refs/tags/v0.4.0.tar.gz",
            .hash = "1220...",
        },
    },
}

Performance

O Mach demonstra a performance excepcional do Zig em computação gráfica:

• Renderização de 100.000+ sprites a 60 FPS em hardware modesto
• Latência de input abaixo de 1ms graças à ausência de GC
• Tempo de compilação significativamente menor que engines C++ equivalentes
• Binários pequenos — um jogo simples pode ter menos de 5 MB

Comparação com Outras Engines

Comunidade e Recursos

O Mach possui uma comunidade ativa com:

• Discord dedicado para discussão e suporte
• Exemplos e demos no repositório oficial
• Blog técnico com artigos sobre arquitetura e decisões de design
• Contribuições bem documentadas e acolhedoras para novatos

Casos de Uso

O Mach é usado em diversos contextos:

• Jogos 2D e 3D independentes
• Visualização de dados em tempo real
• Ferramentas de design e editores gráficos
• Simulações científicas e de engenharia
• Aplicações de realidade aumentada e virtual

Confira o case de sucesso do Mach Engine para detalhes sobre projetos reais construídos com ele, e a análise da Hexops como startup em Zig para o contexto da empresa por trás da engine.

Perguntas frequentes

O que é o Mach Engine?

Uma game engine e um kit de ferramentas gráficas escritos em Zig, desenvolvidos pela Hexops. A camada de GPU é baseada em WebGPU e roda sobre Vulkan (Linux/Windows), DirectX 12 (Windows), Metal (macOS/iOS) e WebGPU no navegador via WASM — o mesmo código gráfico compila para todas as plataformas com a compilação cruzada nativa do Zig.

O Mach Engine está pronto para produção?

Ainda não há uma versão 1.0: APIs e módulos mudam entre releases e o editor visual segue em desenvolvimento. Para jogos comerciais com prazo, o comparativo acima ajuda a ponderar alternativas maduras. Para aprender Zig em gráficos, experimentar WebGPU e construir protótipos, o custo de entrada é baixo.

Como instalar o Mach Engine?

Clone o template oficial mach-example e execute zig build run — as dependências são resolvidas a partir do build.zig.zon. Em um projeto próprio, adicione o Mach como dependência no seu build.zig.zon (como no exemplo acima) e confirme a versão do Zig exigida pela release escolhida.

Mach ou Godot para jogos escritos em Zig?

Godot oferece editor visual, linguagem de scripts própria e anos de maturação, mas a lógica do jogo não é escrita em Zig. O Mach entrega o jogo inteiro em Zig puro — binários pequenos, sem runtime, renderização WebGPU e compilação cruzada — ao custo de uma engine mais jovem e sem editor concluído. Muitos desenvolvedores combinam as duas: protótipos em Godot, experimentos de performance em Mach.

Próximos Passos

1. Bibliotecas gráficas em Zig — OpenGL, Vulkan e renderização 2D/3D fora da engine
2. Capy — GUI multiplataforma em Zig para aplicações não focadas em jogos
3. Case do Mach Engine — como a Hexops constrói a engine na prática
4. Tutoriais de Zig — exemplos práticos do básico ao deploy