/zig-gamedev

Building game development ecosystem for @ziglang!

Primary LanguageCMIT LicenseMIT

Please note that the project requires latest Zig compiler (master/nightly). It can be downloaded here.

Libraries - Sample applications - Vision - Others using zig-gamedev - Monthly reports - Roadmap

zig-gamedev project

We build game development ecosystem for Zig programming language, every day since July 2021. Please consider supporting the project. We create:

To get started on Windows/Linux/macOS try out physically based rendering (wgpu) sample:

git clone https://github.com/michal-z/zig-gamedev.git
cd zig-gamedev
zig build physically_based_rendering_wgpu-run

Quick start (D3D12)

To use zig-gamedev in your project copy or download zig-gamedev as a submodule, for example:

git submodule add https://github.com/michal-z/zig-gamedev.git libs/zig-gamedev

Currently, we have minimal low-level API which allows you to build the lib once (package()) and link it with many executables (link()).

Include necessary libraries in build.zig like:

// Fetch the library
const zwin32 = @import("src/deps/zig-gamedev/libs/zwin32/build.zig");

// Build it
const zwin32_pkg = zwin32.package(b, target, optimize, .{});

// Link with your app
zwin32_pkg.link(exe, .{ .d3d12 = true });
Example build script: 
const std = @import("std");
const zwin32 = @import("libs/zig-gamedev/libs/zwin32/build.zig");
const common = @import("libs/zig-gamedev/libs/common/build.zig");
const zd3d12 = @import("libs/zig-gamedev/libs/zd3d12/build.zig");

pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(.{});

    const optimize = b.standardOptimizeOption(.{});

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

    b.installArtifact(exe);

    const run_cmd = b.addRunArtifact(exe);

    run_cmd.step.dependOn(b.getInstallStep());

    if (b.args) |args| {
        run_cmd.addArgs(args);
    }

    const zwin32_pkg = zwin32.package(b, target, optimize, .{});
    const zd3d12_pkg = zd3d12.package(b, target, optimize, .{
        .options = .{
            .enable_debug_layer = false,
            .enable_gbv = false,
            .enable_d2d = true,
        },
        .deps = .{ .zwin32 = zwin32_pkg.zwin32 },
    });
    const common_d2d_pkg = common.package(b, target, optimize, .{
        .deps = .{ .zwin32 = zwin32_pkg.zwin32, .zd3d12 = zd3d12_pkg.zd3d12 },
    });

    zwin32_pkg.link(exe, .{ .d3d12 = true });
    zd3d12_pkg.link(exe);
    common_d2d_pkg.link(exe);

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

Libraries

Library Latest version Description
zphysics 0.0.6 Zig API and C API for Jolt Physics
zflecs 0.0.1 Zig bindings for flecs ECS
zopengl 0.1.3 OpenGL loader (supports 4.0 Core Profile and ES 2.0 Profile)
zsdl 0.0.1 Bindings for SDL2 (wip)
zgpu 0.9.1 Small helper library built on top of native wgpu implementation (Dawn)
zgui 1.89.6 Easy to use dear imgui bindings (includes ImPlot)
zaudio 0.9.3 Fully-featured audio library built on top of miniaudio
zmath 0.9.6 SIMD math library for game developers
zstbi 0.9.3 Image reading, writing and resizing with stb libraries
zmesh 0.9.0 Loading, generating, processing and optimizing triangle meshes
ztracy 0.10.0 Support for CPU profiling with Tracy
zpool 0.9.0 Generic pool & handle implementation
zglfw 0.7.0 Minimalistic GLFW bindings with no translate-c dependency
znoise 0.1.0 Zig bindings for FastNoiseLite
zjobs 0.1.0 Generic job queue implementation
zbullet 0.2.0 Zig bindings and C API for Bullet physics library
zwin32 0.9.0 Zig bindings for Win32 API (d3d12, d3d11, xaudio2, directml, wasapi and more)
zd3d12 0.9.0 Helper library for DirectX 12
zxaudio2 0.9.0 Helper library for XAudio2
zpix 0.9.0 Support for GPU profiling with PIX for Windows

Vision

  • Very modular "toolbox of libraries", user can use only the components she needs
  • Works on Windows, macOS and Linux
  • Has zero dependency except Zig compiler (master) and git with Git LFS - no Visual Studio, Build Tools, Windows SDK, gcc, dev packages, system headers/libs, cmake, ninja, etc. is needed
  • Building is as easy as running zig build (see: Building)
  • Libraries are written from scratch in Zig or provide Ziggified bindings for carefully selected C/C++ libraries
  • Uses native wgpu implementation (Dawn) or OpenGL for cross-platform graphics and DirectX 12 for low-level graphics on Windows

Sample applications (native wgpu)

Some of the sample applications are listed below. More can be found in samples directory.

  1. physically based rendering (wgpu): This sample implements physically-based rendering (PBR) and image-based lighting (IBL) to achive realistic looking rendering results.
    zig build physically_based_rendering_wgpu-run

    physically based rendering (wgpu)

  2. audio experiments (wgpu): This sample lets the user experiment with audio and observe data that feeds the hardware.
    zig build audio_experiments_wgpu-run

    audio experiments (wgpu)

  3. bullet physics test (wgpu): This sample application demonstrates how to use full 3D physics engine in your Zig programs.
    zig build bullet_physics_test_wgpu-run

    bullet physics test (wgpu)

  4. procedural mesh (wgpu): This sample shows how to efficiently draw several procedurally generated meshes.
    zig build procedural_mesh_wgpu-run

    procedural mesh (wgpu)

  5. gui test (wgpu): This sample shows how to use our zgui library.
    zig build gui_test_wgpu-run

    gui test (wgpu)

Sample applications (DirectX 12)

Some of the sample applications are listed below. More can be found in samples directory. They can be built and run on Windows and Linux (Wine + VKD3D-Proton 2.8+):

  1. bindless: This sample implements physically based shading and image based lighting to achieve realistic looking rendering results. It uses bindless textures and HLSL 6.6 dynamic resources.
    zig build bindless-run

    bindless

  2. rasterization: This sample application shows how GPU rasterizes triangles in slow motion.
    zig build rasterization-run

    rasterization

  3. simple raytracer: This sample implements basic hybrid renderer. It uses rasterization to resolve primary rays and raytracing (DXR) for shadow rays.
    zig build simple_raytracer-run

    simple raytracer

  4. mesh shader test: This sample shows how to use DirectX 12 Mesh Shader.
    zig build mesh_shader_test-run

    mesh shader test

Others using zig-gamedev

  • Aftersun - Top-down 2D RPG
  • Pixi - Pixel art editor made with Zig
  • Simulations - GPU Accelerated agent-based modeling to visualize and simulate complex systems
  • elvengroin legacy - TBD
  • jok - A minimal 2D/3D game framework for Zig

Building sample applications

To build all sample applications (assuming zig is in the PATH and Git LFS is installed):

  1. git clone https://github.com/michal-z/zig-gamedev.git
  2. cd zig-gamedev
  3. zig build

Build artifacts will show up in zig-out/bin folder.

zig build <sample_name> will build sample application named <sample_name>.

zig build <sample_name>-run will build and run sample application named <sample_name>.

To list all available sample names run zig build --help and navigate to Steps section.

Build options

Options for optimizations:

  • -Doptimize=[Debug|ReleaseFast|ReleaseSafe|ReleaseSmall] - enable optimizations

Options for Windows applications:

  • -Dzd3d12-enable-debug-layer=[bool] - Direct3D 12, Direct2D, DXGI debug layers enabled
  • -Dzd3d12-enable-gbv=[bool] - Direct3D 12 GPU-Based Validation (GBV) enabled
  • -Dzpix-enable=[bool] - PIX markers and events enabled

GitHub Sponsors

Thanks to all people who sponsor zig-gamedev project! In particular, these fine folks sponsor zig-gamedev for $25/month or more: