Stillness Through Simplicity

Introduction

Tab Window Manager—TWM—has been around for over 30 years.
That alone is remarkable in a world where software lifespans are measured in months.
But what’s more remarkable is that it still works. Flawlessly. And hasn’t changed.

Why do we assume that progress must mean complexity?
Why do our desktops do more—and feel slower—than ever?

TWM offers a counterpoint. It hasn’t changed in decades. And maybe that’s precisely why it matters.
It is a window manager in the strictest sense. It manages windows—nothing more, nothing less.
In an age when desktops have become operating systems in themselves, that simplicity feels revolutionary.

Because performance is seldom about hardware.
It's not about speed. It’s about weight.

A modern desktop slows not because the CPU is weak or RAM is insufficient but because too much is demanded at once.
Icons, animations, helpers, daemons, popups, panels, monitors, notifications—layers upon layers of software, all speaking simultaneously.

Each update brings another background service, and every feature adds a new dependency.
Even minor UI improvements come with their own compromises: latency, complexity, and noise.

We now live inside systems that try to do everything—predict, automate, smooth over, gloss.
But the more they try to do, the more they must manage.
What began as a tool becomes a terrain.
What was supposed to assist you now needs your assistance: updating, debugging, and understanding.

TWM is the refusal of that burden.
It’s not nostalgia. Not regression.
But a deliberate absence of noise.

There are no welcome wizards. No onboarding.
No animations to distract you. No assistants trying to anticipate your intent.
Just a screen. And a pointer.
You act. It responds. No more.

This is not minimalism for its own sake.
It is restraint with intent.

Nothing But Windows

TWM remains when everything else is stripped away.
It is a window manager and nothing more. There is no compositing, backgrounds, transparency, tray, dock, widget, or hint.

Just windows. They float. You place them. A menu appears when you ask.
Nothing blinks. Nothing guesses. You control it.

TWM speaks Xlib directly. It bypasses D-Bus, offers no compliance with EWMH, and avoids session or notification protocols.
No IPC. No service daemons. No expectations beyond X itself.

And in this silence, a strange sensation: speed.
Not the frantic kind measured by load times or benchmarks, but a deeper kind. The kind born from absence.
Nothing to start. Nothing to monitor. Nothing to crash.

30 Years Ago

TWM was born into a different world.
In the early 1990s, graphical user interfaces were still the exception.
Unix systems were ruled by terminals, and mice were optional.

TWM didn’t emerge to compete with desktop environments. It preceded them.
It wasn’t designed for modernity. It helped define it.

It mapped windows. It drew borders. It showed menus on click. And that was enough.
There was no networked telemetry. No theming engines. No daemons.
Just X11, a keyboard, and the idea that maybe windows could be moved with a mouse.

While others chased innovation, TWM quietly became complete.
Its code solidified. Its behavior stabilized.
And then—it stopped.
Not because it failed. But because it was finished.

20 Years Ago

It was already old.
By the early 2000s, TWM had become a relic. It was still present in X installations, but only because no one had bothered to remove it. It was a last resort, a test.

Newcomers clicked into the void. A crosshatched screen. A maroon titlebar. A blank stare.
They recoiled. It wasn’t friendly. But it wasn’t meant to be.

For those who stayed, it revealed something rare: stability. A window manager that never changed. No rewrites. No trends. No bloat.
One file. One purpose. One job is done well.

10 Years Ago

The world accelerated. Windows blurred. Desktops exploded with features.
And TWM remained unchanged.

In 2015, people asked if it was still viable—not because it had broken, but because it hadn’t moved.
It didn’t support EWMH. It didn’t know what a dock was. It didn’t understand fullscreen.
And yet, it worked. Because it never tried to do more than it should.

Some users migrated to forks. CTWM. FVWM. But TWM itself stood still. Silent. Unassuming.

Today

In a world of Wayland and web-based interfaces, TWM seems alien. Not just old, but other.
It is not sleek. It does not scale. It cannot gesture.

But it starts. Instantly.
It draws. Perfectly.
It waits. Quietly.

TWM makes no assumptions, does not predict your actions, and does not preload, cache, hydrate, sync, notify, or sync again.
It does not bind to Super and does not remember the last sessions.
It appears. It serves. It exits.
And in that sequence, there is something holy.

But the modern world is loud. Chrome expects a handshake that TWM doesn’t offer.
Some apps assume EWMH hints, D-Bus presence, or full compositing. They flicker, resize awkwardly, and forget how to fullscreen.
They want to speak a language TWM never learned.

So people say TWM is broken. Or incompatible.
More often, they say nothing—because they've never heard of it.

And perhaps that is the most telling feature of all: Not that it failed but that it refused to adapt.
And in doing so, became invisible.

Unmodern

TWM is not productive. It has no search bar, dashboard, launcher, tabs, tiling, or overview.
It does not multitask for you.

But maybe the question isn’t what it lacks. Perhaps it’s what you no longer need.
Without a dock, you look at your windows; without a switcher, you focus; without a notification, you listen.
This isn’t regression. It’s discipline.

The Configuration Is the Interface

TWM has no settings panel. No drag-and-drop preferences.
Instead, a file: .twmrc.

You shape everything there: colors, borders, menus, and bindings.
There are no themes to download, no store, and no sliders.
You make it, or you don’t.

This is not user-hostile. It’s user-agnostic. It does not guess your intent. You must express it.
The computer waits. Not because it’s slow. Because it respects you.

Limits That Liberate

No virtual desktops.
No Alt+Tab.
No animations.

These are not flaws. They are boundaries. And boundaries clarify intention.

We are told we can multitask. That we must.
Multiple workspaces. Dozens of windows. Notifications layered over status bars layered over chat clients layered over calendars.

But the human mind is single-threaded.
We task-switch. Poorly.
Every change of context takes a toll—on memory, focus, and energy.

Virtual desktops promise order.
Desktop 1: code. Desktop 2: docs. Desktop 3: chat.
But each switch is a rupture. A micro-reset. A chance to forget what you were doing or why.

And worse—most users don’t use them.
They open everything on one screen, drag windows around, complain of clutter, and forget what lies buried behind.
Because virtual space does not create mental space.
Organization is not achieved by horizontal scrolling.

TWM does not offer you four desktops. It offers you one.
But in that one, you are free to build your own structure.
You tile by hand.
You iconify windows you don’t need now.
You bring forward only what matters.

The result is not less functionality. It is less temptation.
TWM does not distract you with the idea that you can be everywhere.
It invites you to be here.

And technically, it does more than it seems.
Icon managers give you visual context. Menus can be structured, categorized, and dynamic.
You can precisely bind keys to cycle, raise, or focus windows.

You don’t need multiple desktops. You need focus.
And TWM provides exactly that—without layers, weight, or noise.

It is not an environment that assumes chaos and offers management tools.
It is an environment that never creates it.

Conclusion

TWM does not compete.
It doesn’t innovate.
It doesn’t evolve.
Because it doesn’t need to.

There have been no significant updates in years.
And most likely—there never will be.

TWM is finished. Not abandoned. Not outdated. Just finished.

Every useful feature is already there.
Every unnecessary one was never added.

This means something profound:
Once you learn it, it stays.
Once you shape your environment, it remains.

No redesign.
No deprecations.
No new gestures, layers, animations, or extensions.
Your workflow becomes permanent.
Uninterrupted by the churn of modern software.

And because it is old—because it is ancient—
Its code has been read, patched, studied, and trusted by generations of programmers.
Any real bugs? Already found.
Security flaws? Already fixed.

If it works now, it will work tomorrow.
Nothing in it depends on trends, cloud calls, or background agents.
There is no moving part to break.

I am writing this with a TWM session running—remotely, over the network—on a distant machine.
That session has been open for 104 days—no lag, no crashes, no drift.
Just windows. Still where I left them.
Doing exactly what they were meant to do.

While writing this, I tried to check how much RAM and CPU TWM uses.
It was hard to find in top. So I gave up.
You’ll have to believe me—or better, try it and tell me what you see :)