r/eGPU • • 7h ago

eGPU Manager: plug-and-play eGPU for SteamOS handhelds (free Decky plugin + desktop app)

Thumbnail
gallery
22 Upvotes

Using an eGPU on a SteamOS handheld always meant fiddling: Game Mode stays on the iGPU, shaders re-process every time you switch, the handheld screen stays lit black, and pulling the cable can freeze the driver until a reboot.

So I built eGPU Manager, a free, open-source Decky plugin + Desktop app:

- Auto switch: plug the eGPU in → Game Mode restarts on it, on your TV/monitor. Unplug → back on the handheld. (Or turn auto off and use a Switch button.)
- Shaders per GPU: each GPU keeps its own shader cache, so switching doesn't trigger "Processing Vulkan shaders" again. A Shaders page shows every game's size per GPU, and you can delete per GPU.
- Handheld screen turns off while you play on the eGPU.
- Disconnect safely button: releases the card first, so unplugging never freezes amdgpu.
- Smooth Desktop Mode: KDE renders on the eGPU too (no frames copied over USB4).
- Status + Check setup: dock chip, USB4 speed, PCIe link, monitor, and fixes it can apply (like approving the dock).
- One-click install, one-click uninstall. Everything lives in your home folder, so it survives SteamOS updates and never touches the system partition. Uninstall restores stock.

Tested on: Legion Go S (Z1 Extreme) · SteamOS 3.9.5 · RX 9060 XT · AOOSTAR AG02 (USB4 40 Gb/s).
That's the only setup I've tested so far. If you try it on other hardware (Steam Deck, ROG Ally, other docks or cards), there's an "It works: share my hardware" button in the plugin. It pre-fills a GitHub report (no serials) so I can add your setup to the compatibility list. "Report a problem" does the same, with a log.

AMD cards only (NVIDIA isn't supported on SteamOS).

GitHub + download: https://github.com/avishai0258/steamos-egpu-manager

Feedback welcome! If it helps you, you can buy me a coffee: https://www.buymeacoffee.com/Avishai0258


r/eGPU • • 58m ago

Unlocked Two NVIDIA Ampere GPUs in Windows 11 — and Measured Up to an 81% Increase in Tensor Core Throughput

5 Upvotes

A real-world experiment involving NVIDIA GPUs, UEFI firmware, Linux, Windows USB4, Thunderbolt, CUDA, and AI performance benchmarking.

After extensive troubleshooting, testing, failed attempts, and multiple system reboots, I successfully reached a major milestone with my personal AI workstation.

I now have two NVIDIA GPUs reporting UNLOCKED in Windows 11:

  • NVIDIA RTX 3090 Ti — 24 GB VRAM
  • NVIDIA RTX 3080 Ti Laptop GPU — 16 GB VRAM

Even better, the external RTX 3090 Ti is connected through my Dell WD22TB4 Thunderbolt 4 dock, and its measured AI matrix-computation performance is essentially unchanged compared with a direct Thunderbolt connection.

The external GPU demonstrated approximately 77% higher FP16/BF16 throughput and 81% higher TF32 throughput compared with an earlier locked-state benchmark.

Here is how we accomplished it.

1. The hardware configuration

My experimental AI workstation consists of:

  • Windows 11 laptop with an internal RTX 3080 Ti Laptop GPU (16 GB)
  • External RTX 3090 Ti (24 GB)
  • Sonnet Breakaway Box 850 T5 eGPU enclosure
  • Dell WD22TB4 Thunderbolt 4 dock
  • Thunderbolt connectivity between the laptop, dock and external GPU
  • NVIDIA Windows driver 617.42
  • PyTorch 2.10.0 with CUDA 13.0

My objective was to investigate whether the Ampere GPUs' protected performance-related feature registers could be unlocked, whether that state could survive the operating-system boot process, and whether any measurable AI-compute improvement would result.

2. The original problem: Windows kept resetting the unlock

We worked with the open-source nv-uefi-unlocker project, using its UEFI-based unlocking approach.

The unlocker could successfully establish the requested register values before the operating system started.

However, Windows repeatedly cleared those values during startup.

The typical sequence was:

UEFI unlock succeeds → Windows starts → GPU resets or is reinitialized → unlock disappears.

Using the project's register diagnostic tool, we confirmed that the GPUs were returning to their locked states after Windows booted.

This was a critical distinction: seeing an EFI unlock success message did not prove that the GPUs remained unlocked after NVIDIA drivers loaded.

3. We moved the investigation into Linux

To isolate the problem, we built a bootable Linux testing environment using SystemRescue 13.03.

We tested the GPUs with NVIDIA's proprietary Linux driver, version 595.112.07, while adjusting the initialization environment for our experiments.

Eventually, we successfully loaded both GPUs under Linux and executed CUDA calculations on each.

The external RTX 3090 Ti also retained the expected feature-register values after the Linux driver loaded.

That was an important breakthrough.

It demonstrated that the unlock could survive at least one operating-system and driver initialization path.

The internal RTX 3080 Ti's post-driver register readout was inconclusive in that particular Linux test, so we did not count it as independently verified there.

This helped narrow our attention to the Windows boot and USB4 initialization process.

4. Investigating Windows USB4 and Thunderbolt

Our main suspected obstacle became the Windows USB4 device-router initialization path.

We investigated Windows services including:

Usb4HostRouter

Usb4DeviceRouter

Both normally used the startup configuration:

Start = 3

The unlocker's documentation described a possible Windows USB4 workaround involving temporarily disabling the device-router service during boot.

But this was not risk-free.

An earlier attempt had produced a Code 12 resource-allocation problem, so we did not treat the workaround as universally safe.

We instead developed a controlled, reversible experiment.

The temporary test configuration was:

Usb4HostRouter = 3

Usb4DeviceRouter = 4

We preserved the original settings, backed up the configuration, and prepared an administrator-level rollback to restore the device-router startup value to 3.

This gave us a way to investigate the Windows initialization issue without leaving the machine permanently configured with the device router disabled.

5. Creating the EFI-to-Windows boot sequence

We configured the bootable Lexar USB device containing the unlocker so it could chainload Windows Boot Manager after completing the GPU register operation.

Our test sequence became:

Dell F12 boot menu → PENDRO/NVUNLOCK USB → initiate EFI unlock → Windows Boot Manager → Windows 11

The EFI logs confirmed that both GPUs reached the Windows handoff with the expected register values and intact diagnostic markers.

The important register values included:

FEAT_PLM = 0xFFFFFFFF

SS0 = 0x88888888

SS1 = 0x00000008

We also checked diagnostic reset canaries to detect whether a later reset had cleared the unlock state.

On the successful Windows trial, both GPUs reported:

VERDICT [ampere]: UNLOCKED

The reset canaries remained intact.

For the first time in our tests, both GPUs were independently verified as unlocked inside a running Windows 11 session.

6. Measuring the actual performance improvement

We compared previous locked-state measurements against the unlocked system using the same benchmark implementation.

Testing conditions included:

  • 8,192 × 8,192 matrix multiplication
  • FP16, BF16, TF32 and FP32
  • PyTorch 2.10.0 + CUDA 13.0
  • Twelve timed samples per precision
  • Separate GPU testing and thermal monitoring
  • Multiple repeat tests in the unlocked state

RTX 3090 Ti — before vs. unlocked

PrecisionBeforeUnlocked via dockChange
FP1679.91141.39 TFLOPS+76.9%
BF1682.20144.90 TFLOPS+76.3%
TF3241.2274.80 TFLOPS+81.5%
FP3228.9329.43 TFLOPS+1.7%

The most significant improvements appeared in Tensor Core-related computation.

Ordinary FP32 throughput remained essentially unchanged.

The RTX 3090 Ti's unlocked measurements were also highly repeatable across the direct-connection tests.

RTX 3080 Ti Laptop GPU

The internal GPU was also successfully unlocked, although its performance changes were much smaller.

PrecisionEarlier baselineUnlocked medianChange
FP1632.6553.79 TFLOPS+2.2%
BF1636.1556.98 TFLOPS+1.5%
TF3221.4021.77 TFLOPS+1.7%
FP329.129.22 TFLOPS+1.1%

These figures use our documented November 17 baseline, not necessarily the earliest-ever 3080 Ti performance measurement.

The smaller differences on the laptop GPU may reflect normal measurement variation.

Important scientific limitation: Our comparison uses one earlier locked-state benchmark session and repeated unlocked sessions. It is not a fully controlled alternating locked/unlocked experiment, so power, clock and environmental differences cannot be entirely excluded.

Also, these results describe synthetic GPU matrix throughput. They do not establish equivalent gains in LLM tokens per second, video-generation speed or image-generation time.

7. The final challenge: getting the Dell Thunderbolt dock working

Initially, the successful unlocked Windows tests used a direct Thunderbolt connection between the laptop and Sonnet enclosure.

But that was not my desired everyday workstation arrangement.

I needed:

Laptop → Dell WD22TB4 dock → Sonnet RTX 3090 Ti

We shut the system down, moved the Sonnet connection to the Dell dock, and restarted Windows.

Both GPUs appeared correctly.

The external RTX 3090 Ti received a different PCI bus address because the Thunderbolt topology had changed.

We verified NVIDIA driver initialization and performed CUDA kernel calculations on both GPUs.

Both passed.

Next, we repeated our EFI unlock experiment with the Dell dock already connected.

After Windows started, the register diagnostics confirmed:

RTX 3090 Ti: UNLOCKED

RTX 3080 Ti: UNLOCKED

The temporary USB4 service setting was then restored to its normal value.

Both GPUs continued working.

8. Proving the dock was not reducing AI performance

One final question remained.

Would routing the RTX 3090 Ti through the Dell dock reduce the unlocked computational throughput?

We repeated the matrix-multiplication benchmark.

PrecisionDirect Thunderbolt, unlockedDell dock, unlocked
FP16141.74141.39 TFLOPS
BF16144.28144.90 TFLOPS
TF3274.6874.80 TFLOPS
FP3229.2929.43 TFLOPS

The differences were negligible within this test.

This established that our Dell dock connection was not meaningfully reducing measured Tensor Core computation.

It does not imply that the dock has no bandwidth limitations for CPU-to-GPU transfers or other workloads.

9. Final system verification

At the end of our successful test, we had:

Operating system: Windows 11

Internal GPU: RTX 3080 Ti Laptop — UNLOCKED

External GPU: RTX 3090 Ti — UNLOCKED

External connection: Sonnet enclosure through Dell WD22TB4

NVIDIA driver: 617.42

CUDA: Both GPUs passed real CUDA kernel execution

GPU Device Manager errors: Code 0 on both

USB4 Host Router startup: 3

USB4 Device Router startup: 3

RTX 3090 Ti FP16: 141.39 TFLOPS

RTX 3090 Ti BF16: 144.90 TFLOPS

RTX 3090 Ti TF32: 74.80 TFLOPS

Two external Dell monitors were also detected. Windows still reported the Dell and Sonnet USB4 router entries as Unknown during the unlocked session, so not every downstream dock function was independently verified.

10. What this experiment does — and doesn't — prove

This was an experimental, software-controlled unlock of GPU feature registers.

It was not a physical hardware modification, GPU BIOS flash, VRAM expansion or permanent firmware unlock.

The register state is volatile.

A restart, GPU reset or Thunderbolt reconnection may clear it.

The results should not be interpreted as proof that every RTX 3090 Ti or RTX 3080 Ti can obtain the same performance gains.

I would strongly caution anyone trying similar experiments to understand UEFI recovery, Windows driver initialization, PCIe/Thunderbolt resource allocation and the possibility of boot failures or device loss.

The biggest achievement was not simply modifying register values.

It was systematically validating the complete path:

UEFI initialization → GPU register unlock → Windows boot → NVIDIA driver → CUDA execution → register verification → performance benchmarking → Thunderbolt dock integration.

Final thoughts

This project required persistence, careful measurement, and repeated troubleshooting across firmware, operating systems, device drivers and GPU computation.

The result was a running Windows workstation with both Ampere GPUs reporting unlocked, a functioning RTX 3090 Ti CUDA compute path through a Dell WD22TB4 dock, and a repeatable, substantial improvement in the external GPU's measured FP16/BF16/TF32 matrix throughput.

My next goal is to measure how much of that improvement translates into real AI workloads: local LLM inference, image generation, video generation and other GPU-intensive applications.

Hardware experimentation becomes much more valuable when every claimed improvement is backed by diagnostic evidence, repeatable benchmarks and clearly stated limitations.

#NVIDIA #RTX3090Ti #RTX3080Ti #CUDA #GPUComputing #Windows11 #Linux #Thunderbolt4 #ArtificialIntelligence #MachineLearning #AIEngineering #PerformanceBenchmarking #UEFI #OpenSource


r/eGPU • • 17h ago

Looking for TH3P4G3 ATX Accessories (US)

Post image
2 Upvotes

Good day everyone! I recently bought an TH3P4G3 (ATX) from the market place, but it did not come with the original metal brackets, psu pad, and the screws. Does anyone know where I can source replacements for these?


r/eGPU • • 22h ago

Blackmagic eGPU on Linux: nine days of testing, one hardware wall (full write-up)

2 Upvotes

Setup: Blackmagic eGPU (Radeon Pro 580, subsystem BDBD:A14C) on a 2019 iMac (iMac19,1) running Kubuntu, Thunderbolt 3. The same machine has an internal Radeon Pro 570X — same Polaris family — which gave us a working twin to diff against, register by register.

What works: the card enumerates, the unassigned-BAR problem is solvable (three different ways documented), and once the SMC firmware is started from the virgin state, the SDMA and RLC firmware loads cleanly.

The wall: the graphics-core (CP) firmware load never completes. The card's SMU orders a hardware transfer (command byte 0x40) that never happens on a card that arrives cold over the Thunderbolt tunnel, and the driver dies with "SMU load firmware failed," probe -22.

What we ruled out before concluding that, over nine days: both the Linux and genuine Apple SMC firmware builds (extracted from macOS and run byte-clean — they stall identically), Apple's own driver sequence (a 1:1 port of the Linux one), ~1,160 registers diffed between the cold card and the working twin in virgin and post-attempt states, EFI-stage placement via a custom UEFI shim, Apple's EFI drivers (carved out of the iMac firmware — they're display-only, the card gets no EFI init), userspace AtomBIOS POST, and a one-byte SMC firmware patch (rejected by the card's keyed firmware signature — the firmware is cryptographically locked against modification).

Worth noting: this card reportedly works via VFIO passthrough on a normal PC (Framework community guide) — the iMac case is specifically poisoned by the boot chain resetting the card at OS handover. If you've fought this card on other hardware, the data may still save you time.

Full record, all tools, all failures: https://github.com/razer1989-tech/cold-card