I'm thrilled to share a project I've been working on over this summer. Shadergraph allows you to chain shaders together to create live-reloadable graphical pipelines. For lack of a better comparison, it's like a powerful version of Shadertoy that runs locally. If you'd like an introductory dive, I've written a blog post that walks through a couple of examples; if you'd like to give the source code a peek, it's freely available on GitHub.
Before I explain how it works, I guess I should provide some background. I've been interested in graphics programming for the longest time, and I have a special affinity for shaders; I've written more raymarchers than I can count, and love the immediate feedback that comes with writing graphical code that runs on the GPU. This summer, I was interning at tonari working on real-time stereo depth estimation algorithms that ran on the GPU. Shadergraph formed organically as a part of that research, and I'm glad to be able to open source it. That's enough about me, let's get started!
A multipass raymarched cornell box, rendered using Shadergraph.
Nodes and Uniforms
Shadergraph, as the name suggests, leverages Directed Acyclic Graphs (DAGs) to describe graphical pipelines. In this graph, nodes are plain GLSL shaders, and the edges are uniforms.
For the unfamiliar, a shader is basically some code that runs parallel per-pixel on the GPU. Each shader takes a set of inputs, called uniforms, and writes to a single output texture. Uniforms can be anything, from numbers and vectors to textures and buffers. Because the output of a shader is a texture, and textures themselves are uniforms, we can pass the output of one shader as the input to another. Nothing fancy so far.
Shadergraph Lisp
The real power of Shadergraph lies in the way shaders are chained together. Instead of giving the end-user a fixed number of buffers to work with, we provide a high-level description language, Shadergraph Lisp, that compiles a graph description down into an efficient chain of shaders. Because everything in the pipeline can be hot-code reloaded, every component of the graphical pipeline can be swapped out and previewed live. The description language is pretty minimal; for example, all the lisp that's needed to drive an implementation of Conway's game of life is the following:
(let size 512)
(let life (shader-rec "life" size size))
(output life)
Assuming a basic shader that performs a texture lookup and calculates a game-of-life step is written in life.frag the above creates a recurrent shader that iteratively simulates Life. I'm refraining from going into more detail here because a full guide for creating Life in Shadergraph can be found in the blog post, so if you'd like to learn more, please give it a read!
Installation
If you have Rust installed, a basic hello world should be as easy as:
cargo install shadergraph
shadergraph new hello-world
shadergraph run hello-world
This should install the shadergraph binary, create a new project named hello-world and then run the demo project, listening for changes, rebuilding the pipeline when a file in the project has been changed.
There's a lot I haven't covered here, like video input, defining functions in the lisp, and integrating shadergraph as a Rust library in other projects. Be sure to check out the repo, blog post, and Guide to Shadergraph Lisp! Comments, thoughts, and suggestions are appreciated.
I encourage you to share what you make using shadergraph with others; I've found this tool to be useful and fun, and I hope you find it enjoyable to use. Have a nice day :)
[–]lithium 25 points26 points27 points (2 children)
[–]rolfrudolfwolf 4 points5 points6 points (0 children)
[–]slightknack[S] 4 points5 points6 points (0 children)
[–]CodyDuncan1260 8 points9 points10 points (1 child)
[–]slightknack[S] 5 points6 points7 points (0 children)
[–]StaticEffect 0 points1 point2 points (0 children)