simedw

Thank for posting it, happy to answer any questions!

show comments
nico

Very very cool! Impressed that it can be done with only fine tuning

On a very similar theme, I recently built a “lossy git”, which stores your code by training a neural network, then it generates the code back to you on checkout

* web demo: https://nicobrenner.github.io/lossy-git/demo.html

* cli version: https://nicobrenner.github.io/lossy-git/

The web demo runs entirely on the browser, both the version control and the neural network training/inference. You can commit and checkout both images or code - you can also paste/“upload” your own images, no server requests (everything clears from the page on reload)

show comments
gavinray

This is a micro-implementation of what research calls a "Neural Computer", in which the entire UI itself is generative and driven by user actions.

Neural Computers provide the illusion you are interacting with an underlying operating system/application, but are actually a recurring (user input) -> (predicted pixel output) loop.

In theory, it would be impossible to tell a perfect "Neural" computer apart from a "real" one. Which is kind of a wild thought.

https://arxiv.org/abs/2604.06425

show comments
andai

>I used Qwen2.5-Coder-0.5B as the starting point. I needed a small model to get close to realtime performance. Being a coding model, it had also already seen plenty of CLI usage.

Interesting. I wanted to ask, how that model compares with the fine-tuned version, but I just saw the author provided benchmarks. Interesting that fine-tuning improved the memory so significantly, wouldn't have expected that.

Though, on second thought, I had an experience where I was able to, as a human, fine-tune my memory beyond what I previously thought was possible!

Reminds me of one of my favorite jokes.

Excuse me, can you tell me how to get to Carnegie Hall?

—Practice, man... Practice...

show comments
ponyous

One of the first very cool demos I've seen of ChatGPT was in a post where the author prompted AI "pretend to be a terminal". Then went on to execute commands like `cd .fbi`, `ls files`, `cat files/confidential.txt`. Very fun demo. Looking forward to exploring similar idea with this terminal

show comments
atzmzt

so.. it's like dreaming you're in front of the computer terminal

saagarjha

> Is it useful? Not really.

So interestingly enough Anthropic has been using models of this kind for their alignment evaluations: https://alignment.anthropic.com/2026/reward-seeker/#:~:text=...

show comments
dpflan

This reminds me of this post from ~3 years ago: https://news.ycombinator.com/item?id=33847479

"Building A Virtual Machine inside ChatGPT"

- https://www.engraved.blog/building-a-virtual-machine-inside/

It's mentioned in the "Related Work" section too.

mattstir

This is such a fun project! It seems that the model is a bit confused about $_, which I find pretty interesting:

  simedw@laptop:~$ pwd
  /home/simedw
  simedw@laptop:~$ mkdir -p foo/bar/baz
  simedw@laptop:~$ cd $_  
  cd foo  
  simedw@laptop:~/foo$ cd baz
  simedw@laptop:~/foo/bar$ pwd  
  /home/simedw/foo/bar
  simedw@laptop:~/foo/bar$ cd baz 
  simedw@laptop:~/foo/bar/baz$
n0on3

Cool project! For bonus points, you could run this as an honeypot :D

OtherShrezzing

I think this project is a very good way to explore the question:

>What's the difference between a model that predicts intelligent output, and intelligence itself?

It doesn't directly attack the question, but gives a neatly constrained thought experiment which you can see running.

show comments
rowbin

I've built something very similar but with off the shelf models: https://github.com/beleon/vibeSH

EDIT (comparison)

Very impressive, and a lot more work than it looks from the outside (the DAgger loop especially). I built something similar in June, vibeSH, a shell that hallucinates the whole computer, but from the other direction: no training, just a frontier model and a long prompt, so maybe the comparison is useful.

The granularity is different though. You model keypresses and predict which rows change, I batch keystrokes and have the model repaint the whole screen each round trip. Non interactive cli programs work very good, but interactive cli programs like vim, less and top do work, but it feels like SSH over a 1996 modem, you type a burst, wait, and the screen catches up. Yours is going to be a lot more responsive at that.

The big model buys consistency, for as long as the session fits in the context window. Files come back the way you wrote them, python output is usually right instead of guessed, nested paths stay where they are. The price is an API call per round trip and a cost that grows with the session (and it's not 208 MB and doesnt run offline).

Mine offers an @ai prefix that talks to the director instead of the machine, so mid-session you can say "@ai make this a haunted Solaris machine from 1996" and the filesystem, the motd and the error messages all change to match, and the directives stick.

Your hardest problem and mine are the same one I think. For you it's a 360M model losing track of state, for me it's the context window filling up, after which the box gets amnesia and old files have quietly rewritten themselves. I decided early not to fight that completely and made it canon (the box has bad memory), your DAgger setup is an actual fix for it, which I don't have.

show comments
dwoosley

This could be useful for honeypots (cybersecurity) although it also might have its own attack vector if the honeypot isn’t setup carefully. Sure, you can already virtualize some shells but I’m sure those have limits that this might not have.

Cool project, thanks for sharing!

__mp

It would be interesting to expose this on the internet. I wonder what the scrapers etc… would do with it.

oilkillsbirds

Very cool. Fun project. I feel like there’s a wide field to be explored once you understand fine tuning good existing models

amelius

The next step is training a model to pretend to be the internet.

(You could run lynx in that terminal to train/test it without images)

show comments
obilgic

There was a whole fake gui OS with similar concept right

show comments
h1fra

I guess, with enough latency and/or memory, everything can be a filesystem

show comments
crizantlai

It's a very interesting project.

ChanderG

I was searching the blog but couldn't find details on the fine-tuning process. What was the hardware and software used? Any learnings there?

amelius

> I had a blast building this. Is it useful? Not really.

Maybe instead of simulating a terminal you could use it to predict what you'd type next?

So simulate _you_, not the terminal.

suhdonghwi

It's very tricky to make it hallucinate fake commands. I've been trying `dogsay` (instead of `cowsay`) but no luck. Any tips?

show comments
ernestrc

This is super cool! If you publish the weights I would love to bake it into Rune to run a screensaver hallucinating a terminal.

sandGorgon

this is quite similar to amazon-science Cyber-Zero ?

https://github.com/amazon-science/Cyber-Zero

the paper is quite interesting - https://arxiv.org/html/2508.00910v2

LoganDark

    Last login: Tue Oct 13 09:12:44 2026 from 10.0.4.17
    root@prod-web-01:~# cat /etc/nginx/nginx.conf
    cactus=true
    carpet=false
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
    cactus=true
Accurate
psandor

Reminds me of this project from Microsoft. A Quake II “simulation” model where the whole application was just a model.

https://www.microsoft.com/en-us/research/articles/whamm-real...

show comments
robpruzan

It would be cool to see the results of training on programs that emit kitty graphics commands!

wy1981

Questions for folks familiar with fine-tuning: what are the best resources to learn fine tuning?

Lerc

I wonder how much a small model could do if it had a tool calling API for a filesystem, an embedded busybox, and a single output token for 'emit what busybox would do here'. Then presumably the model parameters could learn everything that diverges from what busybox can handle.

show comments
thinkski

This would be great for a honeypot, where can observe attackers, use keystrokes for training data to identify attacks.

show comments
ohadpr

Very cool to do this as a Terminal!

I did it for web apps last year, basically a web server that feeds all requests into an LLM.

https://www.ohad.com/blog/voidware/

6thbit

The 'grid' thinking used here is quite interesting.

I'd love to see a video of this playing game of life.

IncRnd

LS, ls, els, ELS, lsl, and so forth each seem to perform an ls. Once I do Xls, none of the others work anymore.

air7

I remember doing something like this in the ancient era of GPT 3 or 4. I just told it that it was a terminal responding to commands and it was surprisingly consistent.

yjftsjthsd-h

Wait, how did it `sleep 3`? I thought LLMs didn't have a concept of time

show comments
thorum

I regretfully suspect this actually is the future of UI. You just need smart local models running fast enough to keep the framerate high, but that’s inevitable in the long term, isn’t it?

show comments
syngrog66

why?

Meleagris

This is more useful than you’d think. Consider using something like this to drive a high-interaction honeypot.

show comments
prodigycorp

Wow! This this reminds me of when we tried doing this with gpt 3 and.. it worked!

The tmux thing had me confused for a moment until i realized it was emulating tmux. Super fun. Is the model window width aware?

show comments
aurareturn

Holy cow that’s amazing. I’d bet future apps will be built this way.

show comments
4ggr0

wonder if the PHP on this hallucinated terminal is patched already.

show comments
donperignon

I tried it and is not working remotely as close as the demo gif. It keeps telling me that "test1" folder that I want to create already exists (not true), then letting me do "mkdier test2" (sic) but then the folder is not there when ls. I mean all its expected, this has no state, follow no rules and is making up things from the current context, but is not as "magical" as I thought when watching the demo.

_bobm

I fry my brain everyday trying to keep pace, but honestly, stop it guys. Give the guy a break.

This is the most magical time in my adult life. The 70s, 80s, and 90s, look like a painting compared to the current pace of things. I am literally tired at the end of each day. Dog tired.

Great job OP. I mean. This is nuts.

qubex

Finally they’ll stop scrolling HTML or Java sample code on screen.

Muhammad523

Why did it return -1 to 10 - 4

sudo_cowsay

Verry Verrry Cool and neat!

mastax

So, uhh, what's your sudo password? Can't get this thing to install software...

gdevenyi

Perfect honeypot

sehw

How much money?

swe_dima

Now make an agent interact with it and make it lose its mind

htoz1

Where is the point of this project if i have terminal ?

show comments
teiferer

Haha nice!

I'm a noob in this, could you enlighten me: what role does the base model play which you started with?

show comments
gobdovan
gitowiec

BUG: Running in Firefox makes every keypress a slow motion show. It decodes every keypress instead of sending a command with Enter key

show comments