Type a command, it runs on a hosted Linux box through OpenRouter Shell, and you get back whatever it actually printed. Works on your phone too.
You pick one during setup and can switch whenever you want in Settings.
Everything runs in an isolated Linux container on OpenRouter. What you see is the real output, errors included.
Nothing actually runs. A model reads your command and writes what a terminal would probably print, so it can be wrong sometimes.
Termio itself is free and I don't take a cut. The shell runs on OpenRouter using your own key, so you just pay them for what you use, and for most commands that's a few cents or less.
Two things: the model's tokens (depends on the model, cheap ones are really cheap) and the time the container spends running your stuff.
You'll need a bit of credit on your OpenRouter account, even with free models, since container time still counts. OpenRouter's docs ↗
Termio Lite runs on OpenRouter's free models (around 50 requests a day) or a free Mistral key (around 1B tokens a month right now). It won't touch your OpenRouter credits.
Just remember it's simulated. Fine for playing around, not for when you need the real output.
Commands run on a real hosted Linux machine. No emulator, no WebAssembly thing pretending to be a shell.
Quotes, pipes, redirects, variables, multiline stuff. It goes through exactly how you typed it.
You see what the command actually printed, errors and exit codes included. ls and df columns stay lined up too.
It runs what you typed and waits for the next one. It won't go off retrying stuff on its own.
Upload files, work on them, download the results. Stuff in your home folder is still there after the container sleeps.
Try a model for one session or make it your default. Prices come straight from OpenRouter.
Network is off by default. Turn it on and the container can only reach an allowlist, not the whole internet.
A few defaults are there for package managers, and you can add your own domains. Local stuff, private IPs and raw IPs get blocked no matter what.
openrouter:shell is in beta, so Termio is too. It's bound by whatever the hosted container allows, and I can't grant root or install things the environment doesn't support. Model availability, pricing and container lifetime are controlled by OpenRouter, not Termio.
Full behavior is in the OpenRouter Shell docs. Bugs or feedback: the Discord server, or DM blank9485._
Pulled live from OpenRouter. Prices per 1M tokens, input / output.
The questions people actually ask, including the dumb ones.
Not in Termio Shell. Commands run inside a real isolated Linux container and the output you see is the actual stdout and stderr those commands produced.
The AI turns what you type into a shell call, but it isn't making up the output. If you create a file, run Python, compile code, install a package, or completely mess up a command, that happens inside the container. Verify it yourself:
uname -a cat /etc/os-release id ps aux df -h
You can even download a Linux root filesystem and chroot into Alpine. That's a real userspace on the sandbox's kernel, not a model roleplaying a terminal.
The one exception is Termio Lite, which is fake on purpose. It's the free mode where a model guesses the output, and there's a LITE badge whenever you're using it so you don't mix them up.
Termio Shell actually runs your commands in a Linux container through openrouter:shell. Real files, real errors, real everything. It uses your OpenRouter key, usually a few cents or less per command.
Termio Lite doesn't run anything. A model just guesses what the terminal would print. It's free with OpenRouter's free models or a free Mistral key, but since nothing really ran, it can be wrong.
So basically: Shell when you need the real thing, Lite when you're just messing around.
Not a Termio one, that doesn't exist. You just need an API key: OpenRouter for Termio Shell, or OpenRouter / Mistral / whatever provider you want for Lite.
Your key stays in your browser and goes straight to the provider. There's no Termio server for it to touch.
Anything with a decent browser. Phones, tablets, laptops, desktops, even a TV if its browser isn't trash.
Can you use Termio on a TV? Technically, yes. Should you type Linux commands with a TV remote? Unless you have several years to spare, probably not.
Because you can. Nobody is stopping you.
Termio literally uses openrouter:shell underneath. It just wraps an actual terminal around it, with sessions, history, files, network controls, model picking, and a free Lite mode.
If you'd rather use OpenRouter Shell directly, go for it. I made Termio because I wanted to. Not every project needs to solve a previously unsolved problem.
Yep. Come report bugs, show off what you got running, or just hang around.
A little. Usually a few cents.
Termio itself is free. The shell runs on OpenRouter with your own key, so you pay them for the model's tokens plus the time the container spends running. With a cheap model that's usually a few cents or less per command.
You'll need a bit of credit on your OpenRouter account though, even if you pick a free model, since container time still counts.
If you don't want to spend anything at all, use Termio Lite.
Container time is $0.0001 per second while your command runs. Waking up a new or sleeping container counts as at least 30 seconds, so $0.003. After that, a warm container only pays for what it uses, and it costs nothing while it's just sitting there.
On top of that you pay for the model's tokens, which depends on the model. Prices show up in the model picker.
So a cheap model gets you a lot of commands for a dollar. Premium models and huge sessions will obviously eat more.
Commands stop working and Termio tells you you're out of OpenRouter credits. It won't fake any output. Top up, or switch to Lite in the meantime.
Nope. No cut, no subscription, nothing in between. You pay OpenRouter (or your Lite provider) directly with your own key.
Because the command itself isn't using 20K tokens. There's a lot more happening behind the scenes.
The model gets Termio's instructions, the tool definition, shell info, previous results and the rest of the session before it runs anything.
So you might type:
fastfetch
and think, "that's literally one word."
Meanwhile the model is apparently writing its autobiography backstage.
Pick a cheap model and it doesn't really matter. Pick a premium one and you'll feel it.
A fake terminal, on purpose. Instead of running your command, a model reads it and writes what the terminal would probably print.
It's off by default. You can pick it during setup or turn it on later in Settings.
Two ways:
Those limits are up to OpenRouter and Mistral, so they can change.
No. Nothing runs, so it's an educated guess. Most of the time it looks right, sometimes it's confidently wrong.
Don't use it to check if a script works or to trust a result for anything important. That's what the real shell is for.
OpenRouter (free models), Mistral, OpenAI, Anthropic (Claude), Google Gemini, xAI (Grok), DeepSeek and Groq.
Add your key, pick a model, and it plays the terminal. If you use your own paid key, that provider bills you, not OpenRouter.
Termio isn't affiliated with any of them btw.
There's a LITE badge in the top bar when you're in Lite. No badge means your commands are really running.
Yeah, within the session. If you "make" a folder, later commands try to stay consistent, so ls after mkdir test should show test.
It's still a model keeping track, not a real filesystem, so in long sessions it can forget stuff.
No. Interactive stuff isn't supported, you'll just get an error instead of a fake vim screen.
Yep, whenever you want in Settings.
Same as your OpenRouter key: it stays in your browser and goes straight to that provider when you run a command. If you use your own key in Lite, your commands go to that provider instead of OpenRouter.
Yes. Python 3, Node.js and npm are installed by default, so you can use them right away:
python3 --version && node --version && npm --version
Or run some Python directly:
python3 -c 'print("Hello from Termio!")'Mostly. Commands run in your home directory. When the container sleeps (after 5 minutes idle), files in home are saved and loaded back next time.
What's not restored: running processes, environment variables, and system-level stuff like packages you installed with apt. Files outside home aren't saved either.
OpenRouter keeps saved container files for 30 days after the container was last used. Termio can also back up changed files to your browser so a fresh container doesn't wipe your work.
2 minutes by default, 5 minutes max per command. After that it times out and you'll see the timeout instead of output.
Long builds, huge downloads or anything that's meant to run forever aren't a good fit.
Yes. In the model picker, Try model switches only the current session. If you like it, Make default saves it for future sessions.
Each model also has a details page with pricing, context length, supported input/output types and its description. Shell needs a model that supports tool calling.
Probably, yeah. It depends on the tool. A lot of normal Linux packages should work, but some won't because of sandbox or network limitations. You'll need networking on and the right domains allowlisted for most installs.
Termio and openrouter:shell are both still in beta, so expect the occasional bug or something randomly deciding it doesn't want to work today.
Termio's container runs Ubuntu, but you can run an Alpine userspace inside it with chroot, which also gets you Alpine's apk package manager. Here's the full walkthrough, using Fastfetch as the example.
1. Enable networking
Networking is off by default. Turn it on and add this custom domain to the allowlist:
dl-cdn.alpinelinux.org
2. Download the Alpine Mini Root Filesystem
Termio runs on x86_64, so grab the x86_64 rootfs:
wget https://dl-cdn.alpinelinux.org/alpine/v3.20/releases/x86_64/alpine-minirootfs-3.20.9-x86_64.tar.gz
Check it downloaded:
ls -lh alpine-minirootfs-3.20.9-x86_64.tar.gz
3. Extract Alpine
mkdir -p /alpine && tar -xzf alpine-minirootfs-3.20.9-x86_64.tar.gz -C /alpine
4. Verify Alpine works
Each command runs on its own, so an interactive chroot won't persist between commands. Pass the command straight to Alpine instead:
chroot /alpine /bin/sh -c 'cat /etc/os-release'
You should see something like:
NAME="Alpine Linux" ID=alpine VERSION_ID=3.20.9 PRETTY_NAME="Alpine Linux v3.20"
5. Set up DNS and TLS certificates
cp /etc/resolv.conf /alpine/etc/resolv.conf mkdir -p /alpine/etc/ssl/certs cp -a /etc/ssl/certs/. /alpine/etc/ssl/certs/
Skip this and apk will probably throw TLS certificate errors at you.
6. Update Alpine's package index
chroot /alpine /bin/sh -c 'apk update'
7. Install and run Fastfetch
chroot /alpine /bin/sh -c 'apk add fastfetch && fastfetch'
It should report something like:
OS: Alpine Linux 3.20.9 x86_64 Kernel: Linux 6.18.36-cloudflare-firecracker-... Packages: ... (apk) Shell: sh
To be clear: this isn't booting another kernel or a VM. chroot just gives the process Alpine's userspace and root filesystem, on top of Termio's existing kernel.
Note: since /alpine is outside the home directory, it won't survive the container sleeping. Extract it under ~ if you want it to stick around.
Probably. I haven't tested image tools much, so no promises.
It depends on the tool, its dependencies, and whether it plays nice with the sandbox. If it works, nice. If it explodes, well, now we know.
Termio can't magically give you a command that installs anything you name.
It assumes you already know your way around Linux. Different software has different install methods, dependencies and repos, and some of it just won't work inside the sandbox.
If you're still learning, Termio Lite is a decent free place to practice commands without burning credits.
Sure, if you can fit it into about 1.2GB of RAM and 3.7GB of disk. So, no.
And no, Termio Lite can't "simulate" it either. It'll just tell you the command wasn't found, which is honestly the most realistic output possible.
No. The container sleeps after 5 minutes idle, commands time out after a few minutes, and background processes don't survive. It's a terminal, not a hosting plan.
Obviously not. What did you think this was?
You're probably not DDoSing anyone from your own PC, never mind from a tiny sandbox with allowlisted network access.
And if you try anyway, you've found a remarkably stupid way to get your OpenRouter account banned and potentially reported to the relevant authorities. Termio is a terminal, not a complimentary botnet.
No. Termio isn't for breaking into accounts, attacking systems, or anything else you very obviously don't have permission to do.
Having a Linux shell does not come with a complimentary license to commit cybercrime.
No. Nice try.
If you paste some random "ULTRA MEGA HACK TOOL 2026" from GitHub without understanding a single line, break OpenRouter's rules and get banned, that's not suddenly the developer's problem.
Termio comes with a Linux shell, not legal immunity for script kiddies.
Nothing runs on your device, so you can't break anything. Probably.
Termio isn't running some hidden backend collecting your commands. Your browser stores your setup, and OpenRouter runs the actual shell work. That's basically it, a straight line from you to the model. Below is the honest breakdown, skipping the legal padding.
Last checked against the source · Sep 27 2026There's no Termio server sitting in between you and the model. Your browser talks straight to OpenRouter, or straight to your chosen provider if you use Termio Lite with your own key.
"Runs in your browser" doesn't mean nothing ever leaves. A hosted terminal has to send your commands somewhere to actually run them. Here's the split, no sugarcoating.
Sits in your browser's IndexedDB. Only used in the request header when talking to OpenRouter directly. Never touches a Termio server, never shows up in a URL. Lite provider keys work exactly the same way.
Whatever you type, the model you're using, and any shell instructions go to OpenRouter to be processed. In Lite with your own key, they go to that provider (Mistral, OpenAI, etc.) instead. That's kind of the whole point of the tool.
Your settings, command history, and saved sessions live in your browser. So do the filesystem backups if you've got that on.
Anything you upload lands in the OpenRouter workspace. Container files, terminal output, everything the shell spits out lives on their hosted infra, not yours.
There's no account system, no Termio cloud, none of that. It's just IndexedDB keeping things around so you don't lose your setup every reload.
Your model choice, interface stuff, network toggle, custom domains you've allowed, feature flags — the boring config stuff.
Saved sessions, past commands, which models you used, container references, the rendered output blocks.
Just metadata — file name, size, status, the OpenRouter file ID. The actual file contents live on OpenRouter, not in your browser.
If a file you made changes to, it can get mirrored into IndexedDB so a fresh container doesn't just wipe your work out of nowhere.
Not gonna dress this up. Termio uses Google Analytics, measurement ID G-HNR5XW5LXZ.
It's page views and basic interaction stuff, that's it. Your prompts, commands, API key, and terminal output never get sent to analytics. Standard Google Analytics rules apply on their end since it's their infra processing it.
The container can't reach the internet unless you flip that on, and even then it's not a free-for-all.
network_policy: disabled. The shell can't make outbound requests at all until you turn it on.
You get an allowlist, not open internet. Stuff like api.github.com, pypi.org, and *.pythonhosted.org are in by default, plus whatever custom domains you add.
Private network stuff, local addresses, raw IPs, sketchy schemes, malformed hosts, and the OpenRouter API endpoints themselves get rejected even as custom entries.
You're not locked in. Local data can be wiped from inside Termio, and remote files can be deleted from OpenRouter too.
Wipes the stored key out of IndexedDB.
The "remove & delete from OpenRouter" option actually deletes it from their workspace, not just from your view.
Wipes settings, sessions, history, file records, and backups after you confirm you actually want that.
OpenRouter and Google run their own infra and set their own rules for it, not Termio.
Handles the auth, model routing, file storage, billing, and the actual hosted containers your commands run in.
Handles the basic analytics on the main app. Ad blockers or browser privacy settings can mess with what it actually collects.
If you use Termio Lite with your own Mistral, OpenAI, Anthropic, Gemini, xAI, DeepSeek or Groq key, your commands go to that provider under their own privacy policy and terms. Termio isn't affiliated with any of them.
Termio is made in Romania, built and maintained as a small solo project. There's no company behind it, no VC funding, no office, and no legal department writing paragraphs nobody wants to read.
It's a browser terminal made for running a real Linux environment from pretty much any device, without needing powerful hardware of your own. Termio is still new and actively being built, with features added and changed based on actually using the thing rather than some five-year corporate roadmap.
Everything is handled by one person in Romania, from writing the code and fixing bugs to keeping the service running. The same person building Termio uses it too, so privacy isn't something delegated to a policy team. The goal is simply to be clear about what Termio does with your data and what it doesn't do.