Rust 1.30: What's New, Release History & Support Lifecycle

What Is New in Rust 1.30

How can I write custom attribute-like and function-like procedural macros in Rust 1.30?

Rust 1.30 adds stable support for attribute-like and function-like procedural macros, letting you generate code beyond #[derive].

These macros receive raw token streams and return generated code, enabling powerful DSLs and framework integrations.

• Attribute-like macro signature:

  #[proc_macro_attribute]
  pub fn my_attr(attr: TokenStream, item: TokenStream) -> TokenStream { ... }

• Function-like macro signature:

  #[proc_macro]
  pub fn my_macro(input: TokenStream) -> TokenStream { ... }

Example usage in a web framework:

#[route(GET, "/")]
fn index() {
    // handler body
}

Because the proc_macro crate is now stable, crates like syn and quote can be used without nightly features.

What changes were made to the module system and import paths in Rust 1.30?

Rust 1.30 unifies path resolution so that external crates are automatically in scope and the crate keyword can be used in any path.

Key adjustments:

• External crates no longer need a leading ::; serde_json::from_str works from any module.
• The crate keyword explicitly starts a path at the crate root, removing the confusing mix of absolute and relative paths.
• Import statements still begin at the crate root, but regular expressions now follow the same rules as other paths.

Before:

mod foo {
    fn bar() {
        ::serde_json::from_str("...");
    }
}

After:

mod foo {
    fn bar() {
        serde_json::from_str("...");
        // or crate::foo::bar() for internal items
    }
}

How can I use Rust keywords as identifiers with the new raw identifier syntax?

Rust 1.30 introduces raw identifiers, allowing keywords to be used as variable or function names by prefixing them with r#.

This is useful when interfacing between editions or when generating code that collides with future keywords.

let r#for = true;
fn r#match() { /* ... */ }
r#match();

The syntax works everywhere a normal identifier is allowed, and the compiler treats the name literally without reserving it.

How does Rust 1.30 enable building no_std applications with a custom panic handler?

Rust 1.30 stabilizes the #[panic_handler] attribute, allowing developers to define their own panic routine for no_std binaries.

With this attribute you can now ship bare-metal or embedded executables that do not link the standard library.

#![no_std]

#[panic_handler]
fn panic(_info: &core::panic::PanicInfo) -> ! {
    loop {}
}

Prior to 1.30 only libraries could be no_std; now full applications can be built without the standard library.

Which standard library APIs were stabilized or renamed in Rust 1.30?

Rust 1.30 stabilizes several convenience APIs and renames whitespace-trimming methods for better Unicode clarity.

• New constants: Ipv4Addr::BROADCAST, Ipv4Addr::LOCALHOST, Ipv4Addr::UNSPECIFIED, Ipv6Addr::LOCALHOST, Ipv6Addr::UNSPECIFIED.
• Iterator extension: Iterator::find_map combines find and map in one pass.
• Trim method rename: trim_left → trim_start, trim_right → trim_end, and the corresponding *_matches variants.

The old trim_left/trim_right names are deprecated and will be removed in a future release.