The Circle Closes: Thin Clients Are Back and the 80s Never Left

The narrative of computing is often sold as a straight line: bigger, faster, heavier, more expensive. We are told that progress means stuffing more silicon into our pockets until the battery dies by noon. But anyone who has spent time in the trenches knows the truth. Everything in computers is cyclical. We are currently witnessing a massive pendulum swing back to the philosophy of the 1980s: the Thin Client.

The Origins: C64 and the BBS

My journey didn’t start with a standalone workstation. It started with a Commodore 64 acting as a dumb terminal. As a kid, I dialed into Bulletin Board Systems (BBS), connecting to machines miles away that held all the data, the logic, and the power. The C64 was merely a window—a keyboard and a screen. It didn’t matter if the local machine had 64KB of RAM; what mattered was the connection to the host.

This was the original cloud. Efficient, distributed, and brutally honest about where the value lay.

The 486 Experiment: Linux on Scrap Metal

Years later, after moving back from Germany, I faced a hardware bottleneck that would make a modern consumer cry. We had a 486 laptop from circa 2000. It was underpowered, slow, and practically useless for anything resembling “modern” computing.

But I installed Linux. Because that is what I do.

Suddenly, that relic was viable. It couldn’t render high-definition video or compile kernels in minutes, but it could connect to the network. I configured mutt for email, and clients for AIM, ICQ, and IRC. It was a usable, functional workstation. The hardware limitations forced a discipline that modern users have forgotten: do only what is necessary.

The Challenge: A 2013 MacBook Air from Abu Dhabi

Fast forward to a recent experiment. I dug out the MacBook Air I originally purchased back in 2013 in Abu Dhabi. It has been in service for over a decade. On paper, it’s obsolete. In practice? It’s a canvas.

I wiped it and installed Arch Linux (because I run Arch, btw). I didn’t stop there. I configured a minimal Niri tiling window manager with a Noctalia theme. The result? I used this machine as my primary workstation for an entire weekend.

The workflow was starkly simple:

• SSH: To the real compute power.
• Browser: For the few things that demand a GUI.
• Local Terminal: For the interface.

It turns out, for 90% of my day, I don’t need a local GPU or 32GB of RAM. I need a reliable network connection and a shell.

The Software Stack: TUI Interfaces Are Your Friend

Here’s the punchline: modern hardware doesn’t struggle because it’s weak. It struggles because the software is morbidly obese. The fix isn’t new silicon — it’s a diet. And nothing on Earth is lighter than a well-configured TUI.

My stack on the Air:

• Ghostty — Mitchell Hashimoto’s terminal emulator. GPU-accelerated, native, and fast enough that a 2013 iGPU doesn’t even notice it. This is the foundation; everything important in my day happens inside this window.
• Neovim — I’ve written prose, configs, and code in vi-family editors since before this laptop existed. Muscle memory doesn’t expire. Why ship an IDE when 30 years of keystrokes travel with you?
• mutt + protonmail-bridge — Email on this machine, rendered as fast as the terminal can draw. Bridge presents my Proton Mail account as local IMAP, and mutt talks to it like it’s 1998. Which, architecturally, it still is — and that’s the point.
• gomuks — A TUI Matrix client pointed at my self-hosted homeserver. Group chat with zero Electron footprint. My colleagues can’t tell the difference; my RAM sure can.
• Firefox with uBlock Origin, Canvas Blocker, and NoScript — The one GUI concession. With the right extensions, the modern web becomes survivable on old hardware. NoScript in particular is a low-end machine’s best friend: block the 47 scripts on a news article and the page loads in the time the tracking alone would have taken.

None of this requires compromise. It requires taste.

The E-Waste Angle: The Greenest Device Is the One Already Built

Here is where this stops being nostalgia and starts being a duty.

Electronic waste is one of the fastest-growing waste streams on the planet, and computers are among the worst offenders. The environmental cost of a new laptop is front-loaded into manufacturing—the mining of rare earth elements, the fabrication of silicon, the shipping. By the time a machine reaches your desk, most of its carbon budget is already spent.

Every year we keep a device in service is a year that embodied carbon does something useful instead of rotting in a landfill or a shredder in the developing world.

The thin client philosophy is, quietly, one of the most effective anti-e-waste strategies available to an individual:

• Extend, don’t replace: A 2013 MacBook Air running Arch and Niri draws a fraction of the power of a new machine while performing the same tasks over SSH.
• Lower power draw: Lean software means less RAM churn, less CPU spin, less heat. An old Air sipping watts beats a modern gaming brick in energy terms.
• Decoupling capability from hardware: When the compute lives in the server room, the terminal can be ancient. You upgrade the backend once; hundreds of endpoints benefit.

Throwing a functioning laptop away because its OS vendor declared end-of-life is not a technical decision. It is surrender. Linux gives old hardware a second, third, and fourth tour of duty. That C64-era lesson—the terminal is disposable, the compute is centralised—is also the sustainable path.

The RAM Crisis and the Cloud Agent Shift

There is a silver lining to the current global memory shortage. It is forcing a reckoning. Developers and engineers are being pushed to optimise for RAM efficiency, stripping away the fat that has accumulated over decades.

We are seeing a shift towards cloud agents. Instead of running heavy local processes, we are offloading logic to the cloud. The local device becomes a controller, sending instructions and receiving results. This isn’t just about saving money; it’s about architectural sanity—and fewer melted-down devices in landfills.

We Are So Back in the 80s

The cycle is complete. The “Thick Client” era of local bloatware is ending. We are returning to the ethos of the 80s: Thin Client vs. Thick Client is back, baby!

We are rediscovering that the computer is not the destination; it is the vehicle. Whether it was a C64 dialling into a BBS, a 486 running mutt, or a 2013 MacBook Air running Arch and Niri, the principle remains unchanged.

• Efficiency: Do more with less.
• Distributed Power: Let the server do the heavy lifting.
• Longevity: Hardware lasts longer when it isn’t fighting software bloat.
• Sustainability: The greenest machine is the one already on your desk.

If you have old hardware gathering dust, do not throw it away. Install a lean OS, configure a terminal, and remember the days when the computer was just a window. We are so back.