Graphics and engines
Rotex
A Rust-based RHI for graphics APIs, built around a HAL to reduce boilerplate and target multiple platforms with zero-cost abstractions.
Overview
Rotex is a Rust-based rendering hardware interface (RHI) for graphics APIs, built around a hardware abstraction layer (HAL). The goal is to reduce boilerplate and let one codebase target multiple platforms, with zero-cost abstractions that avoid adding overhead or sacrificing speed.

Why I started
I hated the idea that using a game engine felt like one of the only ways to build cross-platform applications, simulations, or games. That can mean taking on overhead from polymorphic code, runtime dependencies, or entity systems that aren't easy to remove.
So I wanted to create an ecosystem that removes repetitive work while giving me full control. Rust and data-oriented programming are the foundation for that: an RHI that lets me prototype compute and graphics solutions without committing to fixed engine overhead.
Approach and decisions
The main decision is to keep the graphics interface separate from the systems an application builds around it. I want to share the code that describes graphics work across backends without making the application adopt a particular entity system or runtime.
The HAL gives the backends a shared vocabulary for resources, descriptors, and commands. Each backend implements that interface for its graphics API. In the core repository, those definitions live in rotex-types, while rotex-core provides the backend and platform interfaces and a thin graphics context.
Other pieces have separate jobs: conformance checks test the capabilities a backend reports, the graph crate turns declared pass usage into barriers, and optional emulation rewrites command lists before execution.
The tradeoff is that a shared interface doesn't make the differences between graphics APIs disappear. I still want those capabilities and limits to be visible. Reducing repetitive code should leave me in control of what runs and what it costs.
Current status
As of 13 November 2026, Rotex is in beta, before 1.0. APIs, behavior, and crate boundaries can still change, and it isn't ready to depend on for production work.
The core repository contains the shared types, backend interfaces, conformance checks, graph support, and optional emulation. The Vulkan, wgpu, OpenGL, and Direct3D 12 backends live in separate repositories.
Zero-cost abstraction is the design goal. It still needs to be checked against the actual implementation and workload; it isn't a blanket claim that every backend or feature has identical performance.
Example workflow
A workflow I want to support is prototyping a compute-driven simulation and then drawing its output. I want to describe the resources and commands through the RHI, use the backend that fits the target platform, and keep control of how the simulation itself is organized.
Moving that experiment to another platform should reuse the shared parts of the code. Where the backends differ, I want to make those choices explicitly instead of hiding them behind assumptions.
This is the kind of workflow Rotex is meant to support, rather than a finished demo or benchmark.
Next steps
I want to keep testing the design against the reason I started: less repetitive graphics code, control over the application, and no fixed engine overhead just to get an experiment running.
That means using concrete compute and graphics examples to find where the abstraction helps and where it gets in the way. Portability and performance need to hold up in those examples, with backend limitations made clear.