Home / Rust / Graphics

Vulkano is a Rust wrapper around the Vulkan graphics API.

Vulkano See also vulkano.rs. Vulkano is a Rust wrapper around the Vulkan graphics API. It follows the Rust philosophy, which is that as long as you do
Information
Category: Rust / Graphics
Watchers: 62
Star: 4.1k
Fork: 420
Last update: Dec 4, 2023
Resource links
https://github.com/vulkano-rs/vulkano

Vulkano

Crates.io Docs Build Status Gitter chat

See also vulkano.rs.

Vulkano is a Rust wrapper around the Vulkan graphics API. It follows the Rust philosophy, which is that as long as you don't use unsafe code you shouldn't be able to trigger any undefined behavior. In the case of Vulkan, this means that non-unsafe code should always conform to valid API usage.

What does vulkano do?

  • Provides a low-levelish API around Vulkan. It doesn't hide what it does, but provides some comfort types.
  • Plans to prevent all invalid API usages, even the most obscure ones. The purpose of vulkano is not to simply let you draw a teapot, but to cover all possible usages of Vulkan and detect all the possible problems in order to write robust programs. Invalid API usage is prevented thanks to both compile-time checks and runtime checks.
  • Can handle synchronization on the GPU side for you (unless you choose do that yourself), as this aspect of Vulkan is both annoying to handle and error-prone. Dependencies between submissions are automatically detected, and semaphores are managed automatically. The behavior of the library can be customized thanks to unsafe trait implementations.
  • Tries to be convenient to use. Nobody is going to use a library that requires you to browse the documentation for hours for every single operation.

Note that in general vulkano does not require you to install the official Vulkan SDK. This is not something specific to vulkano (you don't need the SDK to write programs that use Vulkan, even without vulkano), but many people are unaware of that and install the SDK thinking that it is required. However, macOS and iOS platforms do require a little more Vulkan setup since it is not natively supported. See below for more details.

Development status

Vulkano is still in heavy development and doesn't yet meet its goals of being very robust. However the general structure of the library is most likely definitive, and all future breaking changes will likely be straight-forward to fix in user code.

Documentation

To get started you are encouraged to use the following resources:

  • The guide on vulkano.rs - Starts with trivial compute examples (~50 lines of code) then works up to rendering triangles and mandelbrots.
  • The vulkano-examples repository - Includes examples in the repo and also a list of projects that use vulkano.
  • docs.rs - Full Vulkano API documentation

Setup

Vulkano uses shaderc-rs for shader compilation. Refer to shaderc-rs documentation to provide a pre-built libshaderc for faster build times.

Unless you provide libshaderc, in order to build libshaderc with the shaderc-sys crate, the following tools must be installed and available on PATH:

  • CMake
  • Ninja Is optional except when building with MSVC. It may speed up build time for libshaderc.
  • Python (works with both Python 2.x and 3.x, on windows the executable must be named python.exe)

These requirements can be either installed with your favourite package manager or with installers from the projects' websites. Below are some example ways to get setup.

windows-msvc Specific Setup

  1. rustup default stable-x86_64-pc-windows-msvc
  2. Install Build Tools for Visual Studio 2017. If you have already been using this toolchain then its probably already installed.
  3. Install msys2, following ALL of the instructions.
  4. Then in the msys2 terminal run: pacman --noconfirm -Syu mingw-w64-x86_64-cmake mingw-w64-x86_64-python2 mingw-w64-x86_64-ninja
  5. Add the msys2 mingw64 binary path to the PATH environment variable.

Windows-gnu Specific Setup

windows-gnu toolchain is not supported but you can instead cross-compile to windows-gnu from windows-msvc

Steps 1 and 2 are to workaround https://github.com/rust-lang/rust/issues/49078 by using the same mingw that rust uses.

  1. Download and extract https://s3-us-west-1.amazonaws.com/rust-lang-ci2/rust-ci-mirror/x86_64-6.3.0-release-posix-seh-rt_v5-rev2.7z
  2. Add the absolute path to mingw64\bin to your PATH environment variable. (This path needs to be before the msys2 path)
  3. Run the command: rustup default stable-x86_64-pc-windows-msvc
  4. Run the command: rustup target install x86_64-pc-windows-gnu
  5. Install Build Tools for Visual Studio 2017. If you have already been using this toolchain then its probably already installed.
  6. Install msys2, following ALL of the instructions.
  7. Then in the msys2 terminal run: pacman --noconfirm -Syu mingw64/mingw-w64-x86_64-pkg-config mingw-w64-x86_64-gcc mingw-w64-x86_64-cmake mingw-w64-x86_64-make mingw-w64-x86_64-python2 mingw-w64-x86_64-ninja
  8. Add the msys2 mingw64 binary path to the PATH environment variable.
  9. Any cargo command that builds the project needs to include --target x86_64-pc-windows-gnu e.g. to run: cargo run --target x86_64-pc-windows-gnu

Linux Specific Setup

Use your package manager to install the required dev-tools and vulkan drivers

For example on ubuntu:

sudo apt-get install build-essential git python cmake libvulkan-dev vulkan-utils

macOS and iOS Specific Setup

Vulkan is not natively supported by macOS and iOS. However, there exists MoltenVK a Vulkan implementation on top of Apple's Metal API. This allows vulkano to build and run on macOS and iOS platforms.

The easiest way to get vulkano up and running on macOS is to install the Vulkan SDK for macOS. To install the SDK so that Vulkano will find it and dynamically link with libvulkan.dylib:

  1. Download the latest macOS release and unpack it somewhere, for the next step we'll assume that's ~/vulkan_sdk.
  2. Modify your environment to contain the SDK bin directory in PATH and the SDK lib directory in DYLD_LIBRARY_PATH. We also need to set VK_ICD_FILENAMES and VK_LAYER_PATH. When using the Bash shell, which is the default for macOS, it's easiest to do this by appending the following to the ~/.bash_profile file and then restarting the terminal.
export VULKAN_SDK=$HOME/vulkan_sdk/macOS
export PATH=$VULKAN_SDK/bin:$PATH
export DYLD_LIBRARY_PATH=$VULKAN_SDK/lib:$DYLD_LIBRARY_PATH
export VK_ICD_FILENAMES=$VULKAN_SDK/etc/vulkan/icd.d/MoltenVK_icd.json
export VK_LAYER_PATH=$VULKAN_SDK/etc/vulkan/explicit_layer.d

It is also possible to link with the MoltenVK framework (as vulkano did in previous versions) by adding the appropriate cargo output lines to your build script and implementing your own vulkano::instance::loader::Loader that calls the MoltenVK vkGetInstanceProcAddr implementation.

On iOS vulkano links directly to the MoltenVK framework. There is nothing else to do besides installing it. Note that the Vulkan SDK for macOS also comes with the iOS framework.

Note that as of writing, MoltenVK has some bugs that show up in the examples. Some minor modifications may be required as workarounds: see https://github.com/vulkano-rs/vulkano/pull/1027. The examples also do not work properly on macOS 10.11 and lower without workarounds due to MoltenVK's Metal backend not getting the required features until macOS 10.12. See https://github.com/vulkano-rs/vulkano/issues/1075 for workarounds.

Donate

Austin Johnson (Active maintainer) Become a patron

Rukai (Current maintainer) Become a patron

Tomaka (Original developer) Become a patron

Contributing

Contributions are welcome! Feel free to submit pull requests.

Pull requests that fix bugs or improve documentation are likely to be quickly reviewed, while pull requests that add features or change the API may be more controversial and take more time.

If your change adds, removes or modifies a trait or a function, please add an entry to the CHANGELOG.md file as part of your pull request.

Structure

This repository contains four libraries:

  • vulkano is the main one.
  • vulkano-shaders Provides the shader! macro for compiling glsl shaders.
  • vulkano-win provides a safe link between vulkano and the winit library which can create a window to render to.
  • vk-sys contains raw bindings for Vulkan. You can use it even if you don't care about vulkano.

In order to run tests, run cargo test --all at the root of the repository. Make sure your Vulkan driver is up to date before doing so.

License

Licensed under either of

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you shall be dual licensed as above, without any additional terms or conditions.

89 Open More issues
Closed

Support for MoltenVK

cc #300

Remains to do:

  • [ ] Expose the ActivateMoltenVKLicenseMVK function somewhere in vulkano.
  • [x] Tweak winit to allow exporting the NSView or UIView of the window. For MacOS this is done by adding an additional function here: https://github.com/tomaka/winit/blob/41e1a768e575667a0dfff6bc9c8f56c30d662122/src/os/macos.rs#L9
  • [x] Update vulkano-win to create surfaces on MacOS and iOS.
  • ~~Check that it's a correct thing to do to dlopen the MoltenVK library.~~

After steps 2 and 3, it should "just work" if you put the MoltenVK file next to the executable. Step 1 is optional for now because the free trial doesn't require activating a license.

I'm not sure that I'll finish this PR soon, so feel free to submit PRs to the moltenvk branch if you want to work on it. It should be fairly easy to do steps 2 and 3 (feel free to ask questions).

I'm also unsure about whether we'll want to merge this branch until MoltenVK is stable enough. I don't really want to have obsolete code in vk-sys because they decided to modify their extensions.

opened Oct 5, 2016 by tomaka 66
Closed

About OomError

Most functions in Vulkan can return VK_ERROR_OUT_OF_HOST_MEMORY and VK_ERROR_OUT_OF_DEVICE_MEMORY. In fact most functions can only return one of these two errors.

This is reflected in vulkano by the fact that a lot of functions can return OomError.

However in practice it is very unlikely that an out-of-memory error actually happens, with the exception of vkAllocateMemory.

The API would be much more convenient to use if an out of memory error returned by Vulkan resulted in a panic instead of returning an error, like it's the case for the core Rust. Again, with the exception of DeviceMemory which would still return OomError.

opened Apr 3, 2016 by tomaka 37
Closed

The triangle example crashes with UnsupportedDimensions on MacOS 10.12 + MoltenVK

I'm using a 2017 MacBook Pro with Intel Iris Graphics 550 1536 MB and a 2560 x 1600 display.

The example builds successfully, and when I run it, it starts fine, printing some messages, including: [mvk-info] You require a license for the MoltenVK Vulkan Core feature set. Reverting to evaluation mode

After that, it panics when creating a new Swapchain. The error is UnsupportedDimensions. Debug-printing the dimensions passed to the new method, the dimensions turn out to be [2048, 1536]. The device capabilities are

Capabilities {
	min_image_count: 2,
	max_image_count: Some(2),
	current_extent: Some([1024, 768]),
	min_image_extent: [1024, 768],
	max_image_extent: [1024, 768],
	max_image_array_layers: 1, 
	supported_transforms: SupportedSurfaceTransforms {
		identity: true, 
		rotate90: false, 
		rotate180: false, 
		rotate270: false, 
		horizontal_mirror: false, 
		horizontal_mirror_rotate90: false, 
		horizontal_mirror_rotate180: false, 
		horizontal_mirror_rotate270: false, 
		inherit: false
	}, 
	current_transform: Identity, 
	supported_composite_alpha: SupportedCompositeAlpha {
		opaque: true, 
		pre_multiplied: true, 
		post_multiplied: true, 
		inherit: false
	}, 
	supported_usage_flags: ImageUsage {
		transfer_source: true, 
		transfer_destination: true, 
		sampled: true, 
		storage: true, 
		color_attachment: true, 
		depth_stencil_attachment: false, 
		transient_attachment: false, 
		input_attachment: false
	}, 
	supported_formats: [
		(B8G8R8A8Unorm, SrgbNonLinear),
		(B8G8R8A8Srgb, SrgbNonLinear),
		(R16G16B16A16Sfloat, SrgbNonLinear)
	], 
	present_modes: SupportedPresentModes {
		immediate: false, 
		mailbox: false, 
		fifo: true, 
		relaxed: false
	}
}

So it seems that it fails because of the max/min image extent checks.

I'm not knowledgeable enough to determine which of these values are wrong, but if I understand the meaning of max/min_image_extent capabilities right, it seems odd to me that the device supports only that. What should I do to fix this or to diagnose the problem further?

type: bug 
opened Aug 13, 2017 by golddranks 29
Closed

How to run the examples

I would like to test the examples but I am running into some problems.

On Linux with a NVIDA 1060 I get this error:

➜  vulkano-examples git:(master) cargo run --bin triangle
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running `target/debug/triangle`
thread 'main' panicked at 'failed to create Vulkan instance: LoadingError(LibraryLoadFailure("libvulkan.so.1: cannot open shared object file: No such file or directory"))', /checkout/src/libcore/result.rs:860:4
note: Run with `RUST_BACKTRACE=1` for a backtrace.

Do I need to install something from Vulkan?

On MacOS I get this error:

  = note: ld: framework not found MoltenVK
          clang: error: linker command failed with exit code 1 (use -v to see invocation)


error: aborting due to previous error

error: Could not compile `vulkano-examples`.

Do I need to install anything on macOS to make it work?

Thank you very much for any help.

opened Sep 29, 2017 by adrianbrink 23
Closed

Mac install

  • [x] Added an entry to CHANGELOG.md if knowledge of this change could be valuable to users
  • [x] Updated documentation to reflect any user-facing changes - in this repository

This PR automatically downloads and installs the latest Vulkan SDK from lunarg. It will only do this if VULKAN_SDK is not set. The sdk will be installed at $HOME/.vulkan_sdk and the following environment variables will be set in the users .profile or .bash_profile

export VULKAN_SDK=$HOME/.vulkan_sdk/macOS
export PATH=$VULKAN_SDK/bin:$PATH
export DYLD_LIBRARY_PATH=$VULKAN_SDK/lib:$DYLD_LIBRARY_PATH
export VK_ICD_FILENAMES=$VULKAN_SDK/etc/vulkan/icd.d/MoltenVK_icd.json
export VK_LAYER_PATH=$VULKAN_SDK/etc/vulkan/explicit_layer.d

The only thing that isn't automated is the user will get a error about failing to link the vulkan libs. This is because the changes to their profile are not automatically refreshed. They will need to either source ~/.profile or source ~/.bash_profile or reopen their terminal after the first time they build vulkano.

If anyone knows how to automate this that would be super useful. So far I have tried to pass the env var settings along from the build script to the lib using cargo:rustc_env but that only works if you are directly using Vulkano and not if it's a dependency.

One thing we could do is assume that if the env vars are not set when Vulkano is run then they must just be set to the defaults and but the user has not sourced their profile. Then just std::env::set_var to set them temporarily.

opened Dec 27, 2018 by freesig 21
Closed

Radv leading to panicked main thread in triangle example

Running the triangle example code gives me:

WARNING: radv is not a conformant vulkan implementation, testing use only. Using device: AMD RADV POLARIS10 (type: DiscreteGpu) thread 'main' panicked at 'calledResult::unwrap()on anErrvalue: Timeout', /buildslave/rust-buildbot/slave/stable-dist-rustc-linux/build/src/libcore/result.rs:837 note: Run withRUST_BACKTRACE=1for a backtrace.

I am not sure whether this is a RADV bug or one I could fix. Any ideas here? Will you test with Mesa/Radv as well?

opened Feb 14, 2017 by ghost 19
Open

How would I implement the blas operation `SSCAL` (multiply vector by scalar)?

This is just a question of me learning and asking for help with this.

Seeing the example compute code given in the tutorial it multiplies every value in a given array by 12 (as written into the glsl):

mod cs {
    vulkano_shaders::shader!{
        ty: "compute",
        src: "
        #version 450

        layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in;

        layout(set = 0, binding = 0) buffer Data {
            uint data[];
        } buf;

        void main() {
            uint idx = gl_GlobalInvocationID.x;
            buf.data[idx] *= 12;
        }"
    }
}

How can I modify this and the rest of the example code to multiply every value in an array by a given value (replacing 12 with some x)?

(Apologies about this question being bit dumb, I can't seem to find any good examples).

Current project simply implementing compute tutorial code: vulkano-test.zip

type: question 
opened Jun 15, 2020 by JonathanWoollett-Light 0
Open

Getting pointer to vk_sys::Instance?

Once I have an Instance, how do I get the underlying pointer/vk_sys object?

I'm trying to use vulkano with glfw, which has a wrapper for glfwCreateWindowSurface that uses vk_sys::Instance. My plan was to call that, and then use Surface::from_raw_surface.

The glfw example would have me create the instance myself, but that seems a bit of a waste.

type: question 
opened Jun 14, 2020 by colinmarc 1
Open

SyncCommandBufferBuilderError(Conflict) On Successive Calls to AutoCommandBuffeBuilder::blit_image

  • Versions of Vulkano: 0.19.0 and 0.18.0
  • OS: Linux (Kernel version: 5.6.15-1-MANJARO)
  • GPU (the selected PhysicalDevice): AMD Radeon RX580
  • GPU Driver: VGA compatible controller: Advanced Micro Devices, Inc. [AMD/ATI] Ellesmere [Radeon RX 470/480/570/570X/580/580X/590] (rev e7) (prog-if 00 [VGA controller])

Repository demonstrating the issue: https://github.com/Neightro/vulkan-tutorial-test Branch master uses Vulkano 0.11.1 and works as expected. Branch 'version_0-19-0' uses the latest version and panics on a BlitImageError.

Issue

When adding image blitting commands to a command buffer, successive calls to AutoCommandBufferBuilder::blit_image return a SyncCommandBufferBuilderError(Conflict)). The tutorial I was following warns that this code "results in Validation Layer warnings and may not behave the same on all machines." In the time since the tutorial has been released, has a more reliable way of performing this type of blitting been introduced?

Stacktrace

thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: SyncCommandBufferBuilderError(Conflict { command1_name: "vkCmdBlitImage", command1_param: "source", command1_offset: 1, command2_name: "vkCmdBlitImage", command2_param: "destination", command2_offset: 1 })', src/main.rs:667:13
stack backtrace:
   0: backtrace::backtrace::libunwind::trace
             at /cargo/registry/src/github.com-1ecc6299db9ec823/backtrace-0.3.44/src/backtrace/libunwind.rs:86
   1: backtrace::backtrace::trace_unsynchronized
             at /cargo/registry/src/github.com-1ecc6299db9ec823/backtrace-0.3.44/src/backtrace/mod.rs:66
   2: std::sys_common::backtrace::_print_fmt
             at src/libstd/sys_common/backtrace.rs:78
   3: <std::sys_common::backtrace::_print::DisplayBacktrace as core::fmt::Display>::fmt
             at src/libstd/sys_common/backtrace.rs:59
   4: core::fmt::write
             at src/libcore/fmt/mod.rs:1063
   5: std::io::Write::write_fmt
             at src/libstd/io/mod.rs:1426
   6: std::sys_common::backtrace::_print
             at src/libstd/sys_common/backtrace.rs:62
   7: std::sys_common::backtrace::print
             at src/libstd/sys_common/backtrace.rs:49
   8: std::panicking::default_hook::{{closure}}
             at src/libstd/panicking.rs:204
   9: std::panicking::default_hook
             at src/libstd/panicking.rs:224
  10: std::panicking::rust_panic_with_hook
             at src/libstd/panicking.rs:470
  11: rust_begin_unwind
             at src/libstd/panicking.rs:378
  12: core::panicking::panic_fmt
             at src/libcore/panicking.rs:85
  13: core::option::expect_none_failed
             at src/libcore/option.rs:1211
  14: core::result::Result<T,E>::unwrap
             at /rustc/8d69840ab92ea7f4d323420088dd8c9775f180cd/src/libcore/result.rs:1003
  15: vulkan_tutorial::Renderer::create_texture_image
             at src/main.rs:667
  16: vulkan_tutorial::Renderer::initialize
             at src/main.rs:282
  17: vulkan_tutorial::HelloTriangleApplication::initialize
             at src/main.rs:1057
  18: vulkan_tutorial::main
             at src/main.rs:1069
  19: std::rt::lang_start::{{closure}}
             at /rustc/8d69840ab92ea7f4d323420088dd8c9775f180cd/src/libstd/rt.rs:67
  20: std::rt::lang_start_internal::{{closure}}
             at src/libstd/rt.rs:52
  21: std::panicking::try::do_call
             at src/libstd/panicking.rs:303
  22: __rust_maybe_catch_panic
             at src/libpanic_unwind/lib.rs:86
  23: std::panicking::try
             at src/libstd/panicking.rs:281
  24: std::panic::catch_unwind
             at src/libstd/panic.rs:394
  25: std::rt::lang_start_internal
             at src/libstd/rt.rs:51
  26: std::rt::lang_start
             at /rustc/8d69840ab92ea7f4d323420088dd8c9775f180cd/src/libstd/rt.rs:67
  27: main
  28: __libc_start_main
  29: _start
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
status: needs investigation 
opened Jun 13, 2020 by Neightro 0
Open

macOS: BufferUsage::all() breaks examples

Running the triangle example on a fresh install of macOS with the vulkan SDK, I get a blue screen but no triangles:

Screenshot 2020-06-09 at 23 24 26

My laptop is a 2020 macbook air, still with the new computer smell, and an integrated GPU.

I'm more than happy to debug myself, given some direction! I'm not really sure where to start.

status: unknown-cause 
opened Jun 9, 2020 by colinmarc 8
Open

Black screen when blitting onto swapchain image 0

This is quite a weird issue, so I hope I explain it well enough.

I want to set up my rendering to draw to an offscreen image, and then blit this image onto the swapchain image. To do this, I set up a series of command buffers right after creating the swapchain and attachment images, one for each swapchain image, generated with the following code:

let blit_command_buffers = images.iter()
	.map(|target_image| {
		let mut builder = AutoCommandBufferBuilder::primary(
			device.clone(),
			graphics_queue.family(),
		)?;
		builder.blit_image(
			colour_attachment.clone(),
			[0, 0, 0],
			[width as i32, height as i32, depth as i32],
			0,
			0,
			target_image.clone(),
			[0, 0, 0],
			[width as i32, height as i32, depth as i32],
			0,
			0,
			1,
			vulkano::sampler::Filter::Nearest,
		)?;
		Ok(Arc::new(builder.build()?))
	})
	.collect::<anyhow::Result<Vec<_>>()?;

In my draw loop, I build and execute a draw command buffer (draw_commands), and acquire a swapchain image. The futures are then submitted:

let draw_future = draw_commands.execute(graphics_queue.clone())?;
let (image_num, suboptimal, swapchain_future) = acquire_next_image(swapchain.clone(), None)?;
draw_future
	.join(swapchain_future)
	.then_execute(
		graphics_queue.clone(),
		blit_command_buffers[image_num].clone(),
	)?
	.then_swapchain_present(
		graphics_queue.clone(),
		swapchain().clone(),
		image_num,
	)
	.then_signal_fence_and_flush()?
	.wait(None)?;

All submissions happen on the same queue, so I don't think semaphores would be needed. The command buffer that blits the framebuffer onto the swapchain image is executed after both the drawing and the swapchain acquire.

When doing it this way, I get flickering every few frames. I've determined that whenever swapchain image 0 is acquired, the presented frame is black. The other swapchain images are rendered properly. The odd part is that if I regenerate blit_command_buffers using the first code, immediately before the second code, there is no flickering, all frames are normal. There is no flickering either if I regenerate the command buffers after the present code if image_num == 0 only. The flickering only happens if the original command buffers are used, which are generated once on swapchain (re)creation. So I'm wondering if it has to do with the original state of the swapchain images before any rendering is done. In any case, it's a real mystery to me.

status: unknown-cause 
opened Jun 3, 2020 by Rua 18
Open

A bind-based alternative API for AutoCommandBufferBuilder?

Another ergonomics gripe I've been running into recently. Whenever you issue a draw call, you have to give the entire draw state, and this means that wherever draw calls are being issued, you have to have all this state on hand, and have to pass it around everywhere. Even if the state never actually changes. This seems slightly odd when you know that AutoCommandBufferBuilder actually remembers the previous state, and only binds what differs in each call. It only needs all that state for comparison purposes, not for binding.

I think it would be more ergonomic if the API of draw calls were changed, so that state is bound before the call, and the draw call uses the currently-bound state, like it is in SyncCommandBufferBuilder and raw Vulkan. It would still check the current state before drawing (check_descriptor_sets_validity and friends). StateCacher would be run when bind calls are made, and the bind would be skipped if already bound. So you'd still get all of the benefits.

I can see about making a PR for this, but I wanted to get feedback first. Especially as this is yet another breaking change.

opened Jun 1, 2020 by Rua 2

Contents

    rukai vulkano_text - Render text with the DejaVu font using the Vulkano library
    GPUOpen-LibrariesAndSDKs V-EZ is designed to be a C based light-weight layer around Vulkan
    nihui waifu2x converter ncnn version, runs fast on intel / amd / nvidia GPU with vulkan
    google SwiftShader is a high-performance CPU-based implementation of the Vulkan graphics API. Its goal is to provide hardware independence for advanced 3D graphics.
    hexops mach-glfw Vulkan example
    EQMG A high speed C++17 Vulkan game engine
    viniciusfbb Skia4Delphi is a cross-platform 2D graphics API for Delphi platforms based on Google's Skia Graphics Library. It provides a comprehensive 2D API that can be used across mobile, server and desktop models to render images.
    sebbbi Rust & Vulkan test projects
    gfx-rs Rust Graphics meetups
    jgbit VUDA is a header-only library based on Vulkan that provides a CUDA Runtime API interface for writing GPU-accelerated applications.
    LWJGL LWJGL is a Java library that enables cross-platform access to popular native APIs useful in the development of graphics (OpenGL, Vulkan), audio (OpenAL), parallel computing (OpenCL, CUDA) and XR (OpenVR, LibOVR) applications.
    felixc rexiv2 - This library provides a Rust wrapper around the gexiv2 library, which is a GObject-based wrapper around the Exiv2 library, which provides read and write access to the Exif, XMP, and IPTC metadata in media files (typically photos) in various formats
    tensorflow TensorFlow Graphics: Differentiable Graphics Layers for TensorFlow
    gwihlidal vk-sync - Simplification of core Vulkan synchronization mechanisms such as pipeline barriers and events
    austinj235 nightly basalt - A window/ui framework built upon vulkan
    gabdube A 3D rendering demo powered by Python and Vulkan
    David-DiGioia Diagrams showing relationships between Vulkan objects and how they're used.
    grz0zrg Lightweight C 2D graphics API agnostic library with parallelism support
    fynnfluegge OpenGL/Vulkan Java 3D Engine
    gabdube Standalone python program that draws a triangle using vulkan on Windows and Linux
    nvpro-pipeline Experimental High Level Framework for Vulkan
    Share this repo

    Related Repos


    Graphics
    7
    A lidera japanese tokenizer wrapper for javascript and typescript
    higumachan lindera-js A lidera japanese tokenizer wrapper for javascript and typescript Usage npm i lindera-js import * as lindera from "lindera-js"; console.lo
     
    Graphics
    4
    Rust-idiomatic, compliant, flexible and performant BIP21 crate
    Kixunil Rust implementation of BIP21 Rust-idiomatic, compliant, flexible and performant BIP21 crate. About Important: while lot of work went into polishing th
     
    Graphics
    48
    Rust Graphics meetups
    gfx-rs The Rust Graphics Meetup The Rust Graphics Meetup is a place where formal talks can be given about the state of graphics work in the Rust Language. To
     
    Graphics
    20
    A rust wrapper for the spam protection API
    cyberknight777 SpamProtection-rs Table of contents About Supported Rust version Features How to use Credits License About SpamProtection-rs is a Rust wrapper for Int
     
    Graphics
    28
    IC Drip are randomly generated meta-commerce shopping carts for outfits and personas store...
    dscvr-one IC DRIP An Internet Computer version of Loot Project Projects IC Drip IC Drip are randomly generated meta-commerce shopping carts for outfits and pers
     
    Graphics
    28
    2D Predictive-Corrective Smoothed Particle Hydrodynamics (SPH) implementation in Rust with...
    cerrno 2D Predictive-Corrective Smoothed Particle Hydrodynamics (SPH) implementation in Rust with WASM + WebGL
     
    Graphics
    56
    Real-time Ray Tracing with nannou & rust-gpu
    mitchmindtree A real-time implementation of "Ray Tracing in One Weekend" using nannou and rust-gpu.
     
    Graphics
    13
    A safe Rust FFI binding for the NVIDIA® Tools Extension SDK (NVTX).
    simbleau NVIDIA® Tools Extension SDK (NVTX) is a C-based Application Programming Interface (API) for annotating events, code ranges, and resources in your applications.
     
    Graphics
    19
    Rusty Armor Builds - Monster Hunter Rise Armor Set Creation Tool
    itytophile RAB Rusty Armor Builds - Monster Hunter Rise Armor Set Creation Tool Armor files used by RAB here: https://github.com/itytophile/monster-hunter-rise-a
     
    Graphics
    155
    Font introspection, complex text shaping and glyph rendering.
    dfrg swash Swash is a pure Rust, cross-platform crate that provides font introspection, complex text shaping and glyph rendering. Goals This crate aims to
     
    Graphics
    37
    Artsy pixel image to vector graphics converter
    matze inkdrop is an artsy bitmap to vector converter.
     
    Graphics
    185
    A tool to generate inbetweens for animated sprites, written in godot-rust
    Bauxitedev Bitmapflow is a tool to help you generate inbetweens for animated sprites. In other words, it makes your animations smoother. It uses optical flow to
     
    Graphics
    8
    Rust utilities for working with block devices
    cholcombe973 block-utils Rust utilities for working with block devices. Basic support has been added to detect if block devices are ssd or rotational. Also has sup
     
    Graphics
    167
    Rust & Vulkan test projects
    sebbbi Rust & Vulkan test projects Contains test projects for Rust & Vulkan The first test project renders 1 million cubes, each containing a 950 MB (uncompr
     
    Graphics
    31
    nightly vxdraw - Simple 2D rendering library
    omen-of-aecio VxDraw - Simple 2D rendering for Rust Introduction vxdraw is a rendering library for drawing sprites, text, and streaming textures to a window. It is