That’s Not a Terminal — The Truth About Linux Terminals
What if I told you… this is not a terminal?
What you’re looking at is an emulator.
And the real terminal? It used to be a physical machine.
Let me show you the real story behind what we still call ‘the terminal’ today.
let’s go back in time. In 70s,
Computers were massive, expensive mainframes that cost millions of dollars. No one could afford a personal computer, so these mainframes had to be shared between multiple users.
The solution? Terminals. A terminal was a simple device — just a keyboard, a monitor, and a serial cable connection. No CPU, no RAM, no motherboard, no hard disk. Nothing.
Just an Input from the keyboard and Output to screen
One famous example is the VT-100 terminal
It would connect via serial cable to a central mainframe computer — like a VAX-11 — and that mainframe would do all the actual computing.
These devices were called ‘terminals’ because they were the terminal point — the endpoint — where users interacted with the computer
And something else a ‘TTY’, which you’ll see everywhere in Linux, stands for ‘teletypewriter’ — those were even older machines that literally printed output on paper before monitors existed!
So the terminal was just your window into the system. As this photo show how they worked.
Even though physical terminals are obsolete today, the concept of terminals still exists in Linux. The Linux operating system has software that can communicate with terminal devices, and it offers ways to access that functionality both physically and virtually.
Let me show you what’s actually running on a Linux system right now.
[Let’s press Ctrl + Alt + F3]
This screen is called a virtual console.
I’ll enter my username and password — and this is exactly how Linux systems were used years ago: no windows, no mouse, just pure text.
If I run the command tty, it tells me which terminal I’m connected to.
As you can see, I’m on tty3.
What’s interesting is that this isn’t a separate physical device.
There’s only one keyboard and one screen —
but Linux virtually splits them into multiple independent consoles.
These virtual consoles are text-mode login sessions built directly into the Linux kernel.
You can switch between them using Ctrl + Alt + F1 through F6, and each one runs independently in the background — even while a graphical desktop is active.
Get 0xMarik’s stories in your inbox
Join Medium for free to get updates from this writer.
Before graphical environments existed, this was Linux and it still applied in version that don’t require a graphical environment like Ubuntu server.
Now let me open what you probably use every day:
a terminal emulator.
Let’s run the same command again: tty.
This time, instead of tty3 or tty4, we get something like /dev/pts/0.
This tells us we’re no longer on a virtual console.
What you’re looking at now is a terminal emulator — a graphical application that simulates a terminal in software.
If you check the application menu on some Linux distributions, you’ll literally see it named “Terminal Emulator.”
Now you know why.
These programs are emulating the behavior of old physical terminals,
but instead of real hardware, they use pseudo-terminals.
That’s what pts stands for: Pseudo-Terminal Slave.
Each terminal window you open gets its own device file:
/dev/pts/0,1,2, and so on.
So while it looks similar to a virtual console, it’s actually a GUI program talking to the kernel through a virtual device.
So what’s the relationship between virtual consoles and terminal emulators?
They’re actually siblings — two different ways to achieve the same goal: giving you a text interface to communicate with Linux.
Virtual consoles are implemented directly in the kernel. No GUI needed. They’re your emergency backup — if your graphical desktop crashes, you can always press Ctrl+Alt+F2 and still access your system. You can see it a lot in servers version where GUI is not installed. Like Ubuntu server as we said before.
Terminal emulators in the other hand are GUI applications that run inside your desktop environment. They’re more convenient for daily use, but if your GUI crashes, they go away too.
Here’s the beautiful part: from the shell’s perspective, it doesn’t matter! Whether you’re in virtual console or terminal emulator, the shell just sees a terminal device and works exactly the same way.
There’s a well-known concept in Linux: “Everything is a file.”
That doesn’t just apply to regular files like documents or scripts —
it also applies to devices.
Keyboards, disks, screens… and terminals are no exception.
In Linux, terminals are represented as device files.
Virtual consoles appear as: /dev/tty1, /dev/tty2, and so on.
Terminal emulators, on the other hand, use: /dev/pts/0, /dev/pts/1, etc.
This file-based design is what makes Unix-like systems so powerful — programs don’t talk to hardware directly; they just read from and write to files.
So next time you open a terminal, remember that you’re just interacting with these device files.
If you found this helpful, go subscribe to the channel https://www.youtube.com/@AsgardTech, hit the like button, and drop a comment that you came from medium, see you in the next one.
