Por que Rust é o novo GOAT da IA

Autoria: Better Stack · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: Why Rust Is the New GOAT for AI · Canal: Better Stack · 01:34 · Assistir no YouTube

Tópicos: Agentes de IA, Engenharia de software com IA, Ferramentas de desenvolvimento com IA

Resumo

O vídeo mostra como Rust vem sendo adotada em ferramentas de IA e desenvolvimento, citando xAI, GitHub Copilot, Bun e o Code CLI da OpenAI. No caso do Copilot, a troca de um runtime em TypeScript por Rust eliminou a necessidade de iniciar um processo separado do Node.js, reduzindo o tempo para iniciar uma sessão e receber uma resposta de 5,25 segundos para 292 milissegundos. A migração, feita em cerca de 14 semanas e meia, converteu aproximadamente 430 mil linhas de TypeScript em 832 mil linhas de Rust, além de incluir cerca de 470 mil linhas de testes. Os agentes do Copilot escreveram a maior parte do código, e erros relacionados às regras de memória de Rust representaram cerca de 1,7% dos erros de compilação contabilizados.

Pontos-chave

Elon Musk respondeu “Rust” a uma publicação que afirmava que a AGI seria construída em Python; quase três anos depois, disse que o código da xAI era majoritariamente Rust.
O GitHub reescreveu em Rust o runtime por trás do Copilot.
O runtime anterior, escrito em TypeScript, iniciava um processo do Node.js para cada aplicativo que usava o Copilot pelo SDK do GitHub.
Cada processo do Node.js consumia pelo menos cerca de 100 MB de memória antes de o aplicativo começar a trabalhar.
Com Rust, o aplicativo pode carregar o arquivo compilado diretamente em seu próprio processo, sem iniciar outro programa.
O tempo para iniciar uma sessão e receber uma resposta caiu de 5,25 segundos para 292 milissegundos.
A migração envolveu cerca de 430 mil linhas de TypeScript, 832 mil linhas de Rust e 470 mil linhas de testes.
Os agentes do Copilot escreveram a maior parte da migração, concluída em cerca de 14 semanas e meia.
Erros associados às regras de memória de Rust corresponderam a cerca de 1,7% dos erros de compilação contabilizados.

Capítulos

Início	Capítulo	Resumo
00:00	A adoção de Rust em ferramentas de IA	O vídeo apresenta exemplos de adoção de Rust pela xAI, pelo GitHub Copilot, pelo Bun e pelo Code CLI da OpenAI.
00:32	Como a reescrita acelerou o Copilot	A troca do runtime em TypeScript por Rust removeu a necessidade de iniciar um processo separado do Node.js e reduziu o tempo de resposta.
01:03	Migração feita por agentes e erros de compilação	O vídeo descreve o volume de código migrado, a participação dos agentes do Copilot e a proporção de erros ligados às regras de memória de Rust.

Citações

“A AGI será construída em Python. Pense nisso.” — 00:00

“Rust.” — 00:00

“Cada um deles usava cerca de 100 MB de memória, no mínimo, antes mesmo de o aplicativo fazer qualquer coisa.” — 00:32

“O tempo caiu de 5,25 segundos para 292 milissegundos.” — 01:03

“As regras de memória pelas quais Rust é conhecida causaram apenas cerca de 1,7% deles.” — 01:34

Conceitos e entidades

Rust (conceito): Linguagem de programação usada na reescrita do runtime do Copilot e em outras ferramentas mencionadas.
Python (conceito): Linguagem citada em uma publicação que afirmava que a AGI seria construída com ela.
AGI (conceito): Sigla mencionada na afirmação sobre a linguagem em que seria construída.
GitHub (empresa): Empresa que reescreveu em Rust o runtime por trás do Copilot.
GitHub Copilot (ferramenta): Ferramenta cujo runtime foi reescrito em Rust para reduzir o tempo de inicialização e resposta.
TypeScript (conceito): Linguagem usada no runtime antigo do Copilot e na maior parte do código substituído.
Node.js (ferramenta): Runtime cuja inicialização em um processo separado era necessária na implementação antiga.
Bun (ferramenta): Runtime de JavaScript que, segundo o vídeo, passou de Zig para Rust.
Claude Code (ferramenta): Ferramenta citada como usuária do runtime Bun.
OpenAI (empresa): Empresa cujo Code CLI é descrito no vídeo como sendo 97% Rust.
Code CLI (ferramenta): CLI da OpenAI que, segundo o vídeo, é composto em 97% por Rust.
xAI (empresa): Empresa cujo código Elon Musk descreveu como majoritariamente escrito em Rust.
Elon Musk (pessoa): Pessoa que respondeu “Rust” à publicação sobre a linguagem em que a AGI seria construída.

Tradução completa (pt-BR)

00:00 Em 2023, alguém tuitou: “A AGI será criada em Python. Pense nisso.” Elon Musk respondeu com uma única palavra: “Rust.” Quase 3 anos depois, ele escreveu que o código da xAI é, em sua maior parte, Rust. O GitHub reescreveu em Rust o runtime por trás do Copilot, e o tempo para iniciar uma sessão e receber uma resposta caiu de mais de 5 segundos para menos de 300 milissegundos. O Bun, o runtime de JavaScript que agora é usado pelo Claude Code, migrou de Zig para Rust neste verão, e o Code CLI da OpenAI agora é 97% Rust. Então, como o Copilot passou de 5

00:32 segundos para menos de 300 milissegundos? O runtime antigo foi escrito em TypeScript, e cada aplicativo que usa o Copilot por meio do SDK do GitHub iniciava seu próprio processo do Node para executá-lo. Cada um deles usava pelo menos cerca de 100 MB de memória antes mesmo de o aplicativo fazer qualquer coisa. O Rust compila para um único arquivo .so, então não há nada extra para instalar, como um runtime do Node. E, em vez de iniciar um segundo programa e enviar mensagens para ele, cada aplicativo pode carregar esse arquivo diretamente em seu próprio processo e chamá-lo diretamente, como um plugin. Assim, o aplicativo não precisa iniciar todo um processo do Node

01:03 e foi assim que o tempo para iniciar uma sessão e receber uma resposta caiu de 5,25 segundos para 292 milissegundos. Quando um agent escreve código Rust com erros, o compilador aponta a linha e diz o que falhou. Então, o agent corrige o código e tenta de novo. Foi assim que a migração do GitHub foi feita. Cerca de 430.000 linhas de TypeScript se tornaram 832.000 linhas de Rust, além de cerca de 470.000 linhas de testes. O trabalho foi concluído em cerca de 14 semanas e meia, e os próprios agents do Copilot escreveram a maior parte do código. O GitHub também contabilizou os

01:34 erros do compilador dos agents, e as regras de segurança de memória pelas quais o Rust é conhecido foram responsáveis por apenas cerca de 1,7% deles.

Transcrição original

[00:00] Back in 2023, someone tweeted, “AGI will be built in Python. Let that sink in.” Elon Musk replied with one simple word, “Rust.” Nearly 3 years later, he wrote that xAI’s code is mostly Rust. GitHub rewrote the runtime behind Copilot in Rust, and starting a session and getting one reply went from over 5 seconds to under 300 milliseconds. Bun, the JavaScript runtime that now Claude Code runs on, moved from Zig to Rust this summer, and OpenAI’s Code CLI is now 97% Rust. So, how did Copilot get from 5

[00:32] seconds to under 300 milliseconds? The old runtime was written in TypeScript, and every app that uses Copilot through GitHub’s SDK started its own node process to run it. Each of those used about 100 MB of memory at minimum before the application has even done anything. Rust compiles to one 90 file, so there’s nothing extra like a node runtime to install, and instead of starting a second program and sending it messages, each app can load that file straight from its own process and call it directly like a plugin. So, the app doesn’t have to start a whole node

[01:03] process, and that’s how starting a session and getting a reply dropped from 5.25 seconds to 292 milliseconds. When an agent writes broken Rust, the compiler points at the line and says what failed. So, the agent fixes it and tries again. That’s how GitHub’s port got done. About 430,000 lines of TypeScript became 832,000 lines of Rust, plus about 470,000 lines of tests. That was completed in about 14 and 1/2 weeks, and Copilot’s own agents wrote most of it. GitHub counted the

[01:34] agents’ compiler errors, too, and the memory rules Rust is known for caused only about 1.7% of them.