My i7-4790K: 12 Years and Counting

In 2014, I built what I thought would be a “future-proof” desktop.

Core i7-4790K. 4.0 GHz base, 4.4 GHz boost. The fastest consumer chip you could buy at the time. I paired it with 16GB of DDR3-1866, a 256GB Samsung 840 Pro SSD, and a GTX 970.

Total cost: About $1,800.

That machine is still my daily driver in 2026.

The Original Build (2014)

Component	Model	Price (2014)
CPU	Intel Core i7-4790K	$339
Motherboard	ASUS Z97-A	$149
RAM	16GB DDR3-1866	$150
GPU	NVIDIA GTX 970	$329
SSD	Samsung 840 Pro 256GB	$180
PSU	EVGA 750W Gold	$89
Case	Fractal Define R4	$99
Cooler	Noctua NH-D14	$79
Total		~$1,414

Plus Windows 8.1, peripherals, and a nice monitor. Call it $1,800 all-in.

The philosophy: Buy the best CPU you can afford. Everything else can be upgraded.

Twelve years later, that philosophy has held up.

The Upgrade Timeline

2016: RAM Upgrade

Problem: 16GB wasn’t enough. Chrome alone was eating 8GB.

Solution: Maxed out to 32GB DDR3-1866.

Cost: ~$100 (DDR3 was cheap by then)

Impact: Huge. VMs became practical. Compilation didn’t swap. The machine felt twice as fast for development work.

2018: NVMe Storage

Problem: The 840 Pro was showing its age. SATA3 tops out at 550MB/s.

Solution: Samsung 970 EVO 1TB NVMe via PCIe adapter.

Challenge: The Z97 chipset doesn’t natively support NVMe boot. I had to:

Update BIOS to the latest version
Configure the NVMe as a non-boot drive initially
Clone the system with dd
Fight with GRUB for a day

Cost: ~$200

Impact: Boot times halved. Application launches became instant. The difference between SATA and NVMe is visceral.

Note: Some Haswell boards can’t boot from NVMe at all. My ASUS Z97-A worked. Other boards might not. Check your BIOS options before buying.

2020: The Linux Migration

Problem: Windows 10 was getting slower with every update. Telemetry. Bloat. Forced restarts.

Solution: Switched to openSUSE Tumbleweed (later Gentoo).

Cost: $0

Impact: The machine felt brand new. Linux uses half the idle RAM of Windows. Updates don’t require reboots (usually). No telemetry phoning home.

The i7-4790K was “old” by Windows standards. Under Linux, it was plenty fast.

2023: GPU Upgrade

Problem: The GTX 970 couldn’t run modern games. 3.5GB of usable VRAM (remember that scandal?) wasn’t enough.

Solution: NVIDIA RTX 4070 Ti.

Challenge: Would a 2014 CPU bottleneck a 2023 GPU?

The math:

At 1080p, yes—the CPU bottlenecks hard. At 1440p or 4K, the GPU becomes the limiting factor, and the 4790K keeps up reasonably well.

Cost: ~$800

Results:

Game	Resolution	FPS (970)	FPS (4070 Ti)
Cyberpunk 2077	1440p	Unplayable	80+
Baldur’s Gate 3	1440p	30	90+
Deep Rock Galactic	1440p	60	144+

Is there a CPU bottleneck? Yes. Am I getting the full potential of the 4070 Ti? No. Do I care? Not really. The games run great.

2024: The NVMe Expansion

Problem: 1TB fills up fast when you’re storing VM images and compilation artifacts.

Solution: Added a second NVMe—Samsung 990 Pro 2TB.

Cost: ~$180 (NVMe prices dropped dramatically)

Impact: Dedicated drive for /var/cache/binpkgs. Compilation artifacts don’t compete with system I/O.

Current Specs (2026)

Component	Model	Original?
CPU	Intel Core i7-4790K	Yes
Motherboard	ASUS Z97-A	Yes
RAM	32GB DDR3-1866	Upgraded 2016
GPU	NVIDIA RTX 4070 Ti	Upgraded 2023
Boot NVMe	Samsung 970 EVO 1TB	Upgraded 2018
Data NVMe	Samsung 990 Pro 2TB	Added 2024
PSU	EVGA 750W Gold	Yes
Case	Fractal Define R4	Yes
Cooler	Noctua NH-D14	Yes
OS	Argo OS (Gentoo)	Changed 2024

Total upgrade investment: ~$1,280 over 12 years

Original cost: ~$1,414

Total lifetime cost: ~$2,700 for a machine that’s still competitive

Why It Still Works

Single-Thread Performance Matters

The i7-4790K’s single-thread performance is still decent. Modern chips are faster, but not dramatically so for lightly-threaded workloads.

CPU	Single-Thread (Cinebench R23)	Year
i7-4790K	~1,100	2014
Ryzen 5 5600X	~1,600	2020
i5-13600K	~2,000	2023

The 4790K is 50-80% of modern chips. For everyday tasks—web browsing, document editing, light development—that’s still enough.

RAM Matters More Than CPU

32GB of RAM lets me run:

KDE Plasma with 30+ browser tabs
Multiple VSCode instances
Docker containers
Compilation jobs
VMs for testing

With 16GB, I’d be swapping constantly. 32GB means I rarely think about memory.

NVMe Is Transformative

The difference between SATA SSD and NVMe is bigger than the difference between my 4790K and a modern chip for perceived speed.

Operation	SATA SSD	NVMe
Boot to desktop	18s	8s
Firefox cold start	3s	0.5s
emerge —sync	45s	12s
Kernel compile	12m	8m

For interactive use, storage speed wins.

Linux Extends Hardware Life

Windows 11 officially requires 8th-gen Intel or newer. My 4790K isn’t “supported.”

Linux doesn’t care. Gentoo with -march=native actually uses my CPU better than Windows ever did because every package is compiled specifically for Haswell.

The Bottlenecks

Let’s be honest about what doesn’t work well.

Heavy Compilation

Compiling Firefox from source takes 45 minutes on the 4790K. On a Ryzen 5900X, it takes 8 minutes.

Solution: The Build Swarm. I don’t compile on my desktop anymore. I pull binaries from my binhost.

Parallel Workloads

4 cores / 8 threads was high-end in 2014. It’s entry-level now.

Running 16 Docker containers? The 4790K struggles. Running 4? It’s fine.

Solution: Heavy workloads run on my Proxmox nodes. The desktop is for interactive work.

Memory Bandwidth

DDR3-1866 is slow by modern standards. DDR5-6000 is 6x the bandwidth.

For most tasks, this doesn’t matter. For video editing or heavy virtualization, it hurts.

Solution: I don’t do heavy video editing. When I do, I export overnight.

PCIe Lanes

Z97 has limited PCIe lanes. With an NVMe adapter and a modern GPU, I’m maxed out.

Impact: The 4070 Ti runs at PCIe 3.0 x16 instead of PCIe 4.0 x16. Performance hit is ~5% in GPU-bound scenarios.

The Economics

Option A: Upgrade incrementally (what I did)

Year	Upgrade	Cost
2016	RAM	$100
2018	NVMe	$200
2023	GPU	$800
2024	NVMe	$180
Total		$1,280

Option B: Replace every 5 years

Year	System	Cost
2014	Original build	$1,400
2019	New system	$1,500
2024	New system	$1,800
Total		$4,700

I saved ~$3,400 by not chasing the latest hardware.

The catch: At some point, the 4790K will need replacing. DDR3 availability is declining. Z97 boards are getting rare. When the motherboard dies, the whole platform goes.

But that day isn’t today.

When To Actually Upgrade

I’m planning to eventually build a new system. Here’s what would trigger it:

Hard triggers:

Motherboard failure (no replacement Z97 available)
DDR5 applications require more bandwidth than DDR3 can provide
Games I want to play require AVX-512 or similar

Soft triggers:

Compile times become unbearable (already mitigated by binhost)
New features I can’t live without (not there yet)
Found a really good deal on Ryzen 9000 series

Not triggers:

“The new chip is 50% faster” (upgrade cost isn’t worth 50%)
“DDR5 is the future” (DDR3 works today)
“Your system is old” (old ≠ slow)

Lessons for Long-Term Builds

Buy CPU Quality First

The CPU is the one thing you can’t upgrade without replacing the whole platform. Buy the best you can afford and ride it until the platform dies.

Max Out RAM Early

RAM is the cheapest performance upgrade. 32GB should be minimum for a workstation. 64GB if you can afford it.

NVMe Is Non-Negotiable

Even on platforms that don’t natively support it, an NVMe via PCIe adapter transforms the experience. The speed difference is life-changing.

GPU Is Replaceable

Unlike CPU, you can upgrade GPU without touching anything else. Buy mid-range initially, upgrade when games demand it.

Linux Extends Everything

Windows has hardware requirements. Linux has hardware suggestions. A “too old” Windows machine is a perfectly good Linux machine.

Compile For Your Hardware

Gentoo’s -march=native flag means my binaries are optimized for Haswell specifically. No wasted cycles on instructions my CPU doesn’t have.

The Future

Eventually, I’ll build a new system. AM5 is tempting. DDR5 prices are falling. Zen 5 looks good.

But not yet.

The 4790K still boots in 8 seconds. Games still run at 1440p. Code still compiles (on other machines). The desktop still feels responsive.

When the motherboard dies, I’ll shed a tear and move on. Until then, this 12-year-old Haswell keeps earning its keep.

Build quality beats build frequency. This machine owes me nothing.