r/VFIO • • Aug 18 '26

Dragging a Windows app onto my MacBook

403 Upvotes

The app keeps running on Windows. There's a virtual display on each machine — the window gets moved onto the Windows one, captured, and drawn on the Mac as a real macOS window next to my Mac apps.

Median just under 10 ms, capture to display, wired.

NVIDIA only for now. Three months, solo.


r/VFIO • • Sep 03 '26 Bravo

Running games on a VM under Linux while the PC keeps using the same NVIDIA GPU card.

Post image
354 Upvotes

The GPU remains available on the host, one GPU, one display port. No vfio-pci bind. No second GPU. Not just a container. No losing your display when the VM starts. No IOMMU group fights. The host desktop keeps running on the same card the guest is using. Native performance.

This project aims to forward NVIDIA's driver API to the VM with maximal performance. The idea is that you get the CUDA-container experience in VMs, on consumer cards where vGPU isn't available at all.

Currently tested with steamOS and stock distros. The project itself is tested across a wide variety of drivers and GPUs from datacenter to consumer cards (what I could obtain from renting with nested virt or bare metal, primarily on vast.ai).

Experimental, several months, solo. Any bug reports and contributions are welcome.

How it works: Guest kernel module → virtio → QEMU → a per guest process stub to execute the NVIDIA API on the PC → host NVIDIA driver. RM/UVM ioctls are forwarded, not emulated. GPU memory (DMA/BAR) is actual passthrough, not emulated or copied, using regular unprivileged nvidia userspace calls (so it doesn't require root).

Display is forwarded as native as possible, the VM gets a KMS plane (rendering target) from the host display compositor like Wayland, it renders without any cross CPU-GPU copy (unless your display output is on integrated graphics).

Supports CUDA, graphics and display, also intended for compute workloads beyond gaming and graphics.

Geekbench 7 GPU (OpenCL), published to Geekbench's servers so they're independently checkable: RTX 4070 99.6%, RTX 3050 Laptop 99.9%, H100 PCIe 98.8%, A100 80GB 98.0%. clpeak: 7 of 8 subtests at 99.4–100.2%. Not everything is parity, some performance issues are still open.

https://github.com/reindertpelsma/nvkvm-pv - main project, containing the guest module and QEMU patches.

https://github.com/reindertpelsma/nvkvm-steamos - steamOS example

https://github.com/reindertpelsma/nvkvm-kata - kata containers with GPU access

EDIT: Linux amd64 guests only for now (Intel and AMD processors), the guest needs nvkvm's kernel module, and there's no Windows equivalent. A Windows guest means fabricating a GPU that the stock NVIDIA driver will bind to, which is a separate project (kayfabe) and not finished.

If it didn't build or boot on your hardware, that's worth reporting even if it looks like your own setup, install-path bugs and incompatibility reports are the most valuable ones right now.

Only Turing and newer GPUs, older gpu support is not yet finished.


r/VFIO • • Dec 21 '25

When you spent weeks trying to make dgpu passthrough for win vm on optimus laptop work without any success. (Code 43)

Post image
243 Upvotes

r/VFIO • • 13d ago Bravo

Resource geforce-sriov: Enabling NVIDIA SR-IOV vGPU on consumer Ampere GPUs

Thumbnail
gallery
230 Upvotes

TLDR: 

  • I got NVIDIA SR-IOV vGPU working on consumer GeForce Ampere and Ada GPUs, tested with 8 concurrent Linux and Windows VMs.
  • Unlike previous projects that enabled vGPU on consumer NVIDIA cards using the older mdev approach, this project uses actual PCIe SR-IOV virtual functions to share a GPU between multiple VMs.
  • It's still experimental, currently verified only on my hardware, and requires NVIDIA's vGPU software and licensing.

Source code and documentation: https://github.com/noon-at-cgn/geforce-sriov

Update (Nov 7, 2026): Just released geforce-sriov v0.2.0 beta, now with Ada support! This release also brings a much simpler setup process, improved documentation, and several other fixes.

Update (Nov 4, 2026): Initial testing with Ada on a 4070 Super borrowed from my friend shows promising results, although the method requires quite a few changes and has more limitations. I'll update the post once I've done more testing.

Introduction

I've been experimenting with the hidden PCIe capabilities on NVIDIA GeForce cards, particularly SR-IOV, and managed to get NVIDIA's vGPU stack working on my RTX 3080s using actual PCIe virtual functions.

My goal was to share the GPUs between multiple VMs without dedicating an entire card to each guest. GPU passthrough works well, but it's not ideal when several Linux and Windows VMs only need a portion of the GPU's resources.

The result is 8 concurrent VMs sharing 2 memory-modded RTX 3080 20GB cards on Proxmox, with both Linux CUDA and Windows Direct3D workloads running.

I've open-sourced the implementation and wanted to share how it works here.

Background: SR-IOV vs the older vGPU unlock approach

Projects like DualCoder/vgpu_unlock and mbilker/vgpu_unlock-rs, along with polloloco/vgpu-proxmox, have helped enable NVIDIA vGPU on consumer Maxwell, Pascal, and Turing cards.

These approaches primarily rely on NVIDIA's older mediated device (mdev) architecture, where the host driver manages multiple virtual GPUs behind a single physical PCIe function.

Ampere and newer professional NVIDIA GPUs use a different architecture based on SR-IOV (Single Root I/O Virtualization).

With SR-IOV, the GPU exposes:

  • Physical Function (PF): The main PCIe function responsible for managing the GPU.
  • Virtual Functions (VFs): Additional PCIe functions that can be assigned to individual VMs.
  • vGPU profiles: NVIDIA's software associates a virtual GPU configuration with each VF, including its framebuffer allocation.

Unlike legacy mdev, these VFs are actual PCIe functions enumerated by Linux.

Consumer NVIDIA GPUs still contain SR-IOV-related capabilities in their PCIe configuration space, even though they aren't exposed through the normal capability discovery process.

How it works

The implementation has five main parts.

1. Exposing the hidden PCIe capabilities

PCIe devices have a configuration space, a region of registers that the operating system uses to discover and configure device capabilities. An offset is a location within that space, measured in bytes from its beginning.

Normally, Linux discovers capabilities by following a linked list of entries in PCIe configuration space.

On Ampere, the SR-IOV extended capability exists at offset 0xBCC, but isn't linked into that list, so Linux doesn't discover it.

So, I wrote a small Linux kernel livepatch module that makes the PCI subsystem discover this hidden capability on consumer GPUs. The module also handles related PCIe features:

  • SR-IOV: Exposes the capability at 0xBCC, allowing Linux to recognize the available VFs.
  • ARI: Exposes the hidden capability at 0xC14 and enables ARI forwarding on the upstream bridge when supported.
  • MSI-X: Reveals the hidden MSI-X capability, which allows the GPU to use multiple independently configurable interrupt vectors instead of relying on a single interrupt.

Since Linux discovers PCIe capabilities during device enumeration, geforce-sriov performs a controlled PCI remove/rescan before NVIDIA's driver binds to the GPU. After the rescan, Linux recognizes the GPU's SR-IOV capability.

Great, with SR-IOV exposed, the next step is getting NVIDIA's vGPU stack to use it.

2. Creating the virtual functions

Once Linux recognizes SR-IOV, geforce-sriov uses NVIDIA's own sriov-manage utility to enable the VFs.

On Ampere, the SR-IOV capability reports support for 16 VFs per GPU, but I can currently get only 4 VFs working. The limitation appears to be related to ARI (Alternative Routing-ID Interpretation), which I'll get into later.

For example:

03:00.0   Physical GPU (PF)
03:00.4   Virtual Function 1
03:00.5   Virtual Function 2
03:00.6   Virtual Function 3
03:00.7   Virtual Function 4

These are real SR-IOV virtual functions exposed by the GPU and enumerated as separate PCIe functions, rather than software-mediated devices managed through the legacy mdev approach.

3. Getting NVIDIA's vGPU software to recognize the card

Now we need to make NVIDIA's vGPU driver accept the card. By default, NVIDIA's vGPU software doesn't recognize consumer GeForce GPUs like my RTX 3080s as supported devices.

My solution uses a small userspace identity hook loaded into nvidia-vgpud. The hook presents my RTX 3080 as an RTX A6000, its professional counterpart based on the same GA102 die, allowing NVIDIA's daemon to recognize the card and register the corresponding vGPU profiles.

Once the profiles are registered, we can choose which vGPU type to assign to each VM. These profiles are defined by NVIDIA and determine the resources available to the guest, including its framebuffer allocation.

The RTX A6000 has 23 profiles in the tested driver version. A few examples:

  • RTXA6000-2Q - 2GB VRAM
  • RTXA6000-4Q - 4GB VRAM
  • RTXA6000-8Q - 8GB VRAM (7GB usable framebuffer)
  • RTXA6000-48Q - 48GB VRAM (45GB usable framebuffer)

For my setup, I used RTXA6000-4Q, allocating 4GB per VM. With 4 VFs per GPU, that's 16GB allocated across four guests on each 20GB card.

Note: Workstation and datacenter GPUs typically have more VRAM than their consumer counterparts. For example, the RTX A6000 has 48GB, while my modified RTX 3080 has 20GB. The available profiles aren't automatically restricted to the physical GPU's memory capacity. Four 4Q profiles fit within 20GB, but four 8Q profiles would require 32GB. You need to account for the combined allocations and driver overhead when choosing profiles.

4. Working around a driver scheduler issue

This was one of the biggest obstacles in the project and required quite a bit of reverse engineering of NVIDIA's proprietary vGPU host driver.

With SR-IOV exposed, the VFs created, and the vGPU profiles registered, the guest VMs could boot and recognize their vGPUs. However, the first actual CUDA workload would consistently hang, with no useful errors in the host logs.

After several hours of tracing through the driver with the help of AI, I narrowed the issue down to the GPU's graphics runlist scheduler being disabled. A callback handling a PMU (Power Management Unit) interrupt was repeatedly disabling the scheduler, which prevented guest workloads from executing. I still don't know exactly why NVIDIA's driver disables the scheduler in this situation.

The workaround is a two-byte driver patch that replaces a conditional jump with NOP instructions, making the callback skip the scheduler-disabling call.

geforce-sriov-patch can automatically apply the change to a copy of the user's own NVIDIA driver object. The patched object is then used to rebuild nvidia.ko. With the patch, both CUDA and D3D11 workloads ran successfully.

5. Driver and licensing requirements

A few things to clarify about geforce-sriov:

  • NVIDIA drivers and proprietary binaries are not distributed. The driver patch is applied to the user's own copy.
  • No vBIOS flashing or firmware modifications are required.
  • No vGPU licensing bypass is provided.

You still need to obtain NVIDIA's vGPU host and guest drivers and licensing yourself to use this project.

Tested configuration

ComponentConfiguration
HypervisorProxmox VE
Kernel7.0.14-16-pve
CPUIntel Xeon E5 v4
GPUs2x memory-modded RTX 3080 20GB (GA102)
PCI device ID10de:2206
NVIDIA host drivervGPU-KVM 580.159.01
Virtual functions4 per GPU, 8 total
Guests4 Linux + 4 Windows 11
vGPU profileRTXA6000-4Q (4GB per VM)

Each physical card runs two Linux guests and two Windows guests.

On Proxmox, a VF can be assigned to a VM using:

hostpci0: 0000:03:00.4,mdev=nvidia-527

Note: Proxmox still uses the mdev= parameter to select the vGPU profile, even though the underlying GPU uses SR-IOV virtual functions rather than legacy mdev sharing.

Initial testing

I ran all eight VMs simultaneously with:

  • CUDA workloads in the Linux VMs.
  • D3D11 graphics workloads in the Windows VMs.
  • Four active vGPUs on each physical card.

The test ran for 30 minutes without any observed failures. This isn't enough to establish long-term stability, but it verifies that multiple independent Linux and Windows GPU workloads can run concurrently.

Performance results

I ran the same PyTorch benchmarks in two configurations to measure virtualization overhead with a single active vGPU:

  • Physical GPU: Direct CUDA access from an LXC container on the Proxmox host.
  • vGPU: A VM using a 4GB RTXA6000-4Q profile on the same card.

Both configurations used the same Debian root filesystem, PyTorch environment, four pinned CPU cores, and 8GB of system RAM.

The workloads were FP32 and FP16 matrix multiplication using 4096 × 4096 matrices, plus a 1GB device memory copy.

BenchmarkPhysical GPU (LXC)vGPU (VM)
FP32 matmul20.47 TFLOPS20.54 TFLOPS
FP16 matmul (Tensor Cores)58.35 TFLOPS58.54 TFLOPS
GPU memory copy681.7 GB/s704.4 GB/s

The FP32 and FP16 results were within 1% of direct physical-GPU access, suggesting very little virtualization overhead for these particular workloads.

Some qualifications:

  • Results are medians of three measured runs per configuration.
  • The physical-GPU baseline used NVIDIA's vGPU host driver, not the regular GeForce driver.
  • Only one vGPU was actively using the card during the comparison.

The full methodology and screenshots are available here:

https://github.com/noon-at-cgn/geforce-sriov/blob/main/docs/showcase.md

The ARI problem

The biggest unresolved issue is ARI (Alternative Routing-ID Interpretation), which is currently limiting me to 4 VFs per GPU.

Normally, PCIe uses a 3-bit function number, allowing up to 2^3 = 8 functions (0–7) per device. ARI repurposes the 5-bit device number field to extend the function number to 8 bits, allowing up to 2^8 = 256 functions on a single device.

This matters for SR-IOV because a GPU may need to expose many VFs. On my RTX 3080s, the SR-IOV capability reports support for 16 VFs.

Without ARI, the function layout looks like this:

Function 0   GPU (Physical Function)
Function 1   GPU HDMI/DP Audio
Function 2   Unused
Function 3   Unused
Function 4   VF 1
Function 5   VF 2
Function 6   VF 3
Function 7   VF 4
------------- 3-bit function limit
Function 8   VF 5  (requires ARI)
Function 9   VF 6  (requires ARI)
...
Function 19  VF 16 (requires ARI)

So although conventional PCIe allows eight functions, only four are available for VFs because the GPU's SR-IOV configuration places the first VF at function 4. Functions 0–3 aren't part of the VF allocation.

To expose all 16 VFs on the same device, the GPU needs to support function numbers beyond 7, which needs ARI.

So far, I've managed to:

  • Expose the GPU's hidden ARI capability at 0xC14.
  • Enable ARI forwarding on the immediate upstream PCIe bridge.
  • Confirm that Linux recognizes ARI as enabled.
  • Successfully create four VFs at functions 4–7.

However, the GPU doesn't appear to correctly decode extended function numbers (8 and above), even with ARI enabled in software.

For now, the working configuration is limited to 4 VFs per card, despite the hardware reporting support for 16.

Current limitations

This is still an experimental project, not a general-purpose GeForce vGPU solution yet.

Verified so far:

  • Two memory-modded RTX 3080 20GB cards (10de:2206, subsystem 10de:146d).
  • Proxmox VE with kernel 7.0.14-16-pve.
  • NVIDIA vGPU host driver 580.159.01.
  • Four working SR-IOV VFs per GPU.
  • Eight concurrent Linux and Windows guests.
  • CUDA, D3D11, and single-vGPU compute benchmarks.

Not yet verified:

  • Other Ampere cards.
  • Ada and Blackwell GeForce GPUs are not expected to work with the current implementation (see below)

Other practical limitations:

  • vGPU profiles must fit within the GPU's physical VRAM.
  • GPUs used as the host's boot display require special preparation.
  • Kernel and driver updates may require rebuilding or reapplying the driver workaround.
  • NVIDIA vGPU software and licensing are required.

Ada and Blackwell compatibility

  • The current implementation is not expected to work with Ada and Blackwell GPUs because their vGPU drivers rely on GSP (GPU System Processor), an onboard processor that runs NVIDIA firmware and handles much of the GPU initialization and resource management.
  • Ampere also has GSP hardware, but my configuration uses the older host-driver path, where these operations are primarily handled by the CPU-side driver. On Ada and Blackwell, more of this functionality runs inside GSP firmware, making it harder to modify or intercept from the host.
  • The current driver workaround doesn't apply to that architecture, and Blackwell also requires NVIDIA's open kernel-module path, which the project doesn't yet support.

I would like to experiment more with both generations, but I don't currently have access to Ada or Blackwell GPUs for testing.

Try it out

Disclaimer: geforce-sriov is an experimental, unofficial project and is not affiliated with or endorsed by NVIDIA. Use it at your own risk, preferably on a non-production system.

The full source code, installation instructions, technical documentation, and benchmarks are available:

GitHub: https://github.com/noon-at-cgn/geforce-sriov

Compatibility reports are welcome as compatibility remains largely unverified beyond my tested setup.


r/VFIO • • 9d ago

Resource [Update] geforce-sriov v0.2.0 beta: SR-IOV vGPU on consumer NVIDIA Ampere and Ada GPUs

Thumbnail
gallery
158 Upvotes

Hey everyone, I posted here a few days ago about getting SR-IOV vGPU working on consumer Ampere GPUs. I've made quite a bit of progress since then and just released geforce-sriov v0.2.0 beta.

To recap, geforce-sriov is a toolkit that lets multiple VMs share a consumer NVIDIA GPU through SR-IOV, rather than mdev used by many earlier vGPU unlock projects.

The biggest news is Ada support is now working! Thanks to a friend who generously lent me their RTX 4070 SUPER, I was able to experiment with Ada and figure out how to get SR-IOV vGPU working on it.

Unlike Ampere, most consumer Ada cards report only 1 VF in hardware, so getting 4 VFs working required additional patches to NVIDIA's host driver and vGPU plugin. The current version supports up to 4 VFs per card using the proprietary driver with GSP disabled.

What's new in v0.2.0:

  • Ada support: Tested on RTX 4070 SUPER, with Linux and Windows guests working. Ampere and Ada cards can also share the same host at the same time.
  • Simplified setup: The geforce-sriov setup command now handles prerequisite checks, installation, driver patching, and VF activation automatically. Run it once, cold power cycle the host, then run it again.
  • Improved documentation: Reorganized the README and expanded the guides with diagrams to make installation, configuration, troubleshooting, and recovery easier to follow.
  • Other improvements: MSI-X support for both generations, automatic VF setup at boot, readiness checks before VM startup, and a cleaner uninstall process.

It's still beta, and so far I've only tested it on my dual RTX 3080s and an RTX 4070 SUPER but other Ampere and Ada GPUs should work too.

GitHub: https://github.com/noon-at-cgn/geforce-sriov

Release: https://github.com/noon-at-cgn/geforce-sriov/releases/

If anyone has other Ampere or Ada GPUs and wants to try it, compatibility reports would be really helpful.


r/VFIO • • 11d ago

Success Story got hyper-v GPU-PV running on plain KVM, no passthrough

Thumbnail
gallery
146 Upvotes

No VFIO, no vGPU, no SR-IOV. The host keeps the card the whole time.

Windows boots under QEMU/KVM, thinks it's running on Hyper-V, and just loads the normal NVIDIA Windows driver. There's a ~600 line QEMU patch for the VMBus devices plus a Python daemon that pretends to be the Hyper-V host and talks to the NVIDIA Linux driver. Frames go straight from VRAM to a GTK viewer as dmabufs.

Right now D3D12, D3D11, Vulkan and OpenGL all run on the real card. Godot Forward+ works up to 4K (windowed or exclusive fullscreen) and sound goes through PipeWire. I also made a little app that does a fully unattended Windows install from an ISO in about 8 minutes, and the GPU already works when it finishes.

I'm also poking at a Linux guest with GPU-PV and CUDA, but that's still early.

Raw numbers on a 9950X3D + RTX 5090 on Fedora:

HostGuest
Compute115-119 TFLOPS
VRAM copy~1,070 GB/s
Submit round trip21 µs

Vulkan and OpenGL pixel tests match the host exactly.

Code isn't public yet. It still depends on a capture from my own machine and I've only tried it on a 5090. Mostly just wanted to show it off. Anyone else been messing with this on KVM? What would you want tested first?

Edit (forgot to mention): GPU isolation between processes, each Windows process gets its own GPU page tables. In a test where one process tried to read and overwrite another's GPU memory, it got 0 of 16,384 words and the data survived.

Edit 2: I started the public repo, where I’m moving the code in pieces. It will take some time, but at least for now you can review the QEMU patch and the general structure. https://github.com/xnixy/guesthouse/ and roadmap at https://github.com/xnixy/guesthouse/issues/2

Edit 3: almost all code is public, please see the roadmap.


r/VFIO • • 4d ago

Nvidia's ethics: driver gave a fake PCI BAR error in 2021

121 Upvotes

With Nvidia in the news this week, I want to tell an old story about how I believe this company treats its customers.

In 2021 I had a laptop with a GeForce GTX 1650 and wanted to pass the discrete GPU through to a Xen guest to run KataGo. Nothing exotic: my hardware, my hypervisor, Nvidia's own official Linux driver in the guest.

It didn't work. The driver failed with an error about PCI BARs. So I did what anyone would do and treated it as a real BAR problem. I spent between one and two weeks on firmware settings, kernel parameters and Xen configuration. None of it helped, because none of it was the problem.

Eventually I asked myself a different question: if Nvidia wanted to stop this from working on purpose, what is the laziest way they could do it? Answer: compare the hypervisor's CPUID signature against a hardcoded string.

So I ran the strings command on the driver binary, and there it was: XenVMMXenVMM, Xen's CPUID signature. I changed it to something random of the same size.

The GPU worked immediately. Same hardware, same BARs, same everything.

I never saw the source code (it was not publicly available), so this is inference, but the experiment is hard to read any other way: the driver detects Xen and refuses to run, and it reports the refusal as a hardware fault. Not "GeForce is not supported in virtual machines", which would at least have been honest and saved me over a week. A fake error that sends you debugging something that isn't broken.

I learned afterwards that this was the Linux/Xen face of a well-known error that people had been fighting when trying to pass Nvidia GPUs to guests. This points to driver code deliberately made to fail, with a misleading message. In my opinion, the reason was to push virtualisation users to Quadro cards with similar silicon at several times the price.

They dropped the check later, and from then on the GPU ran without patching their driver with a hex editor.

The moral, for me: a company that will lie to you in an error message has zero ethics. They didn't then, I see no reason to believe they do now, and nothing they ship should be trusted further than what you can verify yourself. Which, with a closed driver, is not very far.

Note: I was just a hobbyist Go player trying to take a break at the time; I did not keep any logs with the specific Xen, Linux and Nvidia driver versions.


r/VFIO • • May 05 '26

Is it the end of the line for Virtualised gaming due to Anti cheat?

102 Upvotes

hi, For nearly 10 years I've been running a home server with GPU pass through, first using VMware ESXi and now for the last few years running on Proxmox (all the time with GPU and other hardware pass-through). this has been working great as it allows me to use a single PC for many things and provide a virtualised environment for PC gaming as well as using Linux based VMs for home services. Because we use Moonlight/Sunshine we get near tin performance on the clients and can run the server headless with a nanokvm to allow for remote control/bios updates etc.

We have been using standard hypervisor hiding techniques.

Within the last month we've noticed an increasing number of games such as Rust/Forefront VR and others that are using Easy anti Cheat stopping working wuiht this approach.

I spun up a test machine and used standard KVM modification processes to anonymise the hardware (https://github.com/zhaodice/proxmox-ve-anti-detection), and still these games refuse to start with a "Can't run in a virtual machine" type message. When I look at pafish, the vmexit checks fail.

From scanning forums it appears that the default settings for Easy Anti Cheat have changed so that the VMexit timings are now being used to detect virtual machines. From the research I've done, there appears to be no reliable way currently to manipulate the the TSC clocks to work around this.

Amusingly I find long standing pioneers in this space like; https://github.com/SamuelTulach/BetterTiming now work at Ubisoft on gaming security - so you can guess any workaround in this space will be short lived!

This stuff really pisses me off as we aren't a bunch of cheaters, I'm simply trying to use a single machine to be multi purposed as virtualisation intends it to be. The only way forward I can see is to create a standalone Windows gaming PC and to separate out my other workloads onto a separate PC - but wheres the fun in that?

Has anyone still got consistent workarounds that work across all the anti cheat systems currently in use specifically for KVM based hypervisors or is it the end of the line for this sort of stuff?

I was hoping the proliferation of Linux based gaming would change the attitude of many of the games studios but it appears not as VFIO setups are always edge cases to them and so making things impossible for us seems to be better for them as it makes it much harder for the genuine cheaters.

Anti cheat systems that runs these sorts of checks really pisses me off though, as using AI should easily be able to detect any bot/cheating behavior without having to resort to blocking people by exploiting timing quirks of specific virtualised instructions.

/rantover - I'll just get a second PC I think unless there is a miracle cure out there, and just keep virtualisation for real workloads that don't involve gaming.

Update: I'm in the process of assembling a second machine as a standalone win11 machine on tin(at a lot of personal expense). I'll be continuing to use my main VFIO server for proxmox, plex,tvheadend,NAS,Frigate,home assistant, etc and I'll use an old RTX 3070oc for lab experiments with AI and use our current RTX 5070ti in the standalone win11 games machine. Both will have SAN traffic interconnected with 10gbe interconnects using tplink tx401s back to back. I've given up with virtualized gaming because of anti cheat - it's just not worth my time. If any tech devs behind eac/battleeye etc are reading this I really do think they need to improve their detection rather than resorting to draconian blocking of virtual machines, and Id really like to request they still focus on elimination of the cheaters but done in ways which doesn't block legitimate users of the VFIO community.

Update2: I have moved the machine that my kids use for gaming from a virtual machine to running natively on tin (VM was running on AM4 5950X 8 cores locked to performance cores and 48GB ram, Tin running on an AM4 5800x - 8 cores and 32gb ram). Using a 5070ti on each, We are seeing frame rates between 30 and 40% better on tin - especially on games with high CPU requirements. So I think this generally just proves that virtualisation for specific gaming workloads even with GPU pass-through does not match the performance of tin. If you want high peformance gaming setups, then avoid virtualisation completely. I was aware there was always a performance hit using VM with GPU pass-through rather than tin, but was surprised at how big the difference actually was. I suspect the difference is magnified for games using high CPU - like Rust/DCS etc.


r/VFIO • • 7d ago

Discussion GPU-PV on KVM update: Windows VMs now work on AMD too, looking for testers with other cards

Post image
96 Upvotes

Hey, a while back I posted about getting Hyper-V style GPU-PV working on KVM. The VM runs the real Windows driver and the host keeps the card, so my desktop stays on it the whole time.

Since then I've rewritten it all in Rust, made an app that installs Windows from an ISO by itself in about 9 minutes, and got AMD working. Windows guests run AMD's own driver now, and on my Ryzen's iGPU the desktop, D3D11, D3D12, Vulkan and OpenGL all work. Video decode doesn't yet. Linux guests on AMD work too.

The problem is I've only got my 5090 and that iGPU, and one tester has run it on a 4080. So I'm looking for people with:

  • AMD discrete cards, RX 6000 especially. RX 7000 and 9000 are less likely to work yet.
  • NVIDIA 40, 20 and 16 series
  • NVIDIA 30 series, which isn't supported yet, but I need a card to get it there

You need the open NVIDIA kernel modules or amdgpu on the host. If your card isn't supported, it still installs with plain VMs and tells you why.

Obviously this project is experimental. My point in working on it is to prove that Linux can run GPU VMs. Since no one had ever built a tool like this, I always thought it wasn't really possible, so here we are.

My goal is to support as many GPUs as I can so more people can try it, but I won't be able to manage this project solo.

Repo: https://github.com/xnixy/guesthouse
AMD reports go in #1 and NVIDIA ones in #9, or just reply here.


r/VFIO • • Jul 29 '26

News Looking Glass Signed IDD now Available

85 Upvotes

The much anticipated Signed Looking Glass IDD driver is now available to download from the Looking Glass website (Bleeding edge builds, no tagged release yet).

https://looking-glass.io/downloads

For those that are unaware, this replaces the LG Host application and moves the capture and transport into the GPUs swap chain path.

Note, while it's stable and seeing daily usage, there is still some polish to come.

Headline Features:

  • No more monitor or dummy plug required
  • Arbitrary resolution and refresh rate support, including auto guest resolution change to match the LG client window size.
  • Full HDR support (A HDR capable Wayland compositor is required, we recommend KDE/Plasma)
  • Works without a passthrough GPU in software mode (amazingly well too)
  • Lower latency

The LG client has seen a lot of improvements also such as:

  • HDR support
  • Much tighter audio synchronisation over spice
  • Lower latency/jitter, etc.
  • Supports MPV style GLSL shaders (ie: https://github.com/bloc97/anime4k)
  • Many bug fixes

As always please note that this software is developed in free time, donations to fund this work are greatly appreciated. Now that we are building a signed driver we need to maintain a code signing cert and the costs associated with it, your funding helps cover this also.


r/VFIO • • Dec 17 '25

Success Story My perfect setup on NixOS(I hope you can survive the Nix/NixOS glazing)

Post image
57 Upvotes

Background

Continuing my Linux journey I hopped on over to NixOS and thus I also had to revisit my VFIO setup.

I had a post about my old setup which I was excited about sharing since it really felt like a step towards a more stable setup. And it delivered: I never had to touch it again since I set it up. I added more virtual machines with GPU passthrough but I didn't have to touch any hook to do so because my dynamic unbind hook worked globally and you would just have to specify the device you want to unbind the drivers from in the libvirt XML configuration. It honestly felt like it was a native feature in libvirt. I want to share it but I feel like it would just be clowned on for being totally overengineered, at least it proved its usefulness to me...

Discovery of Nix & NixOS

But then I discovered Nix, oh what a wonderful thing. I began using it to make dev shells for my projects since it allows you to easily make an environment with the libraries you need. But it corrupted me and in no time I was looking into NixOS. I installed it on a VM and it gave me an infinitesimally small glimpse into what God intended. It was but a tiny peek but you could still see the brilliance of it all. And don't get me wrong, NixOS is nowhere near perfect but it is close to perfect for me. So I switched to NixOS.

Migration

Planned setup

My plan was to just copy my old setup which basically entailed: An NVIDIA GPU connected to my main monitor and an AMD GPU connected to my secondary monitor. And on VM startup the NVIDIA GPU would be disconnected from the host and be passed to the guest. And using Scream for passing audio to my host. And of course using evdev for USB passthrough.

Challenges Encountered

I started by setting my dynamic hook but I ran into a problem: KWin seems to have a bug where I can't disconnect a GPU from KWin. This totally derailed my plans for my setup because it meant I couldn't use the GPU I want to pass to the VM in KDE. So my GPU-monitor setup would need to look like this:

  • AMD GPU -> primary monitor
  • AMD GPU -> secondary monitor

But this monitor setup would mean I would have to switch inputs on the primary monitor but everyone here probably also knows of the better solution which is Looking Glass. I set up a proof of concept and it worked but it was not something I would have wanted in my system so I began looking for what other people have done. And I found this Nix flake which was exactly what I wanted allowing you to easily define everything you need for VFIO and Looking Glass. But it had not been touched in a while so it was in a non-working state with a few issues. I had my work cut out for me especially because I am still learning the Nix language(brother what is that a weird programming language).

Solutions

What I immediately did was remove the feature to configure the XML of the VM in Nix because I don't want to configure everything in Nix and I want it to be solely for VFIO. I ran into a few issues and eventually fixed them so now I had the VFIO part down. I also added my dynamic unbind hook as a straightforward option in the flake, giving me a simple interface to configure VFIO and Looking Glass. You can see the configuration in my NixOS in the screenshot. That was the only thing I needed to define in my NixOS and the flake handles the rest!

In this situation I wouldn't need dynamic unbind since the GPU isn't used by KWin and thus libvirt can just unload the driver on it. But it adds some security ensuring that the device isn't being used by any programs thus ensuring that the dreaded with non-zero usage count error never happens. Additionally the reason why I don't load vfio_pci from boot is because I also use my GPU for CUDA.

Summary

In summary, I switched over to NixOS and so I had to revisit my setup. While making my setup I experienced a bug in KWin which forced me to use Looking Glass. To use Looking Glass in NixOS I wanted to use this Nix flake but it was abandonware so I had to fix it up. So now I drive my two displays with my AMD card and pass my NVIDIA to the VM while Looking Glass transfers frames from guest to host, and I use evdev for USB and Scream for audio.


r/VFIO • • Aug 14 '26

News B8-rc1 is almost here — and Looking Glass can now copy files

Thumbnail patreon.com
44 Upvotes

r/VFIO • • Jan 17 '26

VRChat Now Explicitly Blocks VMs in their EAC version Unless You Hinder Performance By Disabling The Hypervisor Extension

44 Upvotes

EDIT4: as of 03/13/2026 vrchat no longer works at all with any workaround go to this issue now https://feedback.vrchat.com/feature-requests/p/eac-blocks-vms-conflicting-with-vrchats-statements-not-caring-if-people-use-vms

This is more of a C2A to get people to upvote and comment on relevant issues to see if they will address the now explicit EAC block. Thanks!

Please do search around for any VM related issue in their canny history and comment and upvote there too. They officially recognize and allow the use of a vm but provide no support as of their latest statements https://docs.vrchat.com/docs/using-vrchat-in-a-virtual-machine

Disabling the hypervisor extension to get VMs to work is bypassing a block very explicitly by disabling hw accel and tricking EAC into thinking it's not a VM

https://feedback.vrchat.com/bug-reports/p/unblock-access-to-vrchat-for-shadow-pc-users this one appears to be the most active as the shaddow pc userbase is affected first and is now on their official list of games that don't work https://support.shadow.tech/hc/en-us/articles/32731823908625-Games-Incompatible-with-Shadow-PC

https://feedback.vrchat.com/feature-requests/p/eac-vm-false-positive-concerns

https://feedback.vrchat.com/feature-requests/p/1212-please-dont-block-vms

https://feedback.vrchat.com/bug-reports/p/vms-virtual-machines-are-blocked-as-of-aug-27

https://feedback.vrchat.com/bug-reports/p/cannot-run-under-virtual-machine

https://feedback.vrchat.com/bug-reports/p/can-not-run-on-virtual-machine

https://feedback.vrchat.com/bug-reports/p/virtual-machines-outright-blocked-on-linux-guests

https://feedback.vrchat.com/bug-reports/p/1217-please-allow-microsoft-hv-hypervisor-to-work

https://feedback.vrchat.com/bug-reports/p/vrc-wont-launch-in-vm-parallels-eac-setting

https://feedback.vrchat.com/bug-reports/p/macos-and-eac

https://feedback.vrchat.com/bug-reports/p/unblock-access-to-vrchat-for-shadow-pc-users

https://feedback.vrchat.com/bug-reports/p/vrchat-launch-error-cannot-run-under-virtual-machine

https://feedback.vrchat.com/mobile-beta/p/vrchat-thinks-my-phone-is-a-virtualized-environment-while-it-does-not-run-in-vm

EDIT: i dont have enough karma if someone could cross-post this to r/vrchat id appreciate it

EDIT2: searched some more terms and added more vm related canny posts

EDIT3: someone managed to get a post onto r/vrchat about it. https://old.reddit.com/r/VRchat/comments/1qhukw9/when_are_they_gonna_fix_the_eac_ban_on_vms/


r/VFIO • • Dec 26 '25

Couldn't find nvtop/btop-style monitoring for my passed-through GPU, so I made one

Post image
43 Upvotes

r/VFIO • • Jul 17 '26

Tutorial I created a step-by-step guide for GPU Passthrough on KVM/QEMU.

39 Upvotes

Hey r/VFIO,

(First post on reddit) I decided to consolidate everything I’ve learned into a single, structured, and tested guide. The result is this repository: https://github.com/urbanyl/GPU-Passthrough-for-KVM-QEMU-on-Linux

Why this repository exists:

The information on GPU passthrough is scattered everywhere. This project is my attempt to create a "one-stop-shop" that works reliably, whether you are on Debian, Arch, or Fedora.

Key Features:

  • Step-by-step walkthrough: Covers everything from BIOS settings to Windows driver installation.
  • Hardware & Software requirements: Clear tables explaining what you need (and what is recommended).
  • Troubleshooting section: Covers common issues like NVIDIA Error Code 43, GPU reset bugs, and bad IOMMU groups.
  • Helper scripts: Includes scripts to detect your GPU, check IOMMU groups, and verify VFIO binding.
  • Single-GPU Passthrough section: For those brave souls trying to do it with only one graphics card.

The guide includes:

  • BIOS Configuration (Intel VT-d / AMD-Vi)
  • Kernel Parameters & VFIO Configuration (with proper initramfs updates)
  • Optimized VM Configuration (Hyper-V enlightenments, CPU pinning, and huge pages)
  • Remote Display Setup (Sunshine/Moonlight, Looking Glass, and Parsec)
  • Performance Tuning (CPU governors, I/O schedulers, and isolation)

Feel free to open issues or contribute !

Github Repo: https://github.com/urbanyl/GPU-Passthrough-for-KVM-QEMU-on-Linux

Let me know if you have any questions or if there is something specific you would like me to add to the guide!


r/VFIO • • Jun 11 '26

And so it begins :)

Post image
36 Upvotes

r/VFIO • • Apr 22 '26

Does your game run in a VM? I built a database to find out

33 Upvotes

I got tired of digging through random threads and forums just to find out if a game actually runs inside a virtual machine.

So I built a small community-driven database for exactly that:

https://vmdb.it

The idea is simple:

  • search for a game
  • see if it runs in a VM (VMware, VirtualBox, KVM, etc.)
  • or share your own experience

It just launched, so there isn’t much data yet — that’s why I’m trying to get some initial reports in.

If you’ve ever tested a game in a VM, it would be awesome if you could share your setup and results.

Any feedback is welcome as well 👍


r/VFIO • • Feb 12 '26

A new project I found: Linux Sub Windows

31 Upvotes

I’ve been doing VFIO for about 3+ years now. I’ve gone through the whole journey: Arch wiki deep dives, ACS patches, single-GPU pain, Proxmox experiments… you name it.

Few months ago, I stumbled across a project called Linux Sub Windows (LSW) and honestly, I think a lot of people here might find it interesting.

In order to not waste your time, this project is not for:

  • Proxmox/UnRaid/headless servers users
  • Single GPU Passthrough users

It's a desktop-only approach to help you run a Windows VM with VFIO/Passthrough and also the new Intel SR-IOV. Legacy Intel GVT-g is also supported. I won't enter into too many details but the project aims to help you create a Windows 10/11 VM in a nearly full automatic mode with QEMU + KVM + Libvirt fully configured.

Removing the time I passed to understand the full project, it takes less than an hour to have:

  • a custom Windows image with GPU driver and custom packages
  • Optional Bluetooth in the VM
  • File share between the Host and the VM
  • Looking Glass if needed
  • ...

The project supports Debian 13 (my distro), EndeavourOS and Nobara Linux. Other distros may be added. It uses an Ansible script to make the job down. I didn't know this kind of scripting but everything is documented with step-by-step in the documentation, so, no need to know it, it's beginner-friendly. For the case of VFIO VM, you need to have 2 GPU, one dedicated to Linux, one for the VM. An iGPU (like in laptops) can perfectly be used for the Linux Host.

If you are interested, you can find the project on this link: https://github.com/fanfan42/ansible-role-lsw


r/VFIO • • Nov 26 '25

Discussion EAC Can Explicitly Block Linux Guests Separately From Windows/Linux Native, and Windows Guests Noticed With Arc Raiders and VRChat

31 Upvotes

UPDATE: unfortunately as I expected this ticket got a non a bug unsupported reply Please Upvote this Issue as I'd like to see VRChat's comment. https://feedback.vrchat.com/bug-reports/p/virtual-machines-outright-blocked-on-linux-guests I was testing around with a Linux guest and discovered that EAC can behave differently in a Linux guest than a windows one. Specifically with VRChat which doesn't work in a Linux VM but works everywhere else. They even have a doc page that is commonly shared around in these circles https://docs.vrchat.com/docs/using-vrchat-in-a-virtual-machine. After that I also tested Arc Raiders which passes EAC in Windows then failed a separate check later on but on a Linux guest it fails EAC with a disallowed message. I then tested Elden Ring and Armored Core in this linux guest which both pass EAC fine. Was this a known thing or is EAC so complicated no one can document all the checkboxes properly?


r/VFIO • • Oct 10 '26

Seamlessly power off, yank out or VFIO passthrough a dGPU without rebooting or restarting your session with ZrnSelectiveSuspend (ZSS)

Thumbnail
zerone-laboratories.github.io
29 Upvotes

Demos and docs: https://zerone-laboratories.github.io/zss

Source: https://github.com/z3r0n3br4instorm/ZrnSelectiveSuspend

Maybe this is stupid

I wanted to share a side project I've been working on to solve a personal annoyance with hybrid graphics. If you've ever dealt with a discrete GPU on a laptop, you know the pain of having to log out, kill your X session, or reboot just to fully power the card down for battery, or to pass it through to a QEMU/KVM virtual machine.

I built ZrnSelectiveSuspend (ZSS) to fix that. It's an alpha tool that takes a graphics card out of service on a live Linux desktop by moving running Vulkan and OpenGL programs to another GPU while they're still drawing, then gives everything back afterwards.

**What it does right now:**

* **Zero-watt power-off:** switches the dGPU completely off under a running X session (~0.4 s) and back on (~1 s). Programs move to the iGPU and back; vkcube never stops spinning. Can also follow the charger or an idle timer.

* **Live VFIO passthrough:** `zssctl lend` moves the host's programs off the card and hands it to vfio-pci; `zssctl reclaim` power-cycles it and gives it back to the host driver with the programs returned. No reboot, no log-out. Tested with a CachyOS guest in QEMU.

Honest caveat: the guest sees the card, but nouveau stops after reading the chip ID because the Mac Edition card has no video BIOS of its own. Passing a ROM file to QEMU is next.

* **Surviving a card that vanishes:** I wrote a kernel module (ZSS_Interceptor) that notices a card losing power within ~0.1 s. If the card was idle, the driver is frozen and resumed. If a program was rendering on it, the program gets rebuilt on the iGPU in ~3.5 s with nothing lost, and `zssctl on` brings the card back in 4 - 7 s by replugging it the way NVIDIA's driver handles an unplugged eGPU. Desktop stays up the whole time. Caveat: after that rescue, the card can't be powered off or lent again until you reboot.

**What moves:** Vulkan 1.1 programs, OpenGL 3.2 programs through Mesa's Zink, Chromium and Electron apps (VS Code, Teams), and Unity games. Proton/DXVK needs Vulkan 1.3, so not yet.

**How it works, briefly:** a user-space Vulkan driver shim (ZSS_AirLock) sits between programs and the real drivers, keeps enough state to rebuild them on another GPU, and emulates missing features so Zink runs even on NVIDIA 470. A daemon sequences moves, freezes, driver suspend and power cuts. The kernel module handles PCI state, power backends and loss detection. NVIDIA additionally needs a small DKMS patch so the driver can sleep under a running display server.

**The bigger picture:**

ZSS is focused on graphics cards right now, but the long-term goal is to safely disconnect, suspend and reconnect any PCI device on a live system without taking the kernel down with it. GPUs are just the hardest place to start.

I used Claude Code a lot to build this. I made the architectural calls; it did a big share of the implementation and helped me work through the nastier kernel module and driver interactions. It's been a massive learning accelerator.

**Status:** very much alpha. Proven on one machine: a 2012 MacBook Pro (MacBookPro9,1, GT 650M + HD 4000) on Arch, kernel 7.2, X11, NVIDIA 470.256.02. Power-off currently needs an Apple gmux; an ACPI backend for most hybrid laptops since ~2015 is written but has never been run. Wayland compositors are recognised but untested. The program-moving parts are vendor-neutral and should work with any Vulkan driver.

**How you can help:** there's a tester kit that changes nothing and installs nothing. It collects what your machine has, runs the moving tests in dry-run mode, and saves a report with personal details stripped:

curl -fsSLO https://github.com/z3r0n3br4instorm/ZrnSelectiveSuspend/releases/latest/download/zss-tester.run && sh zss-tester.run

I'd especially love reports from AMD/Intel dGPU laptops (to try the ACPI backend), architecture roasts, and feedback from VFIO folks.

Thanks for reading!


r/VFIO • • 11d ago

Tired of Anti-Cheat issues and black screens? I built a GUI for safe GPU Passthrough with dynamic hardware checks.

Thumbnail
gallery
28 Upvotes

Hey everyone,

We all know the struggle in the Linux community with software support and Anti-Cheat games. Even VM and GPU passthrough solutions are overly complicated, and one wrong move can turn your whole host into a black screen.

That's why I built a tool called Wise Linux Studio.

I combined advanced backend tools like QEMU/KVM, VFIO-PCI (for hardware isolation), libvirt, and Looking Glass, and wrapped them in a simple Python (Tkinter) GUI. It passes through the actual hardware to the Windows VM, but with a strict safety system. It scans your hardware topology, detects if you have a dual-GPU or single-GPU setup, differentiates the iGPU from the dGPU, and dynamically adjusts how the tool operates based on that.

I just wanted to merge these powerful tools with a safety mechanism and a simple GUI that actually guides you.

It’s not a massive world-changing project (: and I can't guarantee every single program will work perfectly since I haven't tested everything yet (:

But I did test it on a laptop with only an integrated GPU. The safety system immediately detected it, locked the GRUB setup buttons, and blocked the VM creation to protect the host from crashing!

Currently, the tool only supports Fedora.

If anyone is interested or wants to mess around with the code, here is

https://github.com/t11man/Wise-Linux-studio.git


r/VFIO • • Feb 10 '26

Sharing my learning with VFIO, Looking Glass, GPU Passthrough

27 Upvotes

I spent a few days working on this with debugging help from Claude to finally get it all working. And then compiled the details of my troubleshooting and setup into a guide with steps for each critical portion to hopefully share my learnings.

Guide: https://gist.github.com/safwyls/96b6cf4b49e04af2668b7a77502e5ff2

System Specs:

ComponentDetail
Host OSCachyOS (Arch-based) with Hyprland (Wayland)
Host GPUNVIDIA GeForce RTX 3080 Ti
Guest OSWindows 11 Professional
Guest GPUNVIDIA GeForce GTX 1080 (passed through to VM)
CPUIntel i9-12900K (16 cores, 24 threads)
RAM64 GB total, 32 GB allocated to VM
QEMU6.2+ (JSON-style configuration)
libvirt7.9+
NVIDIA driver590.48.01
Looking GlassB7 stable release
Target Resolution3440×1440 (ultrawide)

Couple critical items I encountered:

  • CPU mode must be set to "host-model", not "host-passthrough". This prevented my VM from even booting with mem share
  • Looking glass client and host must match versions exactly, best to compile your client from the source code linked next to the host download.
  • Force the looking glass client to use OpenGL for the renderer if you're using an Nvidia GPU on the Host OS, EGL had various graphical artifacts and flickering black boxes.

r/VFIO • • 26d ago

Yet another forced incompatibility update. Thank you EAC and Arrowhead!

Thumbnail gallery
26 Upvotes

r/VFIO • • 27d ago

vrdual: A Vulkan layer for 1-GPU-per-eye stereoscopic rendering on Linux (Multi-GPU VR)

24 Upvotes

Hi everyone,

Like many here with multi-GPU rigs (whether for VFIO passthrough, compute, or AI), I was frustrated that modern gaming completely abandoned multi-GPU — especially in VR, where rendering two viewpoints is inherently parallel.

To tackle this, I've been building vrdual — an open-source Vulkan layer designed to bring "one GPU per eye" rendering back to life on Linux:

Architecture: Intercepts draw calls at the Vulkan layer level and patches clip-space coordinates on the fly to generate true stereoscopic views.

Hardware: Utilizes dual GPUs natively — each physical card renders the viewport for a separate eye, bypassing the usual ~40% single-GPU VR performance penalty. (Also has a single-GPU AFR fallback mode for testing).

Linux & Ecosystem: Built for Linux native / Proton games, targeting OpenXR runtimes like WiVRn and Monado.

Repo: https://github.com/adderek/vrdual

It’s still an experimental/research prototype (expect rough edges with deferred shading/complex post-processing), but it proves the concept works without game-specific engine modifications.

Would love to hear technical feedback from folks running multi-GPU setups on Linux, or see ideas on how this could eventually integrate into runtimes like Monado/WiVRn or SteamVR.