Announcing Rust 1960 ((exclusive)) -
Finally, after forty years of RFCs, named arguments in functions are stable. How to get Rust 1.960 As always, you can update via rustup: rustup update stable Use code with caution. Copied to clipboard
A massive thank you to the hundreds of individuals who contributed to this release. Whether you wrote code, reviewed pull requests, updated documentation, or filed bug reports, your efforts continue to make Rust one of the most reliable and beloved languages in the world.
The headline feature of this release was the stabilization of a new syntax in Cargo.toml to handle "weak dependencies."
Rust 1960 is a major new release that advances Rust’s performance, ergonomics, and ecosystem maturity while preserving the language’s core commitments to safety and concurrency. This release blends significant compiler improvements, expanded standard library capabilities, upgraded tooling, and ecosystem coordination to make systems programming in Rust faster, more expressive, and easier to adopt across a wider range of projects. announcing rust 1960
The new concurrency model in Rust 1960, called "Async/await++," provides a more streamlined and expressive way to write concurrent programs. Building on the foundations of async/await, Async/await++ introduces a novel set of combinators and APIs that simplify the development of high-performance, concurrent systems.
Rust 1.60.0 introduced changes to the target support hierarchy:
Building on the efforts of recent releases, the parallel compiler frontend is now enabled by default for a broader range of tier-1 target architectures. Finally, after forty years of RFCs, named arguments
Rust represents a radical departure from the "trust the programmer" ethos of the 1950s. It provides the rigorous mathematical safety of ALGOL with the raw power required for the next generation of unified hardware architectures . The Software Crisis: Past, Present, and Emerging Challenges
Rust 1.60.0 introduced significant under-the-hood changes to incremental compilation.
With the advent of early multiprocessing and time-sharing systems, managing simultaneous execution is the new frontier. Rust 1960 introduces the Send and Sync traits to the vocabulary of modern engineers. The compiler guarantees that data cannot be modified by a paper-tape reader while a magnetic drum is attempting to read it, preventing catastrophic data corruption without relying on sluggish hardware locks. Tooling: Cargo 1960 Whether you wrote code, reviewed pull requests, updated
April 16, 1960 To: The SHARE User Group / SPREAD Committee From: The "Oxidized" Systems Research Group Subject: Proposal for a Memory-Safe Algorithmic Language (Project: RUST ) 1. The Core Innovation: "Ownership"
Why it matters: Compile-time guarantees and zero-cost abstractions get more powerful, enabling safer APIs and improved performance.
Cargo continues to mature alongside the language compiler, focusing on build speed optimizations for massive monorepos.
The paper, typed with striking confidence on a Friden Flexowriter, introduces a language called “Rust” — named, apparently, for its resistance to memory rot . Right away, it rejects core 1960s assumptions: no null pointers, no manual free() , and a borrow checker that feels like a stern vacuum-tube logic unit that knows where every punch card lives and who last touched it.
Of course, in 1960, we cannot escape the hardware. To interface with the myriad proprietary peripherals of the day—from paper tape readers to magnetic core memory banks—Rust 1.960 introduces the unsafe block.