
Master Vulkan fundamentals from an empty C++ project to a full pipeline using CMake, Visual Studio 2022, glfw, and Slung, building a rotating textured cube and advancing toward real-time pbr.
Install Visual Studio with necessary C++ tools, install the Vulkan SDK and GLM, verify environments, then build GLFW from source via CMake to prepare third-party libraries for the Vulkan program.
Create a VulkanApp class to refactor main, initialize a GLFW window and Vulkan resources, set up swap chain, command buffer, and synchro objects, run the main loop, and clean up.
Create a platform window abstraction to decouple GLFW from the Vulkan app and implement a vkfw platform window with window.h and window.cpp.
Create the VK instance, the roots of every Vulkan app, by introducing a Vulkan core folder, an instance wrapper, and platform-specific extension handling with starter code and a CMake setup.
Create a Vulkan instance by checking the driver's supported version, filling a createInfo struct, and enabling platform extensions via GLFW before invoking vkCreateInstance.
Create a Vulkan logical device with C++ by selecting graphics and present queue families, configuring device features and extensions, and creating queues and the device with proper error handling.
Create a command pool bound to the graphics queue family, implement constructor and destructor, configure vk_command_pool_create_reset_command_buffer, enabling per-buffer resets for per-frame command buffers in the Vulkan app.
Query GPU-surface capabilities and select formats, present modes (Mailbox preferred, otherwise FIFO), and the swap extent to prepare a swap chain for rendering.
Configure the Vulkan swap chain by setting min plus one image, considering surface, color space, format, extent, and present mode; handle sharing mode and retrieve images.
Implement a builder-based RenderPaths system by adding SubPaths and RenderPaths, validating color attachments, accumulating attachments, subpaths, and dependencies, converting to vkSubpathDescription, and creating the render path with vkCreateRenderPath.
Explore the CommandBuffer and Pipeline classes in a Vulkan C++ render pipeline, wrapping VK commands and constructing a graphics pipeline with shader stages, layouts, and dynamic states.
Record per-frame command buffers to bind render pass and graphics pipeline, issue a draw, and present with dynamic viewport and scissor, then flip the y-axis to render the red triangle.
Implement semaphore and fence classes to manage synchronization in a Vulkan app. Build the draw frame workflow by waiting on fences, acquiring swap chain images, submitting command buffers, and presenting.
This course teaches you to build a real-time Vulkan renderer from scratch using modern C++ and Slang -- NVIDIA's next-generation shader language.
Part 1 covers the complete Vulkan pipeline: window creation, instance, device, swapchain, render pass, graphics pipeline, synchronization, vertex buffers, uniform buffers, textures, index buffers, depth buffering, and swapchain resize. By the end of Part 1 you will have a rotating textured 3D cube rendered entirely with explicit Vulkan code.
Part 2 extends the renderer with physically based rendering: normal maps, PBR materials with metallic/roughness workflow, image-based lighting with HDRI environment maps, MSAA, and a complete scene management system.
Unlike other Vulkan courses, this course uses Slang -- NVIDIA's modern shader language designed for the era of neural rendering. Slang is already integrated into Unreal Engine 5 and Falcor, NVIDIA's research rendering framework. As neural rendering techniques like NeRF and Gaussian Splatting move into production pipelines, Slang's differentiable shading and cross-platform compilation make it the natural foundation for the next generation of renderers. Learning Slang now puts you ahead of a shift that is already happening in research and beginning to reach industry.
What you will build:
- A reusable Vulkan framework with clean C++ architecture
- A complete PBR renderer with IBL and environment mapping
- A working understanding of how modern GPU rendering works
at the API level
Who this course is for:
C++ developers who want to understand Vulkan from first principles, graphics programmers moving from OpenGL, and engineers who want to build their own rendering engine.