FerrousPath

Nivel 5 · Investigación· Lección 9 de 9 · 40 min

La frontera: problemas abiertos y cómo contribuir

Qué está sin resolver en el diseño, la semántica y las herramientas de Rust; cómo evoluciona el lenguaje; una lista de lecturas de doctorado; y cómo empezar a investigar.

Has llegado al final del mapa. Lo que queda es un territorio que nadie ha cartografiado todavía. Esta última lección repasa los problemas abiertos, explica cómo cambia Rust y sugiere cómo empezar a contribuir, como ingeniero o como investigador.

El diseño de lenguajes se mueve deprisa. Trata toda afirmación de aquí sobre el estado de una característica como una indicación para ir a comprobarlo, no como un hecho.

Cómo evoluciona Rust

  • RFC. Los cambios sustanciales empiezan como una petición de comentarios (request for comments) en el repositorio rust-lang/rfcs, se debaten en público y los acepta o los rechaza el equipo responsable (lenguaje, bibliotecas, compilador, cargo…).
  • Nightly y puertas de características. Las características aceptadas se implementan tras las banderas #![feature(...)] de la toolchain nightly, donde pueden cambiar o eliminarse.
  • Estabilización. Una característica solo pasa a ser estable después de un informe de estabilización y de una decisión del equipo. Una vez estable se conserva para siempre: el código de Rust 1.0 sigue compilando.
  • Las ediciones (2015, 2018, 2021, 2024) permiten cambios en el código fuente voluntarios y por crate —palabras clave nuevas, valores por defecto distintos— mientras todas las ediciones interoperan.
  • Crater ejecuta los conjuntos de pruebas de todo el ecosistema público con un compilador candidato, lo que convierte «¿rompería esto algo?» en una medición.
  • Los objetivos del proyecto se publican cada semestre, y nombran los esfuerzos con los que se han comprometido los equipos.
  • Equipos: lang, types (sistema de tipos, resolutor de traits, borrow checker), opsem (semántica operacional y comportamiento indefinido), compiler, libs-api, cargo y muchos grupos de trabajo.

Para seguir el trabajo: el blog Inside Rust, This Week in Rust, el sitio de los objetivos del proyecto y el Zulip de rust-lang.

Problemas abiertos: semántica y especificación

Una especificación normativa. Durante la mayor parte de su vida, Rust estuvo definido por su compilador. La Reference documenta el lenguaje de manera informal. En 2025, la FLS —la especificación que Ferrous Systems escribió para la cualificación del compilador en entornos críticos para la seguridad— se transfirió al Proyecto Rust para mantenerla como documento oficial. Cubre la sintaxis y la semántica estática de forma descriptiva. Una semántica formal y completa sigue siendo un objetivo: MiniRust para la semántica dinámica y a-mir-formality para el sistema de tipos son los candidatos en curso.

Las reglas del código unsafe. ¿Stacked Borrows o Tree Borrows, o un sucesor? Entre las cuestiones abiertas que sigue el equipo opsem están: cuándo exactamente debe apuntar una referencia a datos válidos; el tratamiento preciso de UnsafeCell; la memoria sin inicializar y el relleno; cómo interactúa la procedencia con las conversiones a enteros y con memcpy; y qué significa un &mut a una región de tamaño cero o parcialmente solapada. Cada respuesta cambia potencia de optimización por cantidad de código unsafe existente que se declara incorrecto.

La corrección del sistema de tipos. No hay una demostración de corrección de extremo a extremo para el lenguaje real. Los agujeros de larga duración —las restricciones implícitas (incidencia #25860), ciertas interacciones de lifetimes con trait objects— se conocen y se siguen bajo la etiqueta I-unsound. El resolutor de traits de nueva generación es el camino de ingeniería para cerrarlos; una demostración mecanizada para un lenguaje del tamaño de Rust es un programa de investigación.

Memoria débil. El problema de los valores surgidos de la nada (thin-air), la compilación verificada a Arm y RISC-V, y la interacción de noalias con la concurrencia (lección anterior).

Problemas abiertos: diseño del lenguaje

Polonius. Un borrow checker sensible a la ubicación que acepte los patrones de retorno condicional y prepare el terreno para préstamos más ricos.

Préstamos autorreferenciales y «de lugar». Pin funciona, pero es difícil de usar. Entre las propuestas están la proyección de pin segura y el reborrowing incorporados en el lenguaje, las referencias &pin, la construcción en el sitio y los constructores de movimiento, y los traits de proyección de campos. ¿Puede un struct guardar de forma correcta, en código seguro, una referencia a su propio campo? ¿Y cómo se llamaría su lifetime?

Async. async fn en traits y las clausuras async son estables. Sigue abierto: el despacho dinámico para traits async sin tener que meter a mano en un box; el drop asíncrono (limpieza que tiene que esperar); la iteración asíncrona (streams y generadores, bloques gen); la concurrencia estructurada y las tareas con ámbito, que chocan con el hecho de que las fugas son seguras; y una interfaz estándar para que las bibliotecas no tengan que estar atadas a un runtime.

Tipos lineales e inolvidables. Los tipos que deben consumirse, o que no pueden perderse (?Leak, «de movimiento obligatorio»), harían correctas las tareas con ámbito y ciertos protocolos de FFI y de sistemas embebidos, y harían posibles los tipos de sesión. Incorporarlos a posteriori toca todas las API genéricas e interactúa con los pánicos.

Genericidad de efectos. Hoy const, async, unsafe, la falibilidad y los generadores (inestables) son «colores» de función separados, y quienes escriben bibliotecas duplican las API para cada uno. Los traits const son lo más avanzado; un sistema de efectos general y utilizable para Rust es una cuestión de diseño abierta, igual que la de si merece la complejidad que trae.

Especialización. Un diseño general y correcto que no permita que la comprobación de tipos y la generación de código discrepen sobre los lifetimes.

Genéricos constantes y cálculo en tiempo de compilación. generic_const_exprs (tipos como [T; N + 1]), genéricos constantes sobre tipos definidos por el usuario y los límites de const fn (llamadas a traits, reserva de memoria). ¿Cuánta potencia de tipos dependientes se puede añadir manteniendo decidible la comprobación de tipos y legibles los mensajes de error?

Genéricos variádicos. Abstraer sobre tuplas y aridades de función, algo que hoy se simula con macros que se detienen en doce.

Transmutación segura. Un trait comprobado por el compilador que diga cuándo los bytes de un tipo pueden reinterpretarse como los de otro, y que sustituya a toda una familia de código unsafe y de macros procedurales.

Contratos. Precondiciones y postcondiciones de primera clase en el lenguaje, comprobadas dinámicamente en las compilaciones debug y utilizables por los verificadores: conectan el código de todos los días con las herramientas de la lección 5.7.

Asignadores y falibilidad. Una API Allocator estable, colecciones que informen de los fallos de reserva, y reserva personalizada en un mundo de Box<dyn Trait>: algo urgente para los kernels y los sistemas embebidos.

Tiempos de compilación. Un front end paralelo, un enlazador por defecto más rápido, el backend Cranelift para las compilaciones debug, una mejor reutilización incremental y reducir el abultamiento por monomorfización (polimorfización). Posiblemente el problema abierto más importante para quienes usan Rust a diario.

Interoperabilidad. Una ABI de Rust estable para el enlazado dinámico (crabi); una mejor interoperabilidad con C++; y Rust en el kernel de Linux, que saca a la luz continuamente requisitos nuevos —inicialización fijada (pinned), reserva personalizada, cuestiones del modelo de memoria— e impulsa características del lenguaje.

Problemas abiertos: verificación y herramientas

  • Un camino de compilación verificado, o validado por traducción, para usos críticos para la seguridad (como CompCert para C), y la cualificación de la toolchain según normas como ISO 26262 y DO-178C.
  • Verificar el código unsafe de la biblioteca estándar (los retos de verify-rust-std).
  • Herramientas de verificación que traten de manera uniforme unsafe, los traits, las clausuras y la concurrencia, con especificaciones que puedan compartirse entre herramientas.
  • Miri a gran escala: ejecución más rápida, FFI, una exploración de la concurrencia más completa.
  • Seguridad de la cadena de suministro: procedencia de los crates, auditoría (cargo-vet), compilaciones reproducibles, scripts de compilación y macros procedurales en un entorno aislado.
  • Trabajo empírico: cómo aprenden realmente los programadores la propiedad; qué patrones de unsafe aparecen en el mundo real y con qué frecuencia son incorrectos; el impacto medido en la seguridad de adoptar Rust.

Una lista de lecturas de doctorado

Fundamentos

  1. Pierce, Types and Programming Languages; después Advanced Topics in Types and Programming Languages (el capítulo de tipos subestructurales).
  2. Harper, Practical Foundations for Programming Languages.
  3. Wadler, «Linear types can change the world!»; Tofte y Talpin, «Region-Based Memory Management»; Grossman et al. sobre Cyclone.

La semántica de Rust

  1. Jung, Understanding and Evolving the Rust Programming Language (tesis).
  2. Jung et al., «RustBelt» (POPL 2018) y «Safe Systems Programming in Rust» (CACM 2021).
  3. Jung et al., «Stacked Borrows» (POPL 2020); Villani et al., «Tree Borrows» (PLDI 2025).
  4. Weiss et al., «Oxide: The Essence of Rust».
  5. RFC 2094 (NLL); las entradas de Matsakis sobre Polonius.
  6. Yanovski et al., «GhostCell» (ICFP 2021).

Verificación

  1. Jung et al., «Iris from the ground up».
  2. Matsushita et al., «RustHorn» y «RustHornBelt»; Denis et al., «Creusot»; Astrauskas et al., Prusti; Lattuada et al., «Verus»; Ho y Protzenko, «Aeneas»; Gäher et al., «RefinedRust».

Concurrencia

  1. Herlihy y Shavit, The Art of Multiprocessor Programming.
  2. Batty et al., «Mathematizing C++ Concurrency»; Lahav et al., «Repairing Sequential Consistency»; Kang et al., «A Promising Semantics».
  3. Dang et al., «RustBelt Meets Relaxed Memory».
  4. Bos, Rust Atomics and Locks.

Sistemas construidos en Rust

  1. Levy et al., «Multiprogramming a 64 kB Computer Safely and Efficiently» (Tock; SOSP 2017).
  2. Boos et al., «Theseus: an Experiment in Operating System Structure and State Management» (OSDI 2020).
  3. Narayanan et al., «RedLeaf: Isolation and Communication in a Safe Operating System» (OSDI 2020).
  4. Anderson et al., «Engineering the Servo Web Browser Engine using Rust» (2016).
  5. Las charlas de Klabnik y Matsakis sobre la historia del diseño del lenguaje; los blogs de Matsakis y de Turon.

Estudios empíricos

  1. Astrauskas et al., «How Do Programmers Use Unsafe Rust?» (OOPSLA 2020).
  2. Evans, Campbell y Soffa, «Is Rust Used Safely by Software Developers?» (ICSE 2020).
  3. Qin et al., «Understanding Memory and Thread Safety Practices and Issues in Real-World Rust Programs» (PLDI 2020).
  4. Bae et al., «Rudra: Finding Memory Safety Bugs in Rust at the Ecosystem Scale» (SOSP 2021).
  5. Crichton et al., «A Grounded Conceptual Model for Ownership Types in Rust» (OOPSLA 2023).

Congresos que conviene seguir: POPL, PLDI, OOPSLA, ICFP, ESOP (lenguajes); CAV, FM (verificación); SOSP, OSDI, EuroSys, USENIX Security (sistemas); el Rust Verification Workshop; RustConf y EuroRust para la práctica.

Cómo empezar

Como contribuidor

  1. Usa nightly en un proyecto personal e informa de los errores con reproducciones mínimas.
  2. Elige una incidencia E-easy o E-mentor en rust-lang/rust, rust-clippy, miri, cargo o rust-analyzer. Los diagnósticos y los lints son los puntos de entrada clásicos.
  3. Lee la rustc dev guide junto al código. Pregunta en Zulip: el proyecto es inusualmente acogedor con las preguntas.
  4. Ayuda con el trabajo poco vistoso que necesita cada versión: clasificación de incidencias, documentación, minimización de pruebas, análisis de crater.

Como investigador

  1. Reproduce antes de ampliar. Mecaniza un cálculo pequeño (un cálculo lambda afín con préstamos) en Rocq, Lean o Agda. Ejecuta Miri con los dos modelos de aliasing sobre crates reales y lee los informes. Verifica una estructura de datos pequeña en Verus o en Creusot.
  2. Encuentra la pregunta en el artefacto. Los buenos problemas aparecen a menudo como una incidencia I-unsound, un patrón que Miri rechaza y que todo el mundo escribe, una petición de característica que lleva cinco años atascada o una demostración que no salía.
  3. Mantente cerca de la implementación. Rust es inusual en que los investigadores y los diseñadores del lenguaje trabajan en abierto, en el mismo Zulip, y los artículos sí cambian el lenguaje: Stacked Borrows dio forma a Miri y a las reglas del UB; RustBelt encontró errores en la biblioteca; Polonius y Oxide comparten un modelo.
  4. Evalúa contra el ecosistema. crates.io es un corpus de mucho más de cien mil paquetes con pruebas. Las afirmaciones sobre lo que hace «el código real de Rust» pueden y deben medirse.
  5. Escribe para los dos públicos. Un resultado con el que el equipo del compilador puede hacer algo vale más que uno que solo pueden leer los teóricos de tipos.

Punto de control final

Has completado el camino si puedes:

  • Explicar la propiedad como una disciplina de tipos afín y los lifetimes como regiones, y nombrar los sistemas de los que descienden.
  • Describir cómo calcula NLL las regiones y qué cambia Polonius.
  • Explicar qué es la procedencia y cómo definen Stacked Borrows y Tree Borrows el UB por aliasing.
  • Leer un objetivo de trait como una consulta lógica, y explicar la coherencia y un agujero de corrección conocido.
  • Esbozar el argumento de corrección semántica de RustBelt y lo que debe demostrar quien escribe una biblioteca.
  • Elegir una herramienta de verificación para un objetivo de garantía dado, e indicar su base de confianza.
  • Enunciar DRF-SC y explicar el problema de los valores surgidos de la nada.
  • Nombrar tres problemas abiertos que te parezcan lo bastante interesantes como para trabajar en ellos.

Ese último punto es el verdadero requisito para graduarse. Elige uno y empieza.

Comprueba lo que has entendido

Elige una respuesta para ver la explicación.

  1. 1.¿Cuál de estas cosas es hoy un problema de diseño abierto y no una parte asentada de Rust?

  2. 2.¿Para qué se usa crater?

  3. 3.¿Por qué las ediciones no dividen el ecosistema?

¿Has terminado la lección y los ejercicios?