Hoy hay una moda en el desarrollo de software: reescribir proyectos en Rust. Algunos proyectos sí necesitan esa reescritura, pero otros se están reescribiendo sin necesidad. Y uno de los ejemplos más claros es curl: en noviembre de este año apareció una versión de curl reescrita entera en Rust con IA.
Eso podría parecer una buena noticia. Pero, al revisarlo con calma, resulta ser un buen ejemplo de cuándo no vale la pena reescribir un proyecto en Rust. Aquí te cuento qué pasó, qué dijo el creador de curl y qué podemos aprender de todo esto.
Qué es curl y por qué importa
Si no lo conoces, curl es una herramienta y una biblioteca que sirve para transferir datos a través de una dirección de internet. Igual que tu navegador carga páginas o descarga archivos, curl hace lo mismo, pero desde la terminal o desde el código de tus programas. Soporta una enorme cantidad de protocolos (HTTP, FTP, SMTP, IMAP, MQTT, WebSocket y muchos más) y viene en dos formas: el programa curl que usas en la terminal y la biblioteca libcurl, que integran miles de aplicaciones.
Además, lleva 30 años en desarrollo: su creador, Daniel Stenberg, celebró el aniversario este mismo noviembre. Muchísimo software depende de él. Y justo por eso la pregunta es interesante: ¿un proyecto así necesita una reescritura en Rust?
La reescritura de curl en Rust con IA
Un desarrollador, conocido en GitHub como kov, dirigió a Claude Code durante 27 días, del 20 de octubre al 16 de noviembre, para reescribir curl y libcurl en Rust. El resultado está en el repositorio kov/curl, en la rama rust-rewrite, y el propio README dice que el código lo escribió Claude bajo la dirección y revisión de su autor.
No fue una traducción línea por línea. El código en C sirvió de referencia, y los tests de curl decidían si algo estaba bien o mal. Según el README, el proyecto suma unos 2.300 commits y unas 430.000 líneas de Rust (contando los tests), frente a unas 200.000 líneas de C. Y produce una libcurl que puede sustituir a la original, así que los programas que ya usan curl funcionan sin cambiar nada.
Para comprobar que funcionaba, ejecutó los tests de curl contra la versión original y contra la de Rust, y comparó los resultados uno por uno. Imagínalo así: cada test es una pregunta; se la haces a los dos, y si responden exactamente lo mismo, pasa. Además, escribió más de 4.000 tests propios en Rust (4.389, para ser exactos) y los puso a prueba rompiendo el código a propósito para ver si alguno lo detectaba. Es como probar una alarma: rompes algo y miras si suena. Si no suena, ese test no estaba protegiendo nada.
Las cifras ya no impresionan
Ahora, hay que tener algo en cuenta. Vas a ver muchos repositorios con métricas como estas, y cada vez importan menos. Hace años, si alguien escribía 430.000 líneas a mano, te impresionaba muchísimo. Hoy un agente puede escribirlas solo, y puede escribir un montón de código de relleno que también suma líneas. Más aún en un lenguaje tan verboso como Rust.
Con el precio pasa algo parecido. Daniel Stenberg habla de unos 8.600 dólares, y en el diario del proyecto aparecen unos 8.650. Pero esa cifra es una estimación a precio de lista de la API, no lo que se pagó. En el propio diario se habla de los límites semanales de uso, algo que solo pasa con una suscripción de Claude. Así que, en resumen, es una persona con una suscripción cara que tuvo la idea de reescribir una biblioteca muy popular en Rust.
La crítica de los 4.832 «unsafe»
En cuanto se publicó, llegó la crítica. The Lunduke Journal se burló de que esta versión de curl usa unsafe 4.832 veces, cuando la gracia de Rust es justo la seguridad de memoria. Pero para entender si esa crítica es justa, primero hay que saber qué significa unsafe.
En Rust, el compilador vigila la memoria por ti. Por ejemplo, aquí muevo un valor a otra variable y luego intento usar la primera:
fn main() {
let nombre = String::from("curl");
let otro = nombre; // el valor se mueve a `otro`
println!("{}", nombre); // error: `nombre` ya no tiene el valor
}
Rust no te deja compilar esto. En C, algo parecido compilaría sin problema y el fallo aparecería después, con el programa ya en marcha.
Pero hay cosas que el compilador no puede comprobar, como llamar a una biblioteca escrita en C o pedirle algo al sistema operativo. Ahí tienes que escribir unsafe, que es como decirle: «esto no lo puedes revisar tú, así que lo garantizo yo». Ojo, no apaga el compilador: solo permite unas pocas operaciones extra, como usar punteros de C. Este es un ejemplo del propio curl en Rust, simplificado:
// SAFETY: `name` es una cadena de C válida durante toda la llamada.
let found = unsafe { libc::getenv(name.as_ptr()) };
getenv es una función de C para leer una variable de entorno. Rust no sabe qué hace por dentro, así que hay que marcarla como unsafe y explicar en un comentario por qué es segura.
Y aquí está la trampa del número. Los unsafe no están repartidos por todo el código, sino en la frontera con C:
- La capa de compatibilidad con C, la que deja que los programas escritos en C usen esta versión como si fuera la
libcurlde siempre. Es donde más hay: casi la mitad. Sin ella, no sería un reemplazo directo. - Las bibliotecas de C que reutiliza, como OpenSSL o GnuTLS para el cifrado, o ngtcp2 para HTTP/3. No vas a reescribir también esas bibliotecas.
- Las llamadas al sistema operativo, como leer variables de entorno o resolver nombres. Esas llevan
unsafeen cualquier programa de Rust.
En cambio, el motor de curl (curl-core), donde está la lógica de HTTP, FTP y el resto, tiene cero, porque empieza con esta línea:
#![forbid(unsafe_code)]
Con ella, Rust ni siquiera compila ese código si alguien mete un unsafe. Además, la cifra de 4.832 sale de contar las líneas que contienen la palabra «unsafe», comentarios incluidos. Así que contarlos sin mirar dónde están es engañoso, y esa crítica no vale tanto la pena.
Lo que dijo el creador de curl: 14 de 81
Daniel Stenberg publicó su opinión sobre estas reescrituras y dio un dato muy claro: de las 81 vulnerabilidades confirmadas en curl en lo que va de 2026, solo 14 se habrían evitado muy probablemente con un lenguaje seguro en memoria como Rust. Es un 17,3 %. Es decir, una versión de curl en Rust habría tenido igual 67 de esas 81 vulnerabilidades.
No es un número despreciable: un fallo de memoria puede ser de los más graves. Pero el resto no tenía nada que ver con la memoria, sino con errores de lógica, y esos los cometes igual en cualquier lenguaje.
La propia reescritura lo confirma de otra forma. Revisó los 239 fallos de seguridad de la historia de curl y, según el diario del proyecto, muchos de ellos (133) los evita solo porque copió el comportamiento de un C que ya estaba corregido. Esa parte de la seguridad no vino de Rust, sino de treinta años de arreglos.
Por qué una reescritura cuesta tanto
Cuando piensas en reescribir, puedes imaginar algo como traducir un artículo del español al inglés. Pero en código no basta con traducir. Hay que comprobar que la reescritura hace lo mismo: reescribir los tests, añadir tests nuevos y revisar cada vulnerabilidad conocida para asegurarte de que el código nuevo no la vuelve a tener. Por eso una reescritura de un programa de verdad consume mucho trabajo, incluso con IA.
Y aquí sí vale la comparación con la traducción: si un artículo está mal redactado en español, al traducirlo al inglés sigue estando mal redactado. Con la lógica del código pasa lo mismo: si la pasas a otro lenguaje, pasas también sus errores.
Ya nació atrasada
El segundo punto de Stenberg es quizás el más importante: escribir el código una vez nunca fue lo difícil. Lo difícil es mantenerlo.
Mientras se hacían estas reescrituras, en algo más de tres semanas, el curl original integró más de 300 commits, con algo más de 200 correcciones de bugs y varias vulnerabilidades arregladas. Y no es algo puntual: curl recibe, de media, unos 11 commits al día. Ninguna de esas correcciones está en la versión en Rust.
Así que la copia nació ya atrasada. Para alcanzar al original, tendría que seguir el ritmo de una comunidad que lleva 30 años manteniéndolo. El autor del fork dijo que está incorporando los commits nuevos; Stenberg le respondió preguntando cuál es el sentido. En sus palabras, él no cree en las reescrituras a ningún lenguaje, sino en pulir, iterar y refactorizar sin parar.
Mi opinión: reescribir por ego
Y aquí va mi opinión. Si de verdad te gusta un proyecto y lo usas mucho, en lugar de hacer un fork y reescribirlo en Rust gastando tokens a lo bestia, ¿por qué no mandas unos cuantos pull requests? Así contribuyes al proyecto real, el que usa todo el mundo, y no a una copia que solo usas tú.
Porque muchas veces estas reescrituras tienen más de ego que de utilidad: copias un proyecto que ya existe, lo reescribes y pasas a ser el dueño del proyecto nuevo. Y tampoco es que C sea lento: según el propio README del fork, la versión en Rust va más o menos a la misma velocidad que la de C, entre 0,81 y 1,11 veces según el caso. Es decir, ni siquiera ganas rendimiento.
Entonces, ¿cuándo sí vale la pena Rust?
Con todo esto no quiero que se malinterprete: Rust no es un mal lenguaje. Si vas a escribir código nuevo, es muy probable que te convenga, sobre todo para las partes más expuestas, como las bibliotecas que leen datos de internet o las que trabajan directamente con la memoria. Ahí tiene todo el sentido, porque no tienes que migrar nada.
Pero reescribir algo que lleva 30 años funcionando no te da 30 años de arreglos de forma automática. Hoy, con agentes, puedes generar código en cuestión de horas. Lo difícil es mantenerlo: un proyecto que usa gente de verdad tiene fallos que corregir y funciones que añadir todo el tiempo. Y ahí es donde valdría mucho más la pena gastar tus tokens.
¿Y tú? ¿Qué proyecto sí reescribirías en Rust, y cuál dejarías como está? Déjamelo en los comentarios.
Fuentes
- Daniel Stenberg: «Actual curl rewrites in rust» (17 de noviembre de 2026)
- Repositorio de la reescritura, kov/curl (rama rust-rewrite) y su README
curl-corecon#![forbid(unsafe_code)]- Ejemplo de
unsafeen la frontera con C (getenv) - Post del autor en Hacker News
- Tuit de The Lunduke Journal
- Lista de vulnerabilidades de curl
- Web oficial de curl y repositorio original