I Built a Steam Machine for Less Than $500 in 2026 (Before There WAS a Steam Machine)

Along the way I learned a few things, solved a few unexpected problems, and then made one huge mistake.

The year is 2026. Computer hardware prices are climbing fast, and my four-year-old gaming laptop is beginning to show its age. Equipped with an RTX 3060 mobile GPU and 6GB of VRAM, it still handles plenty of games well enough, but modern AAA titles are starting to push it beyond its comfort zone. Like most gaming laptops, it also runs hot, and cleaning the dust out of it is a lot more tedious than popping the side panel off a desktop.

Around the same time, I decided to give Linux another try after a roughly 15-year hiatus. Unfortunately, this particular laptop wasn't making a very good first impression. Between the advanced power management features, dual GPUs, the MUX switch, and NVIDIA drivers that still aren't as seamless under Linux as AMD's, I found myself spending more time troubleshooting than actually gaming. The laptop simply worked better with Windows.

That was all the excuse I needed to build a new desktop with an all-AMD hardware combination. My goal was simple: build something that would be easier to maintain, easier to clean, and finally give Linux a fair chance.

My original plan was to build a desktop that could rival my laptop, but after taking a step back, I realized I didn't need to. The laptop's 12th Gen Core i7 paired with 32GB of DDR5 RAM is still a potent combination, even if the RTX 3060 mobile GPU is beginning to show its age. Since the new system would spend most of its life as a gaming HTPC (Home Theater PC), I didn't need workstation-level CPU performance.

Instead of chasing the latest and greatest hardware, I started looking at the AM4 platform.

The Hunt Begins

I checked Newegg, Best Buy, Amazon, and just about everywhere else I could think of. While there were some tempting CPU, motherboard, and RAM bundle deals, the cost of building an entirely new system kept creeping upward.

That's when I decided to look at the used market.

I gave myself a theoretical budget of $400. I knew that budget was probably unrealistic for the level of performance I wanted, but it's always good to have a goal.

After contacting several sellers on Facebook Marketplace—many of whom never responded, and others who simply disappeared halfway through making arrangements—I eventually found a complete working system with a Ryzen 5 3400G, an ASRock B450M Pro4 motherboard, two 8GB sticks of Corsair DDR4-3200 memory, and a 256GB NVMe SSD.

The seller was asking $250.

Fifteen minutes from home and a little friendly negotiation later, I loaded it into my car for just $180.

It didn't have a GPU yet, but the build had begun!

Linux Without a GPU

Because the Ryzen 5 3400G includes integrated Vega 11 graphics, I was able to start experimenting with Linux distributions as soon as I got the computer home. I had already tried Nobara on my laptop because of its reputation for working well with NVIDIA GPUs, but this time I had a different goal in mind. I wanted something that felt as close to a true Steam Machine as possible.

After trying a few different options, I eventually landed on Bazzite. It's an immutable Linux distribution, which essentially means the core operating system is designed to be difficult to accidentally break. That stability, combined with its game-focused design and Steam integration, made it exactly what I was looking for.

Even running on the Ryzen 5 3400G's integrated Vega 11 graphics, I was able to launch Red Dead Redemption 2 at 1080p on the lowest settings. I honestly don't remember what the frame rate was, but it was completely playable.

It looked terrible...

...but it was playable.

That was enough to convince me I was on the right track.

Time for Some Upgrades

Now that I had a solid starting point, it was time to improve the hardware.

I was pretty well burned out on flaky Facebook Marketplace sellers, so I switched my attention to eBay. After a little hunting, I scored a used Radeon RX 6600 XT with 8GB of GDDR6 memory for $143 shipped.

Next, I used some Best Buy rewards points to pick up a brand-new Corsair CX750M power supply for just $43.09 shipped.

One problem remained.

The ASRock B450M Pro4 doesn't include built-in Wi-Fi or Bluetooth, and since this system was destined for my living room, I wanted wireless networking along with Bluetooth support for my headset and controller.

I settled on the TP-Link Archer TX3000E, a PCIe expansion card that adds Wi-Fi 6 and Bluetooth. It solved both problems with a single upgrade.

When everything was installed, my grand total came to $399.46.

I had actually done it.

For less than $400, I was playing Red Dead Redemption 2 at 1080p Ultra settings and a locked 60 FPS.

I thought I had accomplished exactly what I set out to do.

Then the micro-stuttering started.Something Wasn't Right

The excitement didn't last long.

Although the game looked fantastic, I was experiencing serious micro-stuttering. It wasn't enough to make the game unplayable, but it was definitely enough to ruin the experience.

I pulled up some performance statistics and immediately spotted something suspicious. The Ryzen 5 3400G was pinned at 100% utilization while the RX 6600 XT hovered around 70%.

That usually points to a CPU bottleneck. In other words, the processor can't supply data to the graphics card quickly enough, leaving GPU performance on the table. Before blaming the Ryzen 5 3400G, though, I wanted to rule out one other possibility.

Chasing the Wrong Problem

One of the reasons I intentionally built an all-AMD system was to take advantage of Resizable BAR, or Smart Access Memory (SAM) in AMD's terminology. Under normal circumstances, the CPU can only map a relatively small portion of the graphics card's VRAM at a time, constantly remapping different regions of memory as games stream textures and other assets.

With Resizable BAR enabled, the CPU can map the GPU's entire VRAM address space at once. That reduces overhead, improves communication between the CPU and GPU, and, depending on the game, can provide a noticeable boost in performance.

Seeing the CPU maxed out while the GPU still had room to breathe made me wonder if SAM simply wasn't working and was contributing to the bottleneck.

Fortunately, I had also installed Windows 11 as a secondary operating system. While Linux was my primary focus for this build, Windows gave me access to troubleshooting tools that either weren't available or were simply easier to use.

Sure enough, after booting into Windows, AMD Adrenalin reported that Smart Access Memory wasn't enabled.

So I headed into the BIOS—or UEFI, depending on your age and vocabulary. I am OLD, so I still call it the BIOS even though I know better, but that's beside the point.

The motherboard was still running BIOS version 4.30, which didn't support Smart Access Memory, so I updated it to the latest 5.70 release expecting the option to enable Above 4G Decoding and Resizable BAR to finally appear.

It never did.

After a little more research, I finally discovered why.

Despite wearing a Ryzen 3000-series badge, the Ryzen 5 3400G isn't actually based on AMD's Zen 2 architecture like the rest of the desktop Ryzen 3000 lineup. Instead, it's a Zen+ (12nm) APU, and AMD never added Resizable BAR support for those processors.

At that point, it became clear that the missing BIOS setting wasn't a motherboard problem at all.

It was a CPU limitation.

More importantly, it meant my original suspicion was only partially correct. While enabling Smart Access Memory may have provided a small performance boost if it had been supported, it was never going to solve the real problem.

The Ryzen 5 3400G simply wasn't fast enough to keep up with the RX 6600 XT.

It was time to break my $400 budget.

Enter the Ryzen 7 3700X

After another round of bargain hunting, I found what I thought was a pretty good deal: a used Ryzen 7 3700X on eBay for $90.80 shipped.

As an added bonus, it included a brand-new, never-installed Wraith Prism RGB cooler.

That little bonus will become important later.

At this point, some of you are probably wondering why I chose a Ryzen 7 3700X instead of jumping to a Ryzen 5000 processor.

The answer is simple: value.

Although the Ryzen 7 3700X launched back in 2019, it's still an outstanding value on the used market and a much better companion for the Radeon RX 6600 XT than the Ryzen 5 3400G.

The 3400G was designed as an APU, dedicating a significant portion of its silicon to integrated Vega graphics instead of CPU performance. As a result, it offers just four cores, eight threads, and a relatively small 4MB of L3 cache.

The 3700X, on the other hand, features eight cores, sixteen threads, and a massive 32MB of L3 cache. It also supports Smart Access Memory (Resizable BAR), something the Zen+-based 3400G never could despite wearing a Ryzen 3000-series name.

Would a Ryzen 5000 processor have been faster?

Absolutely.

Would it have made a noticeable difference when paired with an RX 6600 XT running at 1080p and 60 FPS on my television?

Probably not enough to justify spending considerably more money.

For this build, the 3700X hit the sweet spot.

I installed the new CPU, but I didn't have the mounting brackets for the Wraith Prism cooler yet. Rather than wait, I reused the Wraith Spire cooler from the Ryzen 5 3400G.

The results were exactly what I had hoped for.

Temperatures were excellent.

The micro-stuttering disappeared.

The GPU was finally being utilized the way it should have been.

For a grand total of $490.26, I had built a Steam Machine before there was a Steam Machine.

But then fate happened...

I couldn't leave well enough alone.

The $5 Mistake That Cost Me Over $100

I already had a perfectly stable gaming PC.

The temperatures were great.

The performance was exactly where I wanted it.

I should have stopped right there.

Instead, I started thinking about that brand-new Wraith Prism RGB cooler sitting on my desk.

I already owned it.

Why not use it?

All I needed were the mounting brackets.

I ordered a set for about $5, fully expecting that to be the end of the project.

It wasn't.

Since I was already taking the system apart, I started thinking, "Maybe I should put everything into a nicer case while I'm at it."

That one thought turned into a new case with a tempered glass side panel and ARGB fans.

The project had officially snowballed.

After moving everything into the new case, I finally installed the Wraith Prism cooler and started wiring up the RGB lighting.

That's when I made the biggest mistake of the entire build.

A Costly Lesson in RGB

The Wraith Prism includes both a 12V RGB cable and a USB cable for lighting control. My motherboard also has a 5V ARGB header for the case fans.

If you've worked with RGB hardware before, you probably already know where this is going.

If you haven't, here's the important part:

5V ARGB and 12V RGB are not compatible.

Unfortunately, the connectors are similar enough that they can be plugged in incorrectly if you aren't paying close attention. The 5V connector is keyed with one missing pin, but when you're reaching into a cramped PC case, it's easier to overlook than you might think.

I accidentally connected the Wraith Prism's 12V RGB cable to the motherboard's 5V ARGB header.

Instantly, I burned out the motherboard's ARGB controller.

Thankfully, nothing else was damaged.

The PC still booted.

The fans still spun.

The lighting...

Well... the lighting had developed an interesting new personality.

Instead of synchronized effects, every fan was stuck displaying an odd blue-and-purple pattern that looked like the PC had permanently entered some kind of cyberpunk emergency mode.

Digging Myself Deeper

Replacing the motherboard over a lighting mistake wasn't something I was willing to do.

Instead, I found a workaround.

I bought an external ARGB controller to bypass the damaged motherboard header along with an internal USB hub so I could connect both the controller and the Wraith Prism cooler.

It worked.

Mostly.

The only problem was that I was now more than $100 over the budget I had originally set for myself—all because I decided I wanted RGB lighting.

If I had simply left the original cooler alone and skipped the flashy case, the build would have stayed well under my self-imposed budget.

Sometimes the cheapest upgrade is the one you never make.

Linux vs. RGB

Unfortunately, the RGB adventure wasn't over yet.

OpenRGB detected all of my hardware, but I could never get it to automatically load my saved lighting profile during startup under Linux.

Every time I booted the system, I was greeted by a retina-burning light show until I manually launched OpenRGB and loaded my profile.

After spending a few hours trying different solutions, I finally admitted defeat.

For now, Windows 11 simply provides the better experience for this particular PC.

The system boots directly into Steam Big Picture Mode, and SignalRGB automatically loads my lighting profile without me having to think about it.

Could I have solved the problem with enough time?

Probably.

Would a different, non-immutable Linux distribution have worked better?

Possibly.

But one of the reasons I wanted to build this machine in the first place was simplicity.

Ironically, RGB became the most complicated part of the entire project.

Final Thoughts

Looking back, I'd absolutely build this system again.

Buying used hardware let me assemble a surprisingly capable gaming PC for less than the cost of a mid-range graphics card. Along the way, I learned a lot about Linux, Smart Access Memory, CPU bottlenecks, and just how much value there still is in older AM4 hardware.

I also learned that sometimes the biggest mistakes don't come from the expensive components.

They come from the $5 upgrades you convince yourself you don't really need.

Today, the system happily plays games at a rock-solid 1080p, 60 FPS, which is all my television can display anyway. The GPU finally spends its time where it should—working hard instead of waiting on the CPU—and regardless of whether I'm booting into Windows or Linux, it's become exactly what I originally set out to build.

Well...

Almost.

I still think one day I'll rebuild it without a single RGB component.

After all, Linux was supposed to simplify my life—not turn my living room into a miniature nightclub.