Vulkano: four Rust crates over Vulkan, and where they stop
Safe and rich Rust wrapper around the Vulkan API
At a glance
- What is it?
- Vulkano wraps the Vulkan graphics API in Rust types that reject invalid usage and manage GPU synchronization for you. Its four crates are published together and all sit on 0.35, its written guide is behind its own API, and the newest tag is about twenty-one months old.
- Who is it for?
- Take Vulkano when the target really is Vulkan, the code is Rust, and you would rather have the compiler reject invalid usage than debug a validation layer at runtime. Leave it when you need Metal, DirectX, WebGPU, or a browser target from one code path, or when you cannot absorb API breaks on a schedule you do not control.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 18 days ago.
- What is it written in?
- Mainly Rust, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 21, 2026, and from our analysis. They are not legal advice.
Star history
- vulkano-rs/vulkano5,193 ★ · +40
| Repository | 2026-09-23 | 2026-11-21 |
|---|---|---|
| vulkano-rs/vulkano | 5.2k | 5.2k |
40 Stars in the last 59 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Four shipped crates, one macros crate the layout leaves out
The root Cargo.toml makes this a single workspace with seven members: autogen, `examples/*`, vulkano, vulkano-macros, vulkano-shaders, vulkano-taskgraph, and vulkano-util, resolved with `resolver = "2"`. Four libraries get described: vulkano is the main one, vulkano-shaders provides the `shader!` macro for compiling glsl shaders, vulkano-taskgraph builds a dependency graph of tasks that are synchronized automatically and then executed on the Vulkan device, and vulkano-util carries utility functions for common operations such as device and swapchain creation. The fifth crate, vulkano-macros, is a workspace member and sits in the top level tree, yet it never appears in that list, so the layout you read about is one crate short of the layout you build. Everything shares one workspace package block: edition 2021, rust-version 1.88.0, license MIT OR Apache-2.0, keywords vulkan, bindings, graphics, gpu, rendering, and the category `rendering::graphics-api`.
The safety guarantee thins out exactly where customization starts
Vulkano states its philosophy plainly: as long as you do not use unsafe code you should not be able to trigger undefined behavior, which for Vulkan means non-unsafe code should always conform to valid API usage. The stated goal is to prevent all invalid API usages, even the most obscure ones, through both compile-time checks and runtime checks, and the project says the purpose is not simply to let you draw a teapot but to cover all possible usages and detect the possible problems. It stays close to the metal on purpose: it does not hide what it does, it adds comfort types around it. GPU side synchronization is handled for you unless you choose to do that yourself, with dependencies between submissions detected automatically and semaphores managed automatically. That last sentence is the trap for a reader who expects the guarantee to hold everywhere. Customizing the behavior means implementing unsafe traits, so every line written that way sits outside the property the wrapper exists to provide.
No install command exists, so the manifest pins four versions at once
Each crate has its own page on crates.io and its own documentation on docs.rs, and the workspace wires them together by hand:
[workspace.dependencies.vulkano]
version = "0.35"
path = "vulkano"
[workspace.dependencies.vulkano-shaders]
version = "0.35"
path = "vulkano-shaders"
[workspace.dependencies.vulkano-taskgraph]
version = "0.35"
path = "vulkano-taskgraph"
[workspace.dependencies.vulkano-util]
version = "0.35"
path = "vulkano-util"Two details in that block matter before a first build. The vulkano entry carries `default-features = false`, so the workspace builds the core crate with its default features switched off. And all four sit on 0.35 together, which means vulkano-shaders, vulkano-taskgraph, and vulkano-util travel with the core crate instead of moving one at a time. A toolchain requirement comes along with them: rust-version 1.88.0 on edition 2021.
The examples folder is the lesson plan, and the written guide admits it lags
The examples folder is the learning path, and it is wide: async-update, basic-compute-shader, bloom, clear-attachments, debug, deferred, dynamic-buffers, dynamic-local-size, gl-interop, image, image-self-copy-blit, immutable-sampler, indirect, instancing, interactive-fractal, mesh-shader, msaa-renderpass, multi-window, multi-window-game-of-life, multiview, occlusion-query, offscreen, pipeline-caching, and push-constants. The guide on vulkano.rs starts with trivial compute examples of about 50 lines of code and works up to rendering triangles and mandelbrot, which lines up with the example names sitting in the tree. The catch is stated in the same place: the guide is currently outdated a little, an update is only planned for the future, and the Gitter chat is not maintained regularly at this moment, so questions belong on GitHub Issues, which maintainers watch regularly. Running the suite has its own requirement:
cargo test --allRun it at the root of the repository, and make sure your Vulkan driver is up to date before doing so.
Bindings are generated, and one dependency is pinned to a commit, not a version
The binding layer is generated rather than written by hand. The `autogen/` directory is a workspace member of its own, and the dependency block carries the maintenance rule in a comment: when Ash is updated, vk.xml must be moved to the same Vulkan patch version that Ash uses, then `cargo run --bin autogen` regenerates the files. Ash is pinned at 0.38.0 here, the vk.xml snapshots come from the Vulkan-Headers registry in the KhronosGroup organization, and the parser and formatter versions next to it are pinned as well: vk-parse 0.15, nom 7.1, heck 0.4, syn 2.0, prettyplease 0.2.32, slabbin 1.2. Other pins reach your build instead of the maintainers' one:
ash = "0.38.0"
bytemuck = "1.9"
concurrent-slotmap = { git = "https://github.com/vulkano-rs/concurrent-slotmap", rev = "6c328e2857f8461c177046414962ee6c7784f61c" }
half = "2.0"
libloading = "0.8"
raw-window-handle = "0.6"
raw-window-metal = "1.0"
vk-parse = "0.15"
winit = "0.30"
x11-dl = "2.0"
x11rb = "0.13"concurrent-slotmap is not a version number at all: it is a git reference frozen at one revision of a repository under the vulkano-rs organization, so the build fetches that commit instead of resolving a semver range. Windowing arrives through winit 0.30 with raw-window-handle 0.6, raw-window-metal 1.0, x11-dl 2.0, and x11rb 0.13 behind it, and `glam = 0.29` plus `png` are marked as only used in examples.
Vulkan is the only backend, and no row of the comparison is stable
The comparison table is where the first hard limit shows up: Vulkano is Vulkan and nothing else. Wgpu carries Vulkan, Metal, DirectX, and WebGPU behind one API and follows the WebGPU specification with an async/await interface, Miniquad stays minimalistic and includes a browser target, and Glium wraps OpenGL only. A project that needs a Metal or WebGPU path cannot get it from this crate.
| Name | Open-sourced Since | API Level | Notable Features | | ---- | ------------------ | --------- | ------------- | | Vulkano | March, 2016 | High-level Rust API wrapping Vulkan APIs. | Type-safe compile-time shaders. Transparent interoperability with glsl and spir-v shader code types in Rust code. Automatically generated types for shader's Layout. | | [Wgpu](https://github.com/gfx-rs/wgpu) | May, 2019 | High-level Rust API with multiple backends. | Supports multiple backends: Vulkan, Metal, DirectX, WebGPU, and other. Follows WebGPU specification. With async/await API. | | [Miniquad](https://github.com/not-fl3/miniquad) | March, 2020 | High-level minimalistic Rust API with multiple backends. | Relatively minimalistic API well suited for small to medium graphics projects. Supports multiple backends, including browser target. | | [Sierra](https://github.com/zakarumych/sierra) | March, 2021 | High-level Rust API for Vulkan/Metal APIs. | Layouts, Descriptors and shader Types construction in Rust code through the macro system. Built on top of [Erupt](https://gitlab.com/Friz64/erupt). Supports Ray Tracing Pipeline. | | [Glium](https://github.com/glium/glium) | October, 2014 | High-level Rust API wrapping OpenGL | OpenGL only. | | [Ash](https://github.com/MaikKlein/ash) | August, 2016 | Low-level API for Vulkan. | Unsafe Vulkan API bindings. | | [Erupt](https://gitlab.com/Friz64/erupt) | April, 2020 | Low-level API for Vulkan. | Unsafe Vulkan API bindings. |
At the other end of the table, Ash and Erupt hand you unsafe low-level bindings, so vulkano against ash is a decision between letting a library write the safety checks and writing them yourself. Then the same page undercuts every row: none of the known projects in the ecosystem, Vulkano included, has reached stable release versions and final design goals, their APIs change in a breakable way, and unfinished features are possible. The expectation offered is that breaking changes stay straightforward to fix in user code, with the choice depending on the end project's goals.
A one to three month cadence the tag dates do not show
The project states that minor releases usually happen between 1 to 3 months on average, depending on the growth of unreleased and breaking changes sitting on master. The tag dates tell a different story: v0.33.0 on 2023-04-03, v0.34.0 on 2023-10-25, v0.35.0 on 2025-02-07. The stretch between 0.34 and 0.35 ran about sixteen months, and roughly twenty-one months have passed since 0.35.0 while the last push landed on 2026-10-27. A manifest pinned to 0.35 therefore gives you February 2025 code, not the code in the tree you are reading now, and the project warns that API changes break. Two process notes matter if you plan around that gap. Changelog entries are requested in the pull request description rather than in the changelog file, and they get transferred into the changelog right after the merge, so the file at the root is a record rather than a submission target. And every pull request must pass tests before it merges to master, which means a red test in the suite holds the queue rather than slipping through.
Editorial conclusion
Take Vulkano when the target really is Vulkan, the code is Rust, and you would rather have the compiler reject invalid usage than debug a validation layer at runtime. Leave it when you need Metal, DirectX, WebGPU, or a browser target from one code path, or when you cannot absorb API breaks on a schedule you do not control. Before committing, compare the examples folder against the version you plan to pin, and read CHANGELOG.md between 0.35 and master.
Frequently asked questions
Who developed Vulkano?
Pierre Krieger, also known as Tomaka, developed the project initially and established its base design goals and code structure. Development is now driven by community members, with Lucas Kent and Austin Johnson named as maintainers and Rua named as an active developer.
vulkano vs ash
Vulkano is a high-level Rust API wrapping Vulkan with type-safe compile-time shaders and automatically generated types for a shader's layout. Ash is a low-level Vulkan API exposing unsafe bindings. Vulkano has been open sourced since March 2016, Ash since August 2016.
vulkano vs wgpu
Wgpu is a high-level Rust API with multiple backends including Vulkan, Metal, DirectX, and WebGPU, it follows the WebGPU specification, and it exposes an async/await API. Vulkano wraps Vulkan only, and its four crates are published together at version 0.35.
Is Vulkan for Nvidia or AMD, and does Vulkano care which vendor you have?
The README does not break the API out per GPU vendor, so it gives no answer to that half of the question. What it does say is that Vulkano wraps Vulkan, the graphics API from Khronos, and that Ash and Erupt expose the unsafe low-level bindings for the same API.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/vulkano-rs-vulkano)Star history chart for your README
[](https://hysenlabs.com/projects/vulkano-rs-vulkano)Was this useful?