Level up your shader game with the GPU + Rust advantage!


Gravy (WIP)

Ya know, my momma always said everything's better with Gravy...

Gravy is a shader programming framework and toolkit built on the union of GPU programming and the Rust Programming Language. Gravy brings amazing features to shader development, such as custom data structures, node-based pipelining, and even package manager support. With Gravy, you can implement existing techniques with a simple package install, and construct novel techniques with the latest programming tools, all while effortlessly building and testing your render pipeline. This is the future of the shaderdev.

What is Gravy?

Gravy sits in a niche with the likes of Shadertoy and Unity's ShaderGraph but stands apart in some key ways:

  • Gravy is an framework and a toolkit. You can build applications with Gravy in flexible ways. Whether using the Gravy IDE as a development framework (like a game engine), or using gravylib directly as a toolkit (like e.g. raylib), the creative possibilities are endless.
  • Gravy is a development environment. Like Shadertoy, Gravy gives you the power to build amazing and beautiful shader programs, without having to worry about asset loading, windowing, i/o, graphics APIs, etc. You can focus on building your masterpiece, and leave the dirty work to us.
  • Gravy is a node graph. Like ShaderGraph, gravylib allows you to build your shader program quickly and intuitively with a simple node-oriented API. Once the API is stable, gravylib will be used to build an IDE-like experience for Gravy, with a visual node editor for easily building managing your render graph.
  • Gravy is Rusty. Featuring a core built on Embark's rust-gpu, gravylib lets you leverage the power of the modern and powerful Rust Programming Language. With Gravy, you can make more complex and beautiful shaders than ever possible before, with the most developer friendly programming experience of our age.1

For the nerds:

More technically, gravylib is an attempt to build a modern programming framework and development toolkit to enable GPU-first development. It builds on rust-gpu as a backend to compile Rust syntax into SPIR-V bytecode, and then makes use of wgpu and winit to run the program on the GPU with cross-platform support. Gravy is usable as a standalone Rust library crate (gravylib), but the goal is to build an IDE-like experience on top of gravylib to make GPU-first development simple and accessible for all developers.

Why Gravy?

Perhaps the most compelling feature of Gravy is shader crates. Using Rust's official package manager and public user repository, you can build your own Rust packages (called crates) with Gravy's shader framework, and publish them for anyone to use. Gone are the days of copy-pasting code from another dev's blog just to implement a standard technique. With package manager support, you can use the latest tools and techniques in your own piplene just by adding the package to your project. When you start using shader crates, shader development quickly becomes more powerful and more dev-friendly at the same time.

Still, Rust has more to give to shader devs; it's also the most developer friendly language of our age, rated highest in developer satisfaction for the last 8 years!1 For an industry plagued by confusing errors and complex code bases, this is a much needed improvement. It also lowers the barrier to entry for learning shader development, by using a language people already know and love, instead of requiring developers to learn an entirely new language.

But it doesn't end there. Gravy empowers the devs of today to create the digital masterpieces of tomorrow, with powerful features like node-based render graphs, platform-agnostic APIs, and more. This is the future of shader dev.

Where do I start?

If you would like to try it out, head over to the official example repo for a tutorial of sorts. However, this project is still a Work In Progress: The structure and API are in a highly fluid state and are constantly being reworked. Keep this in mind before starting any big projects with gravylib.

To learn more about the project, you can join the Discord.

How can I help?

As stated above, the structure is constantly changing, so Pull Requests are discouraged until the initial alpha release.

That being said, if you think you could help with any of the unfinished tasks below, please reach out to me on Discord. I'd love to work with you!

Alpha release checklist (v0.1.0)


  • Eliminate custom constants system; use gravylib_helpers::Constants instead
  • Implement helpers as a module expansion of gravylib
  • Use lib.rs as the common module instead of common.rs
  • Use macros to reduce boilerplate
  • Upgrade wgpu version
  • Upgrade winit version
  • Isolate examples (they live here now)
  • Implement hot reloading
  • Basic image buffer support
  • More examples from shadertoy
  • Make a custom example or two to showcase rust features in shaders
  • Add an example library shader crate to showcase dependency powers
  • Add linter (clippy?)
  • Add automated tests
  • Testing & refactoring
  • Cleanup codebase
  • Final quality check
  • Add documentation
  • Prepare for contributors
  • Shiny new README (with images!)
  • Branding? Logo? Website? mdBook?
  • Release on crates.io


  1. According to the Annual Stack Overflow Developer Survey, Rust has been voted as most loved/most admired language by developers every year since 2015. 2

You might also like...
A graph library for Rust.

Gamma A graph library for Rust. Gamma provides primitives and traversals for working with graphs. It is based on ideas presented in A Minimal Graph AP

Simple but powerful graph library for Rust

Graphlib Graphlib is a simple and powerful Rust graph library. This library attempts to provide a generic api for building, mutating and iterating ove

Kiss3d - Keep it simple, stupid 3d graphics engine for Rust.

Kiss3d - Keep it simple, stupid 3d graphics engine for Rust.

A cool, fast maze generator and solver written in Rust
A cool, fast maze generator and solver written in Rust

MazeCruncher Welcome to maze cruncher! Download Standalone Here Usage To get started, just run the standalone .exe in target/release or compile and ru

ASCII 3D-renderer using Ray Marching technique written in Rust with NCurses
ASCII 3D-renderer using Ray Marching technique written in Rust with NCurses

pistol ASCII renderer using Ray Marching technique written in Rust 🦀 with NCurses. This project is a giga-chad compared to my previous attempt to wri

A high-performance SVG renderer, powered by Rust based resvg and napi-rs.
A high-performance SVG renderer, powered by Rust based resvg and napi-rs.

resvg-js resvg-js is a high-performance SVG renderer, powered by Rust based resvg and napi-rs. Fast, safe and zero dependencies! No need for node-gyp

A little cross-platform graphics engine written in rust.

Bismuth This is a version of my C++ graphics engine named Bismuth re-written with Rust. My goal is to learn more about the Rust language and make my g

The library provides basic functions to work with Graphviz dot lang from rust code.

Description The library provides the basic access to the graphs in graphviz format with ability to import into or export from it. Base examples: Parse

🦀 Rust Graph Routing runtime for Apollo Federation 🚀

Apollo Router The Apollo Router is a configurable, high-performance graph router for a federated graph. Getting started Follow the quickstart tutorial

Dr. Rubisco
Hey, Doc here! I'm a game dev with deep roots in C(++) and experience with Java, C#, NodeJS, and Rust. I love spending time in nature and making cool shaders :)
Dr. Rubisco
svgcleaner could help you to clean up your SVG files from the unnecessary data.

svgcleaner svgcleaner helps you clean up your SVG files, keeping them free from unnecessary data. Table of Contents Purpose Goals Alternatives Charts

Evgeniy Reizner 1.5k Jan 9, 2023
picom-xrdesktop-companion is a program that runs alongside picom, that mirrors your desktop windows to the VR/XR space.

picom-xrdesktop-companion picom-xrdesktop-companion What is this How to use Installation Dependencies Building Limitations Bugs Window stacking Questi

yshui 15 Dec 9, 2022
A toy ray tracer in Rust

tray_rust - A Toy Ray Tracer in Rust tray_rust is a toy physically based ray tracer built off of the techniques discussed in Physically Based Renderin

Will Usher 492 Dec 19, 2022
A complete harfbuzz's shaping algorithm port to Rust

rustybuzz rustybuzz is a complete harfbuzz's shaping algorithm port to Rust. Matches harfbuzz v2.7.0 Why? Because you can add rustybuzz = "*" to your

Evgeniy Reizner 310 Dec 22, 2022
An OpenGL function pointer loader for Rust

gl-rs Overview This repository contains the necessary building blocks for OpenGL wrapper libraries. For more information on each crate, see their resp

Brendan Zabarauskas 621 Dec 17, 2022
Safe OpenGL wrapper for the Rust language.

glium Note to current and future Glium users: Glium is no longer actively developed by its original author. That said, PRs are still welcome and maint

null 3.1k Jan 1, 2023
GLFW3 bindings and idiomatic wrapper for Rust.

glfw-rs GLFW bindings and wrapper for The Rust Programming Language. Example extern crate glfw; use glfw::{Action, Context, Key}; fn main() { le

PistonDevelopers 546 Jan 3, 2023
Safe and rich Rust wrapper around the Vulkan 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

null 3.6k Jan 3, 2023
A vector graphics renderer using OpenGL with a Rust & C API.

bufro A vector graphics renderer using OpenGL with a Rust & C API. A Rust example can be found in examples/quickstart.rs (using glutin). A C example c

Aspect 9 Dec 15, 2022
Graph data structure library for Rust.

petgraph Graph data structure library. Supports Rust 1.41 and later. Please read the API documentation here Crate feature flags: graphmap (default) en

null 2k Jan 9, 2023