Setting Up Qt 5/6 with VulkanSceneGraph (VSG) on Windows Using vsgQt

Qt excels at building desktop interfaces — windows, menus, toolbars. VulkanSceneGraph (VSG) addresses a different need: a modern C++17 scene graph designed around Vulkan for high-performance 3D rendering.

This guide uses Qt for the application layer, VSG for rendering, and vsgQt to integrate them. The complete setup involves installing Visual Studio with C++ support, the Vulkan SDK, PowerShell 7 and Qt, then compiling both VulkanSceneGraph and vsgQt from source.

Why use VSG instead of Qt for everything?

Qt already supports Vulkan through QVulkanWindow, but Qt and VSG operate at different levels. Qt manages the desktop application lifecycle, UI components and event handling. VSG provides scene graph traversal, Vulkan resource management, graphics pipelines and multithreaded rendering.

The architecture combines Qt for the application, VulkanSceneGraph for the renderer, and vsgQt between them.

Qt handles the application

Native desktop windows, widgets, menus, toolbars, dock panels, dialogs, forms, input handling, model/view interfaces, accessibility, application lifecycle and cross-platform deployment.

VSG handles the scene and renderer

A Vulkan-first scene graph, scene graph traversal, Vulkan resource management, graphics pipelines, cameras and views, command graph construction, multithreaded rendering, scene serialization, large-coordinate rendering, GPU resource sharing and database paging.

1. Install Visual Studio

Download Visual Studio from Microsoft's official website. Visual Studio Community suits individual developers, students and open-source projects. This guide supports Community 2026, Community 2022, Build Tools, and Professional/Enterprise editions.

Select the C++ workload

Open the Visual Studio Installer and select Desktop development with C++. Verify that these are included:

• MSVC C++ x64/x86 build tools
• Windows 10/11 SDK
• C++ CMake tools for Windows
• Git for Windows

Visual Studio 2026 and Qt compatibility

Visual Studio 2026 uses the v145 platform toolset by default. Qt 6.11's officially listed Windows configuration currently uses MSVC 2022, whose platform toolset is v143.

Configuration A — Visual Studio 2026 with v145. Visual Studio 2026, the Visual Studio 18 2026 CMake generator, the v145 toolset and Qt msvc2022_64 binaries, relying on Microsoft's cross-version binary compatibility.

Configuration B — Visual Studio 2026 with v143. The same IDE and generator but the v143 toolset. This is the more conservative option, because the compiler toolset matches Qt's officially listed MSVC 2022 configuration.

To use v143, open Visual Studio Installer → Modify → Individual components and install MSVC v143 — VS 2022 C++ x64/x86 build tools. Then set $CMakeToolset = "v143", or leave it as $CMakeToolset = $null to use the default.

2. Install PowerShell 7

Windows includes Windows PowerShell 5.1, but this guide uses PowerShell 7. Install it from the PowerShell releases page and verify:

pwsh --version

Then open PowerShell 7 with pwsh.

3. Install the Vulkan SDK

Download the Windows x64 Vulkan SDK from LunarG. The default installation directory is C:\VulkanSDK\<version>. The installer normally creates the VULKAN_SDK system environment variable, adds %VULKAN_SDK%\Bin to the system Path, and sets VK_SDK_PATH.

Verify the Vulkan installation

Open a new PowerShell window and check the variables:

$env:VULKAN_SDK
$env:VK_SDK_PATH

Verify the headers exist:

Test-Path "$env:VULKAN_SDK\Include\vulkan\vulkan.h"

Confirm the runtime and GPU support:

& "$env:VULKAN_SDK\Bin\vulkaninfo.exe" --summary
& "$env:VULKAN_SDK\Bin\vkcube.exe"

4. Add the Vulkan variables manually when required

The installer should configure these automatically. If they are missing or incorrect, press <kbd>Win</kbd> + <kbd>R</kbd>, enter sysdm.cpl, open Advanced → Environment Variables, and add VULKAN_SDK and VK_SDK_PATH as system variables pointing at the installation path. Then add %VULKAN_SDK%\Bin to the system Path.

5. Are PowerShell $env: changes permanent?

No. A command like this changes the variable only for the current PowerShell process:

$env:VSG_FILE_PATH = "C:\Dev\vsg-stack\src\vsgExamples\data"

The value is available to the current session and to child processes, then disappears when the process closes. This is Process scope. Ordinary PowerShell variables are also temporary, existing only in the current session.

Persistent user environment variable

[Environment]::SetEnvironmentVariable(
    "VARIABLE_NAME",
    "VARIABLE_VALUE",
    "User"
)

Persistent system environment variable

Run PowerShell as administrator:

[Environment]::SetEnvironmentVariable(
    "VARIABLE_NAME",
    "VARIABLE_VALUE",
    "Machine"
)

User- and Machine-scoped variables persist outside the current process.

What should be permanent?

VULKAN_SDK and VK_SDK_PATH should be persistent, and are normally created by the installer. CMAKE_PREFIX_PATH, VSG_FILE_PATH, QT_PLUGIN_PATH, temporary PATH additions, Qt installation paths and VSG build paths are better kept temporary — it prevents accidentally loading the wrong DLLs.

6. Import the Visual Studio x64 environment into PowerShell

MSVC depends on environment variables including PATH, INCLUDE, LIB, LIBPATH, VCToolsInstallDir and WindowsSdkDir. Visual Studio provides vcvarsall.bat, VsDevCmd.bat and Launch-VsDevShell.ps1 to set them.

Simple option: start PowerShell from the Native Tools prompt

Search the Start menu for x64 Native Tools Command Prompt for VS 2026 (or VS 2022), open it and run pwsh. PowerShell launches as a child process and inherits the configured environment. Verify with:

cl
where.exe cl
$env:VSCMD_VER
$env:VCToolsInstallDir

7. A PowerShell utility for importing the Visual Studio environment

This function finds Visual Studio using Microsoft's vswhere.exe, locates vcvarsall.bat, runs the developer environment, captures the result and imports it into the current PowerShell process.

function Import-VSDevEnvironment {
    [CmdletBinding()]
    param(
        [ValidateSet("x64", "x86", "arm64")]
        [string]$Architecture = "x64",
        # Examples:
        # Visual Studio 2026: "[18.0,19.0)"
        # Visual Studio 2022: "[17.0,18.0)"
        [string]$VersionRange,
        # Include preview or prerelease Visual Studio installations.
        [switch]$Prerelease
    )
    $vswhere = Join-Path `
        ${env:ProgramFiles(x86)} `
        "Microsoft Visual Studio\Installer\vswhere.exe"
    if (!(Test-Path $vswhere)) {
        throw "vswhere.exe was not found at: $vswhere"
    }
    $vswhereArguments = @(
        "-latest",
        "-products", "*",
        "-requires", "Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
        "-property", "installationPath"
    )
    if (![string]::IsNullOrWhiteSpace($VersionRange)) {
        $vswhereArguments += @(
            "-version",
            $VersionRange
        )
    }
    if ($Prerelease) {
        $vswhereArguments += "-prerelease"
    }
    $installationPath = (
        & $vswhere @vswhereArguments |
        Select-Object -First 1
    )
    if ([string]::IsNullOrWhiteSpace($installationPath)) {
        throw "No matching Visual Studio installation with C++ tools was found."
    }
    $installationPath = $installationPath.Trim()
    $vcvarsall = Join-Path `
        $installationPath `
        "VC\Auxiliary\Build\vcvarsall.bat"
    if (!(Test-Path $vcvarsall)) {
        throw "vcvarsall.bat was not found at: $vcvarsall"
    }
    # vcvarsall uses these architecture names.
    $vcvarsArchitecture = switch ($Architecture) {
        "x64" {
            "amd64"
        }
        "x86" {
            "x86"
        }
        "arm64" {
            "amd64_arm64"
        }
    }
    $command = "`"$vcvarsall`" $vcvarsArchitecture >nul && set"
    $environmentDump = & $env:ComSpec /d /s /c $command
    if ($LASTEXITCODE -ne 0) {
        throw "vcvarsall.bat failed with exit code $LASTEXITCODE."
    }
    foreach ($line in $environmentDump) {
        $separatorIndex = $line.IndexOf("=")
        # Ignore malformed lines and cmd.exe pseudo-variables such as =C:.
        if ($separatorIndex -le 0) {
            continue
        }
        $name = $line.Substring(0, $separatorIndex)
        $value = $line.Substring($separatorIndex + 1)
        Set-Item `
            -Path "Env:$name" `
            -Value $value
    }
    $compilerLine = (
        & cl 2>&1 |
        Select-Object -First 1
    )
    Write-Host `
        "Visual Studio developer environment loaded." `
        -ForegroundColor Green
    Write-Host "Architecture: $Architecture"
    Write-Host "Installation: $installationPath"
    Write-Host "VS version:   $env:VisualStudioVersion"
    Write-Host "Compiler:     $compilerLine"
}

8. Option A — use the utility temporarily

Paste the function into the current PowerShell window, then run:

Import-VSDevEnvironment -Architecture x64

To target a specific Visual Studio:

Import-VSDevEnvironment -Architecture x64 -VersionRange "[18.0,19.0)"   # VS 2026
Import-VSDevEnvironment -Architecture x64 -VersionRange "[17.0,18.0)"   # VS 2022

Verify with cl, where.exe cl, $env:VSCMD_VER, $env:VisualStudioVersion, $env:VSINSTALLDIR and $env:VCToolsInstallDir.

Both the function definition and the imported compiler environment disappear when the window closes. That suits testing, occasional MSVC use, not wanting to edit $PROFILE, or running commands on another machine.

9. Option B — save the utility in $PROFILE

A PowerShell profile is a script that runs when PowerShell starts, holding functions, variables, aliases and customisations. $PROFILE refers to the current user and current host.

Check the path:

$PROFILE

Create it if it does not exist:

if (!(Test-Path $PROFILE)) {
    New-Item `
        -ItemType File `
        -Path $PROFILE `
        -Force
}

Open it:

notepad $PROFILE

Or in VS Code: code $PROFILE. Paste the complete Import-VSDevEnvironment function in and save. Reload without restarting — the leading dot is PowerShell's dot-source operator:

. $PROFILE

An important distinction

Saving the function in $PROFILE makes the function definition available in future sessions. It does not make the imported Visual Studio environment permanent. Each time you open a terminal and need MSVC, run Import-VSDevEnvironment -Architecture x64. The compiler environment lives only as long as that session.

You can add the call after the function in $PROFILE to activate MSVC on every start, but I would not recommend it unless nearly every terminal session is C++ work.

PowerShell 7 and Windows PowerShell use different profiles

PowerShell 7 and Windows PowerShell 5.1 do not necessarily load the same profile. Run $PROFILE inside the exact shell where you need the function. Note also that pwsh -NoProfile starts without loading it at all.

10. Verify the active Visual Studio version

After importing the environment:

$env:VisualStudioVersion   # 18.0 for VS 2026, 17.0 for VS 2022
cl
where.exe cl
cmake --version
git --version

The Visual Studio 2026 CMake generator is Visual Studio 18 2026, added in CMake 4.2. Check your CMake supports it:

cmake --help | Select-String "Visual Studio 18 2026"

If nothing comes back, update CMake.

11. Select the correct CMake generator automatically

Detect the active Visual Studio version rather than hardcoding it everywhere:

$CMakeGenerator = switch -Regex ($env:VisualStudioVersion) {
    "^18\." {
        "Visual Studio 18 2026"
        break
    }

    "^17\." {
        "Visual Studio 17 2022"
        break
    }
    default {
        throw "Unsupported or uninitialized Visual Studio version: $env:VisualStudioVersion"
    }
}

Verify CMake knows it:

if (
    -not (
        cmake --help |
        Select-String `
            -SimpleMatch `
            $CMakeGenerator
    )
) {
    throw "CMake does not support the generator: $CMakeGenerator"
}

Select the platform toolset

Use $CMakeToolset = $null for the default, which on Visual Studio 2026 normally selects v145. To use the MSVC 2022 toolset installed inside Visual Studio 2026, use $CMakeToolset = "v143".

Prepare the generator arguments:

$GeneratorArguments = @(
    "-G", $CMakeGenerator,
    "-A", "x64"
)

if (![string]::IsNullOrWhiteSpace($CMakeToolset)) {
    $GeneratorArguments += @(
        "-T",
        $CMakeToolset
    )
}

That produces -G "Visual Studio 18 2026" -A x64, optionally with -T v143.

12. Create a clean directory structure

Keeping source, build output and installed libraries separate makes the setup easier to understand, update and remove.

$VsgRoot = "C:\Dev\vsg-stack"
$SourceRoot = "$VsgRoot\src"
$BuildRoot = "$VsgRoot\build"
$InstallRoot = "$VsgRoot\install"

New-Item `
    -ItemType Directory `
    -Force `
    $SourceRoot, `
    $BuildRoot, `
    $InstallRoot

Both VulkanSceneGraph and vsgQt install into C:\Dev\vsg-stack\install. A custom prefix avoids administrator permissions, keeps dependencies together, makes the setup easy to remove, and prevents files being scattered through Program Files.

13. Download and install Qt

Download the Qt Online Installer and choose Custom Installation.

For Qt 6, select a Qt 6 version and an MSVC x64 package — for example Qt → Qt 6.11.x → MSVC 2022 64-bit. The directory will resemble C:\Qt\6.11.0\msvc2022_64.

For Qt 5, vsgQt's current CMake configuration notes Qt 5.10 or later. The directory may resemble C:\Qt\5.15.x\msvc2019_64.

Do not select a MinGW Qt package when compiling VSG and vsgQt with MSVC. Every C++ component should use a compatible compiler family, architecture and runtime.

vsgQt requires Qt Widgets. Qt Creator is optional, since everything here is built from PowerShell.

14. Define the Qt path

$QtRoot = "C:\Qt\6.11.0\msvc2022_64"
$QtPackage = "Qt6"

Or for Qt 5:

$QtRoot = "C:\Qt\5.15.x\msvc2019_64"
$QtPackage = "Qt5"

Check the directory and the CMake package — both should return True:

Test-Path $QtRoot
Test-Path "$QtRoot\lib\cmake\$QtPackage"

Add Qt to the current session:

$env:PATH = "$QtRoot\bin;$env:PATH"
$env:QT_PLUGIN_PATH = "$QtRoot\plugins"

15. Download VulkanSceneGraph

Set-Location $SourceRoot

git clone `
    https://github.com/vsg-dev/VulkanSceneGraph.git

VSG requires a C++17-capable compiler and uses the Vulkan SDK on Windows. Its official Windows guide recommends installing to a known prefix and adding that prefix to CMAKE_PREFIX_PATH for downstream projects.

16. Configure VulkanSceneGraph

cmake `
    @GeneratorArguments `
    -S "$SourceRoot\VulkanSceneGraph" `
    -B "$BuildRoot\VulkanSceneGraph" `
    -DBUILD_SHARED_LIBS=ON `
    "-DCMAKE_INSTALL_PREFIX=$InstallRoot"

The options that matter:

• -S — source directory
• -B — build directory
• -G — Visual Studio generator
• -A x64 — target 64-bit Windows
• -T v143 — optionally select the v143 toolset
• -DBUILD_SHARED_LIBS=ON — build shared libraries and DLLs
• -DCMAKE_INSTALL_PREFIX — where libraries, headers and CMake package files land

17. Build and install VulkanSceneGraph

cmake `
    --build "$BuildRoot\VulkanSceneGraph" `
    --config Release `
    --parallel

cmake `
    --install "$BuildRoot\VulkanSceneGraph" `
    --config Release

Check for the VSG CMake configuration — if it returns a result, downstream projects can discover the installation:

Get-ChildItem `
    $InstallRoot `
    -Recurse `
    -Filter "vsgConfig.cmake"

And the installed DLLs:

Get-ChildItem `
    "$InstallRoot\bin" `
    -Filter "*.dll"

18. Prepare CMAKE_PREFIX_PATH

vsgQt needs to find both Qt and VulkanSceneGraph:

$CMakePrefixPath = "$QtRoot;$InstallRoot"
$env:CMAKE_PREFIX_PATH = $CMakePrefixPath

This is temporary. The commands below also pass the prefix directly to CMake, which makes the build easier to reproduce.

19. Download vsgQt

Set-Location $SourceRoot

git clone `
    https://github.com/vsg-dev/vsgQt.git

vsgQt provides Qt integration for VSG on Windows, Linux and macOS. Its examples are:

• vsgqtviewer — QApplication and QMainWindow with one vsgQt::Window
• vsgqtmdi — QMdiArea with multiple vsgQt::Window instances
• vsgqtwindows — multiple independent vsgQt::Window instances

The single-window vsgqtviewer is the best starting point.

20. Configure vsgQt for Qt 6 or Qt 5

vsgQt's build uses QT_PACKAGE_NAME, accepting Qt5 or Qt6. It currently defaults to Qt5, so select Qt6 explicitly when building against Qt 6.

cmake `
    @GeneratorArguments `
    -S "$SourceRoot\vsgQt" `
    -B "$BuildRoot\vsgQt" `
    -DBUILD_SHARED_LIBS=ON `
    -DVSGQT_BUILD_EXAMPLES=ON `
    "-DQT_PACKAGE_NAME=$QtPackage" `
    "-DCMAKE_PREFIX_PATH=$CMakePrefixPath" `
    "-DCMAKE_INSTALL_PREFIX=$InstallRoot"

During configuration, check that CMake finds Vulkan, vsg, Qt5 or Qt6, and Qt Widgets. The current vsgQt source requires VulkanSceneGraph 1.1.13 or later.

21. Build and install vsgQt

cmake `
    --build "$BuildRoot\vsgQt" `
    --config Release `
    --parallel

cmake `
    --install "$BuildRoot\vsgQt" `
    --config Release

Find the viewer executable:

$Viewer = Get-ChildItem `
    -Path "$BuildRoot\vsgQt", $InstallRoot `
    -Recurse `
    -Filter "vsgqtviewer.exe" `
    -ErrorAction SilentlyContinue |
    Select-Object -First 1

if (!$Viewer) {
    throw "vsgqtviewer.exe was not found."
}

$Viewer.FullName

22. Download assets for testing

vsgqtviewer requires the path to a 3D model or image on the command line — without one it prints a message and exits.

Set-Location $SourceRoot

git clone `
    --depth 1 `
    https://github.com/vsg-dev/vsgExamples.git

There is no need to compile the examples to use their assets. Available native VSG models include models\lz.vsgt, models\openstreetmap.vsgt, models\skybox.vsgt and models\teapot.vsgt.

$env:VSG_FILE_PATH = "$SourceRoot\vsgExamples\data"

VSG uses this path when resolving referenced scene resources.

23. Configure runtime DLL paths

$env:PATH = @(
    "$QtRoot\bin"
    "$InstallRoot\bin"
    "$env:VULKAN_SDK\Bin"
    $env:PATH
) -join ";"

$env:QT_PLUGIN_PATH = "$QtRoot\plugins"
$env:VSG_FILE_PATH = "$SourceRoot\vsgExamples\data"

These exist only in the current session, and that is intentional — it prevents permanently mixing Qt versions, VSG builds, Debug and Release libraries, MSVC and MinGW libraries, or different Visual Studio toolsets.

24. Run the vsgQt viewer

& $Viewer.FullName `
    "$SourceRoot\vsgExamples\data\models\lz.vsgt"

Or the teapot:

& $Viewer.FullName `
    "$SourceRoot\vsgExamples\data\models\teapot.vsgt"

A Qt QMainWindow should open containing a VulkanSceneGraph rendering surface. The official example creates a QApplication, QMainWindow, vsgQt::Viewer, vsgQt::Window, and a widget container via QWidget::createWindowContainer(), assigned as the main window's central widget. It also adds a VSG trackball handler for interactive inspection.

At this point Qt owns the desktop window and the application event loop, VSG owns the Vulkan rendering architecture, and vsgQt connects the two.

25. Enable Vulkan validation

& $Viewer.FullName `
    --debug `
    "$SourceRoot\vsgExamples\data\models\lz.vsgt"

-d is the short form. Validation layers detect invalid Vulkan object usage, incorrect resource lifetimes, invalid command-buffer operations, descriptor errors, synchronisation problems and incorrect API usage. It adds overhead, so leave it off in production builds.

26. Common problems

`Import-VSDevEnvironment` is not recognised. The function is not loaded in this session. If it is in $PROFILE, reload with . $PROFILE. Otherwise paste the function into the terminal first.

`$PROFILE` exists but the function does not load. Check $PROFILE — the function may have been saved in the Windows PowerShell profile while you opened PowerShell 7, or the reverse. Also confirm PowerShell was not started with -NoProfile.

PowerShell blocks the profile script. Check with Get-ExecutionPolicy -List. When appropriate:

Set-ExecutionPolicy `
    -Scope CurrentUser `
    -ExecutionPolicy RemoteSigned

Review organisational security policy before changing execution-policy settings.

`vswhere.exe` is missing. Verify with Test-Path "${env:ProgramFiles(x86)}\Microsoft Visual Studio\Installer\vswhere.exe". If missing, repair or update the Visual Studio Installer.

The wrong Visual Studio version is selected. Select one explicitly with -VersionRange "[18.0,19.0)" or "[17.0,18.0)", then check $env:VisualStudioVersion, $env:VSINSTALLDIR and where.exe cl.

`cl` is not recognised. The developer environment was not imported. Run Import-VSDevEnvironment -Architecture x64.

CMake does not recognise `Visual Studio 18 2026`. That generator requires CMake 4.2 or later. Check cmake --version and update if needed.

CMake selects the wrong generator. Recreate $CMakeGenerator after importing the environment, then delete the old build directories — CMake will not reuse a build directory with a different generator:

Remove-Item `
    "$BuildRoot\VulkanSceneGraph" `
    -Recurse `
    -Force `
    -ErrorAction SilentlyContinue

Remove-Item `
    "$BuildRoot\vsgQt" `
    -Recurse `
    -Force `
    -ErrorAction SilentlyContinue

The v143 toolset cannot be found. Ensure v143 is installed through the Visual Studio Installer, or fall back to $CMakeToolset = $null. Recreate $GeneratorArguments after changing it.

CMake cannot find Vulkan. Check $env:VULKAN_SDK, $env:VK_SDK_PATH and Test-Path "$env:VULKAN_SDK\Include\vulkan\vulkan.h". Restart PowerShell after installing or changing the SDK, delete the VSG build directory, and configure again.

CMake cannot find Qt 6. Check $QtRoot and Test-Path "$QtRoot\lib\cmake\Qt6". Make sure the package is MSVC x64 and not MinGW, and that $CMakePrefixPath contains both the Qt and VSG installation paths.

vsgQt finds Qt 5 instead of Qt 6. Set $QtPackage = "Qt6" so the configure command carries -DQT_PACKAGE_NAME=Qt6, delete the previous vsgQt build directory, and configure again. vsgQt currently defaults to Qt5.

CMake cannot find VulkanSceneGraph. Verify the install with the vsgConfig.cmake search above, and check that $env:CMAKE_PREFIX_PATH includes C:\Dev\vsg-stack\install.

A Qt DLL is missing. Add $env:PATH = "$QtRoot\bin;$env:PATH" and check with where.exe Qt6Core.dll and where.exe Qt6Widgets.dll (or the Qt5 equivalents).

The Qt platform plugin cannot be found. Set $env:QT_PLUGIN_PATH = "$QtRoot\plugins" and confirm the platform plugin exists:

Test-Path `
    "$QtRoot\plugins\platforms\qwindows.dll"

For deployment, use Qt's windeployqt rather than relying on development-machine environment variables.

A VSG DLL is missing. Add $env:PATH = "$InstallRoot\bin;$env:PATH" and inspect Get-ChildItem "$InstallRoot\bin" -Filter "*.dll". Make sure the executable and libraries share a configuration — Release with Release, Debug with Debug. Do not mix them.

The viewer opens and immediately closes. Run it from PowerShell rather than double-clicking, and pass an asset. Without one, the example intentionally prints a message and exits.

The viewer cannot load the model. Check Test-Path "$SourceRoot\vsgExamples\data\models\lz.vsgt" and set $env:VSG_FILE_PATH before running again.

The application loads the wrong Qt DLL. Check every matching DLL visible through PATH with where.exe Qt6Core.dll and where.exe Qt5Core.dll, and inspect $env:PATH -split ";". Remove unrelated Qt installations from the session, or open a clean window. This usually happens when several Qt, MinGW or development-tool installations have been added permanently to the system Path.

Switching between Visual Studio versions. Do not repeatedly import Visual Studio 2022, Visual Studio 2026, x86 and x64 environments into the same PowerShell process. Open a fresh window and import the one you need — a clean process prevents duplicated or mixed compiler paths.

27. Final directory layout

C:\Dev\vsg-stack
├── src
│   ├── VulkanSceneGraph
│   ├── vsgQt
│   └── vsgExamples
│       └── data
│           └── models
│               ├── lz.vsgt
│               ├── skybox.vsgt
│               └── teapot.vsgt
│
├── build
│   ├── VulkanSceneGraph
│   └── vsgQt
│
└── install
    ├── bin
    ├── include
    ├── lib
    └── share

The dependency flow runs from the Visual Studio C++ toolchain, to the Vulkan SDK, to VulkanSceneGraph, to vsgQt, and finally to the Qt desktop application.

Conclusion

Setting up Qt and VulkanSceneGraph on Windows involves more than downloading two libraries. The compiler, architecture, Qt package, CMake generator, toolset, build configuration and runtime libraries must all agree.

A typical Visual Studio 2026 configuration is x64, the Visual Studio 18 2026 generator, v145 or an installed v143 toolset, the msvc2022_64 Qt package, and a Release configuration. For Visual Studio 2022 it is x64, Visual Studio 17 2022, v143, msvc2022_64 and Release.

The PowerShell utility keeps the workflow convenient without permanently modifying the compiler environment. I keep Import-VSDevEnvironment in $PROFILE and activate the x64 environment only when I need it — the function is permanently available, the compiler environment stays local to the terminal.

Once the toolchain is aligned, vsgQt provides a clean boundary between a conventional Qt desktop application and a Vulkan-native rendering system. Qt stays responsible for application structure, native desktop UI, tools and panels, user interaction, window management and cross-platform behaviour. VulkanSceneGraph stays responsible for Vulkan rendering, scene graph management, GPU resources, cameras and views, rendering performance and complex 3D scenes.

The result is not a replacement for Qt. It is a way to give a Qt desktop application a dedicated Vulkan scene graph without rebuilding an entire desktop framework around the renderer.