NeuralOS: Towards Simulating Operating Systems via Neural Generative Models

O artigo apresenta o NeuralOS, um framework neural que simula interfaces gráficas de sistemas operacionais prevendo quadros de tela em resposta a interações de usuário, combinando uma rede neural recorrente para rastrear o estado do sistema com um renderizador difusivo, demonstrando capacidade de gerar interfaces realistas e até simular aplicações não instaladas a partir de dados sintéticos.

O essencial

Imagine que você está tentando ensinar um computador a "sonhar" com a tela do seu computador. Não é um computador real com um sistema operacional como Windows ou Linux rodando por trás, mas sim uma inteligência artificial que aprendeu a desenhar a tela do zero, frame a frame, apenas observando o que você faz com o mouse e o teclado.

Esse é o NeuralOS, um projeto apresentado na conferência ICLR 2026. Vamos descomplicar como isso funciona usando algumas analogias do dia a dia.

1. O Grande Truque: O "Sonhador" vs. O "Gerente"

A maioria dos computadores funciona como uma fábrica: você aperta um botão, e uma peça de código (o sistema operacional) executa uma tarefa específica. Se o código estiver errado, a tela trava.

O NeuralOS funciona de forma diferente. Ele é como um ator de teatro muito talentoso que nunca viu o roteiro, mas aprendeu a imitar perfeitamente a peça apenas assistindo a milhares de gravações.

O sistema é dividido em dois "cérebros" que trabalham juntos:

• O Gerente (RNN): É como um assistente de memória. Ele lembra do que aconteceu antes. "Ah, o usuário clicou no ícone do Firefox há 20 segundos, então agora a janela deve estar abrindo." Ele não desenha nada, apenas mantém o "estado" do computador na cabeça.
• O Artista (Renderer de Difusão): É o pintor. Ele pega as instruções do Gerente e, usando uma técnica chamada "difusão" (a mesma usada para criar imagens do nada), pinta a próxima tela. Ele não sabe o que é um arquivo ou um programa; ele apenas sabe que, quando o Gerente diz "janela aberta", ele deve pintar pixels que parecem uma janela.

2. A Lição de Casa: Como eles ensinaram a IA?

Para treinar esse "ator", os pesquisadores precisaram de milhões de exemplos. Eles não contrataram apenas humanos para clicar no mouse (isso seria muito lento). Eles usaram dois métodos criativos:

1. Agentes de IA: Usaram outra IA (o Claude 3.5) para navegar no computador, abrindo pastas e programas, gerando gravações de "como um humano faria".
2. Exploração Aleatória: Para evitar que a IA aprendesse padrões estranhos (como "se o mouse vai para o botão de fechar, o programa fecha"), eles geraram movimentos de mouse aleatórios e caóticos para que a IA aprendesse a diferença entre um clique real e um movimento sem sentido.

3. O Desafio do "Ponto Vermelho" (O Cursor)

Um dos maiores problemas em fazer isso funcionar é o cursor do mouse. Em uma tela de computador, o cursor é apenas alguns pixels. Para uma IA que está tentando prever milhões de pixels, é como tentar achar uma agulha em um palheiro.

• O Problema: Se a IA errar a posição do cursor por 10 pixels, a tela parece estranha e o usuário não consegue clicar em nada.
• A Solução: Eles deram ao "Gerente" um mapa especial. Em vez de apenas dizer "o mouse está aqui", eles criaram um mapa de calor (uma mancha gaussiana) que mostra exatamente onde o mouse deve estar. Isso ajudou o "Artista" a desenhar o pontinho vermelho no lugar certo com precisão milimétrica.

4. O Milagre do "Doom" (O App que Nunca Existiu)

A parte mais mágica do NeuralOS é o que eles chamam de aprendizado a partir de demonstrações sintéticas.
Imagine que você quer ensinar alguém a dirigir um carro, mas você nunca teve um carro. Você pega vídeos de pessoas dirigindo, edita o vídeo para parecer que o carro está lá, e ensina a pessoa a imitar os movimentos.

Os pesquisadores fizeram algo parecido com o jogo Doom:

• O computador onde a IA foi treinada NUNCA teve o jogo Doom instalado.
• Eles pegaram vídeos de alguém jogando Doom e, artificialmente, criaram uma "ícone" na área de trabalho e simularam o clique duplo para abrir.
• A IA aprendeu a sequência: Clique no ícone -> A tela muda -> O jogo aparece -> O usuário atira.
• Resultado: Quando você pede para o NeuralOS abrir o Doom, ele desenha o jogo Doom na tela, mesmo que o jogo não exista no sistema. Ele "sonhou" o jogo baseado no que aprendeu.

5. Por que isso é importante?

Hoje, se você quer criar um novo sistema operacional ou um aplicativo, precisa programar milhares de linhas de código. Com o NeuralOS, a ideia é que, no futuro, você possa apenas demonstrar o que quer (mostrar um vídeo de como a interface deve funcionar) e a IA aprende a criar o sistema inteiro sozinha.

Além disso, isso cria um ambiente de teste seguro. Você pode treinar robôs (agentes de IA) para usar computadores dentro desse "sonho" do NeuralOS. Se o robô errar e apagar todos os arquivos, não tem problema, porque nada real foi apagado. É um simulador de voo, mas para computadores.

Resumo em uma frase

O NeuralOS é um "ator de IA" que aprendeu a desenhar a tela do seu computador frame a frame, lembrando-se do que você fez antes, e que consegue até simular jogos e programas que nunca foram instalados no computador real, apenas porque "viu" alguém fazendo isso em vídeos de treinamento.

É um passo gigante em direção a um futuro onde a interface do computador não é feita de código rígido, mas sim de inteligência generativa que se adapta a você em tempo real.

Resumo técnico

Título: NeuralOS: Rumo à Simulação de Sistemas Operacionais via Modelos Generativos Neurais

1. Problema e Motivação

As interfaces homem-máquina tradicionais (GUIs) são rigidamente programadas, dependendo de kernels e aplicativos pré-definidos. Embora modelos de linguagem (LLMs) tenham revolucionado a interação via texto, a interface gráfica ainda é estática. O objetivo deste trabalho é investigar se é possível modelar uma interface de sistema operacional (SO) inteiramente através de um modelo generativo neural, em vez de um sistema programado manualmente.

Os principais desafios identificados são:

• Rastreamento de Estado de Longo Prazo: Respostas de interface podem ser atrasadas (ex: abrir um navegador pode levar 30 quadros), exigindo que o modelo lembre de ações passadas distantes.
• Controle Preciso do Cursor: Diferente de jogos onde ações são discretas, o cursor em um SO representa um espaço de ação contínuo e de alta resolução; erros de posicionamento tornam a interação impossível.
• Transições Abruptas: Ao contrário da geração de vídeo tradicional (que lida com transições suaves), um SO sofre mudanças bruscas e imprevisíveis baseadas em entradas do usuário.

2. Metodologia

O NeuralOS é um framework que simula a interface gráfica de um SO (baseado em Ubuntu XFCE) prevendo diretamente os quadros da tela em resposta a eventos de entrada (movimento do mouse, cliques, teclado). A arquitetura é modular, inspirada na separação entre kernel e renderização gráfica:

Arquitetura do Modelo

1. RNN Hierárquica (Rastreamento de Estado):
   • Utiliza uma arquitetura de dois níveis de LSTM (Long Short-Term Memory) para manter o estado interno do sistema (aplicativos abertos, janelas ocultas, histórico de ações).
   • Diferente de Transformers, a RNN mantém complexidade computacional constante por passo de tempo, essencial para simulações de longo horizonte.
   • Incorpora atenção para integrar informações visuais do quadro anterior com as entradas do usuário.
2. Renderizador Baseado em Difusão:
   • Utiliza um modelo de difusão latente (UNet) para gerar os quadros gráficos.
   • O modelo opera em um espaço latente comprimido (redução de 8x na resolução espacial) para eficiência.
   • Codificação Espacial do Cursor: Para resolver o problema da precisão do cursor, o modelo não usa apenas coordenadas discretas. Ele gera um mapa espacial Gaussiano que representa a posição do cursor, concatenado ao contexto do renderizador. Isso permite uma localização de cursor extremamente precisa.

Estratégia de Treinamento Multi-Estágio

Devido à dificuldade de treinar o RNN e o renderizador juntos desde o início, o treinamento segue quatro estágios:

1. Pré-treinamento da RNN: A RNN é treinada para prever quadros latentes usando perda MSE. Isso garante que a RNN aprenda a codificar o estado e não seja ignorada pelo renderizador.
2. Treinamento Conjunto: A RNN pré-treinada e o renderizador de difusão são otimizados juntos.
3. Amostragem Agendada (Scheduled Sampling): Para mitigar o viés de exposição (onde o modelo falha ao usar suas próprias previsões em vez de dados reais), durante o treinamento, quadros de entrada são ocasionalmente substituídos por quadros gerados pelo próprio modelo.
4. Extensão do Contexto: O tamanho da janela de contexto é aumentado (de 32 para 64 quadros) para capturar dependências de longo prazo.

Coleta de Dados

• Agentes de IA: Utilizou-se o agente "Computer Use" do Claude-3.5-Sonnet para navegar no SO, identificando elementos GUI e executando ações em uma árvore de busca de estados.
• Exploração Aleatória: Dados aleatórios foram adicionados para evitar correlações espúrias (ex: o modelo associar movimento do mouse a fechamento de janela sem clique).
• Demonstrações Sintéticas (Doom): Para provar que o modelo pode aprender interfaces que não existem no sistema real, criaram-se dados sintéticos simulando o jogo Doom (com ícone na área de trabalho e gameplay do VizDoom), mesmo que o jogo nunca tenha sido instalado no ambiente de treinamento.

3. Contribuições Chave

• Primeira Simulação Neural de SO: Introdução do NeuralOS, um sistema que gera sequências de GUI realistas puramente a partir de entradas de usuário, sem kernels ou aplicativos reais.
• Arquitetura Híbrida RNN-Difusão: Combinação eficaz de memória de longo prazo (RNN) com geração de alta fidelidade visual (Difusão), resolvendo o problema de rastreamento de estado em interfaces complexas.
• Codificação Espacial do Cursor: Uma inovação técnica que permite a renderização precisa do cursor, superando limitações de modelos anteriores que falhavam em localizar o ponteiro corretamente.
• Aprendizado de Interfaces Sintéticas: Demonstração de que o modelo pode aprender a interagir com aplicativos "fictícios" (como o Doom) apenas através de demonstrações sintéticas, sugerindo um novo paradigma para criação de UIs.

4. Resultados Experimentais

• Precisão do Cursor: O NeuralOS alcançou um erro médio de posição de 1.6 pixels (x) e 1.4 pixels (y) em resoluções de 512x384, superando drasticamente baselines sem o mapa espacial (erros >90 pixels).
• Transições de Estado: O modelo capturou transições críticas (abrir/fechar pastas, lançar aplicativos) com 37.7% de precisão na correspondência de clusters de transição, superando significativamente a votação majoritária (1.4%).
• Avaliação Humana: Em um teste de Turing visual, os participantes tiveram dificuldade em distinguir entre o SO real e o NeuralOS em sequências de até 20 segundos, com taxas de acerto próximas ao acaso (50-60%).
• Memória de Longo Prazo: O modelo conseguiu lembrar se uma pasta havia sido criada mesmo após um atraso de 256 quadros (muito além da janela de contexto de treinamento de 64 quadros), demonstrando generalização de estado persistente.
• Simulação de Doom: O modelo aprendeu a lançar, jogar e fechar o jogo Doom baseado apenas em dados sintéticos, mesmo sem o aplicativo estar instalado no sistema subjacente.

5. Significado e Impacto

O NeuralOS representa um passo fundamental rumo a Sistemas Operacionais Generativos.

• Segurança para Agentes: Oferece um ambiente seguro para treinar e avaliar agentes de IA que usam computadores, sem risco de executar comandos reais no sistema.
• Personalização de UI: Abre caminho para interfaces que se adaptam dinamicamente em tempo real às intenções do usuário, possivelmente substituindo menus fixos por interações naturais.
• Viabilidade de Dados Sintéticos: Demonstra que demonstrações sintéticas, mesmo que fabricadas, podem ser "destiladas" em modelos generativos para criar interfaces funcionais, reduzindo a dependência de dados do mundo real para cada nova aplicação.

Limitações Atuais

• Recursos Computacionais: O treinamento e inferência exigem GPUs de alto desempenho (H100/H200).
• Resolução e Teclado: A resolução é baixa (512x384) e a modelagem de entradas de teclado de alta granularidade (digitação de texto específico) ainda é um desafio.
• Ambiente: Atualmente limitado a Ubuntu XFCE; a extensão para outros SOs (Windows, macOS) é um trabalho futuro.

Em resumo, o NeuralOS prova que é possível aprender a dinâmica complexa de um sistema operacional e suas interfaces gráficas puramente através de dados de interação, sugerindo um futuro onde o "sistema operacional" é um modelo generativo adaptativo.