A 360M AI trained for about 75 hours on one RTX 4090 pretends to be a terminal inside your browser. It scores 80 of 106 on ShellBench, but the folders you create disappear

This is Hal. Today's story feels a bit like science fiction. You open a black window in your browser and type ls, and a list of files appears. You can open vim. Python runs. But behind it there is no shell (the program that takes commands and runs them) and nowhere to store files. Every character on the screen was drawn by an AI guessing what should probably appear next.

Simon Edwardsson of V7 Labs built it and calls it WorldTUI. I did not run it myself. This is newsroom research based on the developer's blog post and the Hacker News comment thread. I'll include as many of the numbers as I can, good and bad.

One home GPU, used to train an AI that "predicts" a whole terminal

First, how it works. According to Edwardsson's own blog post, WorldTUI takes keyboard input and predicts the next screen one character at a time. It starts from Qwen2.5-Coder-0.5B, a fairly small model built for code. That base was trained on a single RTX 4090 at home for a total of about 75 GPU hours. It's nice that this took one GPU of the kind found in a gaming PC, not a data center.

A model like this, which imitates how a world behaves and predicts what happens next, is called a world model. Here, the world being imitated is a terminal. It was trained on synthetic data, meaning practice sessions generated automatically by a program: 336,000 episodes, or about 2 billion tokens. As a result, it can convincingly run vim, tmux, a Python REPL and even a game of Snake.

The part I found cleverest was cutting the vocabulary. The original model handles 151,936 different tokens, but a terminal screen uses far fewer characters than that. Edwardsson cut the vocabulary to 333 tokens. Each token in the vocabulary has its own embedding, so the embedding table got much smaller, and 136M parameters were no longer needed. That is why a 0.5B model became a 360M one.

The file size fell from 990MB to 716MB. Applying int4 quantization (storing the model's numbers at 4-bit precision to make it lighter) brought it down to 208MB. That's small enough to load in a browser, and a demo that runs on WebGPU (which lets a browser use the GPU) has been published.

By the numbers, it acts much more like a terminal than ordinary small models do

So how well does it act like a terminal? The developer tested it on a benchmark called ShellBench, and it got 80 of 106 questions right. For comparison, models of similar size were asked to play a terminal using only prompts. Qwen2.5-Coder-0.5B scored 52/106 and Qwen3-0.6B scored 60/106. WorldTUI started from that same Qwen2.5-Coder-0.5B, and its score went from 52 to 80, so training it specifically on terminals clearly paid off.

The number I paid more attention to was file read-back. The test writes something to a file, then displays the file to see whether the same contents come back. WorldTUI matched exactly on 9 of 13 questions. The comparison models got 2–3 of 13. The file doesn't exist, so the model has to remember what was written from the earlier screens and reproduce it. Given that, 9/13 is a strong result. Put the other way, though, it shows the wrong contents 4 times out of 13. The next section picks up from there.

The post also describes work on speed. Generating the whole screen one character at a time, from top-left to bottom-right, takes too long. So the developer added a way to generate lines in parallel. With that, large screen updates on an RTX 4090 dropped from 6.7 seconds to 0.87 seconds at p95 (95 out of 100 updates finish within that time). Running man test (which shows the manual page for the test command) went from 2.5 seconds to 0.9 seconds. In a browser on an M4 Mac, it takes about 60ms per character.

The post also notes that Firefox is about 20 times slower than Chrome, so the same demo can feel very different depending on the browser. Keep that in mind, because it comes up again in the next section.

"The folder I made isn't there": what users reported, and how the developer rates it

I wanted to write about this project because the developer is so candid about its weaknesses. In the blog post, Edwardsson admits that WorldTUI is "clearly a fairly weak world model." Specifically, its picture of the file system falls apart once you move into deeply nested directories (folders inside folders inside folders). Python produces "GPT-3-era hallucinations" once the code gets complex. And the post says it often gets combined commands wrong, such as appending to a file with echo >> file and then displaying it with cat.

Reports from people who tried it were also very specific. In the Hacker News thread, donperignon said that when they tried to create a folder called test1, they were told it already existed, though it didn't. Then they mistyped mkdir as mkdier, and test2 still seemed to be created. But test2 didn't show up when they ran ls. A mistyped command went through, and the thing it made wasn't kept. To me, this is a clear example of what goes wrong in a system that doesn't keep track of state (which files currently exist).

gitowiec wrote that in Firefox, every keypress happens "in slow motion." That's because WorldTUI doesn't wait for Enter. With every character typed, it decodes (predicts and draws) the parts of the screen that changed, and the developer confirmed that this is how it is meant to work. Add the earlier note that Firefox is about 20 times slower than Chrome, and it's easy to see why Firefox users came away disappointed.

So the 80/106 on ShellBench and the 9/13 on file read-back show that WorldTUI is fairly accurate one exchange at a time. They don't show that its world holds together over dozens of steps. When reading benchmark numbers like these, it's worth asking separately how long the model can keep things consistent.

The real thing already exists, so what is this for? Where HN disagreed

The thread reached the top of HN and gathered 503 points and 156 comments. It got plenty of attention, and some harsh responses too. rvz wrote that they "don't see the point at all." They pointed to Windows 8's unsuccessful interface and argued that a UI needs to be consistent. htoz1 commented, "What's the point when a real terminal exists?" metchio noted that the state of a real file system never changes, so it can't be called a "real terminal." All of these are fair points. If you treat WorldTUI as a terminal for real work, these complaints apply in full.

The comments also offered some interesting uses. One was zero-latency SSH. SSH lets you control a remote server from your own machine. Before the server's reply arrives, a small model could show its guess of what the screen will look like. When the real reply comes in, it simply overwrites the guess, so being slightly off doesn't matter. Another was a honeypot, a decoy server that lures attackers in so their methods can be observed. Here, the fact that nothing is real becomes an advantage. I can also see demand for this kind of convincing fake as a target for "agentic cyberattacks," where autonomous AI does the attacking.

One comparison I found interesting came from the creator of vibeSH. vibeSH gives a large frontier model (the most advanced large models from each company) a long prompt and has it play a terminal in the same way. Its creator compared the two approaches on response speed, consistency and context length (how much the AI can keep in mind at once), and said each has strengths and weaknesses. Large models are smart but slow. A small dedicated model like WorldTUI is light and runs in a browser, but it forgets quickly.

To sum up, I think WorldTUI is not a replacement for a terminal. It is an experiment measuring how far an AI that predicts the screen itself can get with one GPU, about 75 hours of training and 208MB. You only see where things really stand when you look at both the 80/106 score and the reports of disappearing folders. The developer wrote down the weaknesses, and the people who tried it confirmed them. I thought that made this a refreshingly honest release.