Rust (lenguaje de programación)

Rust comenzó como un proyecto personal del empleado de Mozilla Graydon Hoare en 2006. Según MIT Technology Review , comenzó el proyecto debido a su frustración con un ascensor averiado en su edificio de apartamentos cuyo software se había bloqueado, ^{[ 20 ]} y nombró el lenguaje en honor al grupo de hongos del mismo nombre que está "sobreingeniería para la supervivencia". ^{[ 20 ]} Durante el período entre 2006 y 2009, Rust no fue publicitado a otros en Mozilla y fue escrito en el tiempo libre de Hoare; ^{[ 21 ] : 7:50} Hoare comenzó a hablar sobre el lenguaje alrededor de 2009 después de que un pequeño grupo en Mozilla se interesara en el proyecto. ^{[ 22 ]} Hoare citó lenguajes de las décadas de 1970, 1980 y 1990 como influencias, incluyendo CLU , BETA , Mesa , NIL, ^{[ nota 4 ]} Erlang , Newsqueak , Napier , Hermes , Sather , Alef y Limbo . ^{[ 22 ]} Describió el lenguaje como "tecnología del pasado que viene a salvar al futuro de sí mismo". ^{[ 21 ] : 8:17 [ 22 ]} El desarrollador inicial de Rust, Manish Goregaokar, describió de manera similar a Rust como basado en "investigaciones de décadas de antigüedad". ^{[ 20 ]}

Durante los primeros años, el compilador de Rust estaba escrito en aproximadamente 38.000 líneas de OCaml . ^{[ 21 ] : 15:34 [ 23 ]} Las primeras versiones de Rust contenían varias características que ya no están presentes hoy en día, incluyendo la programación orientada a objetos explícita mediante una objpalabra clave ^{[ 21 ] : 10:08} y un sistema de estados de tipo para cambios de estado de variables, como pasar de no inicializado a inicializado. ^{[ 21 ] : 13:12}

Mozilla patrocinó oficialmente el proyecto Rust en 2009. ^{[ 20 ]} Brendan Eich y otros ejecutivos, intrigados por la posibilidad de usar Rust para un motor de navegador web seguro , asignaron ingenieros al proyecto, entre ellos Patrick Walton, Niko Matsakis, Felix Klock y Manish Goregaokar. ^{[ 20 ]} Una sala de conferencias ocupada por los desarrolladores del proyecto fue apodada "la cueva de los nerds", con un letrero colocado en la puerta. ^{[ 20 ]}

Durante este período, el trabajo pasó del compilador OCaml inicial a un compilador autoalojado ( es decir , escrito en Rust) dirigido a LLVM . ^{[ 24 ] [ nota 5 ]} El sistema de propiedad se implementó en 2010. ^{[ 20 ]} El logotipo de Rust se desarrolló en 2011 basado en un plato de bicicleta. ^{[ 26 ]}

Rust 0.1 se convirtió en la primera versión pública el 20 de enero de 2012 ^{[ 27 ]} para Windows, Linux y MacOS. ^{[ 28 ]} A principios de la década de 2010 se observó una creciente participación de ingenieros a tiempo completo en Mozilla y voluntarios de código abierto fuera de Mozilla. ^{[ 20 ]}

Los años de 2012 a 2015 estuvieron marcados por cambios sustanciales en el sistema de tipos de Rust . ^{[ 21 ] : 18:36 [ 20 ]} La gestión de memoria a través del sistema de propiedad se consolidó y expandió gradualmente. Para 2013, el recolector de basura se usaba poco y se eliminó en favor del sistema de propiedad. ^{[ 20 ]} Se eliminaron otras características para simplificar el lenguaje, incluidos los estados de tipo, la purepalabra clave, ^{[ 29 ]} varios tipos de punteros especializados y el soporte de sintaxis para canales . ^{[ 21 ] : 22:32}

Según Steve Klabnik, Rust se vio influenciado durante este período por desarrolladores provenientes de C++ (por ejemplo, rendimiento de bajo nivel de las funcionalidades), lenguajes de scripting (por ejemplo, Cargo y gestión de paquetes) y programación funcional (por ejemplo, desarrollo de sistemas de tipos). ^{[ 21 ] : 30:50}

Graydon Hoare renunció a Rust en 2013. ^{[ 20 ]} Tras la partida de Hoare, evolucionó orgánicamente bajo una estructura de gobernanza federada, con un "equipo central" inicialmente de seis personas, ^{[ 21 ] : 21:45} y alrededor de 30-40 desarrolladores en total en varios otros equipos. ^{[ 21 ] : 22:22} Se agregó un proceso de Solicitud de Comentarios (RFC) para nuevas características del lenguaje en marzo de 2014. ^{[ 21 ] : 33:47} El equipo central crecería a nueve personas para 2016 ^{[ 21 ] : 21:45} con más de 1600 RFC. ^{[ 21 ] : 34:08}

Según Andrew Binstock para Dr. Dobb's Journal en enero de 2014, si bien Rust era "ampliamente considerado un lenguaje notablemente elegante", su adopción se ralentizó debido a que cambiaba radicalmente de una versión a otra. ^{[ 30 ]} El desarrollo de Rust en ese momento se centró en finalizar las características de la versión 1.0 para poder comenzar a prometer compatibilidad con versiones anteriores . ^{[ 21 ] : 41:26}

Seis años después del patrocinio de Mozilla, Rust 1.0 se publicó y se convirtió en la primera versión estable el 15 de mayo de 2015. ^{[ 20 ]} Un año después, el compilador de Rust había acumulado más de 1400 colaboradores y había más de 5000 bibliotecas de terceros publicadas en el sitio web de gestión de paquetes de Rust, Crates.io. ^{[ 21 ] : 43:15}

El desarrollo del motor de navegador Servo continuó en paralelo con Rust, financiado conjuntamente por Mozilla y Samsung . ^{[ 31 ]} Los equipos detrás de los dos proyectos trabajaron en estrecha colaboración; el equipo de Servo probaba las nuevas características de Rust, y las nuevas características de Servo se usaban para dar retroalimentación al equipo de Rust. ^{[ 21 ] : 5:41} La primera versión de Servo se lanzó en 2016. ^{[ 20 ]} El navegador web Firefox se lanzó con código Rust a partir de 2016 (versión 45), ^{[ 21 ] : 53:30 [ 32 ]} pero los componentes de Servo no aparecieron en Firefox hasta septiembre de 2017 (versión 57) como parte de los proyectos Gecko y Quantum . ^{[ 33 ]}

Se realizaron mejoras en el ecosistema de la cadena de herramientas de Rust durante los años posteriores a la versión 1.0, incluyendo Rustfmt , la integración del entorno de desarrollo integrado , ^{[ 21 ] : 44:56} y un ciclo regular de pruebas y lanzamiento de compiladores. ^{[ 21 ] : 46:48} La comunidad de Rust obtuvo un código de conducta y un chat IRC para discusiones. ^{[ 21 ] : 50:36}

La adopción más temprana conocida fuera de Mozilla fue por proyectos individuales en Samsung, Facebook (ahora Meta Platforms ), Dropbox y Tilde, Inc., la empresa detrás de ember.js . ^{[ 21 ] : 55:44 [ 20 ]} Amazon Web Services siguió en 2020. ^{[ 20 ]} Los ingenieros citaron el rendimiento, la falta de un recolector de basura, la seguridad y la agradable experiencia de trabajar en el lenguaje como razones para la adopción. Los desarrolladores de Amazon citaron un hallazgo de investigadores portugueses que indicaba que el código Rust consumía menos energía en comparación con un código similar escrito en Java . ^{[ 20 ] [ 34 ]}

En agosto de 2020, Mozilla despidió a 250 de sus 1000 empleados en todo el mundo, como parte de una reestructuración corporativa provocada por la pandemia de COVID-19 . ^{[ 35 ] [ 36 ]} El equipo detrás de Servo se disolvió. El evento generó preocupación sobre el futuro de Rust. ^{[ 37 ]} La semana siguiente, el Rust Core Team reconoció el grave impacto de los despidos y anunció que se estaban preparando planes para una fundación de Rust. El primer objetivo de la fundación sería adquirir la propiedad de todas las marcas registradas y nombres de dominio y asumir la responsabilidad financiera de sus costos. ^{[ 38 ]}

El 8 de febrero de 2021, cinco empresas fundadoras anunciaron la creación de la Fundación Rust : Amazon Web Services , Google , Huawei , Microsoft y Mozilla . ^{[ 39 ] [ 40 ]} La fundación proporcionaría apoyo financiero a los desarrolladores de Rust en forma de subvenciones y financiación de servidores. ^{[ 20 ]} En una entrada de blog publicada el 6 de abril de 2021, Google anunció el soporte para Rust dentro del Proyecto de Código Abierto de Android como alternativa a C/C++. ^{[ 41 ]}

El 22 de noviembre de 2021, el Equipo de Moderación, responsable de hacer cumplir el código de conducta de la comunidad, anunció su renuncia "en protesta por el hecho de que el Equipo Central se eximiera de toda responsabilidad". ^{[ 42 ]} En mayo de 2022, miembros del consejo de liderazgo de Rust publicaron una respuesta pública al incidente. ^{[ 43 ]}

La Fundación Rust publicó un borrador de una nueva política de marcas registradas el 6 de abril de 2023, lo que generó reacciones negativas generalizadas entre los usuarios y colaboradores de Rust. ^{[ 44 ]} La política de marcas registradas incluía reglas sobre cómo se podían usar el logotipo y el nombre de Rust. ^{[ 44 ]}

A continuación se muestra un programa "¡Hola, mundo!" en Rust. La fnpalabra clave denota una función , y la println!macro (ver §  Macros ) imprime el mensaje en la salida estándar . ^{[ 48 ]} Las instrucciones en Rust se separan con punto y coma .

fn main () { println! ( "Hola, mundo!" ); }

Las variables en Rust se definen mediante la letpalabra clave. ^{[ 49 ]} El siguiente ejemplo asigna un valor a la variable con nombre foode tipo i32y muestra su valor; la anotación de tipo puede omitirse.:i32

fn main () { let foo : i32 = 10 ; println! ( "El valor de foo es {foo}" ); }

Las variables son inmutables por defecto, a menos que mutse añada la palabra clave. ^{[ 50 ]} El siguiente ejemplo utiliza //, que denota el inicio de un comentario . ^{[ 51 ]}

fn main () { // Este código no compilaría sin agregar "mut". let mut foo = 10 ; println! ( "El valor de foo es {foo}" ); foo = 20 ; println! ( "El valor de foo es {foo}" ); }

Varias letexpresiones pueden definir varias variables con el mismo nombre, lo que se conoce como ocultamiento de variables . El ocultamiento de variables permite transformar variables sin tener que cambiarles el nombre. ^{[ 52 ]} El siguiente ejemplo declara una nueva variable con el mismo nombre que duplica el valor original:

fn main () { let foo = 10 ; // Esto imprimirá "El valor de foo es 10" println! ( "El valor de foo es {foo}" ); let foo = foo * 2 ; // Esto imprimirá "El valor de foo es 20" println! ( "El valor de foo es {foo}" ); }

También es posible el sombreado de variables para valores de diferentes tipos. Por ejemplo, pasar de una cadena a su longitud:

fn main () { let letters = "abc" ; let letters = letters . len (); }

Una expresión de bloque está delimitada por llaves . Cuando la última expresión dentro de un bloque no termina con un punto y coma, el bloque se evalúa al valor de esa expresión final: ^{[ 53 ]}

fn main () { let x = { println! ( "esto está dentro del bloque" ); 1 + 2 }; println! ( "1 + 2 = {x}" ); }

Las expresiones finales de los cuerpos de las funciones se utilizan como valor de retorno: ^{[ 54 ]}

fn add_two ( x : i32 ) -> i32 { x + 2 }

fn main () { let x = 10 ; if x > 5 { println! ( "el valor es mayor que cinco" ); }if x % 7 == 0 { println! ( "El valor es divisible por 7" ); } else if x % 5 == 0 { println! ( "El valor es divisible por 5" ); } else { println! ( "El valor no es divisible por 7 ni por 5" ); } }

fn main () { let x = 10 ; let new_x = if x % 2 == 0 { x / 2 } else { 3 * x + 1 }; println! ( "{new_x}" ); }

fn main () { // Iterar sobre todos los enteros del 4 al 10 let mut value = 4 ; while value <= 10 { println! ( "value = {value}" ); value += 1 ; } }

fn main () { // Usando `for` con sintaxis de rango para la misma funcionalidad que arriba // La sintaxis 4..=10 significa el rango de 4 a 10, hasta 10 inclusive. for value in 4 ..= 10 { println! ( "value = {value}" ); } }

( 1 ..= 100 ). filtro ( | x | x % 3 == 0 ). suma ()

fn main () { let value = 456 ; let mut x = 1 ; let y = loop { x *= 10 ; if x > value { break x / 10 ; } }; println! ( "Mayor potencia de diez que es menor o igual que value: {y}" );let mut up = 1 ; ' outer : loop { let mut down = 120 ; loop { if up > 100 { break 'outer ; }Si down < 4 { break ; }abajo /= 2 ; arriba += 1 ; println! ( "arriba: {arriba}, abajo: {abajo}" ); } arriba *= 2 ; } }

Las expresiones matchy se pueden usar para la coincidencia de patrones . Por ejemplo, se puede usar para duplicar un valor entero opcional si está presente y devolver cero en caso contrario: ^{[ 59 ]}ifletmatch

fn double ( x : Option < u64 > ) -> u64 { match x { Some ( y ) => y * 2 , None => 0 , } }

De forma equivalente, esto se puede escribir con y :ifletelse

fn double ( x : Option < u64 > ) -> u64 { if let Some ( y ) = x { y * 2 } else { 0 } }

Rust es fuertemente tipado y estático , lo que significa que los tipos de todas las variables deben conocerse en tiempo de compilación. Asignar un valor de un tipo particular a una variable de tipo diferente provoca un error de compilación . Se utiliza la inferencia de tipos para determinar el tipo de las variables si no se especifica. ^{[ 60 ]}

El tipo (), llamado "tipo de unidad" en Rust, es un tipo concreto que tiene exactamente un valor. No ocupa memoria (ya que representa la ausencia de valor). Todas las funciones que no tienen un tipo de retorno indicado devuelven implícitamente (). Es similar a voiden otros lenguajes de estilo C; sin embargo, voiddenota la ausencia de un tipo y no puede tener ningún valor.

El tipo de entero predeterminado es i32, y el tipo de punto flotante predeterminado es f64. Si el tipo de un número literal no se proporciona explícitamente, se infiere del contexto o se utiliza el tipo predeterminado. ^{[ 61 ]}

let tuple : ( u32 , bool ) = ( 3 , true ); let array : [ i8 ; 5 ] = [ 1 , 2 , 3 , 4 , 5 ]; let value = tuple . 1 ; // true let value = array [ 2 ]; // 3

let array2 : [ char ; 10 ] = [ ' ' ; 10 ];

El sistema de propiedad de Rust consiste en reglas que garantizan la seguridad de la memoria sin utilizar un recolector de basura. En tiempo de compilación, cada valor debe adjuntarse a una variable llamada propietario de ese valor, y cada valor debe tener exactamente un propietario. ^{[ 71 ]} Los valores se mueven entre diferentes propietarios mediante asignación o pasando un valor como parámetro de función. Los valores también pueden tomarse prestados, lo que significa que se pasan temporalmente a una función diferente antes de ser devueltos al propietario. ^{[ 72 ]} Con estas reglas, Rust puede prevenir la creación y el uso de punteros colgantes : ^{[ 72 ] [ 73 ]}

fn print_string ( s : String ) { println! ( "{}" , s ); }fn main () { let s = String :: from ( "Hello, World" ); print_string ( s ); // s consumido por print_string // s se ha movido, por lo que ya no se puede usar // otro print_string(s); resultaría en un error de compilación }

La función print_stringtoma posesión del Stringvalor pasado como argumento; alternativamente, &se puede usar para indicar un tipo de referencia (en ) y para crear una referencia (en ): ^{[ 74 ]}&String&s

fn print_string ( s : & String ) { println! ( "{}" , s ); }fn main () { let s = String :: from ( "Hello, World" ); print_string ( & s ); // s es prestada por print_string print_string ( & s ); // s no ha sido consumida; podemos llamar a la función muchas veces }

Debido a estas reglas de propiedad, los tipos de Rust se conocen como tipos afines , lo que significa que cada valor puede usarse como máximo una vez. Esto impone una forma de aislamiento de fallos de software, ya que el propietario de un valor es el único responsable de su corrección y liberación. ^{[ 75 ]}

Cuando un valor sale del ámbito, se elimina ejecutando su destructor . El destructor puede definirse programáticamente mediante la implementación del Droprasgo . Esto ayuda a gestionar recursos como identificadores de archivos, sockets de red y bloqueos , ya que cuando se eliminan objetos, los recursos asociados a ellos se cierran o liberan automáticamente. ^{[ 76 ]}

fn main () { let mut x = 5 ; // ------------------+- Tiempo de vida 'a // | let r = & x ; // -+-- Tiempo de vida 'b | // | | println! ( "r: {}" , r ); // -+ | // Dado que r ya no se usa, | // su tiempo de vida termina | let r2 = & mut x ; // -+-- Tiempo de vida 'c | } // ------------------+

fn main () { let r ; // ------------------+- Tiempo de vida 'a // | { // | let x = 5 ; // -+-- Tiempo de vida 'b | r = & x ; // ERROR: x no | | } // vive lo suficiente -| | // println! ( "r: {}" , r ); // | } // ------------------+

fn remove_prefix <' a > ( mut original : & ' a str , prefix : & str ) -> & ' a str { if original . starts_with ( prefix ) { original = original [ prefix . len () .. ]; } original }

Los tipos definidos por el usuario se crean con las palabras clave structo enum. La structpalabra clave se utiliza para denotar un tipo de registro que agrupa múltiples valores relacionados. ^{[ 86 ]}enum Los pueden adoptar diferentes variantes en tiempo de ejecución, con capacidades similares a los tipos de datos algebraicos que se encuentran en los lenguajes de programación funcional. ^{[ 87 ]} Tanto los registros como las variantes de enumeración pueden contener campos con diferentes tipos. ^{[ 88 ]} Se pueden definir nombres alternativos, o alias, para el mismo tipo con la typepalabra clave . ^{[ 89 ]}

La implpalabra clave puede definir métodos para un tipo definido por el usuario. Los datos y las funciones se definen por separado. Las implementaciones cumplen una función similar a la de las clases en otros lenguajes. ^{[ 90 ]}

Biblioteca estándar

La biblioteca estándar de Rust define e implementa muchos tipos de datos personalizados ampliamente utilizados, incluidas estructuras de datos centrales como Vec, Option, y HashMap, así como tipos de punteros inteligentes . Rust proporciona una forma de excluir la mayor parte de la biblioteca estándar utilizando el atributo #![no_std], para aplicaciones como dispositivos embebidos. Internamente, la biblioteca estándar se divide en tres partes, core, alloc, y std, donde stdy allocse excluyen mediante #![no_std]. ^{[ 91 ]}

Rust utiliza el tipo de opciónOption<T> para definir valores opcionales, que pueden coincidir utilizando if leto matchpara acceder al valor interno: ^{[ 92 ]}

fn main () { let name1 : Option <& str > = None ; // En este caso, no se imprimirá nada if let Some ( name ) = name1 { println! ( "{name}" ); }let name2 : Option <& str > = Some ( "Matthew" ); // En este caso, se imprimirá la palabra "Matthew" if let Some ( name ) = name2 { println! ( "{name}" ); } }

De manera similar, el tipo de resultado de Rust Result<T, E>contiene un valor calculado correctamente (la Okvariante) o un error (la Errvariante). ^{[ 93 ]} Al igual que Option, el uso de Resultsignifica que el valor interno no se puede usar directamente; los programadores deben usar una matchexpresión, azúcar sintáctico como ?(el operador "try") o una unwrapaserción explícita para acceder a él. Tanto Optioncomo Resultse usan en toda la biblioteca estándar y son una parte fundamental del enfoque explícito de Rust para manejar errores y datos faltantes.

Los tipos de referencia &y están garantizados para no ser nulos y apuntar a memoria válida. ^{[ 94 ]} Los tipos de puntero sin formato y no cumplen con las garantías de seguridad, por lo que pueden ser nulos o inválidos; sin embargo, es imposible desreferenciarlos a menos que el código se declare explícitamente como no seguro mediante el uso de un bloque. ^{[ 95 ]} A diferencia de la desreferenciación, la creación de punteros sin formato está permitida dentro de código Rust seguro. ^{[ 96 ]}&mut*const*mutunsafe

Rust admite el polimorfismo a través de rasgos , funciones genéricas y objetos de rasgos . ^{[ 98 ]}

rasgo Zero : Sized { fn zero () -> Self ; fn is_zero ( & self ) -> bool donde Self : PartialEq , { self == & Zero :: zero () } }impl Zero for u32 { fn zero () -> u32 { 0 } }impl Zero for f32 { fn zero () -> Self { 0.0 } }

// zero es una función genérica con un parámetro de tipo Num fn zero < Num : Zero > () -> Num { Num :: zero () }fn main () { let a : u32 = zero (); let b : f32 = zero (); assert! ( a . is_zero () && b . is_zero ()); }

usar std :: fmt :: Display ;let v : Vec < Box < dyn Display >> = vec! [ Box :: new ( 3 ), Box :: new ( 5.0 ), Box :: new ( "hi" ), ];para x en v { println! ( "{x}" ); }

Rust no utiliza recolección de basura . La memoria y otros recursos se gestionan mediante la convención de "la adquisición de recursos es la inicialización" ^{[ 107 ]} , con conteo de referencias opcional. Rust proporciona una gestión determinista de los recursos, con una sobrecarga muy baja ^{[ 108 ]} . Los valores se asignan en la pila por defecto, y todas las asignaciones dinámicas deben ser explícitas ^{[ 109 ]} .

Los tipos de referencia integrados que utilizan el &símbolo no implican conteo de referencias en tiempo de ejecución. La seguridad y validez de los punteros subyacentes se verifican en tiempo de compilación, evitando punteros colgantes y otras formas de comportamiento indefinido . ^{[ 110 ]} El sistema de tipos de Rust separa las referencias compartidas e inmutables de la forma &Tde las referencias únicas y mutables de la forma &mut T. Una referencia mutable puede ser convertida a una referencia inmutable, pero no al revés. ^{[ 111 ]}

Las comprobaciones de seguridad de memoria de Rust (véase #Safety ) pueden eludirse mediante el uso de unsafebloques. Esto permite a los programadores desreferenciar punteros sin formato arbitrarios, llamar a código externo o realizar otras funciones de bajo nivel no permitidas por Rust seguro. ^{[ 112 ]} Algunas de las funciones de bajo nivel habilitadas de esta manera incluyen el acceso a memoria volátil , intrínsecas específicas de la arquitectura, el juego de tipos y el ensamblaje en línea. ^{[ 113 ]}

Se necesita código inseguro, por ejemplo, en la implementación de estructuras de datos. ^{[ 114 ]} Un ejemplo citado con frecuencia es que es difícil o imposible implementar listas doblemente enlazadas en Rust seguro. ^{[ 115 ] [ 116 ] [ 117 ] [ 118 ]}

Los programadores que utilizan Rust no seguro son responsables de mantener los requisitos de seguridad de memoria y tipos de Rust, por ejemplo, que no existan dos referencias mutables que apunten a la misma ubicación. ^{[ 119 ]} Si los programadores escriben código que viola estos requisitos, esto resulta en un comportamiento indefinido . ^{[ 119 ]} La documentación de Rust incluye una lista de comportamientos considerados indefinidos, incluyendo el acceso a punteros colgantes o desalineados, o la violación de las reglas de alias para referencias. ^{[ 120 ]}

Las macros permiten la generación y transformación de código Rust para reducir la repetición. Existen dos tipos de macros: macros declarativas definidas mediante macro_rules!, y macros procedimentales , que se definen en crates separados. ^{[ 121 ] [ 122 ]}

macro_rules! suma { ( $initial : expr $(, $expr : expr ) * $(, ) ? ) => { $initial $( + $expr ) * } }fn main () { let x = sum ! ( 1 , 2 , 3 ); println! ( "{x}" ); // imprime 6 }

Rust admite la creación de interfaces de funciones externas (FFI) mediante la externpalabra clave. Una función que utiliza la convención de llamada de C se puede escribir usando . Los símbolos se pueden exportar de Rust a otros lenguajes mediante el atributo, y los símbolos se pueden importar a Rust mediante bloques: ^{[ nota 6 ] [ 128 ]}extern"C"fn#[unsafe(no_mangle)]extern

#[unsafe(no_mangle)] pub extern "C" fn exported_from_rust ( x : i32 ) -> i32 { x + 1 } unsafe extern "C" { fn imported_into_rust ( x : i32 ) -> i32 ; }

El #[repr(C)]atributo permite diseños de memoria deterministas para structs y enums para su uso a través de límites FFI. ^{[ 128 ]} Bibliotecas externas como bindgeny cxxpueden generar enlaces de Rust para C/C++. ^{[ 128 ] [ 129 ]}

El compilador de Rust rustccompila el código Rust en binarios . Primero, el compilador analiza el código fuente y lo convierte en un AST . A continuación, este AST se convierte en IR . Luego, se invoca el backend del compilador como un subcomponente para aplicar optimizaciones y traducir el IR resultante a código objeto . Finalmente, se utiliza un enlazador para combinar los objetos en una única imagen ejecutable. ^{[ 137 ]}

rustc utiliza LLVM como su backend de compilación por defecto, pero también admite el uso de backends alternativos como GCC y Cranelift . ^{[ 138 ]} La intención de esos backends alternativos es aumentar la cobertura de la plataforma de Rust o mejorar los tiempos de compilación. ^{[ 139 ] [ 140 ]}

Cargo es el sistema de compilación y gestor de paquetes de Rust . Descarga, compila, distribuye y sube paquetes —llamados crates— que se mantienen en un registro oficial. También actúa como interfaz para Clippy y otros componentes de Rust. ^{[ 141 ]}

Por defecto, Cargo obtiene sus dependencias del registro aportado por los usuarios crates.io , pero también se pueden especificar como dependencias repositorios Git , crates en el sistema de archivos local y otras fuentes externas. ^{[ 142 ]}

Cargo admite compilaciones reproducibles a través de dos archivos de metadatos: Cargo.toml y Cargo.lock. ^{[ 143 ]} Cargo.toml declara cada paquete utilizado y sus requisitos de versión. Cargo.lock se genera automáticamente durante la resolución de dependencias y registra las versiones exactas de todas las dependencias, incluidas las dependencias transitivas . ^{[ 144 ]}

Rustfmt es un formateador de código para Rust. Formatea los espacios en blanco y la indentación para producir código de acuerdo con un estilo común , a menos que se especifique lo contrario. Se puede invocar como un programa independiente o desde un proyecto Rust a través de Cargo. ^{[ 145 ]}

Clippy es la herramienta de análisis estático integrada de Rust para mejorar la corrección, el rendimiento y la legibilidad del código Rust. A partir de 2026, tiene más de 800 reglas. ^{[ 146 ] [ 147 ]}

Tras Rust 1.0, se desarrollan nuevas funcionalidades en versiones nocturnas , que se publican diariamente. Durante cada ciclo de lanzamiento de seis semanas, los cambios de las versiones nocturnas se publican en la versión beta, mientras que los cambios de la versión beta anterior se publican en una nueva versión estable. ^{[ 148 ]}

Cada dos o tres años se publica una nueva "edición". Las ediciones se lanzan para permitir realizar cambios incompatibles limitados , como la promoción awaita una palabra clave para admitir las características async/await . Los paquetes que apuntan a diferentes ediciones pueden interoperar entre sí, por lo que un paquete puede actualizarse a una nueva edición incluso si sus llamadores o sus dependencias aún apuntan a ediciones anteriores. La migración a una nueva edición puede facilitarse con herramientas automatizadas. ^{[ 149 ]}

rust-analyzer es un conjunto de utilidades que proporciona a los entornos de desarrollo integrados (IDE) y a los editores de texto información sobre un proyecto Rust a través del Protocolo de servidor de lenguaje . Esto habilita funciones como el autocompletado y la visualización de errores de compilación durante la edición de código. ^{[ 150 ]}

La Fundación Rust es una organización sin fines de lucro, constituida en Estados Unidos , que administra la marca registrada, la infraestructura y los activos de Rust. ^{[ 202 ] [ 46 ]}

Se estableció el 8 de febrero de 2021, con cinco miembros corporativos fundadores (Amazon Web Services, Huawei, Google, Microsoft y Mozilla). ^{[ 203 ]} El consejo de la fundación estuvo presidido por Shane Miller, ^{[ 204 ]} con Ashley Williams como directora ejecutiva interina. ^{[ 46 ]} A finales de 2021, Rebecca Rumbul se convirtió en directora ejecutiva y CEO. ^{[ 205 ]}

El proyecto Rust es mantenido por 8 equipos de alto nivel a partir de noviembre de 2025.: el consejo de liderazgo, el equipo del compilador, el equipo de herramientas de desarrollo, el equipo de infraestructura, el equipo de lenguaje, la plataforma de lanzamiento, el equipo de bibliotecas y el equipo de moderación. ^{[ 206 ]} El consejo de liderazgo supervisa el proyecto y está formado por representantes de los demás equipos. ^{[ 207 ]}