Video enhancement is often presented as a single checkbox. A real-time application must also capture or decode the source, move frames through GPU stages, synchronize audio and render the result without adding unusable latency.
Veyra-NRVideo is an open-source Windows application built around that pipeline. It combines local video playback, capture-card input and remote-play sources with GPU-based super-resolution, denoising, HDR processing and frame generation.
A third-party daily GitHub Trending snapshot on November 14, 2026 placed the project at position 11, with 256 stars gained in the daily window. Its maintainer published version 2.1.6 on the same date. The release is a useful reason to inspect the project, but its feature list should not be confused with independent benchmark results.
Source: Veyra repository. This screenshot illustrates the interface, not a measured performance comparison.
What Veyra is trying to solve
Veyra treats video playback and capture as a processing graph rather than a simple player window. Its documented sources include local files, images, capture cards, screen capture, PC streaming and console remote-play workflows.
Its processing options include super-resolution, noise reduction, HDR and color controls, optical-flow and frame-generation options, audio capture, recording, export and a node editor for supported stages. That brings local playback, capture-card preview and game-streaming enhancement into one desktop workflow.
How the pipeline is organized
The project's architecture notes describe a C++ bridge that exposes a stable interface to the QML user interface. Implementation responsibilities are split across areas such as hardware detection, capture, remote play, playback, enhancement, frame generation, color, recording, export and node-chain editing.
A simplified pipeline looks like this:
File / capture card / remote-play source
|
v
Decode and capture
|
v
Enhancement and color
|
v
Frame generation / timing
|
v
Display and recording
The order matters. A change in source resolution, HDR mode or frame cadence can affect later processing stages. Veyra's node editor lets users arrange supported stages, but the project documents constraints: it is not an arbitrary branching graph, and some combinations are restricted by the available backend.
Install the current release
Veyra is Windows-only. The project documents Windows 11 x64 and DirectX 12 as requirements. It publishes separate portable packages for NVIDIA and AMD GPUs.
For version 2.1.6:
- Open the official releases page.
- Download the package matching your GPU vendor.
- Extract it into a new writable folder. The project recommends 7-Zip or the Windows extractor.
- Run
veyra_qml_ui.exe. - Start with effects disabled, confirm the source and audio work, then enable one processing stage at a time.
Do not mix runtime files from older packages into a new release. The project warns that the 2.0 UI changed its settings layout and that old configuration folders or DLLs can leave stale components in the installation.
This is a GUI workflow rather than a Python or command-line library. Developers interested in the internals should begin with the repository's development guide and architecture notes.
What changed in 2.1.6
The November 14 release adds several recording and processing improvements:
- Instant replay: an optional rolling buffer that keeps recent processed video and audio. It is off by default and can be configured from 15 seconds up to 10 minutes.
- Microphone recording: capture a microphone alongside game audio, either mixed or as a separate AAC track.
- Effect exclusion regions: define up to four rectangular or elliptical areas where processing is excluded.
- Frame scheduling improvements: the release includes changes to frame-generation scheduling and related processing paths.
- Reliability fixes: the notes describe fixes for replay memory use, fast source switching and concurrent saves.
There is an important cost to instant replay. The application continuously reserves another hardware-encoding path and memory for the rolling buffer. Enabling it can reduce headroom on a GPU that is already close to its limits. The maintainer explicitly warns that a heavily loaded machine is not guaranteed to keep every frame after replay is enabled.
The limitations developers should read first
The project is unusually explicit about backend constraints, and that is useful.
The platform limits are significant. Veyra is a Windows 11 x64 application requiring DirectX 12, not a cross-platform library. NVIDIA and AMD packages are separate, and a visible feature may not be available on every GPU.
The v2.1.6 notes say some ANR frame-generation components are not included in the public package because the upstream collaborator prohibited third-party redistribution during the beta. Without those external runtime files, that option is unavailable. The repository also says its local experiments do not establish that every AMD or Intel GPU has passed validation.
Node mode is a constrained processing chain, not a general visual programming system. The project documents that v2.0.8 node mode does not support offline export or the global noise-reduction protection region available in list mode.
Licensing also varies by component: the original code is GPL-3.0, while the combined Chiaki remote-play application is subject to AGPL-3.0 with an OpenSSL exception. Review the license files and third-party notices before redistributing a build.
Who should evaluate it?
Veyra is worth testing if you have a Windows 11 machine with a supported GPU and want to experiment with real-time enhancement across local video, capture cards or game-streaming sources. It is also interesting to developers studying how a desktop application coordinates capture, GPU processing, display and recording.
It is not a sensible choice if you need a cross-platform playback library, a stable server-side video API, or a guaranteed quality/performance result across all GPUs.
Alternatives depend on the job: OBS for capture and production, mpv for configurable playback, or vendor tools when you need one GPU feature. Veyra's differentiator is its integrated GUI and processing workflow, not a claim that it universally outperforms them.
Watch the maintainer's demo, then test your own source
The video below is from the project's creator channel. Treat it as a product demonstration, not an independent benchmark. Test with your own GPU, source format, refresh rate and recording settings before relying on a configuration.
Sources and further reading
If you test Veyra, which matters more to you: lower latency, better image quality or a reliable recording pipeline?
AI disclosure: This article was prepared with AI assistance; technical claims and commands were checked against the linked primary sources.

Top comments (0)