Rust vs Go: ¿Qué lenguaje deberías elegir en 2026?

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

1~
2Rust y Go son los dos lenguajes de programación de sistemas más comentados en 2026. Rust ha sido votado como el "lenguaje más amado" en cada encuesta de Stack Overflow desde 2016. Go impulsa algunas de las infraestructuras más críticas de internet, desde Docker y Kubernetes hasta la red edge de Cloudflare.
3~
4Pero resuelven problemas diferentes de maneras fundamentalmente distintas. En este artículo, los comparamos en cada dimensión que importa para elegir la herramienta correcta.
5~
6## De un Vistazo
7~
8| Aspecto | Rust | Go |
9|---------|------|-----|
10| **Creado por** | Mozilla (2010) | Google (2009) |
11| **Sistema de tipos** | Estático, fuerte, con ownership | Estático, fuerte, más simple |
12| **Gestión de memoria** | Ownership + borrowing (sin GC) | Garbage collector |
13| **Concurrencia** | async/await, hilos, canales | Goroutines + canales |
14| **Compilación** | Más lenta | Muy rápida |
15| **Tamaño del binario** | Pequeño, estático | Pequeño, estático |
16| **Curva de aprendizaje** | Empinada | Suave |
17| **Manejo de errores** | Tipos Result/Option | Valores de retorno múltiples |
18| **Seguridad null** | Sin null (tipo Option) | Tiene nil |
19| **Generics** | Sí (desde 1.0) | Sí (desde 1.18) |
20~
21## Rendimiento
22~
23Rust produce un rendimiento comparable a C y C++, sin pausas del garbage collector. Te da control completo sobre la disposición y asignación de memoria.
24~
25Go es rápido - mucho más rápido que Python, JavaScript o Java - pero tiene un garbage collector que puede introducir picos de latencia en aplicaciones con requisitos de rendimiento críticos.
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~
49Ambos compilan a código nativo. La diferencia es que las abstracciones de Rust (iteradores, closures) compilan al mismo código máquina que los bucles escritos a mano, mientras que la simplicidad de Go a veces significa menos potencial de optimización.
50~
51**Elige Rust si**: la latencia sub-milisegundo importa (sistemas de trading, motores de juego, embebidos)
52**Elige Go si**: el rendimiento importa más que la latencia (servicios web, herramientas CLI, DevOps)
53~
54## Seguridad de Memoria
55~
56Esta es la característica definitoria de Rust. El sistema de ownership detecta errores de memoria en tiempo de compilación - sin desreferencias de punteros nulos, sin data races, sin 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 categorías enteras de errores que Go (y la mayoría de otros lenguajes) solo puede detectar en tiempo de ejecución.
77~
78**Elige Rust si**: la seguridad es crítica (criptografía, componentes del SO, navegadores)
79**Elige Go si**: las garantías de seguridad del garbage collector son suficientes para tu caso de uso
80~
81## Concurrencia
82~
83Ambos lenguajes destacan en concurrencia, pero con enfoques muy diferentes.
84~
85### Go: Goroutines
86~
87El modelo de concurrencia de Go es simple y elegante. Las goroutines son hilos ligeros gestionados por el runtime de Go, y los canales permiten una comunicación segura entre ellos.
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~
111El modelo asíncrono de Rust es más complejo pero te da más control. El compilador previene data races en tiempo de compilación.
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**Elige Go si**: quieres concurrencia simple y fácil de razonar
140**Elige Rust si**: necesitas seguridad de hilos garantizada y async de costo cero
141~
142## Experiencia de Desarrollo
143~
144### Go: La Simplicidad Primero
145~
146Go fue diseñado para ser simple. La especificación del lenguaje cabe en unas pocas páginas. Generalmente hay una forma obvia de hacer las cosas.
147~
148- **Compilación rápida**: Go compila casi instantáneamente
149- **Baterías incluidas**: net/http, encoding/json, testing - todo en la biblioteca estándar
150- **gofmt**: un estilo de formato, sin debates
151- **Fácil de aprender**: un desarrollador Java/Python puede ser productivo en días
152~
153### Rust: Potencia con Complejidad
154~
155Rust es más difícil de aprender pero te recompensa con más expresividad y seguridad.
156~
157- **Compilación más lenta**: el borrow checker y la monomorfización toman tiempo
158- **Cargo**: excelente gestor de paquetes y herramienta de build
159- **Sistema de tipos rico**: enums, pattern matching, traits, generics
160- **Curva más empinada**: el modelo de ownership toma semanas para interiorizar
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## Ecosistema y Casos de Uso
193~
194### Donde Go Brilla
195~
196- **Infraestructura cloud**: Docker, Kubernetes, Terraform, Prometheus
197- **Servicios web y APIs**: Servidores HTTP rápidos con net/http o Gin/Fiber
198- **Herramientas CLI**: cobra, urfave/cli
199- **Herramientas DevOps**: la mayoría de las herramientas cloud-native están escritas en Go
200- **Microservicios**: despliegue simple, binarios pequeños, inicio rápido
201~
202### Donde Rust Brilla
203~
204- **Programación de sistemas**: componentes del SO, drivers, embebidos
205- **WebAssembly**: soporte WASM de primera clase
206- **Servicios de rendimiento crítico**: Cloudflare Workers, sistema de mensajes de Discord
207- **Blockchain**: Solana, Polkadot, muchos proyectos crypto
208- **Motores de juego**: Bevy engine
209- **Herramientas CLI**: ripgrep, bat, fd, starship
210~
211### Empresas que Usan Cada Uno
212~
213| Go | Rust |
214|----|------|
215| Google (Kubernetes, gRPC) | Mozilla (Firefox) |
216| Docker | Cloudflare (Workers) |
217| Uber | Discord (almacenamiento de mensajes) |
218| Twitch | Dropbox (sincronización de archivos) |
219| Hashicorp (Terraform) | AWS (Firecracker) |
220| Cloudflare | Microsoft (componentes de Windows) |
221~
222## Cuándo Elegir Go
223~
2241. **Construir servicios web y APIs** - la simplicidad de Go y net/http lo hacen ideal
2252. **Tu equipo es nuevo en programación de sistemas** - la curva de aprendizaje de Go es mucho más suave
2263. **Necesitas iteración rápida** - Go compila instantáneamente, genial para prototipado rápido
2274. **Herramientas DevOps e infraestructura** - el ecosistema no tiene rival
2285. **Microservicios** - binarios pequeños, inicio rápido, despliegue simple
229~
230## Cuándo Elegir Rust
231~
2321. **El rendimiento no es negociable** - abstracciones de costo cero, sin pausas de GC
2332. **La seguridad es primordial** - las garantías de seguridad de memoria previenen clases enteras de errores
2343. **WebAssembly** - soporte WASM de primera clase
2354. **Sistemas embebidos** - sin runtime, sin GC, rendimiento predecible
2365. **Reemplazar C/C++** - mismo rendimiento con seguridad de memoria
237~
238## ¿Se Pueden Usar Ambos?
239~
240Sí. Muchas organizaciones usan ambos:
241~
242- **Go** para servicios web, APIs y herramientas DevOps
243- **Rust** para componentes y bibliotecas de rendimiento crítico
244~
245Pueden interoperar vía FFI (Foreign Function Interface), gRPC o APIs REST entre servicios.
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## Conclusión
265~
266Go y Rust son ambos excelentes lenguajes, pero optimizan para cosas diferentes:
267~
268- **Go optimiza para la simplicidad** - rápido de aprender, rápido de compilar, rápido de desplegar
269- **Rust optimiza para la corrección** - seguro, rápido, expresivo, pero más difícil de aprender
270~
271Si estás construyendo servicios web, APIs o herramientas DevOps y quieres moverte rápido, elige Go. Si estás construyendo software de rendimiento crítico, seguridad crítica o a nivel de sistema, elige Rust.
272~
273La mejor elección depende de tu equipo, tus restricciones y tus prioridades. Ambos lenguajes te servirán bien en 2026 y más allá.
274~

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

2Rust y Go son los dos lenguajes de programación de sistemas más comentados en 2026. Rust ha sido votado como el "lenguaje más amado" en cada encuesta de Stack Overflow desde 2016. Go impulsa algunas de las infraestructuras más críticas de internet, desde Docker y Kubernetes hasta la red edge de Cloudflare.

4Pero resuelven problemas diferentes de maneras fundamentalmente distintas. En este artículo, los comparamos en cada dimensión que importa para elegir la herramienta correcta.

6## De un Vistazo

8| Aspecto | Rust | Go |

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

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

11| **Sistema de tipos** | Estático, fuerte, con ownership | Estático, fuerte, más simple |

12| **Gestión de memoria** | Ownership + borrowing (sin GC) | Garbage collector |

13| **Concurrencia** | async/await, hilos, canales | Goroutines + canales |

14| **Compilación** | Más lenta | Muy rápida |

15| **Tamaño del binario** | Pequeño, estático | Pequeño, estático |

16| **Curva de aprendizaje** | Empinada | Suave |

17| **Manejo de errores** | Tipos Result/Option | Valores de retorno múltiples |

18| **Seguridad null** | Sin null (tipo Option) | Tiene nil |

19| **Generics** | Sí (desde 1.0) | Sí (desde 1.18) |

20~

21## Rendimiento

22~

23Rust produce un rendimiento comparable a C y C++, sin pausas del garbage collector. Te da control completo sobre la disposición y asignación de memoria.

24~

25Go es rápido - mucho más rápido que Python, JavaScript o Java - pero tiene un garbage collector que puede introducir picos de latencia en aplicaciones con requisitos de rendimiento críticos.

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~

49Ambos compilan a código nativo. La diferencia es que las abstracciones de Rust (iteradores, closures) compilan al mismo código máquina que los bucles escritos a mano, mientras que la simplicidad de Go a veces significa menos potencial de optimización.

50~

51**Elige Rust si**: la latencia sub-milisegundo importa (sistemas de trading, motores de juego, embebidos)

52**Elige Go si**: el rendimiento importa más que la latencia (servicios web, herramientas CLI, DevOps)

53~

54## Seguridad de Memoria

55~

56Esta es la característica definitoria de Rust. El sistema de ownership detecta errores de memoria en tiempo de compilación - sin desreferencias de punteros nulos, sin data races, sin 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 categorías enteras de errores que Go (y la mayoría de otros lenguajes) solo puede detectar en tiempo de ejecución.

77~

78**Elige Rust si**: la seguridad es crítica (criptografía, componentes del SO, navegadores)

79**Elige Go si**: las garantías de seguridad del garbage collector son suficientes para tu caso de uso

80~

81## Concurrencia

82~

83Ambos lenguajes destacan en concurrencia, pero con enfoques muy diferentes.

84~

85### Go: Goroutines

86~

87El modelo de concurrencia de Go es simple y elegante. Las goroutines son hilos ligeros gestionados por el runtime de Go, y los canales permiten una comunicación segura entre ellos.

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~

111El modelo asíncrono de Rust es más complejo pero te da más control. El compilador previene data races en tiempo de compilación.

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**Elige Go si**: quieres concurrencia simple y fácil de razonar

140**Elige Rust si**: necesitas seguridad de hilos garantizada y async de costo cero

141~

142## Experiencia de Desarrollo

143~

144### Go: La Simplicidad Primero

145~

146Go fue diseñado para ser simple. La especificación del lenguaje cabe en unas pocas páginas. Generalmente hay una forma obvia de hacer las cosas.

147~

148- **Compilación rápida**: Go compila casi instantáneamente

149- **Baterías incluidas**: net/http, encoding/json, testing - todo en la biblioteca estándar

150- **gofmt**: un estilo de formato, sin debates

151- **Fácil de aprender**: un desarrollador Java/Python puede ser productivo en días

152~

153### Rust: Potencia con Complejidad

154~

155Rust es más difícil de aprender pero te recompensa con más expresividad y seguridad.

156~

157- **Compilación más lenta**: el borrow checker y la monomorfización toman tiempo

158- **Cargo**: excelente gestor de paquetes y herramienta de build

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

160- **Curva más empinada**: el modelo de ownership toma semanas para interiorizar

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## Ecosistema y Casos de Uso

193~

194### Donde Go Brilla

195~

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

197- **Servicios web y APIs**: Servidores HTTP rápidos con net/http o Gin/Fiber

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

199- **Herramientas DevOps**: la mayoría de las herramientas cloud-native están escritas en Go

200- **Microservicios**: despliegue simple, binarios pequeños, inicio rápido

201~

202### Donde Rust Brilla

203~

204- **Programación de sistemas**: componentes del SO, drivers, embebidos

205- **WebAssembly**: soporte WASM de primera clase

206- **Servicios de rendimiento crítico**: Cloudflare Workers, sistema de mensajes de Discord

207- **Blockchain**: Solana, Polkadot, muchos proyectos crypto

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

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

210~

211### Empresas que Usan Cada Uno

212~

213| Go | Rust |

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

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

216| Docker | Cloudflare (Workers) |

217| Uber | Discord (almacenamiento de mensajes) |

218| Twitch | Dropbox (sincronización de archivos) |

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

220| Cloudflare | Microsoft (componentes de Windows) |

221~

222## Cuándo Elegir Go

223~

2241. **Construir servicios web y APIs** - la simplicidad de Go y net/http lo hacen ideal

2252. **Tu equipo es nuevo en programación de sistemas** - la curva de aprendizaje de Go es mucho más suave

2263. **Necesitas iteración rápida** - Go compila instantáneamente, genial para prototipado rápido

2274. **Herramientas DevOps e infraestructura** - el ecosistema no tiene rival

2285. **Microservicios** - binarios pequeños, inicio rápido, despliegue simple

229~

230## Cuándo Elegir Rust

231~

2321. **El rendimiento no es negociable** - abstracciones de costo cero, sin pausas de GC

2332. **La seguridad es primordial** - las garantías de seguridad de memoria previenen clases enteras de errores

2343. **WebAssembly** - soporte WASM de primera clase

2354. **Sistemas embebidos** - sin runtime, sin GC, rendimiento predecible

2365. **Reemplazar C/C++** - mismo rendimiento con seguridad de memoria

237~

238## ¿Se Pueden Usar Ambos?

239~

240Sí. Muchas organizaciones usan ambos:

241~

242- **Go** para servicios web, APIs y herramientas DevOps

243- **Rust** para componentes y bibliotecas de rendimiento crítico

244~

245Pueden interoperar vía FFI (Foreign Function Interface), gRPC o APIs REST entre servicios.

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## Conclusión

265~

266Go y Rust son ambos excelentes lenguajes, pero optimizan para cosas diferentes:

267~

268- **Go optimiza para la simplicidad** - rápido de aprender, rápido de compilar, rápido de desplegar

269- **Rust optimiza para la corrección** - seguro, rápido, expresivo, pero más difícil de aprender

270~

271Si estás construyendo servicios web, APIs o herramientas DevOps y quieres moverte rápido, elige Go. Si estás construyendo software de rendimiento crítico, seguridad crítica o a nivel de sistema, elige Rust.

272~

273La mejor elección depende de tu equipo, tus restricciones y tus prioridades. Ambos lenguajes te servirán bien en 2026 y más allá.

274~