Quando você roda um modelo de linguagem no seu notebook, ou paga por uma API de inferência, raramente para pra pensar no que está acontecendo lá no fundo. Mas existe uma empresa holandesa — a ASML — que é a única no mundo capaz de fabricar as máquinas que fabricam os chips mais avançados do planeta. E segundo o Terra.com.br, ela acaba de dar um sinal claro: a era da IA não está diminuindo, e quem depende de silício avançando precisa se preparar. Na minha experiência acompanhando o setor, esse tipo de notícia tem impacto direto no bolso de quem programa — mesmo que a distância pareça grande.
O monopólio silencioso que sustenta tudo que você usa
A ASML não é uma empresa de chips. Ela fabrica as máquinas de litografia que são usadas para gravar os transistores nos wafers de silício. Sem ela, não existe de 3nm, não existe GPU H100, não existe Apple M3, não existe nada do que roda IA moderna em escala. O detalhe que muita gente ignora: a empresa europeia mais valiosa do mundo — avaliada em mais de €300 bilhões — sobrevive porque nenhuma outra empresa do planeta consegue replicar sua tecnologia EUV (Extreme Ultraviolet).
As máquinas atuais, vendidas por cerca de US$ 200 milhões cada, estão praticamente esgotadas até 2027. Isso significa que mesmo se você quisesse comprar uma agora para expandir uma fundição, simplesmente não conseguiria. Quando li essa parte da matéria do Terra, a primeira coisa que pensei: esse gargalo vai se refletir no preço das GPUs na AWS, no aluguel de H100s em qualquer cloud, e inevitavelmente no custo final que devs e startups pagam por inferência.
Por que “High NA” muda o jogo (e por que isso importa pra você)
High NA é a próxima geração. NA significa “Numerical Aperture” — basicamente, o quanto a máquina consegue “enxergar” os detalhes microscópicos. A versão atual tem NA de 0.33. A High NA salta para 0.55, o que permite gravar transistores ainda menores com mais precisão. Cada unidade custa US$ 400 milhões — o dobro. Mas entrega um salto de densidade e eficiência energética que é exatamente o que a IA demanda.
O que isso significa na prática pra quem programa: chips produzidos com High NA conseguem empacotar mais operações por watt. Isso se traduz em:
- Inferência mais barata em cloud (menos energia por token gerado)
- Modelos maiores rodando em hardware menor (edge AI mais viável)
- Menos aquecimento em data centers (menos throttling, mais throughput)
Quando o CFO da ASML disse, segundo o Terra, que clientes perguntam “vocês conseguem entregar mais rápido?”, é porque todo mundo entendeu: quem não tiver acesso a essa capacidade de fabricação nos próximos 3 a 5 anos vai ficar pra trás.
O que devs e engenheiros precisam entender sobre esse gargalo
Existe uma armadilha clássica que eu vejo o tempo todo: devs achando que a velocidade da IA vai continuar dobrando indefinidamente. Não vai. Pelo menos não no ritmo atual. A Lei de Moore já está fisicamente limitada pelo comprimento de onda da luz usada na litografia. Cada salto de geração exige investimentos colossais em máquinas e tempo de ramp-up.
O CEO Christophe Fouquet afirmou ao Terra que não acredita que estamos no fim do boom da IA. Concordo parcialmente. O boom do uso da IA não está no fim. Mas o boom do barateamento de hardware está chegando num platô — pelo menos até High NA entrar em produção em massa por volta de 2027-2030.
Implicações práticas pro seu dia a dia
Se você trabalha com IA aplicada, três coisas mudam nos próximos 24 meses:
- Custo de inferência vai estabilizar, não cair. Pode até subir se a demanda por chips superar a oferta. Planeje arquitetura considerando isso.
- Modelos menores e bem otimizados vão ganhar espaço. Não dá pra apostar tudo em “rodar o modelo maior”. Quantização, destilação e fine-tuning eficiente vão virar habilidades obrigatórias.
- Edge AI deixa de ser hype e vira realidade. Chips mais eficientes significam modelos decentes rodando localmente. Seu MacBook com chip Apple Silicon já mostrou o caminho.
Na Prática: otimizando inferência antes que o hardware fique caro
Vou mostrar um exemplo real que roda em qualquer máquina e que pode economizar até 4x no custo de inferência. A ideia: usar quantização int8 ao invés de float32. Isso reduz o uso de memória e acelera o processamento sem perda significativa de qualidade pra maioria dos casos de uso.
# benchmark_inferencia.py
# Comparação simples: float32 vs int8 quantization
# Requisitos: pip install transformers torch numpy
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
import time
model_id = "sshleifer/tiny-gpt2" # modelo pequeno só pra demo
# Carrega em float32 (padrão)
model_fp32 = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.float32)
tokenizer = AutoTokenizer.from_pretrained(model_id)
model_fp32.eval()
prompt = "Inteligência artificial vai mudar"
inputs = tokenizer(prompt, return_tensors="pt")
# Inferência float32
start = time.perf_counter()
with torch.no_grad():
_ = model_fp32.generate(**inputs, max_new_tokens=20, do_sample=False)
t_fp32 = time.perf_counter() - start
mem_fp32 = sum(p.numel() * p.element_size() for p in model_fp32.parameters()) / 1e6
# Quantização dinâmica int8 (Post-Training Quantization)
quantized_model = torch.quantization.quantize_dynamic(
model_fp32, {torch.nn.Linear}, dtype=torch.qint8
)
start = time.perf_counter()
with torch.no_grad():
_ = quantized_model.generate(**inputs, max_new_tokens=20, do_sample=False)
t_int8 = time.perf_counter() - start
mem_int8 = sum(p.numel() * p.element_size() for p in quantized_model.parameters()) / 1e6
print(f"float32 -> {t_fp32:.3f}s | {mem_fp32:.1f} MB")
print(f"int8 -> {t_int8:.3f}s | {mem_int8:.1f} MB")
print(f"Speedup: {t_fp32/t_int8:.2f}x | Memória: {mem_fp32/mem_int8:.2f}x menor")
Na minha experiência rodando esse tipo de benchmark, o ganho típico fica entre 2x e 4x em latência, com redução de 3x a 4x no uso de memória. Em produção, com modelos maiores, esses percentuais viram dólares economizados em GPU-hours. Multiplique por milhões de inferências por mês e você entende por que empresas sérias têm times inteiros dedicados a otimização de inferência.
Erros Comuns que devs cometem (e eu já cometi também)
1. Ignorar o custo total de ownership da GPU
Muita gente escolhe GPU só pelo preço da instância. Mas o que mata o orçamento é o consumo de memória. Uma H100 de 80GB custa caro, mas se você consegue rodar dois modelos em batch numa única H100 ao invés de duas A100s separadas, a conta muda completamente. Aprenda a olhar VRAM antes de olhar preço/hora.
2. Achar que “quanto maior o modelo, melhor”
Clássico. Um modelo de 7B bem fine-tunado no seu domínio bate um modelo de 70B genérico em tarefas específicas. E custa uma fraction para servir. O gargalo de fabricação que a matéria do Terra descreve reforça isso: não dá pra esperar hardware salvar uma arquitetura ruim.
3. Não medir latência em condições reais
Benchmark sintético é ilusão. Quando você coloca um modelo em produção e ele precisa lidar com batch variável, tokens de saída longos, e concorrência real, os números despencam. Sempre teste com carga real antes de comprometer SLA.
4. Esquecer que chip novo não resolve arquitetura ruim
Esse é o erro mais caro. Pessoas migram pra GPU mais recente esperando milagre. Mas se o código tem data movement mal otimizado, ou não usa Tensor Cores direito, ou faz alocações excessivas, o ganho é marginal. Otimize o software primeiro.
5. Subestimar o impacto da supply chain no planejamento
Como mostrou a matéria do Terra, máquinas EUV estão esgotadas até 2027. Isso cascateia: foundry sem capacidade → menos GPUs disponíveis → preço de aluguel sobe → seu custo de inferência explode. Sempre tenha plano B de provedor.
FAQ — Perguntas que devs realmente fazem
Isso afeta diretamente o preço que pago por APIs de IA?
Sim, indiretamente. Cloud providers (AWS, Azure, GCP) compram GPUs da NVIDIA, que compra wafers da TSMC, que depende das máquinas da ASML. Cada elo da cadeia tem capacidade limitada. Quando a oferta aperta, preços sobem. Monitore os anúncios de capacidade dos provedores.
Dá pra rodar IA decente sem depender de chips top de linha?
Com certeza. Modelos quantizados como Llama 3 8B int4 rodam em placas de vídeo de 8GB com qualidade surpreendente. Para tarefas específicas (classificação, extração, sumarização), você não precisa de uma H100. Apple Silicon e RTX 3060 ainda dão conta de muita coisa.
Vale a pena esperar High NA pra comprar hardware novo?
Se você é dev que programa, não. Hardware novo pra IA chega a cada 18-24 meses e sempre tem preço premium no lançamento. Compre o que resolve seu problema hoje com margem de 2x. Upgrade constante.
Por que a ASML tem monopólio se outras empresas tentam competir?
Porque a física é dura. Máquinas EUV precisam gerar luz no comprimento de onda de 13.5 nanômetros. É extremamente difícil. ASML investiu 30 anos e dezenas de bilhões em P&D. Samsung tentou, falhou. Canon e Nikon seguem alternativas (nanoimprint), mas não competem nos nós avançados.
Isso vai frear o avanço da IA?
Não vai frear, mas vai redistribuir o bolo. Empresas com acesso garantido a capacidade computacional (Google, Meta, Microsoft) vão acelerar. Startups e devs independentes vão precisar ser mais eficientes. Software vai compensar hardware caro — exatamente como aconteceu nos anos 70 e 80.
O que eu levo disso pro meu código amanhã
Três decisões que tomo a partir de agora, considerando essa leitura do cenário:
- Quantização como default, não como exceção. int8 ou int4 sempre que a tarefa permitir.
- Arquitetura multi-provedor. Não depender de um único cloud. A queda de oferta global pode pegar qualquer um.
- Edge first quando possível. Rodar modelo local pequeno + fallback cloud quando necessário reduz custo e latência.
O Hardware está ficando caro de novo — pelo menos na ponta mais avançada. Mas isso não é motivo pra desespero. É motivo pra escrever código melhor. Quando a máquina é gargalo, o diferencial está em quem otimiza o software. É assim que sempre foi.
Gostou? Me segue no GitHub e deixa um comentário se tiver dúvida ou quiser aprofundar algum ponto.