--- title: "Mach Engine — Game Engine de Alto Desempenho em Zig" url: "https://ziglang.com.br/ecossistema/mach-engine-game-engine-de-alto-desempenho-em-zig/" markdown_url: "https://ziglang.com.br/ecossistema/mach-engine-game-engine-de-alto-desempenho-em-zig.MD" description: "Conheça o Mach Engine: game engine escrita em Zig com suporte a Vulkan, DirectX 12 e Metal. Arquitetura, recursos e como começar." date: "2026-02-21" author: "Zig Brasil" --- # Mach Engine — Game Engine de Alto Desempenho em Zig Conheça o Mach Engine: game engine escrita em Zig com suporte a Vulkan, DirectX 12 e Metal. Arquitetura, recursos e como começar. # Mach Engine — Game Engine de Alto Desempenho em Zig O Mach Engine é uma das demonstrações mais impressionantes do potencial do Zig para desenvolvimento de software de alta performance. Trata-se de uma game engine completa e moderna, construída inteiramente em Zig, que se propõe a ser a próxima geração de ferramentas para desenvolvimento de jogos e aplicações gráficas. Com suporte nativo a Vulkan, DirectX 12 e Metal, o Mach combina a performance do Zig com uma arquitetura de engine inovadora. ## 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. O projeto foi iniciado por Felix "xq" Queißner e cresceu para se tornar 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: ```zig 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: ```zig 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: ```zig 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: ```zig 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: ```zig 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: ```wgsl @vertex fn vs_main(@builtin(vertex_index) in_vertex_index: u32) -> @builtin(position) vec4 { let x = f32(1 - i32(in_vertex_index)) * 0.5; let y = f32(i32(in_vertex_index & 1u) * 2 - 1) * 0.5; return vec4(x, y, 0.0, 1.0); } @fragment fn fs_main() -> @location(0) vec4 { return vec4(1.0, 0.0, 0.0, 1.0); } ``` ## Começando com o Mach ### Instalação ```bash # 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 ```zig .{ .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 | Característica | Mach | Raylib-Zig | SDL2-Zig | Godot | |---|---|---|---|---| | Linguagem | Zig puro | Binding C | Binding C | GDScript/C++ | | API Gráfica | WebGPU | OpenGL | OpenGL/Vulkan | Vulkan/OpenGL | | ECS integrado | Sim | Não | Não | Parcial | | Compilação cruzada | Nativa | Via Zig | Via Zig | Via build | | Tamanho binário | Pequeno | Pequeno | Médio | Grande | | Editor visual | Em desenvolvimento | Não | Não | Sim | ## 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](/cases/case-mach-engine-zig/) para detalhes sobre projetos reais construídos com ele. ## Próximos Passos Se o Mach despertou seu interesse, explore também as [bibliotecas gráficas](/ecossistema/zig-graphics-libs/) e [bibliotecas de áudio](/ecossistema/zig-audio-libs/) do ecossistema Zig. Para uma GUI não focada em jogos, confira o [Capy](/ecossistema/capy-gui/). E não deixe de conferir nossos [tutoriais](/tutoriais/) para exemplos práticos de projetos com Zig.