Alright, small blog post regarding the frame graph thingy:

It focuses on what changed compared to the old implementation. The repository is linked as well. But beware, experimental/hobbyist code!

Show thread

Mr. 🦆 had to serve as a test model again. Showcasing an async compute shader + shitty forward rendering using a newer iteration of my frame graph library.

I switched everything to bindless descriptors.

Small blog post follows, screenshots are not really made for sharing code 😅.

I hope I'm finished with the technical pixels for now and can start making shiny pixels again.

New blog post for my bachelor's thesis project is online!
It's a synthesizer using surfaces modeled via SDFs to create sound similar to wavetable synthesizers.

As usual, everything done in / .

All shaders are programmed using EmbarkStudio's rust-gpu.

I learned a lot while working on this, and Nako, the SDF toolkit that drives most of the graphics.

Have a look at my blog for a more technical discussion:


Love the cat game! Honestly the best one I played this year. All the little details that let you not only walk around like a cat, but behave like one, perfection!

🦆 Big (GLTF) duck 🦆

Shout out to the easy-gltf crate developer! (couldn't find his handle on mastodon or twitter). Loading a GLTF scene has never been easier!

Long time no see Mr. triangle.

After only two hours in Renderdoc I got it working with the DynamicRendering extensions. ‣‣‣ 🚀

Currently trying to setup a graphics pipeline for the first time in a while. Was it always this tedious?

At least VK_KHR_dynamic_rendering comes in handy for the RenderPass part.

I got two new blog posts online. This time something different related to .

One is quick start for Rust + esp32-c3, and one describes a driver I wrote for a gas flow sensor I use.

Also: RSS feed is now working for my blog, feel free to subscribe!

✨More cells! Including editing cell patches.✨

Featuring butchered MSAA by the screen recorder as well as strange flickering. I looks smoother irl I swear.


I actually test my Vulkan frame graph implementation with those doodles. In this case the vertex buffer for the Voronoi pattern is uploaded whenever it changes using the graph to synchronize upload and rendering/display of the new frame.

Since the local Lipschitz bound is needed for segment tracing (which is expensive to compute) I started storing local Lipschitz bounds in a volume texture. The algorithm therefore only needs a single texture fetch per "step".

Show thread

I started working on segment tracing for my SDF renderer/toolkit. The images below show steps needed for segment tracing (left) and sphere tracing (right). purple is 0-2 steps, green is 9-10 steps.

The model is a simple sphere.

Implemented some acceleration structure for my sdf renderer. While its fast enough on FullHD, performance gets worse fast when rendering at higher resolutions, like UltraWide 3440x1440.

However, next I want to add 2DSdfs for faster complex structures.

Finally some working rendering on the GPU.
A stack machine on the GPU turned out to be a bad idea. Mostly because I did not find a way to make reading/writing to the stack it self fast enough.

I am currently uploading the operation tree to the gpu and using a small stack to evaluate the tree. So no baking is involved here.

There is already a smooth union instruction, as well as the ability to form more complex return types. For instance in this case a color.

Show thread

I started another graphics related side project. What you are seeing is an instruction stream forming a sdf formula that is rendered to screen (currently by the cpu).

The idea is to have a byte instruction stream that can be send to any renderer and might form a meaningful image. Send might mean a network, the internet, or a pipe on your unix system. Therefore many applications can send instructions to a common renderer.

Tried to build a simple FM-Synthesizer. The frequency is currently changed per buffer, not per sample. So there are sound artefacts. But its fun nevertheless.
Also the node adding process got refactored.

The thing I'm currently working on: Some node software which calculates any graph you can build. The plan is to start and make music with it, later maybe move into other node types like images or web stuff.
As always all in and .

I'm new on mastodon. I guess most of my posts will be about and in general. I program a game engine via in .


The original server operated by the Mastodon gGmbH non-profit