Ben Santora

Resourceful Computing: What Happens When We Optimize for Old Hardware?

Laptop prices have gone past the point of reason. RAM has tripled in cost and gets scarcer every day, and even PC builders are feeling it. Windows 10 support ended in October 2025, and Windows 11 refuses to install on a huge number of machines that work perfectly well. So here is the question I keep coming back to: why does software keep assuming new silicon, when billions of good computers already exist?

I call this resourceful computing. It’s treating efficiency as a real decision with real costs, for your users’ wallets, for the planet and for your own software. Not a matter of taste.

I’m a hardware tech, not a software developer. I’m not writing this from a conference stage. I’m writing it from the bench, where I see what happens when today’s software meets the computers people actually own.

What I see from the bench

For years, software has been written as if CPU is unlimited, RAM is cheap and the cloud is endless. You can feel it: heavy runtimes, layers on top of layers, and chat apps and note-takers that sit at hundreds of megabytes while doing almost nothing. On your development machine you don’t notice. On an older Dell OptiPlex with 8 GB of RAM, the kind of machine that comes across my bench, you notice in the first minute.

Those machines aren’t junk. A quad-core i5 or i7 from 2016 or 2017 with 8 GB and an SSD can browse, write, compile code and edit photos. Millions of them sit in homes, offices, storage rooms and closets. Put a lightweight Linux on one and it feels quick again. I’ve done it a hundred times: boot times shrink, the fan quiets down, and RAM becomes something you have instead of something always running out. The hardware was fine all along. The software around it got heavy.

Obsolete by policy, not physics

Windows 11 requires TPM 2.0 and, in practice, an 8th-generation Intel or 2nd-generation Ryzen processor or newer. That one rule drew a line through a huge number of capable PCs. The analyst firm Canalys estimated that around 240 million PCs could end up as e-waste because of Windows 10’s end of support.

Physics didn’t retire those machines. A policy did. Every one that gets thrown out means new mining, new manufacturing and new shipping to replace it, and for a family on a tight budget, a forced $1,500 to $2,000 purchase they didn’t need.

Many of those machines will get a second life on Linux. Hobbyists and households are already doing it, less out of ideology than out of getting by. But a second life only works if the software people want still runs on the machine. That part is up to developers.

It used to be mandatory

There was a time when nobody had to argue for this. Memory was measured in kilobytes, and software that didn’t fit didn’t ship. Lean code was mandatory. Then hardware kept getting faster and cheaper, and it bailed out every extra layer we added. Efficiency became optional, and most of the industry opted out.

That bailout is ending. RAM is expensive again, upgrades are being forced rather than chosen, and more of us in 2026 are holding on to the devices we have. Efficiency isn’t mandatory anymore, but it’s rational again.

What removing a layer taught me

I learned this hands-on with small language models. Ollama and Jan are nice and they worked fine for me. But I’m a Linux guy and I like to go under the hood. So I dropped the wrappers, ran llama.cpp directly and tuned it for my exact hardware: an HP ENVY laptop with a 4-core i7-1165G7 and no GPU.

The first thing I learned surprised me. When a model writes, each new token means reading the whole model from RAM. Generation is limited by memory speed, not by the CPU. Pushing the cores harder, with turbo, more threads or more watts, adds a lot of heat and very little speed.

So I capped the CPU’s power with Linux’s own controls (RAPL and the intel_pstate driver) and adjusted llama.cpp’s flags. An 8B model writing a 400-word story used to push the CPU to 94 °C, where it started throttling itself. Now the same job peaks at 70 °C with no throttling. It’s about 30% slower, and the output is just as good.

The lesson isn’t really about cooling. It’s that I only found where the work actually was by getting under the layers and measuring. The capability was there all along. The defaults just weren’t built for my machine.

My daily setup follows the same idea. That HP runs xiralinux, my own minimal Debian distro: no desktop environment, only Openbox, and Firefox-ESR (no AI). It could run Mint or Ubuntu with a shiny desktop. I’d rather give those cycles to the work.

Why this is in your interest

I know “think of the planet” doesn’t ship features. So here is the case for developers:

About Electron

Electron is the easy target, and I won’t pretend there are no reasons for it. One codebase on three platforms, built by a small team, is a real advantage. I’m not asking anyone to rewrite their app or throw out their framework.

I’m asking you to measure it. Know what it costs at idle, know how it starts on a modest machine, and decide on purpose. If the answer is “300 MB is worth it for us,” that’s a decision. For most software today, nobody ever made one.

One thing to try this week

If any of this has made you curious, here is a test that takes an afternoon. Find an old machine (every office has one in a closet), or simulate one on Linux:

# run your app capped at 4 GB of RAM and two cores' worth of CPU time
systemd-run --user --scope -p MemoryMax=4G -p CPUQuota=200% ./yourapp

# see the peak memory of a run
/usr/bin/time -v ./yourapp 2>&1 | grep "Maximum resident"

For web apps, Chrome DevTools has CPU throttling built in: open the Performance panel and set it to a 4x or 6x slowdown.

Then write down three numbers: startup time, idle RAM, and how long the one thing your users do most actually takes. Set a budget from those numbers and keep to it as you add features.

My own bench goes back to a 2008 Toshiba laptop. I’m not asking you to target that. A machine from 2017 with 8 GB of RAM is a fair goal, and millions of people own one right now.

Why it matters

The two stories fit together. Developers who write efficient software open the door for people on older hardware. People who keep old machines alive make a bigger audience that rewards efficient software. Less waste in code means less waste in hardware.

None of this needs a lecture or a rejection of modern tools. Constraints are good partners. Asking whether your application runs well on a modest machine isn’t going backward. It’s future-proofing.

So ask the questions. How efficient can this be? What happens if I remove one more layer? Can this still feel good on a machine that has already had a full life?

If the answer is yes, everybody wins, and far fewer of the computers we own right now end up in a landfill.