One Terminal to Rule Them All

Or: how an ADM-3A became the cockpit of my homelab

Usually, when I write here, I try to talk about serious technical things.

• Kernel memory.
• Build systems.
• Functional safety.

The kind of topics where a small mistake can become a paper, a patch, or a very long afternoon.

This time, I want to write about something equally important … to me, at least:

• old electronic stuff.

Not “old” as in “deprecated by a vendor who would like me to buy the new cloud-enabled subscription version.”

I mean properly old… Old enough to have a CRT.

Old enough that when it displays a prompt, it does not feel like a terminal emulator. It feels like the computer is talking to you directly.

The arrival of the dumb terminal

At some point, I bought myself a Lear Siegler ADM-3A terminal. Inside I found a label that says 1977, meaning we are almost the same age.

This object is not just “an old terminal”, it is one of those objects that quietly left fingerprints all over computing history.

For example, if your shell abbreviates $HOME as ~, the ADM-3A keyboard is part of that story: the ~ character lived on the key labeled HOME.

And if your fingers know that h, j, k, and l are movement keys in vi, that is not random ancient wizardry either. On the ADM-3A keyboard, those letters had cursor symbols printed on them. Bill Joy developed vi using this kind of terminal, and apparently the muscle memory never left the building.

So yes, technically it is a dumb terminal… But “dumb” feels unfair.

It is more like a historical device with very few opinions and excellent posture.

• A chunky case.
• A real keyboard.
• A screen that does not care about your GPU.
• No tabs.
• No browser.
• No notifications.
• No “your session has expired.”

Just characters… beautiful, honest, monochrome characters and a hardware keyboard where you can even find a key labeled HERE IS, close to RETURN, which sounds like the terminal is politely introducing itself at a party.

And that is almost what it did. With the optional answer-back feature, the terminal could send a predefined identification string, either when asked by the host or when the operator pressed the key.

A tiny serial-age “hello, it’s me” fingerprint.

The ADM-3A had manners.

The ADM-3A is often called a dumb terminal, but I think that is unfair. It is not dumb! It is focused. It has one job:

“Give me bytes, and I will show them.”

First contact with the homelab

Of course, after buying an old serial terminal, the obvious next question was:

“What should I connect it to?”

The boring answer would have been: nothing. Put it on a shelf. Take pictures. Occasionally say, “yes, it still works,” like people do with classic cars that never leave the garage.

Not what I intended for it: a terminal wants a computer.

So I connected it to my VM host machine, and it worked.

There is something very satisfying about controlling a modern Linux system through a terminal from another era. It feels like time travel, except instead of meeting dinosaurs, you meet systemd, sometimes even scarier.

It feels weird and cute at the same time to have a machine from the past controlling a machine running virtual machines. But then reality arrived, wearing the traditional hat of all homelab problems:

“Nice. But you have more than one machine.”

The problem with having “just one more box”

My VM host was not the only machine in the lab with a serial console; there was also a network switch… and another server… if we want to call it such. It is my home PBX, running on an Atom machine. So it is technically a server, but also spiritually closer to an appliance that refuses to die.

The point is: I had more serial devices than terminals, and I did not want to keep moving cables around.

Moving serial cables by hand is fun the first three times. After that, well, I leave the rest to the reader.

What I was thinking was something like an old KVM switch… but for serial. One terminal, multiple machines and a magic key sequence to switch between them.

The old KVM idea, but with serial

Old KVM switches had a very nice property: they allowed you to keep one keyboard, one video output, and one mouse, and move between machines. How to do this was not always straightforward: sometimes with a button, sometimes with a key sequence and sometimes with a ritual known only to the previous owner.

I wanted the same experience, in serial form but perhaps using a more deterministic way, the key sequence, for example. So the ADM-3A would be the keyboard and screen and behind it, a small box would route traffic to one of several serial ports so that the active machine would receive what I type and the terminal would display what the active machine says.

It sounds simple.

It is because of that that I started the project just after buying the ADM-3A and I finished it only now.

Enter the small box

For the hardware side, I used a tiny FriendlyElec ZeroPi.

It is one of those small ARM boards that exists in the dangerous region between “cheap enough to use casually” and “capable enough to become infrastructure by accident.”

Mine is connected to a multi-port PL2303 USB serial adapter.

My past in the telephony appliances is payback, at last, and I have a good plan to reinvent an old telephony switch but for data instead of voice.

So, ladies and gentlemen, we are about to reinvent the wheel.

Writing the little tunnel

The software became serial_tunnel.

It is a small utility that connects one terminal side to multiple remote serial devices. The terminal talks to the selected device. The selected device talks back. If I press the configured escape sequence followed by a number, the active device changes.

Plain and oldish, but for this kind of project, boring is good. Boring means I can trust it at 1 a.m. when the switch is unhappy and the only thing I want is a console, not a distributed systems lecture.

The configuration defines the serial ports and the tunnels. Each remote has a name, a device path, a speed, and the usual serial parameters. The tunnel then says: these are the devices, this is the terminal, and this is the escape sequence.

The beauty of limits

Using an ADM-3A is a wonderful reminder that computers were not always chatty. A machine from that era did not print five screens of logs just to say “hello.”

It did not emit JSON, YAML, warnings, hints, stack traces, deprecation notices, and one cheerful message from a package manager telling you that funding is available.

It was more like:

login:

That was enough.

Modern machines are different, have feelings, and they express those feelings through logs… Tons of logs.

Still, the ADM-3A provides only 80 columns and 24 lines, beautifully retrò, elegant if you wish, but also disappointing if you consider modern system verbosity. In modern system metrics that 80x24 translates to approximately three boot messages and half a warning, fine if everything is working, very annoying if anything goes wrong.

So the first time I connected it to a Linux machine and watched output fly by, I had a thought:

“This is charming, but I have no idea what just happened.”

screen or tmux can help there”…

The heresy: adding SSH

This is where I committed a small act of retrocomputing heresy.

I added an SSH interface, not to replace the ADM-3A, that would be rude and the ADM-3A is the star of the show, but I wanted an SSH terminal that mirrors the same console hub.

Why?

Because sometimes the old terminal is perfect.

And sometimes I need to scroll back, copy a log line, or look at the same session from a laptop without standing in front of the rack like a 1970s operator waiting for the mainframe to confess.

So serial_tunnel also has an optional SSH terminal interface.

The idea is: the physical terminal and the SSH client share the same selected console. The ADM-3A is still the star of the lab, but the SSH side can observe and, when needed, interact using the same switching mechanism.

This gives me the best of both worlds:

• the tactile joy of the old terminal,
• the practical convenience of a modern SSH client,
• and the emotional conflict of knowing I added network access to a project whose whole charm is a serial cable.

Technology is compromise.

Sometimes compromise listens on port 2222. If you happen to have a terminal, a homelab, and what to use them together, check this out.

So now the dumb terminal is in charge of the smart machines. Which, frankly, feels like a healthy correction.

If you liked the story, please check out the code here