A minha opinião nua e crua sobre Rust, do zero até usar em produção

Contexto geral:

Sou dev há 7 anos profissionalmente, meu primeiro contato com código foi com 12 anos de idade (em Pascal), e entrei pro mercado de trabalho como dev com 20 anos de idade.
Já programei profissionalmente em Python, JavaScript, TypeScript, PHP, SQL (T-SQL e PL/SQL) e agora também em Rust.

Como começou?

Sempre gostei de programação de baixo nível, na faculdade buscava fazer tudo em C quando possível. Depois de um tempo lidando só com linguagens interpretadas, dinâmicas e/ou sofrendo com a tipagem do TS, estava em busca de aprender algo compilado, tipado (de verdade), performático e inovador.
Pesquisando, cheguei em Go e Rust.

Por que Rust?

Gostei de Rust pelo fato da forma inovadora lidando com memória, mostrando uma "terceira via" do gerenciamento da memória atualmente, usando "empréstimo" (borrowing) e "posse" (ownership) de memória e indo completamente contra o usual que era Garbage Collector (que é o caso de Go, Java, C#, etc) ou deixar simplesmente o controle 100% manual (o caso de C, C++, Zig, etc) que as linguagens mainstream fazem. Logo, por conta dessa forma de lidar com a memória que me chamou atenção, deixei de escolher Go e parti pra Rust.

Aprendizado

Esse ano completa o terceiro ano que estudo Rust, sim, ainda estudo e ainda tenho muito o que aprender. Ele vai contra todas as linguagens que já tive contato, vendo agora ele não é "difícil" como eu vejo na internet, ele é "diferente". Diferente do que aprendi na faculdade, diferente das diversas formas que vi por ai.
Até então eu trabalhava com Python (Django) e a stack Frontend (JS). E focava em estudar no meu tempo livre.
Comecei com o básico, instalando o compilador no Linux e lendo o livro oficial disponibilizado gratuitamente (e tem até em pt-br pra quem ainda não domina inglês).
Usei também uma ferramenta disponibilizada pelo time do Rust é o Rustlings, snippets escrito por eles com erros intencionais, e eles ensinam através das correções que você faz. Nessa hora o compilador brilha. As mensagens de erro te guiam pra solução do código, mas em contrapartida tem MUITO erro até se habituar e pensar da forma de Rust.
Alguns cursos na Udemy em inglês, quase não tem conteúdo de Rust em pt-br.
Depois de algum tempo comprei e li o livro Zero to Production in Rust, voltado pra desenvolvimento backend, foi nele que aprendi de fato a desenvolver projetos reais.
Não aprendi tudo e nem pretendo, a parte embarcada, web assembly não me interessam por agora.
Eu sei, mas ainda falta dominar por completo é ponteiros inteligentes (smart pointers) e lifetimes, por enquanto não houve um projeto que precisei me apronfundar nisso.

Projetos iniciais

Comecei simples com projetos pessoais. Pra aprender Rust fiz um clone do "Cloc", o "locof" (Lines of Code Of), basicamente vc aponta um diretório e ele conta as linhas de código de cada tipo de arquivo e te retorna, fiz para aprender lidar com diretórios, arquivos, etc.
Depois fiz um sistema via linha de comando simples de lembretes, o "remme" (Remember Me), aprendi a manipular SQLite, escrever queries SQL direto do Rust e fazer um "listener" pra ficar consultando o banco e notificando via desktop.
Nesse momento eu comprei o livro Zero to Production, já tinha lidado com IO, banco de dados e levemente habituado com a forma de pensar em Rust, dominado o compilador, então parti pro Backend.
Na época, o livro foi e é sensacional até hoje, foca 100% em Rust Backend fazendo um sistema de newsletter, mexe com idempotência, autenticação, envios de e-mail, logs estruturados, etc, tanto é que hoje é o meu template inicial para iniciar meus projetos backend.
Como primeiro projeto backend (ainda em desenvolvimento) comecei a fazer um Blog/portfólio pessoal, comprei meu domínio (lucasbombarda.com) mas ainda não hospedei nada nele, pensei na oportunidade de fazer o blog em Rust, com comentários, login social, etc. Estou desenvolvendo ainda quando tenho tempo livre, logo ele passará a existir.
Mas agora vamos ao que interessa!

Projetos em produção

Aqui começa Rust em produção. Em ordem o projeto mais simples ao mais elaborado.

Sincronização

Meu primeiro projeto em produção foi em novembro/2024 e não foi web, foi ler, sanitizar e salvar logs, nem batizei ele com nome de tão simples que era.
Na empresa que trabalho temos reconhecimento facial de todas as portas, precisávamos ver quem entrava e saia de cada porta. Cada aparelho de reconhecimento facial gerava um log para cada evento (com sucesso ou não), eu tinha vários gigabytes de logs pra ler, tirar os dados úteis e salvar num banco de dados pro time de B.I. gerar um dashboard disso.
Os logs eram um JSON gigante nessa estrutura (dados modificados por motivos óbvios):

[{
	"eventId": "132456789",
	"eventType": 123456789,
	"eventTime": "2026-01-08T16:18:47-03:00",
	"personId": "123456789",
	"personName": "Lucas Bombarda",
	"personType": "0",
	"doorName": "Dispositivo da porta - entrada",
	"doorIndexCode": "123",
	"cardNo": "10000000000",
	"checkInAndOutType": 0,
	"picUri": "https://www.dominio-interno-da-empresa.com/foto.jpg",
	"deviceTime": "2026-01-08T16:18:47-03:00",
	"temperatureData": "",
	"temperatureStatus": 0,
	"wearMaskStatus": 2,
	"readerIndexCode": "112",
	"readerName": "Cardreader 01"
}]

Resultado: Logs organizados, salvo apenas o essencial pra mostrar no dashboard e hoje roda em D-1 (sincroniza todos os dados do dia anterior). O sistema roda desde 2024 sem eu mexer em 1 linha de código sequer. O gerente gostou e me deu mais oportunidades para outros projetos em Rust.

Sistema web de utilitários

Esse foi o primeiro sistema backend que eu fiz, um projeto de "Ferramentas" do dia-a-dia para o pessoal usar na empresa.
Ainda está em desenvolvimento contínuo. Mas basicamente o pessoal da empresa tinha dificuldade em encurtar links (para uso no marketing) e caiam naqueles encurtadores cheio de anúncios, o que atrapalhava bastante.
Então criei uma plataforma que a ideia é ter esses serviços para uso interno.
O uso é extremamente simples: Link grande, geração de um ID aleatório de 5 caracteres e salva no banco. Depois request no id aleatório, busca no banco e redireciona.

Envio de e-mails assíncrono

No nosso sistema principal (feito em Django), estava tendo um problema muito sério: Falhava ao enviar alguns e-mails, seja por erro de rede, muitos envios simultâneos, etc. Mensalmente enviava cerca de 30 mil e-mails de notificação, confirmação, etc.
Eu pensei, por que não fazer um worker multithread em Rust pra processar esses e-mails e tirar essa responsabilidade do Django?
Pois bem, foi o que fiz.
O Django ficou responsável em só salvar o assunto, corpo do e-mail, lista de remetentes, lista de cópia (Cc) e lista de cópia oculta (Cco) no banco de dados, e o worker em Rust (em outro servidor) lê essa tabela periodicamente, coleta 5 e-mails pendentes, inicia um processo para cada e-mail e tenta enviar, em caso de sucesso, marca o e-mail como enviado, em caso de erro, incrementa um contador no banco de dados e roda na próxima run.
Além de aliviar o backend em django tirando essa responsabilidade de enviar e-mails, teve uma leve melhora na performance nos endpoints que enviavam e-mail (era enviado de forma assíncrona, mas ainda consumia tempo) e no backend em geral, já que era menos responsabilidade pro backend, focando só na regra do negócio.

Site catálogo (Pessoal)

Esse foi pessoal mas está em produção. Eu poderia ter escolhido qualquer outra stack, mas escolhi Rust para aprimorar o conhecimento.
Fiz um site que fiz pra minha namorada pra catalogar uns produtos que ela faz. Escolhi Rust pois eu teria que lidar com arquivos, simplesmente por isso, nunca tinha lidado com upload de arquivo no Rust, aproveitei a oportunidade. E está funcionando de forma excepcional.

Conclusão!

Como em qualquer outra linguagem de programação, Rust resolve o problema, a questão é: como ele resolve o problema.
Ele traz uma confiança extrema na hora do desenvolvimento e manutenção do código, você lê a declaração de uma função e sabe exatamente o que ela faz, se pode ocorrer erros, os tipos de cada parâmetro da função. Coisa que em Python é um pesadelo de entender "como eu estava pensando quando escrevi isso?", em Rust se torna uma leitura comum de "ah, parece que fiz ontem essa função".
Mas, ele também traz pontos negativos, e o principal dele pra mim é a velocidade de desenvolvimento.
Comparado com outras linguagens, pra fazer algo funcional em Rust é necessário escrever muito código ou instalar dependências, e acredite em mim, as dependências do Rust vão crescendo de forma extremamente rápida, pois você fica refém delas.
Um servidor HTTP de um endpoint "Hello World" em Go é escrito em 15 linhas de código com zero dependências:

package main

import (
	"encoding/json"
	"net/http"
)

type Response struct {
	Message string `json:"message"`
}

func helloHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	res := Response{Message: "Hello World"}
	json.NewEncoder(w).Encode(res)
}

func main() {
	http.HandleFunc("/hello", helloHandler)
	http.ListenAndServe(":8080", nil)
}

Vira um código de com mais linhas de código com dependências em Rust ou 100+ linhas de código sem dependências, sem servidor HTTP e tendo que lidar com as requisições "cruas":

[dependencies] 
actix-web = "4" # Dependência do servidor HTTP
serde = { version = "1.0", features = ["derive"] } # Dependência para serializar/desserializar structs
serde_json = "1.0" # Dependência para transformar uma struct em JSON

use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use serde::Serialize;

#[derive(Serialize)]
struct Message {
    message: String,
}

async fn hello() -> Result<impl Responder, actix_web::Error> {
    Ok(HttpResponse::Ok().json(Message {
        message: "Hello World".to_string(),
    }))
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new().service(
            web::scope("/hello")
                .route("", web::get().to(hello))
        )
    })
    .bind(("127.0.0.1", 8081))?
    .run()
    .await
}

Obs: Não vou fazer a versão sem dependências, acho que deu pra entender. :)

Rust não é a solução para todos os problemas, mas pela experiência que estou tendo, hoje eu prefiro iniciar um backend em Rust do que em Django.

E vale a pena aprender? Na minha opinião: Depende do que você quer seguir.

Quando NÃO vale a pena:
Se você quer arrumar um emprego em Rust, até hoje eu não vi dez vagas de Rust aqui no Brasil, eu particularmente fiz apenas uma entrevista de Rust, mas o gerente de tech era um entusiasta. Todas as outras vagas que vi foi no exterior e todas pedem muita experiência (pelo menos 5 anos de exp). O mercado não está legal para dev no geral atualmente, muito menos para Rust. Eu não investiria tempo aprendendo se o foco é mercado de trabalho.
Se você quer ferramentas com "baterias inclusas", também não é pra você, no Rust você tem que entender as entrelinhas, desenvolver muita coisa (senão a maioria) do zero, não tem fluxo de autenticação pronto, não tem SDK pronto da maioria dos serviços, é você com você.

Quando vale a pena:
Quando você tem liberdade de escolher com o que trabalha (se for ganhar pra isso), para projetos pessoais, para projetos específicos e pontuais, para criar produtos extremamente rápidos de performance e que consome pouco servidor. (aproveitando essa onda de SaaS e micro SaaS que está tendo).
Quando você gosta de entender como as coisas funcionam, nesse caso compensa aprender.

Do mais, é isso, minha atual experiência em Rust.