NeuralOS: Towards Simulating Operating Systems via Neural Generative Models

Dit paper introduceert NeuralOS, een neuraal raamwerk dat besturingssystemen simuleert door realistische schermbeelden en toestandsovergangen direct te voorspellen op basis van gebruikersinvoer, waarbij synthetische trainingsdata het mogelijk maakt om zelfs niet-geïnstalleerde applicaties te modelleren.

De kern

NeuralOS: De dromerige computer die je besturingssysteem nadoen

Stel je voor dat je een computer hebt die niet werkt met harde code, harde regels en programmeerders die duizenden regels schrijven. In plaats daarvan heeft deze computer een dromerige hersenstam. Hij heeft nooit echt een besturingssysteem (zoals Windows of Linux) geïnstalleerd, maar hij weet precies hoe het eruit moet zien en hoe het moet werken, puur omdat hij miljoenen video's heeft gekeken van mensen die ermee werken.

Dat is NeuralOS. Het is een nieuw experiment van onderzoekers die proberen een computerbesturingssysteem te bouwen dat volledig door een kunstmatige intelligentie (AI) wordt "gedroomd" in plaats van door software.

Hier is hoe het werkt, vertaald naar alledaagse taal:

1. De Twee Delen van de Hersenen

NeuralOS werkt met twee verschillende delen die samenwerken, net als een regisseur en een acteur in een toneelstuk:

• De Regisseur (De RNN): Dit is het geheugen van de AI. Hij onthoudt wat er gebeurt. "Ik heb net op de 'Start'-knop gedrukt," denkt hij. "Dus nu moet er een menu openen." Hij houdt de staat van de computer bij, zoals welke vensters open zijn en waar de muis staat.
• De Schilder (De Diffusion Renderer): Dit is de kunstenaar. Hij kijkt naar wat de Regisseur zegt en schildert het volgende plaatje op het scherm. Hij doet dit niet één voor één, maar door een wazig beeld langzaam te verfijnen tot een scherp scherm, net zoals een schilder die van een grijze vlek een landschap maakt.

2. Het Leerproces: Kijken en Nabootsen

Normaal gesproken leer je een computer om een programma te maken door hem de instructies te geven: "Als je op deze knop klikt, doe dan X."
Bij NeuralOS is het anders. Ze hebben de AI niet verteld hoe een computer werkt. Ze hebben hem gewoon duizenden video's laten kijken van mensen die op een Ubuntu-computer (een soort Linux) werken.

De AI keek naar:

• De muis die beweegt.
• Het klikken op een mapje.
• Het openen van een browser.
• Het typen op het toetsenbord.

De AI leerde de patronen: "Ah, als de muis naar die hoek gaat en er wordt geklikt, moet er een nieuw venster verschijnen." Hij leerde het niet door regels te volgen, maar door het patroon te herkennen, net zoals een kind dat leert hoe een auto werkt door erin te zitten en te kijken, zonder de motor te begrijpen.

3. De Magische "Doom"-Truc

Het meest gekke en fascinerende deel van dit onderzoek is wat ze deden met het spel Doom.

Stel je voor dat je een computer hebt waarop het spel Doom nooit is geïnstalleerd. Er is geen enkele regel code voor Doom op die machine. Maar de onderzoekers gaven de AI een reeks gefabriceerde video's: beelden van een bureaublad, een icoontje dat leek op Doom, en daarna beelden van iemand die Doom speelt.

De AI leerde dit patroon. Toen ze later in NeuralOS op dat icoontje klikten, verscheen er plotseling een werkend spel van Doom.

• Het spel was niet echt geïnstalleerd.
• De AI "bedacht" het spel frame voor frame terwijl je het speelde.
• Het was alsof de AI droomde dat het spel bestond, en dat droombeeld zo realistisch was dat het voelde alsof het echt was.

Dit toont aan dat NeuralOS niet alleen bestaande software nabootst, maar dat hij nieuwe interfaces kan leren die zelfs niet bestaan, zolang hij maar voorbeelden ziet.

4. Waarom is dit belangrijk?

Vandaag de dag is een computer een starre machine. Als je een knop drukt, gebeurt er precies wat er in de code staat. Als je een fout maakt, crasht het programma.

Met NeuralOS kunnen we in de toekomst een computer hebben die:

• Aanpast aan jou: Hij kan je bureaublad veranderen in iets dat jij leuk vindt, puur op basis van wat je zegt.
• Veilig is voor testen: Je kunt een AI-agent laten oefenen om een computer te gebruiken zonder dat hij per ongeluk je echte bestanden verwijdert of je systeem kapot maakt. Hij oefent in een "droomwereld" die er echt uitziet.
• Natuurlijker is: Misschien hoeven we in de toekomst niet meer te klikken op menu's, maar kunnen we gewoon tegen de computer zeggen wat we willen, en hij "droomt" het scherm voor je.

De Korte Samenvatting

NeuralOS is als een virtuele acteur die zo goed is in het spelen van de rol van een computerbesturingssysteem, dat hij zelfs scènes kan spelen die nooit zijn opgenomen. Hij heeft geen echte software nodig; hij heeft alleen een levendige verbeelding nodig, gevoed door duizenden voorbeelden, om een volledig werkende computerwereld te creëren, pixel voor pixel.

Het is een eerste stap naar een toekomst waar computers niet langer statische machines zijn, maar levende, creatieve partners die meedenken en meedromen.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het paper "NeuralOS: Towards Simulating Operating Systems via Neural Generative Models", geschreven in het Nederlands.

Titel: NeuralOS: Naar het simuleren van besturingssystemen via neurale generatieve modellen

Auteurs: Luke Rivard, Sun Sun, Hongyu Guo, Wenhu Chen, Yuntian Deng (Universiteit van Waterloo & National Research Council Canada)
Publicatie: ICLR 2026

---

1. Het Probleem

Traditionele mens-computerinteractie (HCI) is gebaseerd op rigide, vooraf geprogrammeerde besturingssystemen (OS) met commando-regels of statische grafische interfaces (GUI's). Hoewel grote taalmodellen (LLM's) de interactie hebben verbeterd, blijft de visuele interface beperkt tot vooraf gedefinieerde elementen.

De kernuitdaging die dit paper adresseert is: Kan een besturingssysteeminterface volledig worden gemodelleerd door een neurale generatieve model, in plaats van door handmatig geprogrammeerde kernels en applicaties?
Specifieke technische uitdagingen zijn:

• Precieze cursorcontrole: Het nauwkeurig voorspellen van muiskoordinaten in een grote discrete actie-ruimte.
• Lange-termijn state-tracking: Besturingssystemen vertonen vaak vertraagde reacties (bijv. het openen van Firefox duurt 30 frames), waarbij de staat van het systeem (open vensters, verborgen apps) niet direct zichtbaar is in de huidige frame.
• Interactiviteit: Het model moet direct reageren op onvoorspelbare gebruikersinput (muis, toetsenbord) met abrupte veranderingen in de interface, in tegenstelling tot de vloeiende overgangen in traditionele videogenereerders.

2. Methodologie

NeuralOS is een end-to-end getraind framework dat een OS-interface simuleert door direct grafische frames te voorspellen op basis van gebruikersinput. De architectuur combineert twee componenten, analoge aan de scheiding tussen OS-kernel en rendering:

A. Architectuur

1. Hiërarchische RNN voor State Tracking:

   • In plaats van een Transformer (die memory-intensief wordt bij lange sequenties), gebruikt NeuralOS een Recurrent Neural Network (RNN) met twee LSTM-lagen.
   • Onderste LSTM: Codeert gebruikersinput (cursorcoördinaten, muisklikken, toetsaanslagen) en integreert visuele informatie uit het vorige frame via multi-headed attention.
   • Bovenste LSTM: Verwerkt de output van de onderste laag en behoudt de lange-termijn context.
   • Feedback-loop: De output van de bovenste LSTM wordt teruggevoerd naar de onderste, zodat de laag bewust blijft van de hogere context.
   • Dit zorgt voor constante computatiecomplexiteit per tijdstap, essentieel voor realtime simulatie.

2. Diffusion-based Renderer:

   • Een UNet gebaseerd op Latent Diffusion Models (LDM) genereert de daadwerkelijke schermbeelden.
   • Het model werkt in een latente ruimte (gecompressieerd door een autoencoder van 512x384 naar 64x48 met 16 kanalen) om rekenefficiëntie te verhogen.
   • De renderer ontvangt als conditionering de output van de RNN (state) en een expliciete Gaussische ruimtelijke kaart voor de cursorpositie. Deze kaart is cruciaal om fouten in cursorlocatie (vaak honderden pixels) te voorkomen.

B. Trainingsstrategie (Multi-Stage Pipeline)

Vanwege de complexiteit van het trainen van RNN en Diffusion samen, wordt een vierfasige aanpak gebruikt:

1. RNN Pretraining: De RNN wordt eerst getraind om latente frames te voorspellen via MSE-loss. Dit voorkomt dat de renderer de RNN-output negeert (een veelvoorkomend probleem bij directe joint training).
2. Joint Training: De voorgeprogrammeerde RNN en de diffusion-renderer worden samen geoptimaliseerd met een standaard diffusion loss.
3. Scheduled Sampling: Om "exposure bias" (fouten ophopen tijdens inferentie) te mitigeren, wordt tijdens het trainen met een kleine waarschijnlijkheid een gegenereerd frame gebruikt in plaats van het ground-truth frame als input voor de volgende stap.
4. Context Length Extension: Het trainingsvenster wordt uitgebreid (van 32 naar 64 frames) om langere afhankelijkheden te leren.

Daarnaast wordt een curriculum learning strategie toegepast waarbij het model eerst traint op "uitdagende transities" (frames met grote pixelverschillen, zoals het openen van apps) voordat het op de volledige dataset wordt getraind.

3. Belangrijkste Bijdragen

• Eerste Neurale OS: NeuralOS is een van de eerste systemen dat een volledige OS-interface (Ubuntu XFCE) simuleert puur via generatieve modellen, zonder traditionele kernel-code.
• Synthetische Demonstraties voor Nieuwe Apps: Het paper toont aan dat het model applicaties kan leren die nooit zijn geïnstalleerd in het onderliggende systeem. Als bewijs van concept werd een Doom-applicatie gesimuleerd door synthetische trainingdata te combineren met VizDoom-opnames. Het model leerde Doom te starten, te spelen en te sluiten, puur op basis van demonstraties.
• Nieuwe Architectuur voor OS: De combinatie van een hiërarchische RNN (voor state) en een diffusion renderer (voor pixels) lost het probleem op van lange-termijn geheugen in interactieve omgevingen, waar Transformers vaak falen door memory-omvang.
• Openbare Demo: De auteurs hebben een interactieve webdemo, code en voorgeprogrammeerde modellen beschikbaar gesteld.

4. Resultaten

• Realistische GUI-sequentie: Het model genereert realistische schermbeelden met nauwkeurige cursorbewegingen en vensterinteracties.
• Cursornauwkeurigheid: Met de Gaussische spatial map bedraagt de gemiddelde fout in cursorpositie slechts 1.6 pixels (x) en 1.4 pixels (y) op een resolutie van 512x384. Zonder deze map was de fout >100 pixels.
• State Transities: NeuralOS behaalde 37.7% nauwkeurigheid bij het voorspellen van complexe state-overgangen (zoals het openen van een map), wat aanzienlijk beter is dan meerderheidsstemming (1.4%).
• Menselijke Evaluatie: Menselijke beoordelaars konden NeuralOS-video's slechts marginaal beter onderscheiden van echte Ubuntu-sessies dan willekeurig gokken (ongeveer 50-60% correctie), zelfs bij video's tot 60 seconden.
• Lange-termijn Geheugen: In een test waarbij een map werd aangemaakt en het venster later (na 256 frames) weer werd geopend, kon het model correct voorspellen of de map nog bestond, hoewel het tijdens het trainen slechts korte vertragingen (8 frames) had gezien.
• Vergelijking met DIAMOND: Een aangepaste versie van het DIAMOND-model (ontworpen voor games) faalde na abrupte state-wisselingen, terwijl NeuralOS stabiel bleef dankzij de recurrente state-tracking.

5. Betekenis en Toekomstperspectief

NeuralOS vertegenwoordigt een paradigmaverschuiving in mens-computerinteractie:

• Van Programmatie naar Learning: Interfaces hoeven niet langer handmatig te worden geprogrammeerd, maar kunnen worden "geleerd" uit demonstraties, zelfs synthetische of gefabriceerde demonstraties.
• Veilige Agent Training: Het biedt een veilige sandbox om AI-agenten te trainen om computers te gebruiken zonder echte systeemcommando's uit te voeren.
• Toekomstige Toepassingen: Het opent de weg voor interfaces die dynamisch aanpassen aan gebruikersintenties via natuurlijke taal of gebaren, en voor het simuleren van software die niet bestaat of niet beschikbaar is.

Beperkingen:
Het huidige model heeft een lage schermresolutie, ondersteunt geen fijnmazige toetsenbordinput (zoals het typen van specifieke tekens in een terminal) en vereist zware GPU-resources (H100) voor inferentie. Het is momenteel een onderzoeksprototype en geen productief systeem.

Samenvattend demonstreert NeuralOS dat neurale generatieve modellen in staat zijn om de complexe, state-afhankelijke dynamiek van een besturingssysteem te simuleren, wat een fundamentele stap is naar volledig generatieve en adaptieve gebruikersinterfaces.