VulkanTutorial: A Complete C++ Walkthrough of the Vulkan Graphics API

What Vulkan Is and Why This Tutorial Exists

Vulkan is a low-level graphics and compute API developed by the Khronos Group. Unlike OpenGL, it does not maintain hidden state or provide a default framebuffer, a default shader, or automatic memory management. Every resource allocation, synchronization barrier, render pass, and command buffer submission is explicit and under the application's control.

This explicitness is why Vulkan tutorials are necessarily long. Before drawing a triangle, an application must create a Vulkan instance, select a physical device, create a logical device, set up a swap chain, create render passes, allocate framebuffers, write shaders, create graphics pipelines, allocate command buffers, and manage synchronization with semaphores and fences. OpenGL hides all of this; Vulkan exposes it.

VulkanTutorial addresses this by walking through every step sequentially in C++, explaining why each piece is necessary as well as how to write it. The content lives in the en/ directory of the repository as GitHub-flavored Markdown files organized by chapter.

How the Repository Is Organized

The repository contains the tutorial text in two language directories: en/ for English and fr/ for French. The code/ directory contains standalone C++ files for each chapter, named incrementally so that each file represents the complete state of the application at the end of that chapter.

The images/ directory holds diagrams used in the text. The resources/ directory contains prebuilt PDF and EPUB downloads. The ebook/ directory contains assets used by the build_ebook.py script to generate the e-book from the Markdown source.

The website at vulkan-tutorial.com is built using daux.io, a PHP-based Markdown renderer, with a custom theme. The repository includes a daux.patch file that must be applied to a specific older version of daux.io before building. The README gives step-by-step instructions for cloning daux, applying the patch, and serving or statically generating the HTML.

The code files in code/ are licensed separately from the tutorial text. The text is CC BY-SA 4.0. The code listings are CC0 1.0 Universal (public domain equivalent), meaning they can be copied and used in any project without attribution.

Building the E-book and Rendering the Tutorial Locally

The tutorial is available to read online at vulkan-tutorial.com. It can also be downloaded as a prebuilt PDF or EPUB from the resources/ directory. To build the e-book from source, the build_ebook.py script requires two tools on the system path:

python3 build_ebook.py

This requires inkscape for SVG-to-PNG conversion and pandoc for building the PDF and EPUB. A LaTeX distribution is additionally required for PDF generation. The README notes the versions it was tested with: inkscape 1.0.2 and pandoc 2.13.

To render and serve the tutorial locally, you need PHP, Composer, and a patched build of daux.io. After cloning daux, checking out a specific older revision, applying the included patch, and running Composer, PHP's built-in server can serve the tutorial:

php -S localhost:8080 index.php

The README includes instructions for generating static HTML files as well, which can be put on any web server without PHP.

The Code Progression: How Chapters Connect

Each chapter in the tutorial introduces a new Vulkan concept and extends the running C++ application. The code files in code/ follow this progression: each file is a self-contained application that compiles and runs to demonstrate the concepts covered in its chapter.

Changing code that appears in multiple chapters requires special handling. The README describes the exact procedure: update the first file that uses the changed function, create a patch file with diff, and then apply it incrementally to all subsequent chapter files using the incremental_patch.sh script:

./incremental_patch.sh base_code.cpp patch.txt

This ensures that all later chapters stay consistent with the change. The incremental patch approach is what makes cross-chapter code maintenance feasible without manually editing every file.

Is Vulkan Difficult to Learn?

Vulkan is significantly more verbose than OpenGL or Direct3D 11. The tutorial does not minimize this. A working triangle in Vulkan requires substantially more code than the same result in OpenGL because every decision that OpenGL makes automatically must be made explicitly in Vulkan.

The trade-off is control. Vulkan's explicitness exposes opportunities for optimization that are hidden in higher-level APIs: you can control which command buffers are submitted, when resource transitions happen, and how synchronization is structured across frames. These controls matter for high-performance graphics engines.

Developers who want to learn GPU programming concepts without the full weight of Vulkan's setup cost should consider learning OpenGL first, then transitioning to Vulkan. The tutorial itself assumes no prior knowledge of graphics APIs, but comfort with C++ is required.

VulkanTutorial versus vkguide.dev

vkguide.dev is another widely referenced Vulkan tutorial that takes a more project-oriented approach, focusing on getting to a functional rendering engine quickly and using the Vulkan Memory Allocator (VMA) from the start to handle allocation. VulkanTutorial handles memory management manually without VMA, which makes the allocation mechanics more explicit.

VulkanTutorial is more comprehensive as a reference for Vulkan's API surface. vkguide.dev is more focused on engine architecture decisions and tends to introduce modern rendering techniques sooner. The two tutorials complement each other: VulkanTutorial for understanding the API in depth, vkguide.dev for building a working renderer with practical shortcuts.

For Rust, a community-maintained Vulkan tutorial follows the same structure as VulkanTutorial but uses the ash and winit crates. It is a separate project and is not part of this repository.

Maintenance, License, and Contribution

The last push to the repository was on 2026-05-18. The repository has no GitHub releases; content updates are pushed directly to the main branch and the website reflects the current state.

The tutorial text is licensed under CC BY-SA 4.0. Contributing to the text requires agreeing to license contributions under the same license. The code listings in code/ are CC0 1.0 Universal and carry no attribution requirement.

Issues and pull requests are the supported channels for feedback about the website content. For questions about personal code that follows the tutorial, the README directs users to the comments section on the relevant chapter page rather than to GitHub issues.

The tutorial is available in a French translation maintained in the fr/ directory. The e-book build process generates both English and French EPUB and PDF outputs.

The repository uses a pyproject.toml that specifies Python 3.13 for the ebook build tooling. A uv.lock file pins the Python tool dependencies. The overall repository structure separates the tutorial text (en/, fr/), the code examples (code/), static site assets (images/, resources/), and the ebook build tooling (ebook/, build_ebook.py) cleanly so that contributing to any one part does not require understanding the others. The config.json at the root configures daux.io with the document title and navigation settings, and is the file that must be edited to remove the google_analytics line before generating static HTML locally.

Editorial conclusion

VulkanTutorial is the right starting point for graphics programmers who want to learn Vulkan from first principles in C++. It requires patience: Vulkan's explicit design means the tutorial must cover memory management, synchronization, and render pass setup before anything appears on screen. Developers who want a Rust path should note that a Rust variant is frequently mentioned alongside this tutorial by the community but is a separate project. The code listings are CC0-licensed, which means they can be copied into any project without attribution requirements.

Frequently asked questions

Official sources

1. Issues
2. License: CC-BY-SA-4.0
3. Overv/VulkanTutorial on GitHub
4. Project website
5. README