Level 5 · Research· Lesson 9 of 9 · 40 min
The frontier: open problems and how to contribute
What is unsolved in Rust's design, semantics and tooling; how the language evolves; a doctoral reading list; and how to start doing research.
You have reached the end of the map. What remains is territory nobody has charted yet. This final lesson surveys the open problems, explains how Rust changes, and suggests how to begin contributing — as an engineer or as a researcher.
Language design moves quickly. Treat every statement here about the status of a feature as a pointer to go and check, not as a fact.
How Rust evolves
- RFCs. Substantial changes begin as a request for comments in the
rust-lang/rfcsrepository, are debated in public, and are accepted or declined by the responsible team (language, libraries, compiler, cargo…). - Nightly and feature gates. Accepted features are implemented behind
#![feature(...)]flags on the nightly toolchain, where they can change or be removed. - Stabilisation. A feature becomes stable only after a stabilisation report and a team decision. Once stable it is kept forever: Rust 1.0 code still compiles.
- Editions (2015, 2018, 2021, 2024) allow opt-in, per-crate source changes — new keywords, changed defaults — while all editions interoperate.
- Crater runs the test suites of the whole public ecosystem against a candidate compiler, turning “would this break anything?” into a measurement.
- Project goals are published each half-year, naming the efforts the teams have committed to.
- Teams: lang, types (type system, trait solver, borrow checker), opsem (operational semantics and undefined behaviour), compiler, libs-api, cargo, and many working groups.
To follow the work: the Inside Rust blog, This Week in Rust, the project-goals site, and the rust-lang Zulip.
Open problems: semantics and specification
A normative specification. For most of its life Rust was defined by its compiler. The Reference documents the language informally. In 2025 the FLS — the specification Ferrous Systems wrote for safety-critical qualification of the compiler — was transferred to the Rust Project to be maintained as an official document. It covers syntax and static semantics descriptively. A formal and complete semantics remains a goal: MiniRust for the dynamic semantics and a-mir-formality for the type system are the in-progress candidates.
The rules of unsafe code. Stacked Borrows or Tree Borrows — or a successor? Open questions tracked by the opsem team include: exactly when a reference must point to valid data; the precise treatment of UnsafeCell; uninitialised memory and padding; how provenance interacts with integer casts and with memcpy; and what a &mut to a zero-sized or partially overlapping region means. Each answer trades optimisation power against the amount of existing unsafe code declared incorrect.
Soundness of the type system. There is no end-to-end soundness proof for the real language. Long-standing holes — implied bounds (issue #25860), certain trait-object lifetime interactions — are known and tracked under the I-unsound label. The next-generation trait solver is the engineering path to closing them; a mechanised proof for a language the size of Rust is a research programme.
Weak memory. The thin-air problem, verified compilation to Arm and RISC-V, and the interaction of noalias with concurrency (previous lesson).
Open problems: language design
Polonius. A location-sensitive borrow checker that accepts conditional-return patterns and prepares the ground for richer borrows.
Self-referential and “place” borrows. Pin works but is hard to use. Proposals include safe pin projection and reborrowing built into the language, &pin references, in-place construction and move constructors, and field-projection traits. Can a struct soundly hold a reference into its own field in safe code — and what would its lifetime be called?
Async. async fn in traits and async closures are stable. Still open: dynamic dispatch for async traits without boxing by hand; async drop (cleanup that must await); async iteration (streams and generators, gen blocks); structured concurrency and scoped tasks — which collide with the fact that leaking is safe; and a standard interface so libraries need not be tied to one runtime.
Linear and unforgettable types. Types that must be consumed, or cannot be leaked (?Leak, “must-move”), would make scoped tasks and certain FFI and embedded protocols sound, and enable session types. Retrofitting them touches every generic API and interacts with panics.
Effect genericity. Today const, async, unsafe, fallibility and (unstable) generators are separate “colours” of function, and library authors duplicate APIs across them. Const traits are the furthest along; a general, usable effect system for Rust is an open design question — as is whether it is worth its complexity.
Specialization. A sound, general design that does not let type checking and code generation disagree on lifetimes.
Const generics and compile-time computation. generic_const_exprs (types such as [T; N + 1]), const generics over user-defined types, and the limits of const fn (trait calls, allocation). How much dependently-typed power can be added while keeping type checking decidable and error messages readable?
Variadic generics. Abstracting over tuples and function arities, currently simulated with macros that stop at twelve.
Safe transmutation. A compiler-checked trait stating when one type’s bytes may be reinterpreted as another’s, replacing a family of unsafe code and procedural macros.
Contracts. First-class preconditions and postconditions in the language, checked dynamically in debug builds and usable by verifiers — connecting everyday code to the tools of lesson 5.7.
Allocators and fallibility. A stable Allocator API, collections that report allocation failure, and custom allocation in a world of Box<dyn Trait> — pressing for kernels and embedded systems.
Compile times. A parallel front end, a faster default linker, the Cranelift backend for debug builds, better incremental reuse, and cutting monomorphization bloat (polymorphization). Arguably the most important open problem for everyday users.
Interoperability. A stable Rust ABI for dynamic linking (crabi); better C++ interop; and Rust in the Linux kernel, which continuously surfaces new requirements — pinned initialisation, custom allocation, memory-model questions — and drives language features.
Open problems: verification and tooling
- A verified or translation-validated compilation path for safety-critical use (cf. CompCert for C), and qualification of the toolchain to standards such as ISO 26262 and DO-178C.
- Verifying the standard library’s unsafe code (the
verify-rust-stdchallenges). - Verification tools that handle
unsafe, traits, closures and concurrency uniformly, with specifications that can be shared between tools. - Miri at scale: faster execution, FFI, more complete concurrency exploration.
- Supply-chain security: provenance of crates, auditing (
cargo-vet), reproducible builds, sandboxed build scripts and procedural macros. - Empirical work: how programmers actually learn ownership; which unsafe patterns occur in the wild and how often they are wrong; the measured security impact of adopting Rust.
A doctoral reading list
Foundations
- Pierce, Types and Programming Languages; then Advanced Topics in Types and Programming Languages (the substructural-types chapter).
- Harper, Practical Foundations for Programming Languages.
- Wadler, “Linear types can change the world!”; Tofte and Talpin, “Region-Based Memory Management”; Grossman et al. on Cyclone.
Rust’s semantics
- Jung, Understanding and Evolving the Rust Programming Language (thesis).
- Jung et al., “RustBelt” (POPL 2018) and “Safe Systems Programming in Rust” (CACM 2021).
- Jung et al., “Stacked Borrows” (POPL 2020); Villani et al., “Tree Borrows” (PLDI 2025).
- Weiss et al., “Oxide: The Essence of Rust”.
- RFC 2094 (NLL); Matsakis’s Polonius posts.
- Yanovski et al., “GhostCell” (ICFP 2021).
Verification
- Jung et al., “Iris from the ground up”.
- Matsushita et al., “RustHorn” and “RustHornBelt”; Denis et al., “Creusot”; Astrauskas et al., Prusti; Lattuada et al., “Verus”; Ho and Protzenko, “Aeneas”; Gäher et al., “RefinedRust”.
Concurrency
- Herlihy and Shavit, The Art of Multiprocessor Programming.
- Batty et al., “Mathematizing C++ Concurrency”; Lahav et al., “Repairing Sequential Consistency”; Kang et al., “A Promising Semantics”.
- Dang et al., “RustBelt Meets Relaxed Memory”.
- Bos, Rust Atomics and Locks.
Systems built in Rust
- Levy et al., “Multiprogramming a 64 kB Computer Safely and Efficiently” (Tock; SOSP 2017).
- Boos et al., “Theseus: an Experiment in Operating System Structure and State Management” (OSDI 2020).
- Narayanan et al., “RedLeaf: Isolation and Communication in a Safe Operating System” (OSDI 2020).
- Anderson et al., “Engineering the Servo Web Browser Engine using Rust” (2016).
- Klabnik and Matsakis’s talks on the language’s design history; Matsakis and Turon’s blogs.
Empirical studies
- Astrauskas et al., “How Do Programmers Use Unsafe Rust?” (OOPSLA 2020).
- Evans, Campbell and Soffa, “Is Rust Used Safely by Software Developers?” (ICSE 2020).
- Qin et al., “Understanding Memory and Thread Safety Practices and Issues in Real-World Rust Programs” (PLDI 2020).
- Bae et al., “Rudra: Finding Memory Safety Bugs in Rust at the Ecosystem Scale” (SOSP 2021).
- Crichton et al., “A Grounded Conceptual Model for Ownership Types in Rust” (OOPSLA 2023).
Venues to watch: POPL, PLDI, OOPSLA, ICFP, ESOP (languages); CAV, FM (verification); SOSP, OSDI, EuroSys, USENIX Security (systems); the Rust Verification Workshop; RustConf and EuroRust for practice.
How to start
As a contributor
- Use nightly on a side project and report bugs with minimal reproductions.
- Pick an
E-easyorE-mentorissue inrust-lang/rust,rust-clippy,miri,cargoorrust-analyzer. Diagnostics and lints are the classic entry points. - Read the rustc dev guide alongside the code. Ask on Zulip — the project is unusually welcoming to questions.
- Help with the unglamorous work that every release needs: triage, documentation, test minimisation, crater analysis.
As a researcher
- Reproduce before you extend. Mechanise a small calculus (an affine lambda calculus with borrows) in Rocq, Lean or Agda. Run Miri under both aliasing models on real crates and read the reports. Verify a small data structure in Verus or Creusot.
- Find the question in the artefact. Good problems often appear as an
I-unsoundissue, a pattern Miri rejects that everyone writes, a feature request that has been stuck for five years, or a proof that would not go through. - Stay close to the implementation. Rust is unusual in that researchers and language designers work in the open, on the same Zulip, and papers do change the language — Stacked Borrows shaped Miri and the UB rules; RustBelt found library bugs; Polonius and Oxide share a model.
- Evaluate against the ecosystem. crates.io is a corpus of well over a hundred thousand packages with tests. Claims about what “real Rust code” does can and should be measured.
- Write for both audiences. A result that the compiler team can act on is worth more than one that only type theorists can read.
Final checkpoint
You have completed the path if you can:
- Explain ownership as an affine type discipline and lifetimes as regions, and name the systems they descend from.
- Describe how NLL computes regions and what Polonius changes.
- Explain what provenance is and how Stacked and Tree Borrows define aliasing UB.
- Read a trait goal as a logic query, and explain coherence and one known soundness hole.
- Sketch the semantic soundness argument of RustBelt and what a library author must prove.
- Choose a verification tool for a given assurance goal, and state its trusted base.
- State DRF-SC, and explain the thin-air problem.
- Name three open problems you find interesting enough to work on.
That last item is the real graduation requirement. Pick one, and begin.
Check your understanding
Pick an answer to see the explanation.
1.Which of these is currently an open design problem rather than a settled part of Rust?
2.What is crater used for?
3.Why do editions not split the ecosystem?