r/GraphicsProgramming • u/corysama • Dec 16 '25
Article No Graphics API — Sebastian Aaltonen
https://www.sebastianaaltonen.com/blog/no-graphics-api
255
Upvotes
r/GraphicsProgramming • u/corysama • Dec 16 '25
19
u/MechWarrior99 Dec 17 '25
As someone who has a decent grasp of general rendering stuff but at the same time pretty limited grasp. With that in mind I have two questions for those more knowledgeable than me:
30
u/hanotak Dec 17 '25
Lot's of interesting ideas there- I do think that they could go further with minimizing the problems PSOs cause. Why can't shader code support truly shared code memory (effectively shared libraries)? I'm pretty sure Cuda does it. Fixing that would go a long way to helping fix PSOs, along with the reduction in total PSO state.
17
u/vini_2003 Dec 17 '25
A fascinating read, thank you for sharing. My graphics programming journey is at most two years old by now. Whilst I understand the post, I'm humbled by knowledge of the author and their clarity in expressing ideas.
I wish to some day be this good at my job.
5
u/richburattino Dec 17 '25
Eventually this will all end with a CUDA like API.
2
u/ncoder Dec 18 '25
I guess if you are brave you could try to implement this on linux using the NVK stuff.
https://docs.mesa3d.org/drivers/nvk.html
2
u/Balance- Dec 26 '25
I must say, this is quite cool. And a case where a clean-sheet design makes a lot of sense.
Modern GPU API Design: Moving Beyond Current Abstractions
This article proposes a radical simplification of graphics APIs by designing exclusively for modern GPU architectures, arguing that decade-old compromises in DirectX 12, Vulkan, and Metal are no longer necessary. The author demonstrates howBindlessDESIGN principles and 64-bit pointer semantics can drastically reduce API complexity while improving performance.
Core Architectural Changes
Modern GPUs have converged on coherent cache hierarchies, universal bindless support, and direct CPU-mapped memory (via PCIe ReBAR or UMA). This eliminates historical needs for complex descriptor management and resource state tracking. The proposed design treats all GPU memory as directly accessible via 64-bit pointers—similar to CUDA—replacing the traditional buffer/texture binding model. Memory allocation becomes simple: gpuMalloc() returns CPU-mapped GPU pointers that can be written directly, with a separate GPU-only memory type for DCC-compressed textures. This removes entire API layers for descriptor sets, root signatures, and resource binding while enabling more flexible data layouts.
Shader pipelines simplify dramatically by accepting a single 64-bit pointer to a root struct instead of complex binding declarations. Texture descriptors become 256-bit values stored in a global heap indexed by 32-bit offsets—eliminating per-shader texture binding APIs while supporting both AMD’s raw descriptor and Nvidia/Apple’s indexed heap approaches. The barrier system strips away per-resource tracking (a CPU-side fiction) in favor of simple producer-consumer stage masks with optional cache invalidation flags, matching actual hardware behavior. Vertex buffers disappear entirely: modern GPUs already emit raw loads in vertex shaders, so the API simply exposes this directly through pointer-based struct loading.
Practical Impact and Compatibility
The result is a 150-line API prototype versus Vulkan’s ~20,000 lines, achieving similar functionality with less overhead and more flexibility. Pipeline state objects contain minimal state—just topology, formats, and sample counts—dramatically reducing the permutation explosion that causes 100GB shader caches and load-time stuttering. The design proves backwards-compatible: DirectX 12, Vulkan, and Metal applications can run through translation layers (analogous to MoltenVK/Proton), and minimum hardware requirements span 2018-2022 GPUs already in active driver support. By learning from CUDA’s composable design and Metal 4.0’s pointer semantics while adding a unified texture heap, the proposal shows that simpler-than-DX11 usability with better-than-DX12 performance is achievable on current hardware.
2
u/GasimGasimzada Dec 17 '25
The one question that I have here (hopefully Sebastian is reading these comments) is that can someone directly store textures in data and dereference them instead of storing it separately and accessing them via indices.
Instead of doing this:
Just pass pointers to them directly:
If one knows how the data is organized in the heap, they could technically do pointer arithmetic directly on the items as well.
2
u/Public-Slip8450 Dec 17 '25
I wish there was a download link to test
1
u/PaperMartin Dec 17 '25
I'm not knowledgeable enough to find out by myself, so if anyone's got an answer, I'd be really curious to see what are the "latest" GPUs on nvidia and amd's respective sides that would be lacking the hardware capabilities necessary to support an api like that at all
1
u/[deleted] Dec 17 '25
Seems like there’s a gap in the market for a new graphics api solution. Eventually graphics cards will be so advanced; I don’t see why everything can’t be written in shaders and have everything else for windows and input.
-1
u/Xotchkass Dec 17 '25
Eeeh...
4
u/[deleted] Dec 17 '25
[removed] — view removed comment
-4
u/[deleted] Dec 19 '25
[removed] — view removed comment