Preserving Google Coral (Google's small AI Chip)

I'm writing this article to document basically everything I know about Google Coral, including how to configure a chip, because on April 19 2026 Google has archived all github repos associated with it and I get the feeling they'll shut down the apt repository any day now (It already gives a deprecated key warning). My objective is to simply make a virtual machine that acts as a preservation device, where I can just copy it into any machine and start working with the chip immediately because who knows, it may prove useful at some point in the future.

The problem with getting Coral to work in the #CurrentYear of our Lord 2026™ is twofold: The drivers will fail to load most of the time on ver. 6 of the Linux Kernel (ANY 6.x kernel version) and the fact that Google released the chips and never updated the code or anything, making it require a Python version older than 9 (The whole software stack is actually made for Python 8 which is what I used here) and having at least one pip package completely unusable in modern system, I struggled with this for a while (Probably compounded with trying to run it in a virtualized environment instead of bare-metal?) but I eventually got it to run.

Originally I had intended to put this off for a while because I remember it was a PITA to setup but me starting development of this blog also coincided with the deadline 10 days before Ubuntu ended all support for Jammy, which is the last non-RHEL-based Linux distro that I could think of that still supported the Linux kernel 5.x and apt so instead it went to the front of my priorities as this was the last time I could get a virtual machine to work with the chip in the future without major headaches.

I'll keep this guide as descriptive as possible (Including things that I usually don't find necessary to document like adding a repository or running apt install) because honestly? The way Google is treating this project makes me think this may end up as the only surviving guide on how to configure it given enough time.

What is/Was a Google Coral TPU 

Coral TPU's (Tensor Processing Units) are a set of devices that Google released in 2019 in order to allow developers to run AI models for small devices.

Coral TPU's came in three form factors:

• A USB dongle: Probably the most common as most Youtube videos I've seen featuring coral use these. They were commonly used with SBC's or raspberry Pis.
• Different M.2 models: Keyed for PCIe or to be insterted in the slot where the wifi network card usually goes.
•  A dev board: A fully-featured SBC that had a Coral TPU embedded into it, despite having some of the worst specs I've seen for a SBC I've always seen it for up to 3x times the cost of a raspberry pi, it's the rarest model and I've never seen one in action (Not like I'd really want to though). 

I own two M.2 versions and I'm gonna use the one keyed in E over a x1 PCI adapter. This one is probably the most powerful Coral TPU ever released as it actually had two TPU's embedded in the same board and as such allowed you to run two models at once, not like it made a world of difference given that the models that the Coral TPU's were rather... bad by today's standards?

I think the main problem with Coral TPUs is that the models that Coral could run were limited, you won't find any Large Language Models here and I only ever saw it being used for facial and image recognition or for simple automation using a camera (E.g. the system that Flippy over at White Castle uses to handle fryers). This is by design as the intent of Coral was making a chip that could allow for automation with a very small power footprint and without requiring an internet connection. Unlike the intent though, the thing the chips ended up being used with the most were CCTV systems, ESPECIALLY Frigate, to the point where most of the trouble-shooting you find online for a Coral TPU eventually points you to the Frigate community where some people are continuing to use the chips to this day.

The most complex thing I ever saw a Coral TPU being used for was surprisingly (Or maybe unsurprisingly...) cheating in videogames, specifically botting. both of them were private developments that I don't think were ever made public but both worked the same way, basically you would setup a computer with the TPU and a capture card to send the keyboard and mouse inputs where the game was actually running and basically make an undetectable bot that would farm things for you, one of the developments was for Runescape and another for CS:GO but I honestly don't know if either development went anywhere or if the devs changed their hardware for something more capable at one point.

Creating an environment for preservation purposes

First I loaded the chip with vfio drivers in order to pass it  to a VM, I already went over that in my Virtual AI environment and Windows 11 VM gaming setup so I'll just summarise it. I added the device identifiers of the TPU into GRUB and modprobe.d.

Updated both of them:

sudo update-grub && sudo update-initramfs -u

And after a reboot I made a minimal Ubuntu Jammy VM (Server edition, No gui) , there really was nothing special about it.

After I created the VM: I logged in, checked everything was working correctly, shut down the VM attached the TPU, fired the VM again and ran lspci to check the TPU was loaded correctly.

At this point I just proceeded with the installation as per Google's instructions.

Installing everything and running the sample model

The installation went mostly according to Google's instructions except for a few hiccups due to the lack of care and maintenance. I'll document the process and troubleshooting I did.

First I had to install the drivers and assigning permissions to allow my user to use the device, this went mostly according to plan except for APT giving me a warning due to Google failing to maintain their repository keys, regardless since I'm running kernel 5.x everything went smoothly.

Once that's done and checked the drivers were actually loaded and working with lspci -knn.

Installing the Deadsnakes PPA:
sudo apt install software-properties-common
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt update

Installing python 3.8 and related packages:
sudo apt install python3.8 python3.8-venv python3.8-dev

Now all it's left is install pycoral. And this is the point where things went wrong.

Great that's just the whole fucking software stack, no biggie. I just have to find a workaround.  First I tried to make python3.8 the main python version with a symlink in Linux, I'm not even bother gonna document doing this and I'll just tell you not to do it, that broke the entire system and it wouldn't boot any longer. 

I also tried installing tflite-runtime and pycoral using pip but that also didn't work

What worked: First I ensured pip was installed and afterwards I installed the pycoral version directly from Google's github

python3.8 -m ensurepip
python3.8 -m pip install --extra-index-url https://google-coral.github.io/py-repo/ pycoral~=2.0

Afterwards I just cloned the coral git and downloaded an example.

mkdir coral && cd coral
git clone https://github.com/google-coral/pycoral.git
cd pycoral
bash examples/install_requirements.sh classify_image.py

Finally, all I had to do was run a very long command and just like that I verified it was working properly and ready for archival.

sudo python3.8 examples/classify_image.py --model test_data/mobilenet_v2_1.0_224_inat_bird_quant_edgetpu.tflite --labels test_data/inat_bird_labels.txt --input test_data/parrot.jpg

This is the image the command is pointing to by the way: 

The reasons why I think it failed and why I think they were still a good idea and why I'm preserving this.

There are quite a few things that I think contributed to Coral being shelved by Google almost immediately after release

One may think a contributing factor was the leak of the uncensored Stable Diffusion models by NovelAI in 2022 that effectively lead to the rapid replacement of small computing devices for Large Language Models and the current AI craze the world finds itself in (After all why have a stationary robot like Flippy at White Castle when you can have a whole fleet of robot workers on your Amazon warehouse?). But more than anything I believe killed Coral was because it ran against Google's business model, allow me to elaborate.

The main thing that killed Coral in general in my opinion is that SBC's began using NPU's everywhere, in particular Risc V SBCs, and since most of the people interested in this tech are companies or governments (Be it for automation or mass surveillance) there really is no point to having a cheap device that allows your average Joe to run basic image recognition models. For instance one of the worst Risc V SBCs I own a Sipeed M1S Dock; a rather limited SBC with only 64MB of RAM and even there I see no practical difference in using that over using another SBC or computer with a Coral TPU as far as using it for automation is concerned (I may make an article on that device later).

There is a big difference between a TPU and an NPU though: you cannot train models on an NPU, only run them, and for that alone combined with the ridiculously small power footprint, I think these devices are worth preserving. However, I also get why Google abandoned this idea and hasn't looked back, after all why allow end-consumers to train their own models and run them offline when you can train the models, sell them to companies and implement DRM on them? 

I may look into upgrading the software stack one day just out of spite but for now Coral joins the Google graveyard in the long list of projects killed by Google.

 -Batlog

If you enjoyed this article or if it was of any use to you, please consider donating some crypto. All funds go towards paying for the hosting.

Monero/XMR:
88MC6ksaVyLbtH9fT4owLSPX16vYD9cf6YELmXjaNWWd71R6iwfFV6DJtp7BXR5c6vWnxLEEGyu1tfwXwTqDM1CUCqDGeRY

Bitcoin/BTC: 
bc1qzw9g97ffhllwukhagkvn5g0u9d8rhjv86xhf8h

Ethereum/ETH:
0xf948ab59E492865Fb5200A97F0F4F2f31F7b443f

Litecoin/LTC:
ltc1qqfv05jpyh8yvzyetmf7n5ve500jl656yxpc8y4

Doge:
DT5iG6GxoyZtHSSmaZHHV63NpEoH5yuixg

There is a rather cool program (If a bit outdated) that I came across a few years ago called "Archipelis 3D Designer". I'm currently trying to get into game development and I decided to finally make use of my copy (Which I bought for a whole 30 dollars).

However, to my shock when I wanted to check the manual, only available online, it was gone and not only was the page for the manual gone, As of 22/06/2026 the whole website was hijacked and used to promote some crypto online casino scam shit or something. I have no idea what happened to the developer and neither do the couple of people that I contacted about it that had a partnership or relationship with them, the software is about 20 years old now so it's safe to assume the software is gone for good.

I'm wising this post not so much as a guide but rather as a showcase as I think this is an idea worth re-exploring and why I'll likely use the software despite requiring a VM to run it.

What is/Was Archipelis

Archipelis was a software used to translate 2D images into fully textured 3D meshes by tracing over them. It was also very simple and very easy to do (The exe installer is 5 MB in size and once installed the binary is only 2.5 MB). This worked by "inflating" the shapes that you drew which you can then fine-tune and adjust according to your needs, act following you can export them to quite a few file types (Some of which are relevant and usable even 20 years later) and animate them or add them to your game engine or whatever.

It came from a bizarre moment in time when people thought Second Life would become the metaverse rather than a furry paradise and was intended to make exports for it. It doesn't work all that well for humans or furniture with sharp corners but it works very well for minor assets or non-human characters and honestly if this idea had caught on I can't help but think it would've accelerated some workflows massively, particularly on the indie side.

Getting Archipelis to work

I have no proof but I swear back when the website existed it claimed to be able to be installed on Windows 7, windows 8 and Wine. I can vouch having this run on wine is 100% nonsense, I could never get it to run. After some testing the last version of Windows that this runs on is Windows 8.1 with all the updates. Therefore I just made a Windows 8.1 WM with very few modifications. Except a rather obvious one.

This virtual machine has no network card and the reason for that is because Archipelis actually phones home and not only it phones home it does so in a way that it communicates to the server which buyer is using it (See addendum why I can't distribute it below). Funnily enough you can bypass this by just removing all network capabilities from your computer, it doesn't even need to phone home once or anything.

I also did a small change in the xml so the virtual machine could load more than two cores (This is an issue with any windows version).

Then I installed virtio guest tools to make the VM run smoother, you want version 0.189, any newer version doesn't work on windows 8.1... 

... And finally I transfered the files I needed into the VM using a usb drive 

Now that I have everything I just ran the installer (Which was a very standard affair) and I was good to go.

Actually using Archipelis

If there's one thing I think all archipelis users agree on is that it's specially good for two types of things, rounded objects and animals. For this example I'll be using a public domain painting of a dog made in the 18th century by Francis Calcraft Turner.

First you start by importing an image and then you have to draw over it, for this I recommend drawing over the largest body part like the torso (You cannot zoom or do anything else, all menus are gone until you've drawn this first part).

After you close the loop (Or come close to) The software will immediately generate a 3D render that you can then jump into edit mode and adjust the line of it in case it has taken some of the picture's background.

Act following You can just continue drawing and making shapes which will be accumulated and stored individually 

And eventually I ended up with an initial render that looks like this

Nice, until you look at it from the front.

... However from this point on you can just fine-tune it, the software allows you to change the scale of all your parts, their position, mirror them and rotate them.

Eventually I ended up with a model  that looks like this

From here all you have to do is save it and export it, which as I said in the beginning has quite a few formats to do so.

I know the results may not look that impressive for today's standards but what if I told you the result is very low poly and it was done by someone that has barely any knowledge regarding 3D modeling barely putting any effort or heart in it in 30 minutes? I honestly don't know of any software that's faster than this and I think it would effectively reduce the workload of small teams exponentially, maybe even enable the creation and distribution of easily-made assets

Similar software (And why there's no replacement for this)

Monster mash is the obvious one, I'd dare say it was inspired by this software. However that software comes with one huge caveat in the form of the license, while their github makes it seem like you can use the software without any problems under an Apache license the reality is that you cannot, and you may get into legal trouble for doing so as per their forums:

This promise to change the library was never followed upon and 4 years later I don't think they're doing squat about it. Archipelis has a very permissive license that allows you to do whatever you want with the outputs produced by the software as long as you Attribute that it was done in part or fully by Archipelis.

The second one is a plugin for blender called 'Tesselate texture plane' by Pullusb on Github, which... does exactly what it says on the box.

The problem I have with that one is that it does not inflate the parts of whatever you draw over (Which curiously is the same issue Monster Mash has regarding licensing) So anything you do ends up as a paper render in 3D

It's cool but not really a replacement for Archipelis

It's a shame really, if the idea had caught on I can't help but think there would be something way easier to use and more modern by now.

Addendum 1: Why I can't distribute it

Going back to the software calling home it does something weird, when you downloaded the software it would make a special version of the software that baked in your mail and full name into the program and basicallly makes a version for you and only you.

The mail and the name of the person that purchased it can be seen front and centre in any project that you open, which for me would result in immediate doxing. For an example of what I'm talking about look at the video of pdhowler using the software on youtube, where his full legal name and personal mail is displayed for the world to see.

 -Batlog

If you enjoyed this article or if it was of any use to you, please consider donating some crypto. All funds go towards paying for the hosting.

Monero/XMR:
88MC6ksaVyLbtH9fT4owLSPX16vYD9cf6YELmXjaNWWd71R6iwfFV6DJtp7BXR5c6vWnxLEEGyu1tfwXwTqDM1CUCqDGeRY

Bitcoin/BTC: 
bc1qzw9g97ffhllwukhagkvn5g0u9d8rhjv86xhf8h

Ethereum/ETH:
0xf948ab59E492865Fb5200A97F0F4F2f31F7b443f

Litecoin/LTC:
ltc1qqfv05jpyh8yvzyetmf7n5ve500jl656yxpc8y4

Doge:
DT5iG6GxoyZtHSSmaZHHV63NpEoH5yuixg

This article will cover the process on how to make a virtual environment for generative AI by attaching a GPU to a virtual machine and running the latest version available of SDNext.

I already covered parts of this in my guide to make a Windows 11 VM for gaming (They use the same GPU), but regardless I'll document this process due to the difference regarding the installation of drivers and intent.

Step 0:  Checking motherboard compatibility and enabling IOMMU

Before making any virtual machines or anything you may want to check if the motherboard you're working with is even compatible with detaching PCI devices from the host.

Assuming you already have a computer or can test it before buying it, you'll want to run the following bash script :

#!/bin/bash
for d in $(find /sys/kernel/iommu_groups/ -type l | sort -n -k5 -t/); do 
    n=${d#*/iommu_groups/*}; n=${n%%/*}
    printf 'IOMMU Group %s ' "$n"
    lspci -nns "${d##*/}"
done;

(Script taken from flungo at github)

What this does is list the IOMMU groups of your PC, which allows you to check if there are any conflicts.

If the video card you're trying to pass through is not part of some other group (Eg your usb ports or your sound card or something else) Then you're in the green. Otherwise I don't recommend you follow up with this, there is a method around it by using a modified kernel called  linux-vfio which can be found in the Arch AUR repository but honestly It's outside the scope of this article.

Lastly you need to ensure your motherboard supports IOMMU and enable IOMMU in the bios, most modern motherboards support this but depending on your model you may have to look for it under advanced PCI or advanced CPU settings. (Sorry about the green tint, my capture card doesn't like VESA graphics). It's usually labeled as 'intel VT-D' for intel motherboards and as AMD IOMMU for AMD motherboards, however the names aren't completely standardised and may vary, check your motherboard manual or support forum.

Step 1: Configuring a VM for GPU Pass-through

First, you have to create a VM. Honestly the process is rather straight-forward and you're free to make the install of any packagages you want as the only real dependency is python3 venv (I picked Debian 13 and installed Xorg and JWM). On this note the only distro I wouldn't recommend is Ubuntu because they use Pythion for networking and as such can cause dependency issues. The only notable thing you should take inti consideration is allocating the most amount of memory and processing power available without stunting your host system, for me it was 60GB of RAM out of 64 and 14 threads out of 16:

Once you ahve your VM configured to your liking, you need to pass-through a GPU into the VM.

The process is rather simple, first identify your GPU with lspci -nn and write down ALL the devices IDs that share the same group as the GPU, In my case I only had to write two devices down, the graphics card itself and the sound card that comes with the GPU.

Then open edit /etc/default/grub with your favorite text editor (In my case nano) and under 'CMDLINE-LINUX-DEFAULT' add:

1. intel_iommu=on (Or amd_iommu=on if you're on an amd motherboard) and;
2. vfio-pci.ids=<the values you wrote down separated by commas> 

Afterwards update grub, if you get no errors you're in the clear

Afterwards, execute lspci -knn to check the driver currently loaded in the kernel for your graphics card and other devices. Then, create a new file on /etc/modprobe.d/virtio.conf and add to it:

1. options vfio-pci ids=<same device values you added on grub>
2. softdep <kernel module currently loaded> pre: vfio-pci (You must do this for all the devices individually)

Afterwards, upgrade your initramfs (Please note this command varies greatly from distro to distro). If you get no errors, you may be in the green.

Afterwards reboot your system and run lspci -knn if the command shows that your devices are using vfio-pci drivers then you're golden, if not go back and check that you configured the file in modprobe.d correctly (It's very sensitive to spaces).

Attach the GPU and attached devices (In my case just the unlabelled sound card) to the virtual machine and fire it up.

Step 2: installing the drivers

WARNING: AVOID INSTALLING THE NVIDIA DRIVERS CONTAINED IN PACKAGE MANAGERS UNLESS YOU'RE USING A ROLLING RELEASE DISTRO, THEY'RE USUALLY SEVERAL VERSIONS BEHIND THE LATEST VERSION AND AS SUCH PYTORCH WILL FAIL TO RUN.

Verify the GPU is detected in the VM.

The next step is installing drivers, since I'm using a card that's still supported by Nvidia and as such is supported by the latest drivers (And by extension, the latest Cuda version) I can just install the drivers by downloading the latest version available from Nvidia's website.

Nvidia's drivers for Linux require you to enter CLI-only mode and run the installer as root, in Debian this is easily accomplished by going into recovery mode.

There are a three dependencies that the drivers need, the linux headers, gcc and make. I recommend installing the latest headers and build essentials (I also recommend running these commands apart instead of in a single apt)

sudo apt install linux-headers-$(uname -r) && sudo apt install build-essential

After you run the drivers the first time, if nouveau drivers are loaded (Which they most likely are) Nvidia will generate a file to blacklist them completely in modprobe.d and will prompt you to update initramfs. Honestly? The installer has always failed at updating initramfs for me, so just pick you don't want for the installer to do anything anything else and update initramfs by yourself.

Reboot the virtual machine and run the installer again, select whatever version of the driver you want (I always do proprietary) and just proceed with the installation as normal (You may get a couple of errors regarding 32 bit libraries and EGL, ignore those they're not needed for this particular project).

After a reboot enter your graphical environment and if nvidia-smi shows the latest driver CUDA versions they've been installed correctly.

Step 3: Cloning the WebUI and launching it

Clone the repository and execute the webui by using --use-cuda as an argument, if you get no Torch errors that causes the webui to default to CPU mode, you're pretty much  done.

Now all you have to do is open a browser with Javascript enabled, open the localhost in the port 7860, download a model and run a prompt.

Addendum 1: Why do this?

Aside from the obvious advantage of replicability and being able to host multiple environments from a single server, one problem I often come across when running LLMs is VRAM usage and the lack of tools to manage it, the more you use a virtualized environment the more the VRAM fills up with data 'learning' of previous iterations in order to speed up generation and get more accurate results but eventually you cannot generate more images or text anymore, your environment becomes useless and you must start over again (I even had an AIO GUI solution store this data outside the venv and I had reinstall the whole system).

For small users like me this posses an issue that is easily solved by just taking a snapshot and nuking everything out of existence, the system is once again reset from zero and I can generate dozens of images at once again. This is also great for development or testing environments, honestly I don't know why people don't do this instead of using docker for everything.

 -Batlog

If you enjoyed this article or if it was of any use to you, please consider donating some crypto. All funds go towards paying for the hosting.

Monero/XMR:
88MC6ksaVyLbtH9fT4owLSPX16vYD9cf6YELmXjaNWWd71R6iwfFV6DJtp7BXR5c6vWnxLEEGyu1tfwXwTqDM1CUCqDGeRY

Bitcoin/BTC: 
bc1qzw9g97ffhllwukhagkvn5g0u9d8rhjv86xhf8h

Ethereum/ETH:
0xf948ab59E492865Fb5200A97F0F4F2f31F7b443f

Litecoin/LTC:
ltc1qqfv05jpyh8yvzyetmf7n5ve500jl656yxpc8y4

Doge:
DT5iG6GxoyZtHSSmaZHHV63NpEoH5yuixg

WARNING: If You're reading this, you're not me and you're thinking of getting a TESLA P40 now that they're in the bargain bin again, don't just plug the damn thing into the first PCI slot you see, you WILL fry it. See addendum 1 for ideas and notes on this.

This was relatively easy to pull off on Ubuntu Noble (Version 24.04), however I still feel like documenting it because I feel torch may stop providing the required files in order to get the venv working any day now.

The long story of why this article exists is because Pytorch decided to end support for Volta, Pascal and Maxwell Nvidia cards before Nvidia announced their EOL, which caused for my entire environment to break down after updating my python virtual environment and I get the feeling it may happen again but permanently some time in the future as I cannot find versions of Pytorch compatible with old CUDA versions anywhere. As of right now I managed to get this working on a small SSD for storage but in the future I want to preserve a small virtual machine or a FreeBSD jail, failing that I'll do an LVM (ANYTHING that allows me to do snapshots really I document the reason why this is important to me on my virtual AI article).

Step 1: Installing Cuda 

Here's a very specific restriction: you need CUDA version 12.6, no other version will work as that's the exact point in time when Pytorch stopped providing support for Volta, Pascal and Maxwell cards. I recommend doing this in Ubuntu 24 as it's the last OS officially supported by this particular CUDA version and will continue to have support until April 2029 (Also, Debian 13 gave me issues, so there's also that).

Here are the commands to get the cuda toolkit installed, if the apt update half-way through shows the Cuda 12.6 repositories you're in the green:

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-ubuntu2404.pin
sudo mv cuda-ubuntu2404.pin /etc/apt/preferences.d/cuda-repository-pin-600
wget https://developer.download.nvidia.com/compute/cuda/12.6.0/local_installers/cuda-repo-ubuntu2404-12-6-local_12.6.0-560.28.03-1_amd64.deb
sudo dpkg -i cuda-repo-ubuntu2404-12-6-local_12.6.0-560.28.03-1_amd64.deb
sudo cp /var/cuda-repo-ubuntu2404-12-6-local/cuda-*-keyring.gpg /usr/share/keyrings/
sudo apt-get update
sudo apt-get -y install cuda-toolkit-12-6

Afterwards you need to install the CUDA kernel modules (Because Nvidia doesn't bundle them for some reason) NVidia pushes you to try out the open source version but honestly in my experience the proprietary version is still better and in the case of Pascal they don't even work as they only work with Turing and onwards.

sudo apt-get install -y cuda-drivers

Afterwards reboot your system and run nvidia-smi, if the version shows version 12.6 you can move to the next step.

Step 2: Installing SDNEXT 

Afterwards you need to install SDNext, to be honest there aren't a lot of dependencies to work here, you just need to install python3-venv

Next, clone the latest version of SDNext and enter the directory

And now you just have to run it for the first time but before you do you must set some environment variables, the guide on SDNext says to use 'set TORCH_COMMAND='torch==2.9.1 torchvision==0.24.1 torchaudio==2.9.1 --index-url https://download.pytorch.org/whl/cu126' but to be honest that didn't do it for me, but what did do it was 'export':

export TORCH_COMMAND='torch==2.9.1 torchvision==0.24.1 torchaudio==2.9.1 --index-url https://download.pytorch.org/whl/cu126'

If the system tells you the versions matching the environment variables you set are being installed and doesn't give you a 'This version of Cuda is too old' error then you're pretty much done, otherwise you must go back, delete the directory, clone again and try again.

If it did resolve without errors, let it run for a while until fully loaded, then I recommend running nvidia-smi -l 1 to monitor your GPU while working and finally, open Firefox and go to the localhost address where SDNext is running. Just download the version 1.4 for testing.

The First time I ran it, it didn't work. This is normal as the model wasn't pre-loaded before opening the website and SDNext didn't load it.

Just close Firefox, stop SDNext with Ctrl C and start it again (You don't need to set the environment variables again). This time, it ran without issues.

Update 01/Jul/2026: Making a virtual machine to make a replicable environment.

Previously I had tried to get this work on a VM (And as a matter of fact it was always my intention to run this in a VM) due to the fact that torch loves 'cleaning' (Read: making completely inaccessible by pulling them from their servers) older versions and that was the whole reason why I went on this crusade in the first place as after an update the version that I used to use with the original AUTOMATIC1111 webui stopped working completely on my M40 and P40, both of which I believe have still a lot to give as Nvidia has yet to make consumer-grade GPU's with more than 24 gigs of VRAM.

However every time I tried it I got a lot of errors when firing up the VM and couldn't install CUDA 12.6 (Bizarrely the packaged drivers worked fine, it was just the official Nvidia CUDA drivers that didn't work).

I had the feeling it was a BAR problem due to the large amount of VRAM the P40 had but didn't know if it was an error with the virtual machine BIOS or the host computer BIOS. So, I decided to get rid of the three problems to see if it works and troubleshoot later, I made a virtual machine in a better-quality motherboard and used a P4 due to the reduced RAM. Long story short I did the same as I did in my Virtualized AI environment article.

First I did the usual song and dance of loading the vfio drivers

Afterwards I rebooted and upon checking the correct kernel modules were loaded I made an Ubuntu 24 VM. It has nothing special other than using most of my resources and leaving me only with 2 cores and 4GB of RAM for my base system. I also tried to keep the install as lightweight as possible installing DWM.

Then I attached the P4, followed Nvidia's instructions for installing CUDA 12.6 and to my shock it went without a hitch.

I rebooted and ran lspci -knn nvidia-smi to verify the card was loaded properly

Once that was done I cloned sdnext and set the variables as I did previously. Once it passed past Pytorch without errors I was basically done. I just opened the webui and downloaded a model.

At this point I decided on installing Badwolf for my browser because it's very lightweight, loads SDNext without issues and most importantly, doesn't come in a snap like everything in ubuntu these days and wastes resources running snapd in the background. However I ran into an issue where I kept running out of VRAM because it was trying to generate a 1024 x 1024 image and I couldn't change that because the window was too small and Badwolf doesn't handle zoom very well. So, I installed arandr and changed the resolution.

Then everything worked as intended after I adjusted the image size to 512 x 512

I still have to get this running on my P40 but given I have a functional VM it will be easier to troubleshoot. For the moment I'm happy I preserved this before pytorch pulls the plug.

Addendum 1: Cooling a Tesla card

Used Tesla cards normally sell for cheap in the second hand market and usually come with nice features for Cuda tasks but the problem is that they are meant to run on special server chasis that incorporate high-pressure fans to cool them and that I assume most people don't have, this means if you want to stick one in a home PC you need to mod.

If you buy a passive-power low profile (A P4 or a T4 for instance). You really don't have a whole lot of problems cooling it, here is my ghetto cooling solution for a P4 for instance:

It's not the prettiest mod I've ever done but honestly it just gets the job done, the card never over-heats, there really isn't much to cooling a small Tesla.

The big ones though? Those a re a problem. The small passive-energy Teslas pull between 50 and 75w. The big ones? They pull 250w and while performing any task they usually run at 100% speed and power consumption, cooling them can be a legitimate headache.

Most people use a blower style fan and a 3D printed funnel, I tried a solution like this first but to be honest I found the cooling to be lacking if I left the card running for hours (Which I imagine is what most people want), I was letting my PC cool down every 4 hours like a vintage car or something and honestly that didn't sit well with me.

So, I decided to go the full Water cooling route, here is my card as of June 2026:

Tacky choices of aesthetics aside, I don't think anyone that looks at the thermals of it can argue with the results, I don't think I've ever seen it go over ~60°C after running it for hours.

What I did and what I used:

I think I was rather lucky when I got mine as I got an NZXT Kraken G12 for very cheap that fits perfectly with the card (The Kraken was designed for high-end gaming pascal cards, Specifically the GTX 1080 and the Titan, and really what is the P40 but a 1080/Titan without HDMI output?), from there it was just a matter of finding a cheap water cooling solution that had the same manufacturing process as the kraken intended to use in 2017 and while NZXT keeps using it their coolers were a bit too expensive for this project. On the other hand XPG and Asus also used the same manufacturing process and were on my price range.

I used thermal glue with copper heatsinks (Not aluminium) for the vram modules and along with the fan of the Kraken and a few aluminum heatsinks I managed to cool down the rest of the components. The thermal glue (Not paste) was necessary as the copper heatsinks would fall off with nothing but gravity regardless of anything else I used (E.g. thermal pads or the glue they came pre-applied with); Due to the use of thermal glue I had to let the card curate overnight and it added about 10 hours to the project.

Overall this whole thing added about 80 dollars to my budget so if you're thinking of doing this have a cooling solution already in your possession or already on your way  before-hand. Also, bear in mind this basically kills all after-market value of the card, nobody buys modified Teslas so bear in mind if you modify one you're keeping it forever or trashing it afterwards.

 -Batlog

If you enjoyed this article or if it was of any use to you, please consider donating some crypto. All funds go towards paying for the hosting.

Monero/XMR:
88MC6ksaVyLbtH9fT4owLSPX16vYD9cf6YELmXjaNWWd71R6iwfFV6DJtp7BXR5c6vWnxLEEGyu1tfwXwTqDM1CUCqDGeRY

Bitcoin/BTC: 
bc1qzw9g97ffhllwukhagkvn5g0u9d8rhjv86xhf8h

Ethereum/ETH:
0xf948ab59E492865Fb5200A97F0F4F2f31F7b443f

Litecoin/LTC:
ltc1qqfv05jpyh8yvzyetmf7n5ve500jl656yxpc8y4

Doge:
DT5iG6GxoyZtHSSmaZHHV63NpEoH5yuixg

In this guide I'm gonna do something the Whonix Community™ would look heavily down on and wag their finger but honestly who gives a shit they're redditors anyways.

Basically what I'm gonna do is make a normal Virtual machine and connect it to a Whonix Gateway in order to anonymize all internet traffic that goes through it, I've added an addendum near the bottom as to why someone may want to do this.

Step 1: Installing Whonix

I would skip this step but hot damn all guides I've read on this subject matter (INCLUDING THE OFFICIAL GUIDE) are full of useless fluff that doesn't really add anything?. Getting Whonix installed is not that hard or impressive guys, seriously.

The first hurdle is... downloading the qcow images from the official website (Seriously, this took forever, why even throttle the download at 300 KBPS, what if someone is on a life or death situation, whatever, just download it).

Then just...

Extract it

Import the configuration files and move the qcow2 files wheile you're on the same directory.

....And that's it, Whonix is now installed (Jesus Christ why does everyone make such a big fuss of this).

After that I just entered the reduced the memory of the gateway to 512 MB in order to force it into terminal mode, upgraded the gateway using the sysmaint user and the upgrade-nonroot command and just checked the workstation was working as intended.

There is no further configuration required on the Whonix side except maybe adding passwords to the gateway, there is a non-zero chance a malicious bot may find the gateway, try 'user' with no password on it and get in. Honestly while there is very little they can do when they're inside they are still a waste of bandwith.

Step 2: Making a (Non-Whonix) Virtual machine and connecting it to the gateway

For this you'll need a debian VM, the latest stable version will do and there really isn't anything special I did to mine other than skip ALL optional software(This includes the standard system utilities which has things like wget), you want a virtual machine as minimal as possible.

(Optional) Once that's done you can do some customization, all I did was install sudo, add my user to sudoers and install DWM for a graphic interface. If you ARE planning on running an user interface I recommend you use a Window Manager and avoid desktop environments altogether (If you don't want to bother compiling DWM or other Window Manager you can install something like jwm or i3). The reason for this is because Desktop environments often come with utilities to make handling of the network more easy and they interfere with the files I'm modifying in a bit. On that note, if you run into issues with the network after everything is configured, install nmtui, DO NOT install an applet to handle your internet.

Step 3: Connecting the VM to the Whonix gateway

At this point you want to remove the network the VM you want to connect to the gateway is using and use the one that the whonix Workstation uses (Labeled 'Whonix Internal') with the gateway running in the background.

Fire up the VM again. You're after two specific files /etc/resolve.conf and /etc/network/interfaces. You want to add the whonix gateway as your name server and default gateway, as well as add a static ip within the same range (10.152.152.* except .10).

A few pointers: the domain and search in resolv.conf should be the same domain as your virtual machine and the network interface in interfaces should match the name of the interface shown by ip -br address show, for me it was epn1s0 but sometimes it can also be eth0 or other interface name.

Once this is done you should reboot your machine. If apt update (Or the equivalent of whatever distro you're using) clears then that means you're most likely in the green but just to make sure I installed Firefox and visited TOR check (Bear in mind this is vanilla firefox with no special rules or security features, Librewolf or Badwolf are significantly better alternatives but I was just testing out things).

Finally if you're sure everything is working as intended I recommend making the files immutable with chattr, Happy browsing!

sudo chatter -i /etc/resolve.conf 
sudo chattr -i /etc/network/interfaces.

Addendum 1: Why do this

I can think of a couple of reasons to do so.

The first one is running services that you want to run but you don't want exposed on clearnet without major headaches. This is the easiest way that I know to host a Monero node that I don't intend to use for mining with P2Pool for instance as I can just do a normal install of the node and it just works without any headaches, fanfare or having to worry about my IP leaking.

The second reason is bypassing basic internet censorship or age checks (The UK in particular seems to be a rather hot topic about this lately as of June 2026), most computers these days are under-utilised as far as resources are concerned and I think this can provide some level of normalcy to browising the internet on a censored network. Aside from running a few select services and programs, this is also the easiest way I know to run a VPN over TOR, which I feel is a subject privacy users often jeer at but c'mon man sometimes you just want to browse the internet normally and major DNS providers more often than not will block TOR exit nodes (See below where google and quad nine failing to ping).

I can hear arguments of using x or y service provider but that will only carry you so far in countries where said provider isn't allowed to operate (Bear in mind some 'privacy-respecting' service providers are not completely truthful about their commitment to privacy, Quad nine claims to respect privacy and yet as shown above has some TOR nodes blocked).

Addendum 2 How to extract files from a Virtual machine anonymously

Finally I feel like talking about the matter of transferring things you've downloaded from your guest to your host anonymously. I have tried a few ways but I believe the most 'Clean' (As it leaves no fingerprints in the guest) is by mounting the virtual disk as a normal drive and then just copy the files from the mounted drive as shown below.

 -Batlog

If you enjoyed this article or if it was of any use to you, please consider donating some crypto. All funds go towards paying for the hosting.

Monero/XMR:
88MC6ksaVyLbtH9fT4owLSPX16vYD9cf6YELmXjaNWWd71R6iwfFV6DJtp7BXR5c6vWnxLEEGyu1tfwXwTqDM1CUCqDGeRY

Bitcoin/BTC: 
bc1qzw9g97ffhllwukhagkvn5g0u9d8rhjv86xhf8h

Ethereum/ETH:
0xf948ab59E492865Fb5200A97F0F4F2f31F7b443f

Litecoin/LTC:
ltc1qqfv05jpyh8yvzyetmf7n5ve500jl656yxpc8y4

Doge:
DT5iG6GxoyZtHSSmaZHHV63NpEoH5yuixg

Let me preface this article by saying that I've seen guides for this in quite a few places but I still feel the need to document them as none of them replicate all the exact steps I follow (Usually skipping things like installing the virtio drivers hard drive or fixing the clock). The most complete guide I've seen is by Bryan Steiner on github and even then there are a couple of issues with his approach that I disagree with such as using hooks and using a whole volume instead of a disk image or LVM.

I am therefore making this guide more to myself than anyone else, I'm fairly certain I missed a couple of things but I get a good balance of security and performance doing that I'm rather happy with and have used for over two years now (My main PC notes the installation date as April 1st 2024).

Step 0. Things to know before-hand

First of all before you jump right in there are a couple of things to consider, what you have at hand and what you want to do regarding storage. Do you want security or performance? Here are the basic pointers.

What you'll need:

• A computer with two GPU's (One of them can be an igpu), both of them with a video output. I heavily recommend you use an Nvidia card for the card you're intending to passthrough (See addendum 2).
• A Motherboard that actually supports IOMMU without major issues (See step 1)
• An EDID Dummy plug (See addendum 1).

Select your approach regarding storage:

• Disk image (Qcow2, img, etc): Slowest speed (Although admittedly not that much compared to using an LVM) but the most portable, effectively you can backup your whole windows system in an external hard drive and replicate it several times. You could toss your entire computer out and still continue to be able to replicate your VM endlessly as long as you have the image really. I recommend this one if you're more concerned with security and availability than performance
• LVM (This guide): The in-between middle-of-the-road fence-sitting approach, you can take external snaps, can take the disk out of a system place it on a new system, load the LVM as a VM on the new system and keep going. I recommend it if you're looking for a balance between security and performance as the disk doesn't touch your host system.
• Disk passthrough: The best performance but honestly you lose all portability and snaps plus some security as the disk is in direct contact with the hardware and if you watch ransomeware or something on windows it can easily be game over, I wouldn't do this one unless I was using a laptop. use this one if you're preoccupied only with performance and just want to be able to dual boot Linux and windows.

As stated above I'm going with the LVM approach but honestly it doesn't make that much of a difference in regards to setup. I'm also not doing a method known as 'hooks'  for this guide (See addendum 2) if you want to do hooks check out Bryan Steiner's guide on Github.

Finally you need to ensure your motherboard supports IOMMU and enable IOMMU in the bios, most modern motherboards support this but depending on your model you may have to look for it under advanced PCI or advanced CPU settings. (Sorry about the green tint, my capture card doesn't like VESA graphics). It's usually labeled as 'intel VT-D' for intel motherboards and as AMD IOMMU for AMD motherboards, however the names aren't completely standardised and may vary, check your motherboard manual or support forum.

Step 1: Check the motherboard compatibility,

Assuming you already have a computer or can test it before buying it, you'll want to run the following bash script :

#!/bin/bash
for d in $(find /sys/kernel/iommu_groups/ -type l | sort -n -k5 -t/); do 
    n=${d#*/iommu_groups/*}; n=${n%%/*}
    printf 'IOMMU Group %s ' "$n"
    lspci -nns "${d##*/}"
done;

(Script taken from flungo at github)

What this does is list the IOMMU groups of your PC, which allows you to check if there are any conflicts.

If the video card you're trying to pass through is not part of some other group (Eg your usb ports or your sound card or something else) Then you're in the green. Otherwise I don't recommend you follow up with this, there is a method around it by using a modified kernel called  linux-vfio which can be found in the Arch AUR repository but honestly It's outside the scope of this article.

Step 2: Creating an LVM and making the windows virtual machine.

Before you can even begin installing you need an LVM to live in, it has to be completely unfatted and I recommend using a second drive as it makes it easier to handle if you have to re-install your host, change distros or something else of that nature (For the record this LVM can exist  alongside your host if you made an OS install making use of LVM's and left some space left in your disk).

For this example I'm targeting the Volume group VGSSD created in the physical volume sdd1 (Previously formatted as an ext4).  The exact commands I used it for create the LVM were:

sudo pvcreate /dev/sdd1
sudo vgcreate VGSSD /dev/sdd1

And then I just added the LVM to the VG

Now you can use virt manager and make a normal virtual machine but when prompted with picking a storage for it you have to select Volume group and then select the LVM you just made.

After you're done and everything looks good, before you begin the installation remove the network card, change the main storage device to virtio and add the virtio iso, then fire up the virtual machine.

Follow the Windows 11 installation normally (DO NOT ENTER A LICENSE AT ANY POINT AS YOU'LL BE MAKING A LOT OF CHANGES TO THE HARDWARE AND WINDOWS WILL MAKE THE LICENSE INVALID, LOAD A LICENSE ONLY AFTER YOU'RE DONE DOING EVERYTHING) until you reach selecting a storage device, at that point the system will claim you don't have any. Select the option to load drivers and pick the disk drivers from the W11 folder on the virtio guest tools disc. After this the installation should proceed and complete normally.

After the system reboots, proceed with the installation as normal.

When windows asks you to connect press Shift + F10 , this will open a cmd window, enter OOBE\BYPASSNRO . This will reboot the virtual machine in a mode where you are no longer asked for a microsoft account and can setup a local account. I've heard from other people that the ability to open cmd during install was removed in later ISOs you download from Microsoft, so if you  encounter this issue you may need to ask someone you trust for an old ISO try and avoid the wayback machine as I've encountered tampered discs there in the past. 

I heavily recommend using a local account by the way, there is a non-zero chance you'll encounter a piece of hardware that looking glass (A vital program for this guide) does not support and if that happens to you then you're toast and must use freeRDP, which is very easy to use with a local account but extremely annoying to work with using an online account. If you insist on having your data stolen by Microsoft at all times at least make sure to make a second account that works locally.

Step 3: Installing the virtio drivers and CPU Pinning

Once you're inside open the virtio guest tools disc and install all the virtio drivers. The process is very straight-forward and once you change your video output to virtio after a reboot you'll immediately notice your first performance boost.

Chances are you'll encounter your first hurdle when you notice windows is only using 2 cores at all time.

To solve this you must add the topology in the XML on virt manager under the cpu tag manually like this for 14 threads:

<topology sockets="1" dies="1" cores="7" threads="2"/> 

After a reboot it now does display the correct number of vCPU's

This will effectively bring you into 'workable' performance levels, if all you want is to run some program or use windows for office work then you can just stop here.

If you want to use the machine for gaming however, there are still quite a number of steps. FIrst you'll have to pin your CPU cores,  list all your CPUs with lscpu -- extend (I do recommend using lscpu extend and not something else, don't bloat the host, you'll need the resources later on). 

This tells you the exact order of your threads and which physical core they are attached to, which is important when pinning as you must pair the threads that belong to the same core (In my case for instance I must pair 0 with 8, 1 with 9, 2 with 10, etc.).

Now, as I only have 16 threads I'll be reducing the amount of vcpus on the virtual machine to 10 in a move that may seem rather counter-intuitive. The reason for this is because I want to keep two for my linux host, to threads for emulation pining and two for iothread pining. My config looks like this:

Now what do the threads I reserved and left out of the VM do?

emulatorpin handles tasks by the hypervisor rather than the virtual machine itself, basically it handles tasks that would normally be assigned to your virtual machine CPUs and isolates them so your virtual cpus can handle what's going on in the virtual machine itself.

iothreadpin: Handles storage and network management, depending on your setup I recommend allocating two full cores (4 threads) to this, poor disk speed in virtual machines is an issue I encounter very often.

If you boot your machine and the task manager says you're using the amount of threads you pinned down, then you're in the green and can finally move towards the next step.

Step 4: Passing through the Nvidia GPU and installing the Nvidia drivers

It is at this point you should add back the network card you deleted (Ensure it's using virtio drivers) but most importantly it's at this point you need to start working in passing the GPU to your windows guest.

The process is rather simple, first identify your GPU with lspci -nn and write down ALL the devices IDs that share the same group as the GPU, In my case I only had to write two devices down, the graphics card itself and the sound card that comes with the GPU.

Then open edit /etc/default/grub with your favorite text editor (In my case nano) and under 'CMDLINE-LINUX-DEFAULT' add:

1. intel_iommu=on (Or amd_iommu=on if you're on an amd motherboard) and;
2. vfio-pci.ids=<the values you wrote down separated by commas> 

Afterwards update grub, if you get no errors you're in the clear

Afterwards, execute lspci -knn to check the driver currently loaded in the kernel for your graphics card and other devices. Then, create a new file on /etc/modprobe.d/virtio.conf and add to it:

1. options vfio-pci ids=<same device values you added on grub>
2. softdep <kernel module currently loaded> pre: vfio-pci (You must do this for all the devices individually)

Afterwards, upgrade your initramfs (Please note this command varies greatly from distro to distro). If you get no errors, you may be in the green.

Afterwards reboot your system and run lspci -knn if the command shows that your devices are using vfio-pci drivers then you're golden, if not go back and check that you configured the file in modprobe.d correctly (It's very sensitive to spaces).

Attach the GPU and attached devices (In my case just the unlabelled sound card) to the virtual machine and fire it up.

Once inside the virtual machine download the Nvidia drivers, install them and check the system is detecting the correct card using the Nvidia panel.

If you reach this part you can pretty much use the card for anything related to cuda tasks (Handbreak, sfx, Ai, etc.) but gaming performance is piss-poor, this is because the display driver isn't actually being used as it doesn't have a screen attached, keep on reading on how to fix it.

Side note: On my main rig I also passthrough a wifi card that came with my motherboard because I have no use for it and honestly would rather avoid any windows shit on my Linux environment, including my virtual networks. I didn't include that in this article as the motherboard I'm using doesn't have a wireless card.

Step 5: Looking glass and Scream (Correcting Video and Sound)

Now you need to get an application called looking-glass in order to act as your display and interface between your Linux host and Windows guest. To install it just go to their website and download the latest stable version (V7 as of June 2026) then just install it as you would any program.

Next you need for looking glass to load at boot, this is accomplished by creating a new task using the task scheduler, just open the aforementioned task scheduler, create a new task and make it launch looking glass at boot.

After you install looking glass and setting up the task, shut down and fire up the VM again and if your tray shows looking glass is running then shut down the machine and disable virtio display, just set your display to 'none'.

You're done with the Windows guest for a bit, the last thing you want to do is CONNECT YOUR EDID Dummy Plug TO YOUR GPU.

Now jump to the Linux host and download the source code for looking glass. Then just extract it.

IMPORTANT: DOWNLOAD AND USE USE THE 'SOURCE' COMPRESSED FILE FROM THE SAME WEBSITE WHERE YOU DOWNLOADED THE WINDOWS VERSION, DO NOT CLONE THE GITHUB REPO AS DETAILED IN THEIR DOCUMENTATION, IT WILL NOT WORK AND YOU'LL SPEND HOURS TROUBLE-SHOOTING WONDERING WHAT YOU'RE DOING WRONG.

You need to build the binary next, open the directory in a terminal and create a new directory under /client/build, then change directory into it.

The Looking Glass guide tells you to install the following dependencies for debian...

apt-get install binutils-dev cmake fonts-dejavu-core libfontconfig-dev \
gcc g++ pkg-config libegl-dev libgl-dev libgles-dev libspice-protocol-dev \
nettle-dev libx11-dev libxcursor-dev libxi-dev libxinerama-dev \
libxpresent-dev libxss-dev libxkbcommon-dev libwayland-dev wayland-protocols \
libpipewire-0.3-dev libpulse-dev libsamplerate0-dev

... But I'll be honest, whenever I try to compile the application I'm usually missing a dependency or two, so this is a process that may take you a bit as you must try to compile the app, come across the missing dependency, install it (Make sure it's the devel version) and keep going until you get a clean binary without warnings.

use cmake ../ and if you don't get any warnings or errors regarding missing dependencies use make, and if you get no error or warnings again you're done

This will give you a binary called 'looking-glass-client' as detailed in the make logs, hold on to it (In my case I made a copy and placed it on my home directory).

Now that you have finished building the client you have to make it connect to the host on the windows machine, for this you'll need to add a shem into the bottom of your xml of your VM as shown below. (Also set the memballoon value to 'none', I forgot to do it here)

Don't worry about the PCI values, those get auto-filled when you fill the other info and click apply.

Depending on the model of your EDID you may need to change the value based on the max resolution it supports, here is a table on which value to use (Please make sure to use the max resolution supported, not the native resolution).

Now create a file at /etc/tmpfiles.d/10-looking-glass.conf (Yes, it has to be tmpfiles) with the following information:

Reboot your whole system, after the reboot fire up the windows VM and execute the looking-glass-client binary, if everything goes according to plan you should see something like this:

You should now be running the display with your GPU instead of a virtuall display, you will see a massive performance boost with this, to the point where you can actually game without issues on low-performance titles or even do some work in taxing tasks like CAD programs.

But... You'll notice the next problem almost immediately, there is a 90% chance that your sound is completely gone because your EDID didn't come with speakers. There are a few ways to remedy this but I'll use a hard one by installing a program called 'scream' on the linux host and the windows client, simply because I find this solution to be the one that has the best audio quality output with little to no delays and it still allows you to run everything on a single pc without a second set of speakers or additional gizmos.

To start you just need to download Scream on your Windows guest (Don't decompress it yet).

Next you need to disable driver enforcement. The way I like to do this is by killing your VM forcefully a few times until the recovery menu pops up, then select Troubleshoot -> Advanced settings -> Startup settings and rebooting, then pressing F7 to disable driver enforcement

Once inside windows again decompress the archive and select 'run as administrator' in the bat script provided, the script will tell you if the install was successful.

Next you'll have to build Scream, the process is pretty similar to looking glass, download the source code, make a directory under /Receivers/unix/build, run cmake, make sure you don't have any unresolved dependencies and if you do resolve them, then run make.

Afterwards move the resulting binary to /usr/bin

At this point I ran into an issue where I ran into an undeclared dependency for pulse audio, after installing and rebooting it worked normally.

To use scream what you have to do is execute it pointing to one of your virtual machine's virtual networks (In my case and I assume most people's virbr0, therefore I must execute /usr/bin/scream -i virbr0, the VM doesn't even need to be running), while running it won't appear to be doing anything, not even when it establishes a connection successfully. 

Fire up your VM, run scream in one terminal and looking glass in another. The end result should look something like this:

If you can't hear any audio make sure to switch the sound option in your VM to CH9.

If you want a script to tie it all up and have the computer, looking glass and scream to start with a single command or .sh in the desktop it's as simple as  something like this:

#!/bin/bash
virsh start win11gaming
sleep 30
/usr/bin/scream_audio.sh & /home/<youruserhere>/looking-glass-client

(Do mind the single ampersand operand, running two will run one service and close the other)

You may think you're done here but you'll likely notice an odd behaviour on high-performance games like cyberpunk, any unreal 5 game or really anything that makes use of the card, this behaviour is caused mainly due to two issues, a new and very useful and wonderful feature in Windows that throttles your CPU and the fact that the clock of the host and the guest aren't running synchronously to one another. If everything looks fine except for the crappy frame rate move to the next section, we're almost done.

Side note: I recommend creating a new virtual network and use it for scream and only scream, it doesn't use a lot of bandwith that's shared with the rest of  the data your Window guests uses but it uses enough to be noticeable. Ultimately though, this really doesn't make that much of a difference so I decided to skip it in this guide.

Step 6: Correcting the clock, some performance enhancements and disabling the Windows option throttling performance (Core isolation)

The first thing that you wan't to do (Because really it's the easiest) is disable core isolation/memory integrity, just look in settings for it and un-toggle the switch, then turn off your VM.

Next you need to correct the clock by setting it to utc, correct the following lines in your VM XML (While you're at it also add the missing enhancement  lines to the cpu and hyperv segments, keep in mind evmcs is an intel-only feature): 

Fire up the VM again and you'll immediately notice the clock is now several hours off. to fix it go to the sysreg and add a new QWORD under HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\TimeZoneInformation called 'RealTimeIsUniversal', edit the QWORD to 1 as shown below

Aaand... that's it! No, really. You're finally done. Turn off the VM, turn it on again and if you see the hour is the same as your Linux Host then it's time for you to install some games.

optional: You can turn off all visual effects on performance options, honestly I haven't seen this making any difference because of how bloated Windows 11 is but hey maybe it raises the FPS by 1.

Step 7: Time for some gaming!

For this I picked two games, QUAKE 2 RTX and Gori: Cuddly carnage. The reason for this is because Quake2 RTX is actually extremely demanding and in my opinion underrated for RTX benchmarks and Gori just because it's an unreal engine 5 game that doesn't take 50+ Gigs to install and it's choke-full of particle effects (It also has an intro cutscene rendered in-game that works as a good benchmark). I knocked down the resolution to 1080p because to be honest my poor RTX 1000 (Equivalent to a cut-down GTX 1650) cannot handle the Neutron Style.

Gori ended up with an average framerate of 50fps and 1% lows of 29 at both cutscenes and gameplay with very little drops.

As for Quake 2 RTX... Well.. I ended up with 6 FPS (lol). Even funnier I got 1000+ FPS if I turned RTX off.

I completely forgot about it while configuring all this but the RTX 1000 is in fact, not an RTX card. It has 0 RTX cores so these results are completely normal. 

Still, I wanted to check if I hadn't screwed up so I went back to step 4 and swapped my RTX 1000 for an RTX A2000. This time the mighty 30 crtx cores of the A2000 gave me the mighty impressive result of 30 FPS on Quake 2 RTX. So yes, this is in fact working properly.

If you like the results all you have left is to activate your license and relax.

Addendum 1: EDID Dummy plugs

I want to make a quick comment on EDID Dummy plugs because I feel there isn't a whole lot of info about them online and their operation, while simple, is a bit more nuanced than one may think.  If you've never heard of them EDID stands for "Extended Display Identification Data" In other words they're the chips inside monitors that tell the GPU what kind of monitor you're using but since they're dummies there's no actual monitor attached to them, basically they serve the purpose of fooling GPU's into thinking there's a monitor attached.

First of all, try and get an HDMI plug (And by extension a graphics card with HDMI output) I used a DP dummy plug for this guide and yeah, they work great if you're doing remote work, but they're rather trash for gaming, refer to the screen tearing below (Which I swear is 100% on the dummy plug as evidenced by the fact the framerates are solid). I haven't come across a good DP EDID but who knows you may have better luck finding one than I did.

Now that you've discarded the DP dummy plugs, which Dummy plug should you pick? I'll be honest here they're completely luck of the drawer. Fueran and Evanlak respect the specs they advertise but they're expensive and don't ship everywhere, the kicker though? I don't use either of those, instead I use the shitty gold one on the far-right that has Adwits written on it (A company that I'm not fully convinced actually exists) and I bought on Amazon in a package of 3 units for 10 USD. Why? Because it was ripped from a monitor that had integrated speakers, which in turns means it has integrated speakers (Despite having no output), which means I don't have to use scream or any other method to get audio out of it, I just run looking glass and the audio works, it's great. Honestly for this reason alone where you may luck out and the fact there really isn't much difference between an expensive edid dummy and a cheap one (Other than refresh speeds at higher resolutions) I recommend you buy the cheapest one that can give you 120hz at 1080p or whatever refresh rate you're looking for.

On the subject of the black Evanlak don't get a dummy plug that looks like it (With a male and female end. They're great at what they do but what they do it's not gaming, rather, what they do is fool a device to think there's a monitor or TV plugged in and send a clean signal to the monitor or TV on the other end. Why do this? I think it's rather obvious for some people but I'll just spell it out: these are mostly used to bypass HDCP and record footage from a device with a capture card. Personally though? I use them to patch video signals for wacky monitors and GPU's, refer to the image below of an imagination GPU sending a signal to a repurposed crypto-miner picked up from the literal garbage being used as a controller for an e-ink display to better understand the kind of wacky video signal nonsense I'm talking about.

Addendum 2: Why I don't use hooks and a note regarding other cards

I feel like someone may read other guides and wonder why I don't use hooks, and the reason for it is because if you have a monitor or EDID dummy plugged into your computer and your motherboard isn't from a server or professional workstation... chances are it will crash the moment you fire up the VM. The reason for this is because Xorg tends to generate a new display (Even if hidden) whenever a monitor is plugged in and the moment you fire up the VM the display server has no idea what the hell just happened to that display and goes kaput.

There are ways around it by scripting and I don't recall if this also happens on Wayland but regardless it's out of my use-case and the less trouble-shooting I have to do the better, so I just don't do it. As I stated in the beginning I've been using a Windows VM regularly for over 2 years now and I'd rather not have to fix it every boot.

Hooks are great when working with workstation cards that have no video output (E.g. Nvidia Tesla cards) but for gaming? They're not worth the hassle, sometimes I've found it's necessary to do both loadiong the vfio drivers AND using hooks (Arc cards in particular gave me a lot of grief with this).

And while we're on this subject: Don't use Arc cards, just don't. I love them but the moment they detach from the VM (Even for a second before the virtio drivers kick in) they're loaded into the kernel and your host computer will just crash, moreover last time I used one with looking glass they weren't supported so it's not like you can even make proper use of them anyways (For the record if you want to give it a shot what I ended up using as a replacement was freerdp).

As much as I don't like Nvidia I have to admit they're the easiest solution for a virtual gaming PC, even AMD (Which is the best at bare-metal Linux) gave me a headache once as it wouldn't load without further modifications to the xml (long story short I had to dump the BIOS of the card with GPU Z and then load the BIOS into the VM manually with something similar to the lines below).

<hostdev mode='subsystem' type='pci' managed='yes'>
  <driver name='vfio'/>
  <source>
    <address domain='0x0000' bus='0x01' slot='0x00' function='0x0'/>
  </source>
  <rom file='/var/lib/libvirt/vbios/my_vbios.rom'/>
  <address type='pci' domain='0x0000' bus='0x03' slot='0x00' function='0x0'/>
</hostdev>

Happy gaming.

 -Batlog

If you enjoyed this article or if it was of any use to you, please consider donating some crypto. All funds go towards paying for the hosting.

Monero/XMR:
88MC6ksaVyLbtH9fT4owLSPX16vYD9cf6YELmXjaNWWd71R6iwfFV6DJtp7BXR5c6vWnxLEEGyu1tfwXwTqDM1CUCqDGeRY

Bitcoin/BTC: 
bc1qzw9g97ffhllwukhagkvn5g0u9d8rhjv86xhf8h

Ethereum/ETH:
0xf948ab59E492865Fb5200A97F0F4F2f31F7b443f

Litecoin/LTC:
ltc1qqfv05jpyh8yvzyetmf7n5ve500jl656yxpc8y4

Doge:
DT5iG6GxoyZtHSSmaZHHV63NpEoH5yuixg