Em 1980, um engenheiro de 24 anos chamado Tim Paterson estava frustrado. A Seattle Computer Products, onde ele trabalhava, vendia placas com o novíssimo processador Intel 8086 — mas ninguém comprava. O motivo? Não existia sistema operacional para rodar nele. O CP/M-86, que deveria resolver isso, estava eternamente atrasado pela Digital Research.

Paterson decidiu resolver o problema ele mesmo. Em seis semanas, usando um cross-assembler que ele próprio tinha escrito para rodar num Z80, criou o QDOS — Quick and Dirty Operating System. O “rápido e sujo” do nome não era modéstia: era literal. Ele precisava de algo funcional, não bonito.

Esse código de aproximadamente 4.000 linhas em Assembly virou o 86-DOS, depois foi comprado pela Microsoft por míseros US$ 50 mil, renomeado para MS-DOS e… bom, o resto é a história de uma empresa que hoje vale mais de US$ 3 trilhões.

E agora, em 2026, a Microsoft liberou o código-fonte original como open source. O mais antigo já descoberto.

O que exatamente foi liberado

No dia 28 de abril de 2026 — aniversário de 45 anos do 86-DOS 1.00 — a Microsoft publicou no GitHub o repositório DOS-History/Paterson-Listings, licenciado sob MIT. O conteúdo é fascinante para qualquer pessoa que se interesse por história da computação:

O repositório está organizado em três diretórios:

• 1_transcription — transcrições brutas das impressões
• 2_printed_files — arquivos originais extraídos das listagens
• 3_source_code — código-fonte compilável (o que você quer olhar)

E aqui está o detalhe mais impressionante: nada disso estava em formato digital. O código existia apenas em papel.

Resgatando código de uma garagem (literalmente)

A história de como esse código chegou ao GitHub é quase tão interessante quanto o próprio código. Uma equipe liderada por Yufeng Gao e Rich Cini — parte do chamado “DOS Disassembly Group” — localizou os documentos originais com o próprio Tim Paterson. Eram rolos de papel contínuo de impressora matricial, guardados na garagem dele por mais de 40 anos.

As listagens tinham anotações manuscritas do Paterson — correções de bugs, notas de implementação, ideias rabiscadas nas margens. Funcionam como um “git log impresso”, mostrando a timeline de desenvolvimento, erros encontrados e correções aplicadas, tudo documentado à mão.

O problema é que papel de impressora dos anos 80 não envelhece bem. A equipe precisou:

1. Escanear dezenas de páginas de papel contínuo amarelado
2. Tentar OCR — que falhou miseravelmente com a qualidade das impressões
3. Transcrever manualmente boa parte do código Assembly, linha por linha
4. Verificar se o código transcrito compilava corretamente usando o assembler original da Seattle Computer Products

Os scans originais em PDF e PNG estão disponíveis no Archive.org para quem quiser conferir o estado dos documentos.

Por dentro do código: Assembly puro, sem frescura

O repositório é 100% Assembly. Não tem C, não tem abstrações, não tem camadas de compatibilidade. É código direto para o Intel 8086, escrito com as ferramentas mais primitivas possíveis.

Para compilar o 86-DOS a partir do código-fonte, você precisa do assembler ASM da Seattle Computer Products e do utilitário HEX2BIN — ferramentas da época. O projeto aceita pull requests, mas apenas para correções de transcrição e typos. Ninguém vai adicionar features ao DOS em 2026.

Olhando o código do kernel (86DOS.A86), algumas coisas chamam atenção:

; File system implementation
; FAT - File Allocation Table
; 12-bit entries for disk clusters
; Maximum disk size: 16MB (laughable today)

O sistema de arquivos FAT (File Allocation Table) implementado no 86-DOS é o ancestral direto do FAT12, FAT16 e FAT32 que dominaram pen drives e cartões de memória por décadas. A implementação original usava entradas de 12 bits, limitando o tamanho máximo de disco a — segura essa — 16 megabytes.

Hoje um único emoji em alta resolução pode ocupar mais espaço que isso.

O CHKDSK, que qualquer usuário de Windows conhece (ou pelo menos conhecia, antes do sfc /scannow dominar), está lá na sua forma original. Mesma lógica de verificação de integridade do sistema de arquivos, só que para disquetes de 160KB.

A jogada de US$ 50 mil que valeu trilhões

A história da aquisição do DOS pela Microsoft é um daqueles casos que professores de MBA usam para falar sobre timing e oportunismo — geralmente sem a nuance necessária.

Em 1980, a IBM estava desenvolvendo secretamente o PC e precisava de um sistema operacional. O plano original era licenciar o CP/M da Digital Research, mas a reunião entre IBM e Gary Kildall (criador do CP/M) é um dos maiores desastres de negociação da história da tecnologia. Dependendo de quem conta a história, Kildall estava voando seu avião particular, ou sua esposa recusou assinar o NDA da IBM, ou simplesmente não deu importância suficiente à reunião.

Bill Gates, que já tinha contrato com a IBM para fornecer o BASIC, viu a oportunidade. A Microsoft não tinha um sistema operacional, mas sabia quem tinha. O fluxo de acontecimentos:

A Microsoft pagou US$ 50.000 pelo código completo. A Seattle Computer Products posteriormente processou a Microsoft, argumentando que não sabia que o comprador final era a IBM. O caso foi resolvido por cerca de US$ 1 milhão. Ainda assim, um negócio absurdamente bom para a Microsoft.

Para colocar em perspectiva: US$ 50 mil em 1981, ajustados pela inflação, equivalem a aproximadamente US$ 170 mil em 2026. A Microsoft hoje vale mais de US$ 3 trilhões. O retorno sobre aquele investimento é tão grande que precisa de notação científica para ser expresso.

CP/M vs 86-DOS: a polêmica que nunca morreu

Uma das controvérsias mais duradouras da história da computação é se o 86-DOS (e consequentemente o MS-DOS) foi “copiado” do CP/M. A resposta curta: não. A resposta longa: é complicado.

Paterson projetou o 86-DOS para ser compatível com o CP/M em nível de API. Ele usou o manual publicado do CP/M como referência para as chamadas de sistema, de modo que programas escritos para CP/M pudessem ser portados facilmente. Isso é fundamentalmente diferente de copiar código.

Uma analogia moderna: se você criar uma API REST que aceita os mesmos endpoints e parâmetros que a API do Twitter/X, você não copiou o código do Twitter. Você criou uma implementação compatível.

CP/M System Calls     →  86-DOS System Calls
BDOS Function 1       →  INT 21h, AH=01h  (Console Input)
BDOS Function 2       →  INT 21h, AH=02h  (Console Output)
BDOS Function 9       →  INT 21h, AH=09h  (Print String)
BDOS Function 15      →  INT 21h, AH=0Fh  (Open File)

As chamadas de sistema do CP/M foram mapeadas para interrupções do 8086, mantendo a mesma numeração de funções. Inteligente? Sim. Cópia? Juridicamente, não. A Digital Research nunca venceu um processo contra a Microsoft por isso, embora tenha tentado.

O que Paterson inovou foi o sistema de arquivos. O CP/M usava uma tabela de alocação simples e limitada. Paterson criou a FAT (File Allocation Table), uma abordagem diferente para rastrear quais clusters de disco pertencem a quais arquivos. Esse design sobreviveu por décadas e ainda é o formato padrão de pen drives e cartões SD no mundo inteiro.

O que esse código nos ensina sobre desenvolvimento de software

Mergulhar no código do 86-DOS em 2026 é um exercício de humildade para qualquer desenvolvedor moderno.

Primeiro: a escala. O kernel inteiro do DOS cabia em aproximadamente 4.000 linhas de Assembly. Para referência, o kernel do Linux hoje tem mais de 30 milhões de linhas de código. O Node.js tem cerca de 2,5 milhões. Até um create-react-app gera mais linhas do que o sistema operacional que iniciou a revolução do PC.

Segundo: as ferramentas. Paterson escreveu o assembler que usou para escrever o DOS. Ele escreveu o debugger. Suas ferramentas de desenvolvimento cabiam em um EPROM de 2KB. Hoje, o VS Code precisa de mais de 500MB instalado — e isso sem extensões. Eu já vi node_modules maiores que o DOS inteiro.

Terceiro: a velocidade. Seis semanas do conceito ao sistema operacional funcional. Claro, o escopo era incomparavelmente menor. Mas a proporção entre o que foi entregue e o tempo gasto é impressionante. Sem sprints, sem standups, sem Jira, sem code review, sem CI/CD. Um cara, um assembler e um deadline.

Não estou romantizando a era — debug em papel com impressora matricial é uma tortura que ninguém deveria passar. Mas existe algo para aprender sobre foco e simplicidade.

Preservação digital: o problema que ninguém quer resolver

Um aspecto subestimado dessa liberação é o esforço de preservação. O código do 86-DOS quase se perdeu para sempre. Se Tim Paterson tivesse jogado aquelas listagens fora durante uma mudança — e convenhamos, quantos de nós guardaríamos papel de impressora por 40 anos? — esse pedaço da história da computação teria desaparecido.

O projeto faz parte de um esforço maior de preservação da história do DOS. A Microsoft já tinha liberado o MS-DOS 1.25 e 2.11 em 2014 (re-publicados em 2018 no GitHub), e o MS-DOS 4.0 em 2024. Mas essas eram versões posteriores, já sob o nome Microsoft. O código liberado agora é anterior a tudo isso — é o DNA original.

Isso levanta uma questão incômoda: quantos outros artefatos históricos de software estão apodrecendo em garagens, porões e depósitos ao redor do mundo? Código que definiu indústrias, que rodou em milhões de máquinas, que simplesmente… sumiu porque ninguém achou importante preservar.

O trabalho da equipe de Gao e Cini mostra que a preservação é possível, mas trabalhosa. Escanear, transcrever manualmente, verificar, compilar, documentar. Não é glamuroso, não gera likes no LinkedIn, mas é fundamental.

Como explorar o código você mesmo

Se bateu a curiosidade (e deveria), aqui está como dar uma olhada:

# Clone o repositório
git clone https://github.com/DOS-History/Paterson-Listings.git
cd Paterson-Listings

# O código compilável está em 3_source_code
ls 3_source_code/

# Para ler o kernel do 86-DOS
cat 3_source_code/86DOS.A86 | less

# As transcrições brutas estão em 1_transcription
ls 1_transcription/

Alguns bundles ainda não foram transcritos — especificamente os bundles 09 e 10, que contêm LIBLST.LOG, BASLIB.PRT, PAINT.ASM e CIRCLE.ASM (sim, tinha um programa para desenhar círculos). O projeto aceita contribuições para transcrição, caso você queira fazer parte da história.

Para quem quer ir mais fundo, os PDFs originais escaneados estão no Archive.org. Ver as anotações manuscritas do Paterson nas margens é quase uma experiência arqueológica — você está lendo os pensamentos de um programador de 1981 enquanto ele debugava o sistema operacional que mudaria o mundo.

A comunidade já está reagindo

No Hacker News, a discussão sobre o release acumulou centenas de pontos e comentários. Alguns destaques interessantes da comunidade:

Vários desenvolvedores compararam o esforço de transcrição com outros projetos de preservação de código histórico. O código-fonte do Apollo Guidance Computer (o computador que levou o homem à Lua) passou por um processo similar — mas tinha a vantagem de checksums binários que facilitavam a verificação de erros na digitalização. O código do DOS não tinha essa facilidade.

Outros apontaram a ironia: a Microsoft liberou o código mais antigo do DOS, mas ainda mantém sob sigilo versões muito mais recentes e relevantes, como o Windows XP. A resposta provável é que código de 45 anos não tem valor comercial — é pura preservação histórica. Código de 25 anos ainda pode ter implicações legais e de segurança.

O legado que ainda roda (de um jeito ou de outro)

Pode parecer que o DOS morreu há décadas, mas sua influência está por toda parte. O sistema de arquivos FAT, inventado por Paterson no 86-DOS, ainda é o formato padrão de pen drives, cartões SD e partições de boot EFI em praticamente todo computador moderno. Quando você formata um pen drive no Windows, a opção padrão ainda é FAT32 — um descendente direto do código que agora está no GitHub.

As chamadas de sistema INT 21h, que definiam a API do DOS, influenciaram gerações de programadores de sistemas. O conceito de interrupções de software como interface entre aplicações e o sistema operacional sobreviveu em diversas formas, incluindo as syscalls do Linux.

E o mais curioso: existem sistemas embarcados e máquinas industriais rodando variantes do DOS até hoje. ATMs, sistemas de controle de elevadores, equipamentos médicos — uma quantidade surpreendente de infraestrutura crítica ainda depende de código que descende diretamente daquelas 4.000 linhas de Assembly escritas por um programador frustrado em 1980.

Quarenta e cinco anos depois, o código que custou US$ 50 mil e gerou trilhões finalmente pertence a todos. Se Tim Paterson soubesse, na garagem da Seattle Computer Products, que suas listagens manchadas de café se tornariam um repositório no GitHub com mais de mil estrelas… bom, ele provavelmente teria cobrado mais.

Fonte de inspiração: Continuing the story of early DOS development — Microsoft Open Source Blog