Methodox Technologies · coming to Steam

Terminal Simulator A whole computer,
in one file.

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.

Wishlist on Steam
  • Windows · Linux · macOS
  • Single-player, offline
  • One file, carried anywhere
Methodox MX-80 F9 tube F10 phosphor
FIELD TRAINING 0/8
01 · what it is

A computer you are allowed to destroy

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.

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.

A 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.

Programs that really run

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.

A network with rules you can read

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.

Editors that fight back

vim and nano ship inside the machine. Yes, you can get stuck in vim. That is not a bug we intend to fix.

An 80s tube, rendered properly

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.

02 · the machine

Your computer is a file called machine.pocket

Everything — 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.

sessionyour writable overlay — copy-up on first write, whiteouts for deletes
devtoolsCPython, QuickJS, coreutils, clang — pinned releases, embedded
basethe shell, the userland, /etc, your home directory
manifestcontent-addressed digests; identical layers stored once
tmpfs/tmp — deliberately not in the file, and gone on every boot

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: ~
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.
03 · the toolchain

Real tools, really running, fully sandboxed

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.

cc / clang C

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.

python CPython 3.14

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.

qjs / js QuickJS

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.

coreutils multicall

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.

vim & nano editors

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.

easy shell

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.

04 · the tube

The CRT is a shader, not a filter

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.

post-process pass
// 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)
05 · ways to play

Four ways in

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.

Field Training

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.

Incidents

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.

Sandbox

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.

Workshop

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.

06 · learn by doing

Everything below works in the terminal above

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.

Coming to Steam

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.

07 · questions

Reasonable questions

Is this real Linux?

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.

Can it damage my computer?

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.

Do I need to know the command line already?

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.

Does it need an internet connection?

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.

Will my machine survive an update to the game?

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.

Is this good for teaching?

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.

What is this website, exactly?

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.

08 · press & creators

Safe to hand to an audience

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.

fact sheet
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.