A user-mode virtual machine
The whole computer is one process on your desktop. No hypervisor, no container runtime, no admin rights — and nothing inside it can see your real filesystem.
Boot PocketOS on a simulated CRT and get a Unix-flavoured machine of your own: a real filesystem, real processes, a real toolchain — a C compiler, CPython, QuickJS, vim — and a network you can read the rules of. Break any of it. The blast radius is exactly zero.
Most people learn the command line on a machine where mistakes are expensive, so they learn to be careful instead of curious. Terminal Simulator gives you the opposite: a full machine that costs nothing to break, and puts everything about it in reach.
The whole computer is one process on your desktop. No hypervisor, no container runtime, no admin rights — and nothing inside it can see your real filesystem.
Image layers plus a writable overlay, copy-up on first write, whiteouts for deletes. Save commits your changes as a new layer; a reboot throws away whatever you did not keep.
Not scripted responses. A process table, pipes, redirection, exit codes, an execute bit that is enforced, and a Ctrl+C that interrupts the foreground job and never the shell.
Every request goes through one virtual device governed by a policy file inside the image: allow, deny, or record responses so a lesson replays offline forever.
vim and nano ship inside the machine. Yes, you can get stuck in vim. That is not a bug we intend to fix.
Curvature, scanlines, an aperture grille, phosphor bloom and a drifting hum bar — a shader pass over sharply rasterised text, not a scanline image laid on top.
machine.pocketEverything — the filesystem, the programs you installed, the notes you wrote, the mess you made — lives in one portable image. Copy it to a USB stick and boot it on another operating system; it comes up exactly where you left it.
Saves are incremental diffs written atomically, so a crash mid-save leaves the previous machine intact. Corruption is detected at load rather than discovered three lessons later.
student@pocket:~$ write notes.txt remember this student@pocket:~$ save committing session layer… files changed : 1 digest : sha256:0c33…8ea1 written : machine.pocket (atomic replace) student@pocket:~$ exit # …a week later, on a different computer, a different OS student@pocket:~$ cat notes.txt remember this student@pocket:~$ ls /tmp # empty. /tmp is a real tmpfs. That is the lesson.
The interpreters and the compiler are not impressions of the real things. They are the binaries those projects publish, running unmodified inside the machine, against a filesystem that is the image and nothing else.
A C compiler that lives in the machine. The compiler is itself sandboxed, so it plans the build and the kernel runs each step as an ordinary process. Compiled code, compiled by compiled code, inside a sandbox.
The standard library and all, laid out in the image like a real
distribution. pathlib writes to the virtual filesystem;
sys.platform tells you the truth about where it is.
QuickJS for scripts from the image, plus an embedded JavaScript host whose syscall surface is deny-by-default: the engine starts with nothing and is handed only what the calling process already had.
ls, cat, grep, find, sort, base64, wc, cp, chmod, ln — one multicall binary behind a farm of symlinks, dispatching on the name you invoked, exactly the way busybox always did it.
A computer you cannot write a file on is a slideshow. Both editors ship, both behave, and one of them will keep you for a while the first time.
The resident shell: pipes, redirection, variables, tab completion, and the same language in a script as at the prompt — so what you learn interactively is what you write down.
The text grid is rasterised sharp into an offscreen buffer at exactly columns × rows, and one post-process pass applies the analogue damage. That separation is why the glyphs stay readable while the glass misbehaves. This page runs the same pass in CSS — switch the layers off and watch it come apart.
Three phosphors ship with the game: full colour on the xterm 256 palette, P1 green and P3 amber. The monochrome modes tint by luminance rather than throwing away channels, which is what the real tubes did and why they never looked flat.
Everything here is optional. Some people want the 1983 experience; some people want to read code. F9 settles it either way.
// one pass, in this order barrel curvature the corners pull away from the glass chromatic aberration growing towards the edges phosphor glow 9-tap bloom, squared: only bright things bloom scanlines one soft dark band per virtual row aperture grille RGB stripe mask, in output pixels phosphor tint monochrome modes tint by luminance hum bar + flicker a slow drift down the tube static + vignette the last five percent that sells it student@pocket:~$ phosphor amber phosphor: amber (P3 — kinder on the eyes at 2am)
Progress is checked by inspecting the machine, not your keystrokes. If you find a stranger route to the same result, the machine still says yes.
A guided course from ls to writing a script: navigate, read,
edit, permissions, pipes, packages, networking. Every lesson is a real
task on a real machine.
Timed scenarios on a broken box. A disk fills. A script loops. A file was deleted an hour ago and the only copy is in a layer. Diagnose it before the clock runs out.
An empty machine and no objectives. Build something, save it, carry the file to another computer. This is the mode that turns into a habit.
Author your own machine — contents, network policy, tasks — and hand the file to somebody else. A lesson is a file, and files can be shared.
The prompt on this page is a small imitation of the machine — enough to be honest about the shape of it. Click any command to run it. Tab completes, ↑ recalls, Ctrl+C interrupts.
| command | what it does | run it |
|---|---|---|
| help | Everything this machine knows — grouped, and honest about it. | |
| missions | Eight steps of field training, with progress kept in your browser. | |
| ls -l /usr/bin | The symlink farm: one multicall binary wearing forty names. | |
| tree /etc | Draw a subtree. The machine's configuration is a handful of files. | |
| grep -r KEYCARD /var | Search a tree. There is something in the logs you will need. | |
| ls / | wc -l | Pipes work. One program's output is the next one's input. | |
| wget https://example.com | Meet the network policy. The refusal is the lesson. | |
| chmod +x ~/launch.sh | The execute bit is enforced here, exactly as it is in the game. | |
| python hello.py | In the game, that really is CPython, sandboxed against the image. | |
| rm -rf / | Go on. We will wait. |
Windows, Linux and macOS from the same image. Wishlisting is the whole ask — it is how Steam decides to show the game to anyone else, and how you find out the day it ships.
The store page is not live yet — this link is a placeholder until it is.
No, and it does not pretend to be. PocketOS is a Unix-flavoured machine built from scratch in user mode. The concepts, the commands and the consequences are real; the kernel is not Linux, and the game says so out loud. What transfers to a real system is everything that matters: how a filesystem is shaped, what a process is, why permissions exist, how pipes compose.
No. The machine cannot see your filesystem — the sandbox's root is
the image, so there is no path out of it by construction, and network access
goes through a device that answers to a policy shipped inside the image.
rm -rf / costs you a reboot.
No. Field Training starts at ls and assumes nothing. If you do
already know your way around, Sandbox mode and the Incidents will be more
your speed.
No. The virtual network is simulated, and lessons that use it can be recorded into the image so they replay identically offline, years later, on a laptop in a classroom with no wifi.
That is exactly what the image format is for. Your file is the machine, the format is versioned, and layers are content-addressed so an update adds to the stack rather than replacing what you built.
It was built with that in mind. An instructor can author a machine — contents, network policy, tasks — and hand out one file that boots identically on every student's operating system, with no installs and nothing that can be broken in a way that matters. Mail press@terminalsim.com if you want to talk about classroom use.
A small imitation of the machine, written in plain HTML, CSS and JavaScript
with no dependencies and no build step. The CRT is the game's post-process
pass ported to CSS, and the colours are the game's palette verbatim. The
real thing is considerably faster, considerably deeper, and does not run in
a browser tab. Type credits in the terminal.
You cannot livestream a shell without thinking about what is on the screen. You can livestream this one: there are no credentials in it, nothing on your machine is reachable from inside it, and the worst outcome on camera is a reboot.
Builds, assets and interviews: press@terminalsim.com. Educators are explicitly welcome.
Title Methodox Terminal Simulator Developer Methodox Technologies Platforms Windows · Linux · macOS Genre Simulation · educational · sandbox Players Single-player, offline Price announced with the store page Contact press@terminalsim.com Site theeldermachine.com The machine is a file. That is the pitch, and it is also the feature list.