Zignite: Cross-Platform Graphics Engine

Overview

Zignite is a modern graphics engine built with the Zig programming language, designed for cross-platform development with native performance and WebAssembly compatibility. This project leverages Zig's memory safety and performance characteristics to create a robust foundation for interactive applications, games, and visualization tools.

The engine supports two deployment targets:

• Native Applications using Dawn Native (currently tested on macOS)
• Web Applications using WebGPU via Emscripten/WebAssembly

Getting Started

Installation

Use fetch:

zig fetch --save https://github.com/Thomvanoorschot/zignite/archive/main.tar.gz

Or add Zignite to your build.zig.zon:

.dependencies = .{
    .zignite = .{
        .url = "https://github.com/thomvanoorschot/zignite/archive/main.tar.gz",
        .hash = "...", // Update with actual hash
    },
},

Add to your project

const std = @import("std");
const Build = std.Build;
const zignite_pkg = @import("zignite");

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

    const zignite_dep = b.dependency("zignite", .{
        .target = target,
        .optimize = optimize,
        .with_imgui = true,
        .with_implot = false,
        .use_glfw = true,
        .use_webgpu = true,
        .use_filesystem = false,
    });

    const zignite_lib = zignite_dep.artifact("zignite");

    const example_names = .{
        "simple_imgui",
        "simple_implot",
        "simple_webworker",
        "simple_webworker_websocket",
    };

    inline for (example_names) |example_name| {
        const example_mod = b.addModule(example_name, .{
            .target = target,
            .optimize = optimize,
            .root_source_file = b.path(example_name ++ ".zig"),
        });

        // Handle both native and web targets
        if (target.query.os_tag == .emscripten) {
            // Web/WASM build
            const example = b.addStaticLibrary(.{
                .name = example_name,
                .root_module = example_mod,
            });

            example.linkLibrary(zignite_lib);
            example.linkLibC();
            example.root_module.addImport("zignite", zignite_dep.module("zignite"));

            _ = zignite_pkg.emRunStep(b, .{
                .name = example_name,
                .zignite_dep = zignite_dep,
                .lib_main = example,
            });
        } else {
            // Native build
            const example = b.addExecutable(.{
                .name = example_name,
                .root_module = example_mod,
            });
            example.root_module.addImport("zignite", zignite_dep.module("zignite"));
            b.installArtifact(example);

            const run = b.addRunArtifact(example);
            b.step(example_name, "Run " ++ example_name).dependOn(&run.step);
        }
    }
}

Goals

• Build a lightweight, high-performance graphics engine using modern APIs
• Explore Zig's compile-time features and manual memory management capabilities
• Create seamless cross-platform deployment (native + WebAssembly)
• Integrate immediate-mode GUI capabilities with Dear ImGui and Dear ImPlot
• Enable concurrent processing with Web Workers and WebSocket communication
• Provide a clean, type-safe API for graphics programming \

Architecture

Zignite is built around modern graphics APIs and cross-platform libraries:

Core Graphics

• WebGPU Backend – Cross-platform graphics API for native and web targets
• Dawn Native – Google's native WebGPU implementation for desktop applications
• GLFW Integration – Window management, input handling, and context creation \

UI & Visualization

• Dear ImGui – Immediate-mode GUI system for developer tools and interfaces
• Dear ImPlot – Advanced plotting library for data visualization and analysis \

Web Features

• Web Workers – Non-blocking concurrent processing with shared memory support
• WebSocket Integration – Real-time communication through web workers
• Emscripten Support – WebAssembly compilation for browser deployment \

Engine Core

• Engine Core – Unified rendering loop and resource management
• Cross-Platform Abstraction – Single codebase for native and web deployment

Features

Cross-Platform Rendering

• Native desktop applications using Dawn Native (macOS tested, Windows/Linux support planned)
• Web applications using WebGPU via Emscripten/WebAssembly
• Unified API for both deployment targets

Web-Specific Features

• Web Worker support for non-blocking background processing
• WebSocket communication through web workers with shared memory
• WebAssembly compilation for browser deployment

Running Examples

The project includes several examples demonstrating engine capabilities for both native and web platforms.

Prerequisites

For Native Development (macOS)

• GLFW library (for now install via Homebrew: brew install glfw)

Native Examples

To build and run examples as native applications:

# Build and run the simple ImGui example natively
zig build simple_imgui

# Build and run the simple ImPlot example natively
zig build simple_implot

# Build and run the web worker example natively
zig build simple_webworker

# Build and run the WebSocket web worker example natively
zig build simple_webworker_websocket

Web/WASM Examples

To build and run examples in the browser using WebAssembly:

# Run the simple ImGui example in browser
zig build simple_imgui -Dtarget=wasm64-emscripten

# Run the simple ImPlot example in browser
zig build simple_implot -Dtarget=wasm64-emscripten

# Run the web worker example in browser
zig build simple_webworker -Dtarget=wasm64-emscripten

# Run the WebSocket web worker example in browser
zig build simple_webworker_websocket -Dtarget=wasm64-emscripten

# The examples will automatically open in Chrome browser

Available Examples

• simple_imgui - Basic ImGui integration with rendering loop

• simple_implot - Basic ImPlot integration with rendering loop

• simple_webworker - Web Worker integration with shared memory for concurrent processing

• simple_webworker_websocket - WebSocket communication through web workers for real-time data

Platform Support

Learning Outcomes

This project provides hands-on experience with:
• Zig's comptime features and build system
• Manual memory management with custom allocators
• Cross-platform graphics programming with WebGPU
• Native graphics development with Dawn Native
• C interoperability and binding generation with ImGui/ImPlot
• Web Worker implementation and shared memory management
• WebSocket communication in concurrent environments
• WebAssembly deployment strategies
• Modern graphics pipeline architecture
• Cross-platform build system design

Project Status

🚧 Active Development – Core engine functionality is implemented with WebGPU + ImGui + ImPlot integration. Native desktop deployment via Dawn Native is working on macOS, with WebAssembly deployment supported via Emscripten. Windows and Linux native support are planned for future releases.