VectorXR is a Windows desktop app and OpenXR API layer for tuning VR experiences on a per-game basis.
It is built for users who want practical controls for stereo depth, convergence, enhanced head rotation, and OpenXR layer management without hand-editing config files or digging through the Windows registry.
Developed by DienerTech LLC.
Pivot your foveated view. When using OpenXR quad-views foveated rendering, VectorXR is the first and only solution that also pivots your head pose so the foveated region follows the rotated view. Foveated rendering exists in a few forms — the Quad-Views-Foveated OpenXR layer, some runtimes, some game engines — and neck-assist tools rotate the view, but no one had combined the two: run as independent OpenXR layers they don't coordinate, so the high-detail foveal region is left behind the moment the view rotates. VectorXR computes Pivot and Quadviews in a single layer with shared runtime state, keeping the foveal region locked to your gaze through the rotation. In DCS — the title that benefits from both at once — they work together cleanly.
- Tune stereo depth and convergence through the Depth module.
- Configure enhanced yaw and pitch rotation through the Pivot module.
- Drive foveated-style rendering with a visible performance budget through the Quadviews module.
- Override OpenXR runtime frame pacing per application with Turbo, on SteamVR too, and compare strategies using built-in diagnostics.
- Add optical-flow generated frames between real frames with experimental Frame Generation, so the headset gets a fresh image every refresh even when the game renders fewer. It can use NVIDIA's hardware optical flow and the game's depth.
- Monitor application frame times, Turbo and Frame Generation state, and enhancements with a configurable in-headset OSD for Direct3D 11, Direct3D 12, and Vulkan games.
- Create per-application profiles so different OpenXR games can use different settings.
- Track OpenXR apps VectorXR has seen and register them as profile targets.
- Bind feature toggles to keyboard shortcuts or detected input devices.
- Inspect, enable, disable, reorder, and remove stale OpenXR implicit API layer registrations.
- View VectorXR runtime logs from inside the app.
- Check for newer VectorXR releases from the About tab.
- Import, export, reset, and validate local settings.
- Use the app, tray, OSD, and installer in eleven languages: English, Simplified and Traditional Chinese, Japanese, Korean, German, French, Spanish, Brazilian Portuguese, Polish, and Russian.
The Home tab is a status dashboard: runtime and layer status, system health, and an Active overview of every Enhancement's default profile, custom profiles, and current state.
Depth profiles tune world scale and the convergence plane globally or per application, with a live pairing map, a native-submission Depth Lock, and runtime toggles for quick in-headset A/B comparisons.
Pivot profiles configure continuous or stepped yaw and pitch assistance, per-direction tuning, bounded step glides, activation behavior, and multiple keyboard or device bindings. Snap Views add named origin-relative poses with Hold or Toggle behavior, smooth transitions, and optional position offsets. Reusable Nudge Sets provide accumulating fixed-step yaw/pitch controls. See the Snap View and Nudge setup guide.
Quadviews configures foveated-style rendering with a live performance budget that estimates render cost before you launch a game. It is not a universal injector: the game must already request OpenXR quad-view rendering. DCS is the primary tested title; other D3D11 titles may work only when they implement the same quad-view functionality. Likely, but unconfirmed, candidates include Pavlov VR, VAIL VR, The 7th Guest VR, and Kayak VR: Mirage.
For the recommended DCS + synthesized VectorXR setup:
- Turn on Use Quad View in DCS. Turn on Use Eye Tracking when you want gaze-tracked focus.
- Keep the VectorXR OpenXR layer and the relevant VectorXR Quadviews profile enabled.
- Use one software quadviews provider at a time. Disable
XR_APILAYER_MBUCCHIA_quad_views_foveated; on Pimax, also turn Native Pimax Quad Views off. Native Varjo Quadviews remains runtime-driven; on Varjo, overlays such as OpenKneeboard take the Peripheral resolution outside the focus area.
Controls marked Restart required can be saved during play, but DCS must be fully restarted for their complete effect. See the usage guide's live-update reference and Quadviews FAQ for details, alternative layer setups, and common setup pitfalls.
The in-headset diagnostic overlay has a live session control and an interactive guide for reading render zones, focus alignment, gaze filtering, and tracking availability. See Diagnostic visualization.
Turbo provides an opt-in per-application frame-pacing override, automatic runtime strategy selection, in-headset A/B controls, and performance diagnostics.
Auto tries Async first, falls back to Sequenced when needed, and remembers a strategy after 60 seconds of stable play. Custom profiles can also choose experimental Toolkit-style or Custom timing strategies, and Performance Diagnostics labels each capture with the strategy it used. Since 0.20 Turbo works on SteamVR, which used to reject some of its frames: see Turbo on SteamVR. Turbo keeps runtime reprojection such as SteamVR Motion Smoothing from working, so use one or the other, and it does not remove runtime-enforced FPS caps.
Turbo Safety is on by default and can hold Turbo off after an interrupted session or repeated runtime fault. Inspect blocked setups and fault details, retry in-game, or use Clear & retest for a fresh strategy test. Clear Logs clears fault history while preserving blocks and learned pacing decisions. Global and per-profile controls let you bypass persistent protection. See the Turbo setup and Safety guide for the controls and save/relaunch behavior.
Frame Generation inserts optical-flow generated frames between a game's frames, so the headset gets a fresh image every refresh even when the game renders fewer. By default (Dynamic) the game runs as fast as it can and generated frames fill the gaps; a Fixed rate (Auto, 2x, 3x, or 4x) holds it at a fraction of the refresh rate instead. Choose per profile between Interpolate (smoothest, fewest artifacts, a little latency) and Extrapolate (lowest latency, more edge artifacts), and compare them in game with an A/B toggle and diagnostic views. Motion is measured on the GPU's shader cores on any GPU, or with an NVIDIA RTX GPU's optical flow hardware, which Interpolate falls back from automatically when it can't keep up. Where a game sends usable depth (Direct3D 12, and Vulkan through the bridge), generated frames use it to keep cockpit detail still and sharp. The On-Screen Display shows FG ON and the headset's frame rate beside its FPS, and notes uses depth while depth helps. It works with Direct3D 11, Direct3D 12, and Vulkan games, in stereo or Quadviews.
It is experimental, and developed and tested mainly on one PC: an NVIDIA RTX 5090 with a Pimax Crystal Super on PiOpenXR and SteamVR, in DCS (Direct3D 11 with quad views), MSFS 2024 (Direct3D 12), and Star Citizen (Vulkan); beta testers have also run it on Varjo headsets and on Steam Frame. AMD and Intel GPUs are untested: measuring motion on the shader cores works on any GPU, but the bridges that carry Direct3D 11 and Vulkan games' images to Frame Generation have not been verified on AMD. Motion is measured on the final images (no game motion vectors yet), text and HUDs can shimmer on generated frames, and the real frames it keeps take video memory: about 0.55 GB each at 6864x6908 per eye. Turn off runtime smoothing, in the runtime and in the headset's own software, such as SteamVR Motion Smoothing, Pimax Smart Smoothing or ASW (the OSD and log say so when the runtime holds Frame Generation's frames to half rate), and expect Turbo to stay off where Frame Generation runs. Turning it on needs a game restart. See the Frame Generation guide. In Star Citizen and other online games with anti-cheat, it is at your own risk: see Current Status.
The On-Screen Display adds an optional head-following panel in Direct3D 11, Direct3D 12, and Vulkan games showing application FPS, frame times, a frame-time graph, CPU and GPU headroom with video memory, Turbo and Frame Generation state, Pivot, and active enhancements. Choose compact or expanded layouts, place the panel with a live preview, customize its contents and colors, save presets, pick its language (or follow the app's), and show or switch it in game with Ctrl+Alt+F10 and Ctrl+Alt+F11. See the On-Screen Display guide.
The application registry keeps profile targets organized and can turn discovered OpenXR apps into reusable application entries.
The OpenXR layer manager inspects installed implicit API layers across the Windows registry slices, shows signature and path status, and can enable, disable, reorder, or remove stale registrations.
Settings holds the runtime master switch, the app language, theme, the system tray icon, discovered-app tracking, input rescan, logging and the debug export, sound feedback volume, and config import/export/reset.
The About tab includes release status, GitHub update checks, project links, patch notes, and support information.
VectorXR has two main pieces:
- A Tauri desktop app for settings, profiles, update checks, logs, and OpenXR layer management.
- A Windows OpenXR API layer that reads those settings and applies runtime adjustments when an OpenXR app is running.
The installer registers the VectorXR API layer with Windows so OpenXR runtimes can load it automatically. Settings are stored locally under %LOCALAPPDATA%\VectorXR.
For a walkthrough of configuring profiles and each module — Depth, Pivot, Quadviews, Turbo, Frame Generation, the application registry, and OpenXR layer management — see the usage guide.
Download the latest Windows installer from the GitHub Releases page:
https://github.com/DienerTech/vectorxr/releases/latest
Run the installer, then launch VectorXR from the Start menu or desktop shortcut.
VectorXR installs its OpenXR API layer machine-wide, so the installer may require administrator permission.
The About tab can check GitHub for the latest published VectorXR release and open the release page when a newer build is available.
VectorXR does not currently auto-download or auto-install updates. Updates are installed manually from GitHub Releases.
VectorXR is in beta. It is feature-complete for its current scope — the desktop app, Windows installer, OpenXR layer registration, per-application profile model, Depth, Pivot, Quadviews, and Turbo modules, app discovery, logs, update checks, and the OpenXR layer manager are all implemented and working. Frame Generation is new and experimental.
Beta means it is ready to use day-to-day, but it is young and has had limited real-world testing across the range of VR runtimes, hardware, and game-specific VR behavior. Some games expose Force IPD or world-scale controls that can override Stereo Boost; disable those controls before testing Depth. VectorXR is designed to be reversible: you can disable any Enhancement, disable the VectorXR layer, or uninstall entirely if anything misbehaves.
Feedback and bug reports are welcome — that is what this stage is for.
Official Windows releases include an app, OpenXR layer, and installer signed by DienerTech LLC. Local source builds may be unsigned. Broader cross-runtime testing and packaging improvements remain part of the road to 1.0.
Online games with anti-cheat: Using VectorXR in online games with anti-cheat, including Star Citizen, is at your own risk, and that includes your game account. Official releases are code-signed, and VectorXR has run under Star Citizen's Easy Anti-Cheat in testing, but no game developer has endorsed it, and a developer can change what its anti-cheat allows at any time. Report problems with VectorXR, Frame Generation included, to VectorXR rather than to the game's developer.
VectorXR is Windows-focused and expects:
- Visual Studio with Desktop C++ tools
- CMake 3.28+
- Node.js 22+ (CI uses Node.js 22)
- Rust toolchain with
cargo - Tauri 2 prerequisites for Windows
- Download the OpenXR SDK from KhronosGroup
- VectorXR needs either an OpenXR SDK that provides
OpenXRConfig.cmake, or a localOpenXR.Loader.*.nupkgpackage in the repository root
The local OpenXR.Loader.*.nupkg package is intentionally not tracked in source control.
CI and the GitHub release workflow install the OpenXR loader from a pinned vcpkg registry
before building the layer.
Frame Generation's NVIDIA hardware optical flow builds from the two MIT-licensed interface
headers of the NVIDIA Optical Flow SDK
included in third_party/nvidia-optical-flow/; no SDK download is needed. The optical flow
library itself, nvofapi64.dll, comes with the NVIDIA driver and is loaded at run time.
Install app dependencies:
cd app
npm ciBuild the frontend:
npm run buildBuild the production Windows installer:
npm run installer:buildThe installer build compiles the OpenXR layer, stages the layer DLL and manifest for Tauri, and produces an NSIS installer under app\src-tauri\target\release\bundle\nsis.
GitHub builds release installers from vMAJOR.MINOR.PATCH tags. First add the release as the first object in app/src/lib/patchNotes.json. The release script uses that object as the single source for the date, title, summary, and complete nested change list; it then updates every version location and lock file, generates matching Markdown release notes, validates the result, commits it, creates an annotated tag, atomically pushes the branch and tag, and waits for the GitHub Release workflow:
.\scripts\Set-Version.ps1 -Version 0.14.0 -PublishRun the command from a clean branch with working Git credentials and an authenticated GitHub CLI (gh auth login). Use -WhatIf to preview the operation, or -NoWait with -Publish to return after the tag is pushed instead of following the workflow. The generated release body is committed at release/notes/vMAJOR.MINOR.PATCH.md; .github/workflows/release.yml uses it verbatim and uploads the Windows installer plus a SHA-256 checksum.
In-app and GitHub release data lives in app/src/lib/patchNotes.json. Author the complete entry there before running Set-Version.ps1; nested items are preserved in both the app and generated Markdown:
"items": [
{
"html": "<strong>DepthXR</strong>",
"items": [
"First DepthXR change.",
"Second DepthXR change."
]
}
]Patch-note summaries and item text support the attribute-free inline tags <strong>, <em>, <code>, and <br>. Lists stay structural JSON rather than raw HTML, and all other markup is escaped by the app renderer.
app/: Tauri 2 and Vue 3 desktop applayer/: C++20 OpenXR API layer and runtime logicconfig/: shared schema and config notesdocs/: architecture notes, the usage guide, and screenshots (index)examples/: sample settingsscripts/: Windows build, install, staging, and release helpers
Programs that read VectorXR's live state while a game runs (for example, to tune the game's settings around Frame Generation) use the status API.
An opt-in real-runtime OpenXR diagnostic client is also available for deterministic Pivot reference-space and Turbo frame-threading tests. See the hardware probe guide.
VectorXR exists in the wider OpenXR community, and several open source projects helped shape it.
- Quad-Views-Foveated by mbucchia: an OpenXR API layer for quad views and foveated rendering. It has been a major reference point for real-world OpenXR API layer behavior and compatibility concerns.
- OpenXR API Layers GUI by Fred Emmott: a Windows tool for viewing, enabling, disabling, and reordering OpenXR API layers. It directly inspired VectorXR's built-in OpenXR layer management experience.
- XrNeckSafer by NobiWan: an OpenXR neck-saver utility that helped prove how useful runtime rotation assistance can be for seated VR and flight simulation setups.
Thank you to the maintainers and contributors behind these projects.
The VectorXR source code is released under the Mozilla Public License 2.0 (MPL-2.0). See LICENSE.
MPL-2.0 is a file-level copyleft license: you are free to use, modify, and redistribute VectorXR, including as part of a larger work that combines it with proprietary code, provided that modifications to the MPL-covered files themselves remain available under the MPL.
THIRD-PARTY-NOTICES.txt lists the third-party code that VectorXR ships, with the notices and license texts it requires. The installer puts it next to the app, together with LICENSE as LICENSE.txt. After changing the app's dependencies or its build setup, regenerate the list with node scripts/generate-third-party-notices.mjs.
VectorXR, the VectorXR name, and VectorXR branding are product identifiers of DienerTech LLC. Consistent with MPL-2.0 section 2.3, the license covers the source code but does not grant rights to use DienerTech LLC trademarks, logos, or branding except to refer to the project.