Computador a Válvulas: Como o MK3 Com 460 Tubos Ensina Devs

Eu vejo muita gente tratando hardware antigo como peça de museu. Quando me deparei com a história do Mike e do The Tube Computer MK3 — um computador funcional construído do zero com 460 válvulas a vácuo das décadas de 1950 e 60 — percebi que vale a pena parar e refletir. Não é nostalgia barata. É um lembrete físico de como a computação realmente funciona no nível mais fundamental. E, segundo o Xataka.com.br, essa máquina existe, liga e roda. Demora 15 minutos para aquecer, mas funciona.

O Projeto do Mike e a Inspiração em Bletchley Park

O criador, conhecido apenas como Mike, não é um professor universitário nem uma empresa com orçamento de milhões. É um maker que visitou Bletchley Park — o centro britânico de quebra de códigos da Segunda Guerra Mundial, onde funcionou a máquina Colossus — e se fez a pergunta certa: por que só reconstruir o passado se eu posso usar essa tecnologia pioneira para criar algo novo?

O resultado foi o The Tube Computer MK3, uma máquina inédita que não tenta emular nenhum computador histórico. Ela implementa sua própria arquitetura usando válvulas a vácuo originais daqueles anos. São 460 válvulas que, juntas, formam portas lógicas, registradores e o barramento de dados da máquina. Não há nenhum transistor de silício no caminho crítico do sinal. É computação pura com electrões passando por filamentos aquecidos a vácuo.

O detalhe dos 15 minutos de aquecimento não é trivial. Válvulas dependem de emissão termiônica: um filamento precisa atingir cerca de 800–1000°C para que os electrões “evaporem” da superfície catódica e possam ser modulados pela grade. Antes disso, a máquina simplesmente não conduz. Mike documentou todo o processo em vídeos e postagens técnicas, mostrando inicialização, glitches e tudo mais.

Por Que Válvulas a Vácuo Ainda Importam Para Devs em 2026

Quando estou no terminal otimizando uma query SQL ou ajustando latência de uma API, parece absurdo pensar em válvulas. Mas existe um motivo muito prático para entender essa camada: quem entende a física do transistor entende por que o software se comporta como se comporta.

Uma válvula termiônica é, essencialmente, um interruptor controlado por tensão. A grade (grid) recebe um sinal baixo e decide se a corrente entre cátodo e ânodo passa ou não. É a mesma abstração binária que usamos em portas NAND — 1 ou 0, conduz ou bloqueia. A diferença está nos números:

• Consumo: cada válvula consome entre 0,5W e 5W só para aquecer o filamento. O MK3 com 460 válvulas gasta quilowatts só para existir.
• Latência: válvulas comutam em microssegundos. Transistores modernos comutam em picossegundos. São 3 a 6 ordens de grandeza de diferença.
• Tamanho físico: cada válvula é maior que um chip moderno inteiro com bilhões de transistores.
• Tolerância a radiação: válvulas resistem bem a ambientes hostis — por isso ainda vemos válvulas em transmissores de rádio militar e em fornos de micro-ondas industriais.

A grande lição: o gargalo de um sistema nem sempre está no código. Quando você percebe que um transistor leva tempo finito para alternar estado, começa a entender melhor por que pipelines de CPU têm profundidade limitada, por que caches importam e por que async/await não é mágica — é só esconder latência.

Na Prática: Simulando uma Porta Lógica a Válvula em JavaScript

Eu adoro mostrar isso em workshops. Uma válvula triodo se comporta como uma porta NOT com características bem específicas: tempo de aquecimento, histerese e degradação. Dá para simular isso de forma razoavelmente fiel em JavaScript para visualizar o comportamento:

// Modelo simplificado de uma válvula triodo usada como inversor lógico
class VacuumTube {
  constructor(id, heaterVoltage = 6.3) {
    this.id = id;
    this.heaterVoltage = heaterVoltage;
    this.heaterTemp = 0; // 0 a 1 (frio -> operacional)
    this.warmUpTime = 15000; // 15s simulado (real seria ~15min)
    this.gridVoltage = 0;   // entrada lógica (0V ou -10V)
    this.aged = false;
  }

  // Aquece o filamento ao longo do tempo
  warmUp(deltaMs) {
    const progress = deltaMs / this.warmUpTime;
    this.heaterTemp = Math.min(1, this.heaterTemp + progress);
    if (progress >= 1 && Math.random() < 0.001) {
      this.aged = true; // válvulas degradam com uso
    }
  }

  // Aplica sinal na grade e retorna a saída no ânodo
  switch() {
    if (this.heaterTemp < 0.95) {
      throw new Error(`Válvula ${this.id} ainda fria (${(this.heaterTemp*100).toFixed(1)}%)`);
    }
    // Grade negativa = corta corrente = saída HIGH
    // Grade zero/positiva = passa corrente = saída LOW
    return this.gridVoltage < -5 ? 1 : 0;
  }
}

// Construindo um flip-flop SR com duas válvulas (latch básico)
const tubeA = new VacuumTube('A');
const tubeB = new VacuumTube('B');

function tick(ms) {
  tubeA.warmUp(ms);
  tubeB.warmUp(ms);
}

try {
  tick(16000); // aquece até ficar operacional
  tubeA.gridVoltage = -10; // SET
  console.log('Q  =', tubeA.switch()); // 1
  console.log('Q̄ =', tubeB.switch()); // 0
} catch (err) {
  console.error('Falha:', err.message);
}

O código acima captura três comportamentos reais:

1. Aquecimento não instantâneo: a válvula lança erro até atingir 95% da temperatura operacional.
2. Threshold não-linear: a grade precisa de tensão mais negativa que -5V para cortar a corrente de forma confiável.
3. Degradação temporal: com uso, válvulas perdem emissão (o fenômeno do "aged" simula perda de vácuo ou coating do cátodo).

Quem trabalha com FPGA, ASIC ou até mesmo emuladores de CPUs antigas encontra esses mesmos princípios — só que abstraídos em HDL ou microarquitetura. É o mesmo problema com roupas diferentes.

Erros Comuns Que Devs Cometem Quando Olham Para Hardware Vintage

Eu já cometi vários desses. Vou listar os mais frequentes que vejo em fóruns e code reviews quando o tema aparece:

• Tratar "antigo" como sinônimo de "simples". ENIAC, o primeiro computador eletrônico, tinha 17.468 válvulas. Não era simples — era caótico, com fiação que levava semanas para reprogramar.
• Confundir frequência de clock com performance. O MK3 provavelmente opera na casa de quilohertz, mas isso não significa que é lento — significa que cada operação é gigante em significado. É como comparar takt time de fábrica com RPM de motor.
• Esquecer a camada de alimentação. Válvulas precisam de fontes de alta tensão (250V a 400V DC). Sem entender isso, qualquer projeto caseiro morre em curto-circuito ou na queima de filamentos.
• Subestimar o calor residual. 460 válvulas dissipam calor suficiente para aquecer um apartamento. Cooler e ventilação não são opcionais.
• Ignorar que sinais analógicos viraram digitais. Válvulas comutam com curvas exponenciais. O "0" e "1" limpos do silício não existem — existe tensão acima ou abaixo de um threshold, com ruído, ringing e bounce. Isso afeta diretamente quem programa drivers de GPIO ou interfaces industriais.

Comparativo: Válvula vs Transistor vs CMOS Moderno

Cada linha dessa tabela é uma revolução em si. Quando você programa em C e fica bravo com um loop de 100ms, lembre-se que essa mesma operação num computador de válvulas poderia levar segundos — não por software ruim, mas por física.

FAQ — Perguntas Que Todo Dev Faz Sobre Computadores a Válvula

1. Um computador a válvulas ainda pode rodar software útil em 2026?

Não no sentido prático. Mas pode rodar sua própria ISA, executar operações lógicas e aritméticas, e servir como ferramenta educacional riquíssima. O valor não está na produtividade — está no entendimento.

2. Dá para comprar válvulas a vácuo novas hoje?

Sim. Existem fabricantes russos, chinesos e eslovacos que ainda produzem válvulas para áudio Hi-Fi e transmissores de rádio. O preço varia de US$ 5 a US$ 200 por unidade, dependendo do tipo e da procedência.

3. Qual linguagem de programação rodar nesse tipo de máquina?

No nível mais baixo, você programa diretamente em microcódigo ou diretamente na fiação. Projetos modernos como o MK3 geralmente implementam uma arquitetura customizada com um conjunto mínimo de instruções. Não espere Python — espere pensar em bits literalmente.

4. Por que alguém construiria isso em vez de emular no FPGA?

Porque emular no FPGA perde o propósito didático e o contato com a física real. FPGA é uma abstração poderosa, mas abstrai o tempo de propagação, o ruído, o aquecimento e a degradação. Válvulas reais ensinam coisas que simuladores não ensinam.

5. Esse tipo de projeto é viável para um dev solo?

É viável tecnicamente, mas exige conhecimento forte de eletrônica analógica, fontes de alta tensão, segurança elétrica e milhares de horas. Não é projeto de fim de semana — é projeto de anos.

O Que Eu Levo Disso Para o Meu Dia a Dia Como Dev

Toda vez que estudo hardware antigo, volto a programar com mais cuidado. Fico mais atento a latências, mais criterioso com abstrações e mais humilde diante da complexidade que a indústria empacota silenciosamente para nós. O Mike gastou anos montando um computador com peças que a maioria joga fora. Isso não é hobby — é engenharia no sentido mais puro.

Se você trabalha com sistemas embarcados, FPGA, drivers de baixo nível ou simplesmente quer entender de verdade o que acontece quando um bit vira outro, estudar projetos como o MK3 vale cada minuto. E se quiser ver o trabalho original do Mike, vale procurar os vídeos dele — a engenharia é brilhante mesmo que a máquina leve 15 minutos para acordar.

📰 Ler matéria original no Xataka

Gostou? Me segue no GitHub e deixa um comentário se tiver dúvida ou quiser aprofundar algum ponto.