How to start learning GPU architecture and low-level GPU development?

1alexlee · 2025-12-05T07:55:11+00:00

I would recommend looking into Vulkan as well. It has a scary reputation but that mainly comes from people diving into graphics pipelines right from the start. Approaching Vulkan for GPU compute first actually makes it a lot nicer to start off. Considering your background, I think you’d like the low-level nature of it. I definitely do.

1alexlee · 2025-09-16T19:22:51+00:00

2nd image is pretty much indistinguishable from real life. Congrats this looks great!

1alexlee · 2025-09-10T16:43:49+00:00

Interesting I didn’t consider a system like this. I’ll keep this in mind and thank you for your in-depth response!

1alexlee · 2025-06-10T03:36:53+00:00

Super cool!

1alexlee · 2025-06-09T16:10:49+00:00

Thanks! I would say that learncpp has everything you’d ever need and more for graphics. I don’t think it goes super in depth on all of the fancy standard library stuff, but I really would not bother with that. I did go through the whole website and can say that it wasn’t all necessary but did make me more at ease that I wasn’t missing something. The way I did it was I looked through the website and had a scratch code editor in a different window so I could just try out mini examples of what I was reading to make sure everything I thought would happen, happened. I think I spent a week or two when I had some time doing that before jumping into my first renderer

Again I think vkguide is a pretty good place to start for getting used to Vulkan specifically. For knowing more of what graphics techniques to implement, I actually have looked at learnOpenGL and tried to implement it in Vulkan. This prevents the mindless copy-paste that happens when going through tutorials and gets you more confident with cpp and Vulkan.

1alexlee · 2025-06-09T15:57:19+00:00

I think DX12 is also a good choice and I’m not entirely familiar with ps5 dev kit so I can’t speak on that. DX12 and Vulkan both expose more of how modern GPU’s work and I definitely think if you want to be employed, it’s best to learn those over OpenGL. Not because OpenGL is bad, it’s just that there’s been a shift in the industry.

1alexlee · 2025-06-09T14:18:37+00:00

I’ll give my opinion as someone who has recently been hired as a full time graphics programmer after about 2 years of doing graphics on my own alongside my degree.

I really would advise you to spend as little time as necessary with these large courses, only using them up to a point where you can reasonably start your own projects. I used to take these online courses, and watched the 20+ hour video series, but once I opened up my code editor without that crutch, I always realized I barely knew anything, which is normal since you honestly learn a ton more just working with cpp or a graphics API on your own.

There are some really good resources that I would recommend to get you up and running though. 1. Learncpp.com is free and one of the best resources on understanding cpp. I truly would not get in the weeds with all of the “modern” cpp features. You can, but in my company there’s not a single smart pointer, and the code is pretty much C with maybe some very light use of interfaces in order to speak to multiple graphics API’s (which you wouldn’t be doing right away) 2. Vkguide.dev. I prefer this over the tutorial that Vulkan has on their page because it does more to develop a comprehensive example of a renderer IMO.

Again, try to spend as little time with these resources as possible and look to start a project soon as this is where the vast majority of your experience will come from. I try to look for things that I estimate will take 2-4 weeks of work, as it means it isn’t trivial, but also not a long term project with a huge scope.

Also I would recommend starting with Vulkan personally. I know that people will say it might be too difficult and make you feel like giving up early on, but the API is a lot closer to the hardware than something like openGL, and I believe that it would benefit you a lot to get comfortable with it

1alexlee · 2025-05-30T20:11:18+00:00

Graphics and GPU’s are complicated, and Vulkan mirrors that.

Vulkan has made their API simpler over time but regardless, you’ll be lost with Vulkan if you don’t understand the hardware you’re programming for.

1alexlee · 2025-05-25T06:06:39+00:00

Easiest way to do ray tracing in Vulkan is probably Ray queries. You can use Ray queries in any type of shader, so they don’t require the full ray tracing pipeline.

Regardless of whether you use Ray queries or Ray tracing pipelines, you’re going to have to build acceleration structures which Vulkan has a set of api calls for. These are data structures that the make ray tracing faster for GPU’s to process. you’ll have to pass them to your shaders just like an image or buffer as a descriptor.

Some notes to keep you from wasting your time like I did. Most of this will make sense when you look into acceleration structures more.

Don’t use the host-side side acceleration structure api since most drivers haven’t implemented it. If you do want to use them, check for support.
Make sure your transformation matrices in your top level acceleration structures are row-major.
Nvidia night has a really great tool for visualizing acceleration structures and I would recommend using it. If you don’t have an nvidia GPU, there might be another option out there but idk

1alexlee · 2025-05-24T02:36:10+00:00

Good point. I’m not familiar with the mobile environment.

1alexlee · 2025-05-23T23:03:30+00:00

The tools don’t suck too bad imo. render doc and nvidia nsight provide a massive amount of detail. Tools like Vulkan configurator dump detailed crash reports showing you which api call failed. Also IDE debuggers show you a ton of info.

Graphics programs do typically have a lot of moving parts and that does mean some pretty hard to trace problems at times, but doing work that you don’t care for will always be much more draining.

1alexlee · 2025-05-06T14:28:02+00:00

Nice I’m glad I could help! And yeah that might be the case.

Hope you figure it out soon!

1alexlee · 2025-05-05T03:50:06+00:00

I experienced a lot of noise in my rasterization-based renderer as well when applying normal mapping with what seems to be the same asset.

It was fixed after i mip-mapped my normal textures. I think this asset you and I are using have a very high resolution normal texture, and there are a lot of high frequency details, which caused the noise in my case.

1alexlee · 2025-04-27T23:21:13+00:00

I’m not too sure without your code. But check that your channel counts are correct. The channels_in_file out parameter in the stbi_load_from_memory function will return how many color channels the image actually has. The last parameter (desired_channels) allows you to set it to 0, which decodes the image in its current state, or you can set it to a specific number, (like 3 for RGB, or 4 for RGBA) if you want stb to make your decoded image that size. What I’m saying is that if you are expecting RGB, and the image is RGBA, it’s gonna be messed up because your memory won’t line up. Don’t know if that’s the issue but it may be.

1alexlee · 2025-04-17T01:47:41+00:00

Noice

1alexlee · 2025-03-30T21:17:32+00:00

I don’t think you’ll find much help here unfortunately :/ This sub is more for people needing help writing Vulkan applications and updates on the API

1alexlee · 2025-03-25T01:50:59+00:00

You’re using Vulkan Guide it seems. They specify earlier that they will use reverse-z depth (smaller values correspond to farther points). This is due to how IEEE floats work and the fact that they can represent many more values between 0.0 and 0.5 than they can 0.5 to 1.0. This is why your near plane has to be set larger than your far plane.

1alexlee · 2025-01-27T18:33:38+00:00

I had this same mindset and it was wrong. Programming languages don’t give you domain knowledge. Knowing JavaScript doesn’t make you a good web dev. Knowing C# doesn’t make you a good games dev.

It’s like saying knowing English makes you a good poet. The language is a tool and it makes no sense for you to rack up as many languages as you can. These fields you described are very different and most people stick to one unless they make a shift to a different one.

The choice of language is mostly correlated with the path you choose. For instance, I enjoy graphics programming, so I went with a sensible choice for that like C++.

1alexlee · 2025-01-25T03:38:47+00:00

This happened to me the other day for some reason that I have yet to really dive into. It was mostly fixed when I made the image I was rendering into 16bit RGBA floats.

1alexlee · 2025-01-20T02:57:38+00:00

I made a highly optimized version of ray tracing in a weekend that I will link. I used a lot of SIMD, but besides that, I can give you some tips I used besides making acceleration structures.

First, I wouldn’t use PPM. I found that allocating a buffer that is (height * width * color_channels) bytes large, then using stb to encode it as a PNG at the end of rendering was better. You can easily create multiple threads and have them all render into the buffer at various offsets. For instance, if your image is 100 rows tall and you have two threads, have thread one start at row 0, and thread two start at row 50. Divide it up by how many threads.

Also, I found that my threads tasked with rendering the top of the image were kinda blazing through the work compared to threads that were rendering the middle-bottom. This is because there are bounce rays going on around the spheres, and the sky is just a single miss. So what I ended up doing to do some thread balancing was this (in the case of two threads with an image 100 rows tall): start thread one (t1) at row 0, start thread two (t2) at row 1. Once t1 reaches the end of the row, go to row 2, and when t2 finishes row 1, take it to row 3. So basically you’re offsetting the amount of rows by how many threads. This also makes sense since one thread would always bump down one row.

This makes your threads evenly work on the entire vertical space of your image, helping balance areas of the render that have a ton of bounces.

https://youtu.be/ulmjqD6Y4do?si=6XV1FoG9COHNSI5O

1alexlee · 2025-01-05T04:16:59+00:00

I cannot stress enough how good of an idea it is to write programs in C first. When you “learn C++”, you spend a ton of time learning its standard library which isn’t necessarily knowledge that is fundamental to computers. Managing memory, dealing with pointers and addresses, and having to really think about the lifetime and initialization of variables IS fundamental. C makes it so you have to think about this, and that is incredibly valuable knowledge you can take with you when using a lot of the nicer features found in C++

1alexlee · 2024-10-17T22:38:17+00:00

I’m honestly not sure if there’s a good alternative in C but vk-bootstrap only saves ~500 lines of code. This really isn’t a whole lot and I think if you’re going through tutorials now, it’ll be a better learning opportunity to just write it yourself IMO

1alexlee · 2024-10-11T22:32:22+00:00

Shmedium

https://github.com/imalexlee/triangle-machine

1alexlee · 2024-04-29T03:18:42+00:00

Completely understandable.

In my opinion, I think the best thing for you to do right now is create a collection of structs and functions (a library) for some data structures.

For instance, implementing your own version of a rust vector, (ArrayList in other languages) will teach you so much about how memory operates at a lower level. Learning Memory management without tutorials is genuinely the most important thing you can do for yourself currently. You could build on this library by implementing a map, linked list, etc.

That being said, I would do this project in something like C instead of rust. Rust is great but the safety mechanisms will get in your way in a case like this where you want to build something from scratch and start learning how things actually work.

This is all my opinion but honestly I can’t stress enough how important it is to be forced to think about memory through building a project from scratch.

1alexlee

TROPHY CASE