The Rust team just dropped their 2026 project goals, and there's a lot to be excited about. This isn't a minor release year — it's a year where several long-awaited features finally land on stable Rust.

Async Closures Are Here (Finally)

Async closures — functions that return futures — stabilized in Rust 1.85 (December 2025). If you've ever written code like this:

async fn fetch_data() -> String {
    let client = reqwest::Client::new();
    let response = client.get("https://api.example.com/data").send().await;
    response.text().await.unwrap()
}

You've been working around the lack of async closures. Now you can pass async logic as parameters:

fn with_async_callback<F>(callback: F)
where
    F: async Fn() -> String;

This seems small, but it's huge for library authors building async APIs.

Box — The End of Workarounds

For years, returning async traits required the async-trait crate:

#[async_trait]
trait Processor {
    async fn process(&self, data: Data) -> Result<Output>;
}

That's finally changing. The new Box<dyn async Trait> syntax lets you write:

trait Processor {
    async fn process(&self, data: Data) -> Result<Output>;
}

fn create_processor() -> Box<dyn Processor> { ... }

No proc macros. No extra dependencies. Just Rust.

Field Projection — Accessing Nested Data Without Destruction

This one is subtler but important. Currently, if you have a struct with a nested field that you want to borrow independently, Rust forces you to destructure:

struct Outer { inner: Inner }
struct Inner { value: i32 }

fn get_value(outer: &Outer) -> &i32 {
    let Inner { value } = &outer.inner; // Have to destructure
    value
}

Field projection lets you skip the intermediate step. It's a quality-of-life improvement for people writing performance-critical code who want to avoid unnecessary moves.

The Ergonomics Push

Beyond big features, there's a concerted push to make Rust feel less hostile to newcomers:

This isn't flashy, but it matters. The Rust team has explicitly called out "polished diagnostics" as a 2026 priority.

What This Means For You

If you're starting a new Rust project in 2026:

  1. You don't need async-trait anymore — write async traits directly
  2. Async closures work — pass async logic around without boxing it manually
  3. The compiler is friendlier — error messages are getting better

If you have existing code using async-trait, this is a good year to migrate. The crate will still work, but you won't need it.

The Bigger Picture

What's notable is what isn't here. Features like GATs (generic associated types) and full reflection are still in progress. The 2026 goals are deliberately scoped — they're finishing what they started rather than promising more.

That's actually reassuring. The Rust team could have listed 20 flagship features. They listed a handful of finished features. That's the difference between a language that promises and a language that delivers.

The first Rust 1.95+ release candidates should be out soon. Keep an eye on the Inside Rust blog for exact timelines.