Rust vs Go: Qual Linguagem Você Deve Escolher em 2026?

spinny:~/writing $ vim rust-vs-go-comparison.md

1~
2Rust e Go são as duas linguagens de programação de sistemas mais discutidas em 2026. Rust foi votada como a "linguagem mais amada" em todas as pesquisas do Stack Overflow desde 2016. Go alimenta algumas das infraestruturas mais críticas da internet, de Docker e Kubernetes à rede edge da Cloudflare.
3~
4Mas elas resolvem problemas diferentes de maneiras fundamentalmente diferentes. Neste artigo, comparamos as duas em todas as dimensões importantes para escolher a ferramenta certa.
5~
6## Visão Geral
7~
8| Aspecto | Rust | Go |
9|---------|------|-----|
10| **Criada por** | Mozilla (2010) | Google (2009) |
11| **Sistema de tipos** | Estático, forte, com ownership | Estático, forte, mais simples |
12| **Gerenciamento de memória** | Ownership + borrowing (sem GC) | Garbage collector |
13| **Concorrência** | async/await, threads, canais | Goroutines + canais |
14| **Compilação** | Mais lenta | Muito rápida |
15| **Tamanho do binário** | Pequeno, estático | Pequeno, estático |
16| **Curva de aprendizado** | Íngreme | Suave |
17| **Tratamento de erros** | Tipos Result/Option | Múltiplos valores de retorno |
18| **Segurança null** | Sem null (tipo Option) | Tem nil |
19| **Generics** | Sim (desde 1.0) | Sim (desde 1.18) |
20~
21## Desempenho
22~
23Rust produz desempenho comparável a C e C++, sem pausas do garbage collector. Dá a você controle completo sobre layout e alocação de memória.
24~
25Go é rápido - muito mais rápido que Python, JavaScript ou Java - mas tem um garbage collector que pode introduzir picos de latência em aplicações com requisitos críticos de desempenho.
26~
27```rust
28// Rust: Zero-cost abstractions
29fn sum_even(numbers: &[i32]) -> i32 {
30    numbers.iter()
31        .filter(|&&n| n % 2 == 0)
32        .sum()
33}
34```
35~
36```go
37// Go: Simple and clear
38func sumEven(numbers []int) int {
39    sum := 0
40    for _, n := range numbers {
41        if n%2 == 0 {
42            sum += n
43        }
44    }
45    return sum
46}
47```
48~
49Ambas compilam para código nativo. A diferença é que as abstrações do Rust (iteradores, closures) compilam para o mesmo código de máquina que loops escritos à mão, enquanto a simplicidade do Go às vezes significa menos potencial de otimização.
50~
51**Escolha Rust se**: latência abaixo de milissegundos importa (sistemas de trading, motores de jogos, embarcados)
52**Escolha Go se**: throughput importa mais que latência (serviços web, ferramentas CLI, DevOps)
53~
54## Segurança de Memória
55~
56Esta é a característica definidora do Rust. O sistema de ownership captura bugs de memória em tempo de compilação - sem desreferenciação de ponteiro nulo, sem data races, sem use-after-free.
57~
58```rust
59// Rust: This won't compile - ownership prevents use-after-free
60fn main() {
61    let s1 = String::from("hello");
62    let s2 = s1; // s1 is moved to s2
63    // println!("{}", s1); // ERROR: s1 is no longer valid
64    println!("{}", s2); // OK
65}
66```
67~
68```go
69// Go: nil can cause runtime panics
70func main() {
71    var s *string = nil
72    fmt.Println(*s) // PANIC at runtime: nil pointer dereference
73}
74```
75~
76Rust elimina categorias inteiras de bugs que Go (e a maioria das outras linguagens) só consegue detectar em tempo de execução.
77~
78**Escolha Rust se**: segurança é crítica (criptografia, componentes do SO, navegadores)
79**Escolha Go se**: as garantias de segurança do garbage collector são suficientes para seu caso de uso
80~
81## Concorrência
82~
83Ambas as linguagens se destacam em concorrência, mas com abordagens muito diferentes.
84~
85### Go: Goroutines
86~
87O modelo de concorrência do Go é simples e elegante. Goroutines são threads leves gerenciadas pelo runtime do Go, e canais permitem comunicação segura entre elas.
88~
89```go
90func fetchAll(urls []string) []string {
91    results := make(chan string, len(urls))
92~
93    for _, url := range urls {
94        go func(u string) {
95            resp, _ := http.Get(u)
96            body, _ := io.ReadAll(resp.Body)
97            results <- string(body)
98        }(url)
99    }
100~
101    var bodies []string
102    for range urls {
103        bodies = append(bodies, <-results)
104    }
105    return bodies
106}
107```
108~
109### Rust: async/await + Tokio
110~
111O modelo assíncrono do Rust é mais complexo, mas oferece mais controle. O compilador previne data races em tempo de compilação.
112~
113```rust
114use tokio;
115use reqwest;
116~
117async fn fetch_all(urls: Vec<String>) -> Vec<String> {
118    let mut handles = vec![];
119~
120    for url in urls {
121        handles.push(tokio::spawn(async move {
122            reqwest::get(&url)
123                .await
124                .unwrap()
125                .text()
126                .await
127                .unwrap()
128        }));
129    }
130~
131    let mut results = vec![];
132    for handle in handles {
133        results.push(handle.await.unwrap());
134    }
135    results
136}
137```
138~
139**Escolha Go se**: você quer concorrência simples e fácil de entender
140**Escolha Rust se**: você precisa de segurança de threads garantida e async de custo zero
141~
142## Experiência do Desenvolvedor
143~
144### Go: Simplicidade Primeiro
145~
146Go foi projetado para ser simples. A especificação da linguagem cabe em poucas páginas. Geralmente há uma maneira óbvia de fazer as coisas.
147~
148- **Compilação rápida**: Go compila quase instantaneamente
149- **Baterias incluídas**: net/http, encoding/json, testing - tudo na biblioteca padrão
150- **gofmt**: um estilo de formatação, sem debates
151- **Fácil de aprender**: um desenvolvedor Java/Python pode ser produtivo em dias
152~
153### Rust: Poder com Complexidade
154~
155Rust é mais difícil de aprender, mas recompensa com mais expressividade e segurança.
156~
157- **Compilação mais lenta**: o borrow checker e a monomorfização levam tempo
158- **Cargo**: excelente gerenciador de pacotes e ferramenta de build
159- **Sistema de tipos rico**: enums, pattern matching, traits, generics
160- **Curva mais íngreme**: o modelo de ownership leva semanas para internalizar
161~
162```rust
163// Rust's expressive error handling
164fn parse_config(path: &str) -> Result<Config, ConfigError> {
165    let content = std::fs::read_to_string(path)
166        .map_err(ConfigError::IoError)?;
167~
168    let config: Config = serde_json::from_str(&content)
169        .map_err(ConfigError::ParseError)?;
170~
171    Ok(config)
172}
173```
174~
175```go
176// Go's straightforward error handling
177func parseConfig(path string) (*Config, error) {
178    content, err := os.ReadFile(path)
179    if err != nil {
180        return nil, fmt.Errorf("reading config: %w", err)
181    }
182~
183    var config Config
184    if err := json.Unmarshal(content, &config); err != nil {
185        return nil, fmt.Errorf("parsing config: %w", err)
186    }
187~
188    return &config, nil
189}
190```
191~
192## Ecossistema e Casos de Uso
193~
194### Onde Go Brilha
195~
196- **Infraestrutura cloud**: Docker, Kubernetes, Terraform, Prometheus
197- **Serviços web e APIs**: Servidores HTTP rápidos com net/http ou Gin/Fiber
198- **Ferramentas CLI**: cobra, urfave/cli
199- **Ferramentas DevOps**: a maioria das ferramentas cloud-native são escritas em Go
200- **Microsserviços**: deploy simples, binários pequenos, startup rápido
201~
202### Onde Rust Brilha
203~
204- **Programação de sistemas**: componentes do SO, drivers, embarcados
205- **WebAssembly**: suporte WASM de primeira classe
206- **Serviços de desempenho crítico**: Cloudflare Workers, sistema de mensagens do Discord
207- **Blockchain**: Solana, Polkadot, muitos projetos cripto
208- **Motores de jogos**: Bevy engine
209- **Ferramentas CLI**: ripgrep, bat, fd, starship
210~
211### Empresas que Usam Cada Uma
212~
213| Go | Rust |
214|----|------|
215| Google (Kubernetes, gRPC) | Mozilla (Firefox) |
216| Docker | Cloudflare (Workers) |
217| Uber | Discord (armazenamento de mensagens) |
218| Twitch | Dropbox (sincronização de arquivos) |
219| Hashicorp (Terraform) | AWS (Firecracker) |
220| Cloudflare | Microsoft (componentes Windows) |
221~
222## Quando Escolher Go
223~
2241. **Construir serviços web e APIs** - a simplicidade do Go e net/http o tornam ideal
2252. **Sua equipe é nova em programação de sistemas** - a curva de aprendizado do Go é muito mais suave
2263. **Você precisa de iteração rápida** - Go compila instantaneamente, ótimo para prototipagem rápida
2274. **Ferramentas DevOps e infraestrutura** - o ecossistema é incomparável
2285. **Microsserviços** - binários pequenos, startup rápido, deploy simples
229~
230## Quando Escolher Rust
231~
2321. **Desempenho não é negociável** - abstrações de custo zero, sem pausas do GC
2332. **Segurança é primordial** - garantias de segurança de memória previnem classes inteiras de bugs
2343. **WebAssembly** - suporte WASM de primeira classe
2354. **Sistemas embarcados** - sem runtime, sem GC, desempenho previsível
2365. **Substituir C/C++** - mesmo desempenho com segurança de memória
237~
238## Pode-se Usar Ambos?
239~
240Sim. Muitas organizações usam ambos:
241~
242- **Go** para serviços web, APIs e ferramentas DevOps
243- **Rust** para componentes e bibliotecas de desempenho crítico
244~
245Podem interoperar via FFI (Foreign Function Interface), gRPC ou APIs REST entre serviços.
246~
247```mermaid
248graph LR
249    subgraph "Go Services"
250        API[API Gateway\nGo]
251        Auth[Auth Service\nGo]
252    end
253~
254    subgraph "Rust Services"
255        Search[Search Engine\nRust]
256        ML[ML Pipeline\nRust]
257    end
258~
259    API -- gRPC --> Search
260    API -- gRPC --> Auth
261    API -- gRPC --> ML
262```
263~
264## Conclusão
265~
266Go e Rust são ambas linguagens excelentes, mas otimizam para coisas diferentes:
267~
268- **Go otimiza para simplicidade** - rápido de aprender, rápido de compilar, rápido de entregar
269- **Rust otimiza para correção** - seguro, rápido, expressivo, mas mais difícil de aprender
270~
271Se você está construindo serviços web, APIs ou ferramentas DevOps e quer se mover rápido, escolha Go. Se está construindo software de desempenho crítico, segurança crítica ou nível de sistema, escolha Rust.
272~
273A melhor escolha depende da sua equipe, suas restrições e suas prioridades. Ambas as linguagens servirão bem em 2026 e além.
274~

NORMAL · rust-vs-go-comparison.md [readonly]274 lines · :q to close

2Rust e Go são as duas linguagens de programação de sistemas mais discutidas em 2026. Rust foi votada como a "linguagem mais amada" em todas as pesquisas do Stack Overflow desde 2016. Go alimenta algumas das infraestruturas mais críticas da internet, de Docker e Kubernetes à rede edge da Cloudflare.

4Mas elas resolvem problemas diferentes de maneiras fundamentalmente diferentes. Neste artigo, comparamos as duas em todas as dimensões importantes para escolher a ferramenta certa.

6## Visão Geral

8| Aspecto | Rust | Go |

9|---------|------|-----|

10| **Criada por** | Mozilla (2010) | Google (2009) |

11| **Sistema de tipos** | Estático, forte, com ownership | Estático, forte, mais simples |

12| **Gerenciamento de memória** | Ownership + borrowing (sem GC) | Garbage collector |

13| **Concorrência** | async/await, threads, canais | Goroutines + canais |

14| **Compilação** | Mais lenta | Muito rápida |

15| **Tamanho do binário** | Pequeno, estático | Pequeno, estático |

16| **Curva de aprendizado** | Íngreme | Suave |

17| **Tratamento de erros** | Tipos Result/Option | Múltiplos valores de retorno |

18| **Segurança null** | Sem null (tipo Option) | Tem nil |

19| **Generics** | Sim (desde 1.0) | Sim (desde 1.18) |

20~

21## Desempenho

22~

23Rust produz desempenho comparável a C e C++, sem pausas do garbage collector. Dá a você controle completo sobre layout e alocação de memória.

24~

25Go é rápido - muito mais rápido que Python, JavaScript ou Java - mas tem um garbage collector que pode introduzir picos de latência em aplicações com requisitos críticos de desempenho.

26~

27```rust

28// Rust: Zero-cost abstractions

29fn sum_even(numbers: &[i32]) -> i32 {

30 numbers.iter()

31 .filter(|&&n| n % 2 == 0)

32 .sum()

33}

34```

35~

36```go

37// Go: Simple and clear

38func sumEven(numbers []int) int {

39 sum := 0

40 for _, n := range numbers {

41 if n%2 == 0 {

42 sum += n

43 }

44 }

45 return sum

46}

47```

48~

49Ambas compilam para código nativo. A diferença é que as abstrações do Rust (iteradores, closures) compilam para o mesmo código de máquina que loops escritos à mão, enquanto a simplicidade do Go às vezes significa menos potencial de otimização.

50~

51**Escolha Rust se**: latência abaixo de milissegundos importa (sistemas de trading, motores de jogos, embarcados)

52**Escolha Go se**: throughput importa mais que latência (serviços web, ferramentas CLI, DevOps)

53~

54## Segurança de Memória

55~

56Esta é a característica definidora do Rust. O sistema de ownership captura bugs de memória em tempo de compilação - sem desreferenciação de ponteiro nulo, sem data races, sem use-after-free.

57~

58```rust

59// Rust: This won't compile - ownership prevents use-after-free

60fn main() {

61 let s1 = String::from("hello");

62 let s2 = s1; // s1 is moved to s2

63 // println!("{}", s1); // ERROR: s1 is no longer valid

64 println!("{}", s2); // OK

65}

66```

67~

68```go

69// Go: nil can cause runtime panics

70func main() {

71 var s *string = nil

72 fmt.Println(*s) // PANIC at runtime: nil pointer dereference

73}

74```

75~

76Rust elimina categorias inteiras de bugs que Go (e a maioria das outras linguagens) só consegue detectar em tempo de execução.

77~

78**Escolha Rust se**: segurança é crítica (criptografia, componentes do SO, navegadores)

79**Escolha Go se**: as garantias de segurança do garbage collector são suficientes para seu caso de uso

80~

81## Concorrência

82~

83Ambas as linguagens se destacam em concorrência, mas com abordagens muito diferentes.

84~

85### Go: Goroutines

86~

87O modelo de concorrência do Go é simples e elegante. Goroutines são threads leves gerenciadas pelo runtime do Go, e canais permitem comunicação segura entre elas.

88~

89```go

90func fetchAll(urls []string) []string {

91 results := make(chan string, len(urls))

92~

93 for _, url := range urls {

94 go func(u string) {

95 resp, _ := http.Get(u)

96 body, _ := io.ReadAll(resp.Body)

97 results <- string(body)

98 }(url)

99 }

100~

101 var bodies []string

102 for range urls {

103 bodies = append(bodies, <-results)

104 }

105 return bodies

106}

107```

108~

109### Rust: async/await + Tokio

110~

111O modelo assíncrono do Rust é mais complexo, mas oferece mais controle. O compilador previne data races em tempo de compilação.

112~

113```rust

114use tokio;

115use reqwest;

116~

117async fn fetch_all(urls: Vec<String>) -> Vec<String> {

118 let mut handles = vec![];

119~

120 for url in urls {

121 handles.push(tokio::spawn(async move {

122 reqwest::get(&url)

123 .await

124 .unwrap()

125 .text()

126 .await

127 .unwrap()

128 }));

129 }

130~

131 let mut results = vec![];

132 for handle in handles {

133 results.push(handle.await.unwrap());

134 }

135 results

136}

137```

138~

139**Escolha Go se**: você quer concorrência simples e fácil de entender

140**Escolha Rust se**: você precisa de segurança de threads garantida e async de custo zero

141~

142## Experiência do Desenvolvedor

143~

144### Go: Simplicidade Primeiro

145~

146Go foi projetado para ser simples. A especificação da linguagem cabe em poucas páginas. Geralmente há uma maneira óbvia de fazer as coisas.

147~

148- **Compilação rápida**: Go compila quase instantaneamente

149- **Baterias incluídas**: net/http, encoding/json, testing - tudo na biblioteca padrão

150- **gofmt**: um estilo de formatação, sem debates

151- **Fácil de aprender**: um desenvolvedor Java/Python pode ser produtivo em dias

152~

153### Rust: Poder com Complexidade

154~

155Rust é mais difícil de aprender, mas recompensa com mais expressividade e segurança.

156~

157- **Compilação mais lenta**: o borrow checker e a monomorfização levam tempo

158- **Cargo**: excelente gerenciador de pacotes e ferramenta de build

159- **Sistema de tipos rico**: enums, pattern matching, traits, generics

160- **Curva mais íngreme**: o modelo de ownership leva semanas para internalizar

161~

162```rust

163// Rust's expressive error handling

164fn parse_config(path: &str) -> Result<Config, ConfigError> {

165 let content = std::fs::read_to_string(path)

166 .map_err(ConfigError::IoError)?;

167~

168 let config: Config = serde_json::from_str(&content)

169 .map_err(ConfigError::ParseError)?;

170~

171 Ok(config)

172}

173```

174~

175```go

176// Go's straightforward error handling

177func parseConfig(path string) (*Config, error) {

178 content, err := os.ReadFile(path)

179 if err != nil {

180 return nil, fmt.Errorf("reading config: %w", err)

181 }

182~

183 var config Config

184 if err := json.Unmarshal(content, &config); err != nil {

185 return nil, fmt.Errorf("parsing config: %w", err)

186 }

187~

188 return &config, nil

189}

190```

191~

192## Ecossistema e Casos de Uso

193~

194### Onde Go Brilha

195~

196- **Infraestrutura cloud**: Docker, Kubernetes, Terraform, Prometheus

197- **Serviços web e APIs**: Servidores HTTP rápidos com net/http ou Gin/Fiber

198- **Ferramentas CLI**: cobra, urfave/cli

199- **Ferramentas DevOps**: a maioria das ferramentas cloud-native são escritas em Go

200- **Microsserviços**: deploy simples, binários pequenos, startup rápido

201~

202### Onde Rust Brilha

203~

204- **Programação de sistemas**: componentes do SO, drivers, embarcados

205- **WebAssembly**: suporte WASM de primeira classe

206- **Serviços de desempenho crítico**: Cloudflare Workers, sistema de mensagens do Discord

207- **Blockchain**: Solana, Polkadot, muitos projetos cripto

208- **Motores de jogos**: Bevy engine

209- **Ferramentas CLI**: ripgrep, bat, fd, starship

210~

211### Empresas que Usam Cada Uma

212~

213| Go | Rust |

214|----|------|

215| Google (Kubernetes, gRPC) | Mozilla (Firefox) |

216| Docker | Cloudflare (Workers) |

217| Uber | Discord (armazenamento de mensagens) |

218| Twitch | Dropbox (sincronização de arquivos) |

219| Hashicorp (Terraform) | AWS (Firecracker) |

220| Cloudflare | Microsoft (componentes Windows) |

221~

222## Quando Escolher Go

223~

2241. **Construir serviços web e APIs** - a simplicidade do Go e net/http o tornam ideal

2252. **Sua equipe é nova em programação de sistemas** - a curva de aprendizado do Go é muito mais suave

2263. **Você precisa de iteração rápida** - Go compila instantaneamente, ótimo para prototipagem rápida

2274. **Ferramentas DevOps e infraestrutura** - o ecossistema é incomparável

2285. **Microsserviços** - binários pequenos, startup rápido, deploy simples

229~

230## Quando Escolher Rust

231~

2321. **Desempenho não é negociável** - abstrações de custo zero, sem pausas do GC

2332. **Segurança é primordial** - garantias de segurança de memória previnem classes inteiras de bugs

2343. **WebAssembly** - suporte WASM de primeira classe

2354. **Sistemas embarcados** - sem runtime, sem GC, desempenho previsível

2365. **Substituir C/C++** - mesmo desempenho com segurança de memória

237~

238## Pode-se Usar Ambos?

239~

240Sim. Muitas organizações usam ambos:

241~

242- **Go** para serviços web, APIs e ferramentas DevOps

243- **Rust** para componentes e bibliotecas de desempenho crítico

244~

245Podem interoperar via FFI (Foreign Function Interface), gRPC ou APIs REST entre serviços.

246~

247```mermaid

248graph LR

249 subgraph "Go Services"

250 API[API Gateway\nGo]

251 Auth[Auth Service\nGo]

252 end

253~

254 subgraph "Rust Services"

255 Search[Search Engine\nRust]

256 ML[ML Pipeline\nRust]

257 end

258~

259 API -- gRPC --> Search

260 API -- gRPC --> Auth

261 API -- gRPC --> ML

262```

263~

264## Conclusão

265~

266Go e Rust são ambas linguagens excelentes, mas otimizam para coisas diferentes:

267~

268- **Go otimiza para simplicidade** - rápido de aprender, rápido de compilar, rápido de entregar

269- **Rust otimiza para correção** - seguro, rápido, expressivo, mas mais difícil de aprender

270~

271Se você está construindo serviços web, APIs ou ferramentas DevOps e quer se mover rápido, escolha Go. Se está construindo software de desempenho crítico, segurança crítica ou nível de sistema, escolha Rust.

272~

273A melhor escolha depende da sua equipe, suas restrições e suas prioridades. Ambas as linguagens servirão bem em 2026 e além.

274~