Rust 1.99 Ships With Stable C-Variadic Functions and Expanded APIs

by Geth Author

The Rust programming language shipped version 1.99 on October 1, 2026, landing one of the most requested low-level features in the language's history: the ability to define C-compatible variadic functions in stable Rust.

C-Variadic Functions Are Finally Stable

C has long supported functions that accept a variable number of arguments — think printf. Until now, Rust developers who needed to expose this interface (for FFI purposes, or to write code that C libraries can call directly) had to use unsafe nightly-only features that could break without notice. Rust 1.99 stabilizes unsafe extern "C" fn foo(args: ...) syntax on the stable channel, no feature flags required.

This matters most for projects doing systems programming, writing C-compatible APIs, or building FFI layers between Rust and C or C++ codebases. It removes a meaningful barrier for anyone trying to replace a C library with a Rust implementation that existing callers can use without modification.

Raw Pointer Layout APIs

Rust 1.99 also stabilizes new APIs for inspecting raw pointer layout — specifically, the ability to query size and alignment information from raw pointers to dynamically sized data. This fills a longstanding gap for unsafe code that works close to the metal, making certain patterns less error-prone without requiring workarounds.

Standard Library Additions

The release packs a sizeable collection of standard library stabilizations:

  • New Vec methods for decomposing and rebuilding allocations — useful for writing zero-copy data structures
  • Support for processing invalid UTF-8 without unnecessary copying
  • New filesystem timestamp APIs
  • Iterator and memory handling additions across several types

Cargo and RISC-V

The default dev debug profile in Cargo gets a tweak in this release. RISC-V Tier 2 target support also expands, continuing Rust's push into embedded and alternative-architecture contexts — an area where the language has been gaining serious ground.

Why It Matters

Rust's adoption in systems programming, Linux kernel development, and safety-critical applications continues to accelerate. Each release that smooths FFI boundaries and reduces the friction of interoperating with existing C codebases makes Rust more practical for projects that can't afford a clean-room rewrite — which describes most of the important infrastructure software running today. Stable C-variadic functions is a small feature with a long tail of practical consequences.