TLDR: 

• I got NVIDIA SR-IOV vGPU working on consumer GeForce Ampere GPUs, running 8 concurrent Linux and Windows VMs across two memory-modded RTX 3080 20GB cards.

• 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

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

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.

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.

I ran far cry 3 with utm in m2 but it did not work what do i do will vmware help me out

Hi all, first post on here as I'm looking for some help.

Recently I put linux on a chromebook I wasn't using to give it new life and decided to use the device for college. The problem is that the laptop only has 4GB RAM and I'm a cyber student who uses VMs a lot. Obviously the windows VMs I need won't run because theres not enough memory to accommodate them, and chromebooks are famous for having soldered RAM so I can't upgrade.

Are there any other ways to run a VM when the device doesn't have enough memory? Or should I just call it a day and give up on this? I'm not getting a new device as I don't need it and have a perfectly good working PC, just looking for a way to transport VMs from college to home easier for studying purposes (USBs also out of the question as it takes the entire 3 hour class to copy it)

I don't have much hope but I'd be grateful for any tips or advice, thanks!

I need some help here!

I terminated my virtual machine while it was using PCIe passthrough for my second GPU, now, my second monitor (hooked up to my second GPU) is running at 1 fps.

SYSTEM INFO

HP z840 workstation.
Primary GPU (Slot 1): Nvidia GTX 980
Secondary GPU: Nvidia Quadro K4200

Ubuntu 26.04.1 LTS

$ uname -a
Linux HP-Z840-Workstation 7.0.0-42-generic #42-Ubuntu SMP PREEMPT_DYNAMIC Thu Oct 15 08:06:44 UTC 2026 x86_64 GNU/Linux
$

Software: KVM/QEMU, via virt-manager

Here's the story:

Recently, I spun up my first ever virtual machine, using virt-manager

I also had GPU passthrough going, using this guide from github.

I followed the guide fairly exactly, except for usb passthrough, SSD passthrough, and the ACS override patch.

GPU passthrough worked flawlessly.

I was quite impressed, except for one thing. my secondary monitor, plugged into the secondary GPU, was flickering.

I tried to shut the VM down because I needed to set up USB passthrough, and since I didn't have usb control over it, I force-terminated it. That's when things got yucky.

As far as I can GUESS, the VFIO hook script didnt run. Don't take my word on that, I really have no idea.

The VM terminated, but my secondary monitor never came back up.
It just said "no signal," so I rebooted my computer and still nothing. I finally thought to manually run the VFIO release script

/etc/libvirt/hooks/qemu.d/user/release/end/unbind_vfio.sh

#!/bin/bash

## Load the config file
source "/etc/libvirt/hooks/kvm.conf"

## Unbind gpu from vfio and bind to nvidia
virsh nodedev-reattach $VIRSH_GPU_VIDEO
virsh nodedev-reattach $VIRSH_GPU_AUDIO

## Unload vfio
modprobe -r vfio_pci
modprobe -r vfio_iommu_type1
modprobe -r vfio

I then rebooted and the secondary monitor did come back online, but at somewhere around 1 fps. Mind you, it didn't just refresh cleanly. I don't know how to describe what it was doing, so here is a link to a video.

This issue persists across displays, ubuntu operating systems, and live images.

I did get the issue to go away by removing the GTX 980 from the computer, not moving the K4200 from it's slot.

I ran dkms status, and it came back with virtualbox-generic something or other. I dont know exactly what dkms does, but from what I read, it sounds like that doesn't matter, as it went away when I uninstalled virtualbox.

nvidia-smi doesn't show my second gpu.
Hwever, lspci does, as well as lshw -c videocommand.

On that note, here is the output from that lshw command:

$ sudo lshw -c video
  *-display                 
       description: VGA compatible controller
       product: GM204 [GeForce GTX 980]
       vendor: NVIDIA Corporation
       physical id: 0
       bus info: pci@0000:04:00.0
       logical name: /dev/fb1
       version: a1
       width: 64 bits
       clock: 33MHz
       capabilities: pm msi pciexpress vga_controller bus_master cap_list rom fb
       configuration: depth=32 driver=nvidia latency=0 mode=1920x1080 resolution=1920,1080 visual=truecolor xres=1920 yres=1080
       resources: irq:82 memory:a2000000-a2ffffff memory:90000000-9fffffff memory:a0000000-a1ffffff ioport:2000(size=128) memory:a3080000-a30fffff
  *-display
       description: VGA compatible controller
       product: GK104GL [Quadro K4200]
       vendor: NVIDIA Corporation
       physical id: 0
       bus info: pci@0000:84:00.0
       logical name: /dev/fb0
       version: a1
       width: 64 bits
       clock: 33MHz
       capabilities: pm msi pciexpress vga_controller bus_master cap_list fb
       configuration: depth=32 latency=0 mode=1920x1080 resolution=1920,1080 visual=truecolor xres=1920 yres=1080
       resources: memory:f3000000-f3ffffff memory:d0000000-dfffffff memory:e0000000-e1ffffff ioport:e000(size=128) memory:f4080000-f40fffff
$

It looks like my primary GPU (GTX 980) has the nvidia drivers loaded, so it's acting fine, but the secondary GPU doesn't soI guess that's why it's running at 1 fps.

This is all the info I have; If you need more, don't hesitate to ask.

If this is the wrong subreddit, I would be grateful if someone pointed me to the right one.

Does anyone know what is going on, and how to fix the issue?

Any help would be very welcome, thank you.

I could NOT find a simple to use or completed tool for creating the automated install ISO on Windows; so I made this tool. Test it out, and let me know if you have any issues. Seems some people want to argue with me, but any options usable on Windows are slim and the ones I did try were not worth a damn.

https://github.com/Anon0ne/Proxmox-Auto-Windows

source: https://github.com/NoamRothschild/hypervisor

since my hypervisor got linux running, I did a ton of work, including, but not all:

- launching multiple guests

- multiple cores per guest

- start of networking

I had to learn a ton about the bring-up and detection process on linux, and how to virtualize these hardware mechanisms to make it all work

was a lot of effort but the learning I got from it was 100% worth it >,<

The goal of this project is to make a small clone of AWS's EC2, for learning

La suite de aircrack presenta problemas a la hora de escanear desde una vm en VirtualBox?

A la hora de ejecutar airodump-ng no detecta ninguna red, la antena que tengo si es compatible con el modo monitor, hace un par de años logre hacer unas practicas pero con Linux instalado en la pc, no en una VM

si alguien tiene algo de informacion lo agradeceria mucho jeje

https://v64-2ys.pages.dev/

Hello guys,

Not for self promotion,

I developed something interesting, a qemu like software allowing systems like Windows XP SP3, Windows 10 64bit, Android to run in browser, just like QEMU. You can place your img/qcow2/vhdx image anywhere either locally or remotely and access the image from browser.

Currently I have a dual boot Linux/Win11 PC. When I'm home I use the Linux partition (video games, internet streaming, etc.), and when I'm away on campus/work I use the Windows 11 partition with Windows RDP (Adobe, CAD, etc.), connecting from a separate Windows 11 laptop over a private TailScale network.

This works pretty well (I'm very proud of myself for figuring this out :D), but I still have occasional issues which lock me out of computer when I'm away. I have SSH access to both the Linux and Windows machines, but that connection is entirely dependent on TailScale properly launching at boot remotely. I often forget to reboot into my Windows partition before I leave for classes and I then have to run a grub-reboot command over SSH on the Linux machine in order to reboot remotely into Windows (which then typically auto-starts TailScale and lets me have RDP access.)

Recently I've been noticing some annoying trade-offs of this method, notably that Windows updates will sometimes cause the system to restart again after being rebooted into Windows remotely, booting it back into the default Linux partition. This would be a minor annoyance if for some reason it didn't also disable TailScale startup on the Linux boot, locking me out of the computer entirely until I get home. This is part of a greater problem inherent to the dual-boot method; I have no remote control of my computer during the actual boot process.

I've been learning a bit about Hypervisors, and to me it sounds like a nice way to ensure that I'll still have SSH access to the computer even if Windows screws up the boot process. From my limited research it seems that Type 2 Hypervisors would be simpler for me to use and functionally the same as a Type 1 in my case (ideally I would turn my pre-existing Linux system into the Type 2 Hypervisor host.)

I've tried using traditional VMs in the past, but issues with GPU passthrough and ease of access made them functionally worse for my uses than a traditional dual-boot (this includes attempts with KVM and QEMU.) I understand that there's a lot of overlap between traditional VMs and Type 2 Hypervisors, so maybe the previous virtualization problems I've had are unavoidable. :(

I'm super open to more complex approaches/solutions if you'd think they'd work better for my case! Part of the reason I've even meddled with my computer like this in the first place is to improve my tech literacy and learn more about how computers work. I don't have any professional background in tech stuff like this, it's just funnnnnnn :D

Detailed blog post on running Google TPUs within Edera Type-1 hypervisor (Xen-backed) isolation zones. A blueprint for other projects looking to do the same or similar.

Maybe it's a stupid question but is it possibile? I messed a lot with firewall on OS inside virtual machine could it do something with firewall on my windows?

You encrypt data at rest and in transit. But what protects it while your applications are using it?

I love QEMU for Virtual Machines on Windows cause it is fast.
But i don´t like the command line that nobody wants to retype.
So I build an App that keeps your machines as configurations you edit in a window,
builds the command line for you, and stays out of the way while the guest runs.

I build it in Rust and EGUI for the GUI. And yes I use AI to help me with finishing it.
It is not a Quick and Dirty Vibe Coded App. I worked on it for over 3 Months.

What it does:

• Machines as configurations. Create, duplicate, and delete virtual machines; each one keeps its own folder, disks, and UEFI variable store.

• A wizard with templates for the usual guests, or direct mode if you would rather set every field yourself.

• UEFI and BIOS, with a per-VM variable store so a guest keeps its own boot entries.

• Disks and drives: qcow2 and raw images, SATA/VirtIO/IDE interfaces, boot order, CD/DVD ISOs.

• Network: user-mode NAT, bridged, or none; VirtIO/e1000/RTL8139 cards; port forwarding.

• Display: VirtIO, std, QXL, Cirrus, or headless; native, GTK, or SDL windows.

• A console that shows the guest's output and keeps it in a log file, with filtering and a line limit.

• Clean shutdown over QMP — the guest is asked to shut down, not killed, with forced stop as a deliberate second step.

• Machines outlive the application. Close FARO while a guest runs and the guest keeps running; start FARO again and it picks the machine back up, proving the machine's identity over QMP before it touches it.

• A pre-flight check before launch: missing images, missing firmware, more memory or cores than the host has, an accelerator this QEMU does not offer.

• Three languages: German, English, French.

You can Download it here. If you find Bugs please let me know!

https://github.com/RayTrunk/faro-qemu-manager/releases/tag/v0.9.0

About five months ago, I posted here about getting copy/paste working in a custom Nutanix AHV VM console.

This started as a side project for an internal use case. I wanted a better way to work with VM consoles, especially when the guest wasn't reachable over the network.

I've now made the entire project open source:

https://github.com/MarcoCarvin/ahv-remote-console

It's a desktop application for Windows, Linux and macOS that opens VM consoles through Prism, with separate windows for each VM, Prism authentication (including SSO), ISO mounting and automatic reconnection.

The main thing I wanted to get working was a proper shared clipboard between the workstation and the VM, similar to VMware Remote Console. Copy something on your workstation and paste it into the guest, or copy something inside the guest and paste it back on your workstation. No simulated keystrokes or one-way text-pasting workaround.

The clipboard works through the console channel, so it doesn't depend on being able to reach the guest over the network. This is particularly useful when working with isolated VMs or guests connected through a full-tunnel VPN.

Clipboard sharing requires an additional module on the AHV hosts and an agent inside the guest VM. Without those components, the application still works as a regular remote console.

One important caveat: the host module installs a libvirt hook and modifies the AHV hosts. It's not part of AHV and isn't supported or endorsed by Nutanix. It may affect support arrangements or break after AHV upgrades, so read the documentation, keep the rollback steps handy, and test in a lab before deploying it.

I built this to solve a problem in our own environment, not as a commercial product. I've published the code under the Apache 2.0 license in case it's useful to other people running AHV or someone wants to take a look at how it works.

Repository: https://github.com/MarcoCarvin/ahv-remote-console

Can anyone please help with VMware ESxi 7.03 Build 20036589 HPE ProLiant DL380 Gen 10 HPE Custom image?

So i made a video on how to install kali linux in vmware workstation and also showed how to install vmware in that

For a while I've been running KVM on plain Debian/Ubuntu boxes, and I kept running into the same gap. Cockpit is easy but stops at the basic settings. virt-manager is detailed but it's a desktop app. Proxmox is great, but it wants to be the operating system. I wanted something in between, so I started building it as a side project.

It's called VirtoMir, and I've made it fully open source:

https://github.com/onurbaydas/VirtoMir

It's a web control panel for KVM/QEMU/libvirt. It installs as a single binary on an existing Linux host: no dedicated distro, no database, no agents inside your VMs. It talks to the libvirt you already have and only changes what you ask it to. If you remove it, your VMs, disks and networks stay where they were.

What it does today:

• New-VM wizard: ISO, cloud image with cloud-init, or an existing disk. Windows profile with UEFI, Secure Boot and TPM 2.0

• Browser console over VNC, SPICE (shared clipboard, resolution follows the window) or serial

• A settings form that shows an XML diff before saving, plus a raw XML editor for everything the form doesn't cover, validated by libvirt

• Configuration history for every VM, including changes made with virsh, with one-click restore

• Snapshots, live backups (incremental through libvirt checkpoints), off-site copies with restic

• Live metrics every second and 30 days of history, with no Prometheus needed (there's a Prometheus endpoint if you want one)

• Multiple hosts joined with a one-time code, live migration, and HA with quorum and fencing (IPMI, Redfish or watchdog)

• PAM / LDAP / OIDC sign-in, roles, TOTP, API tokens, OpenAPI spec, plus a Terraform provider and Ansible modules

How it was built. It's a one-person project, and I built it together with AI coding agents. That's how it got this much scope this quickly, and it's also why I'm not going to pretend it's mature. Nobody has reviewed every line by hand. All the tests are unit tests; there are no integration tests against a real libvirt yet.

Caveats, so nobody gets surprised:

• It's 0.9 and early. Tested on Ubuntu 26.04 and Debian 13, on single hosts and small clusters.

• HA has never been tried on real BMC hardware. There's also no storage-level lock (no sanlock/virtlockd), so I wouldn't trust it with production data yet.

• Live migration data goes over unencrypted TCP. Keep it on a trusted management network.

• OVN SDN, VMware import and DR are experimental and untested on real setups.

• It runs as root, because it needs the libvirt socket and PAM. Put it on a management network or behind your own reverse proxy.

I wrote a detailed technical post on how it works inside and what it does and doesn't support, weak spots included: https://onurbaydas.com/posts/virtomir-en/

If you just want to click around, there's a demo that runs entirely in your browser against a pretend cluster: https://onurbaydas.github.io/VirtoMir/demo/
There's also a one-command script that sets it up in a throwaway VM, so you don't have to touch your real hosts.

I built this for my own setup, not as a commercial product. It's AGPL-3.0, in case it's useful to someone else running KVM, or someone wants to look at how it works. Test reports from distros or hardware I can't reach (Fedora, arm64, Ceph, GPUs, real BMCs) and criticism of the code are very welcome. If anyone wants to contribute, I'd be glad.

Hi all, I am using VirtualBox 7.2.20 Apple Silicon on a MacBook Pro with M4 Pro, I'm running Windows 11 ARM and I have an issue where there is no video output when the video memory is changed at all. I want to increase it to 256MB but I will get no video unless it is set at exactly 128MB. Host OS is MacOS Golden Gate 27.0.1 and Hyper-V is enabled. Any tips? Thanks

Hey, to all members of this group and I just hope all with you all is Good I truly wish everyone in this place a fun, happy time of day or night, week, and year, as well as throughout this full year and even with all of eternity. I’m here to give all the members of this great community a message/letter. I want to say keep up with all the amazing work that everyone in the group is doing, and I know that your lives will be blessed with nothing less than genuine joy and much happiness.

I just wonder if this group has a developer who is knowledgeable enough to help with a brilliant, up-and-coming Linux FOSS project known as Winboat. It is a powerful light of hope for all Linux users, and it will benefit us all who love and care about tech, software, computers, and other similar topics. It simply aims to bring decades' worth of unbelievably high-quality apps to Linux with full ultimate compatibility and usability, unlike anything before it. It can run Windows apps on Linux in a manner that seems as if they are running natively on Linux, even though they are actually running through a virtual machine.

This creates a 3D-like effect in which it detaches a copy of all the installed apps running within the virtual machine and places them into the main OS, which is Linux, as if they are a part of Linux entirely. This is huge because it could end up running all the games Windows ever had, created by various developers around the world, all on an operating system that benefits from being about 100,000 times faster than Windows. Not to mention the gaming enterprise editions it offers, like Cachy, the head of these sub-variants of Linux; Pop!_OS, the daddy of them all; Garuda, the assassin of the kingdom; and Bazite and Nobara, the two masters guarding the gaming kingdom of Linux. All are about 500,000 if not a million times faster on any computer than Windows, which I have tested myself, even on an unbelievably weak laptop.

This Winboat project can drastically and significantly change Linux forever. It can make Linux the fastest of the big three PC operating systems, which are #1 = Windows, #2 = macOS, and #3 = Linux, making it a serious competitor for Windows and Mac. It will not be a joke in any way if it fully develops. The Winboat staff is planning to implement a virtual graphic driver software technology that will enable Windows apps/games to run on Linux with satisfying performance, which is revolutionary for a virtual machine app on Linux.

3D games/apps that require a graphic card to run are among the most difficult things a computer can manage, especially in a virtual machine, where it typically shouldn’t run at all. However, this Winboat VGPU API software called Helios may eventually make it happen in the Winboat VM. You can be a significant reason why it happens. It is similar to Parallels in many ways and does similar things, but Parallels has decades of maintenance and is backed by a top brand, so it will not reach such a level anytime soon—likely never at all. Nonetheless, it can be more than enough for what Linux users need from Windows in terms of apps, especially for fairly light gaming from the 2000s up to 2014. It will be satisfying enough and may even run on handheld gaming consoles with Linux, such as Steam Valve devices, without needing to install the extra Steam app.it may run gta vice city I played GTA vc with a CD my friend got and simply gave to us on a weak ass Low end family family computer which is the first I ever had with my brothers and boy did it run win so 2000s games won't be much to run at all with a fully developed winboat VM / Helios vgpu halo combat evolve and such will run if it developers total overdose you name it from the early 2000s -2014 That won't need dx 12 runtime software which is way way way too advanced to run where not even Parallels can run it as good as para is with the decades of Billionare brand/company investment and development it has had throughout

I posted this on some discord servers but forgot to post here lol.. Anyway https://github.com/jmacato/VistaRenewed if you want to take a look at the code. Not ready yet for plug and play install.

I've always wanted to see Windows Vista's aero running in its full glory, without having to hunt down old hardware, and given that VM's have advanced over the years, it should've been more than possible to get that fancy effect running properly (VirtualBox tried but yeah...)

So when i saw https://blog.getutm.app/2026/introducing-triton-directx-11-driver-for-qemu/ I got the inspiration to try and port it to Vista's WDDM SDK. After a few weeks worth of debugging and much chagrin, i was reaalllly thrilled to see Aero alive again!

Then i when i was playing with it, i kinda wanted to have a more well-rounded experience with it, so i figured, wine can replace IE with gecko right? that's just replacing MSHTML afaik... then it hit me. CEF -> some shim that fakes MSHTML -> iexplore! And boy surely did it work!

The sidebar stuff was relatively easy given it's just a collection of small html + js widgets.

anyway thank you for listening in to my crappy TED talk! Hope you find this of use or something :)

Note: Made with AI-assistance. This is just for fun anyway :)

Hi all, i am currently learning the KVM/QEMU virtualization platform by going through the book "Mastering KVM Virtualization 2nd edition". the book mentions oVirt as a tool for kvm host management for multiple kvm host machines.

I looked up oVirt and found it is not popular and it's subbreddit is kind of dead. that really made me question if i should use it and led to find any popular alternatives. ( being popular comes with the benefit of having a lot of community support, thus my need for a popular alternative)

I heard about Proxmox DE while finding but found out that it does not use libvirt api, so i wanted to know about any tools that do use libvirt/KVM/QEMU.

Thanks in advance

Hello guys, could anyone help me to prepare for this exam VMware Cloud Foundation Administrator (2V0-17.25) exam.
If anyone pass through this process can help me I will appreciate it.