Skip to content

Releases: rust-lang/rust

Rust 1.7.0

10 Sep 08:07
@rustbot rustbot
1.7.0
a5d1e7a

Choose a tag to compare

View all tags
Rust 1.7.0

Libraries

Misc

Cargo

Compatibility Notes

  • Soundness fixes to the interactions between associated types and lifetimes, specified in RFC 1214, now generate errors for code that violates the new rules. This is a significant change that is known to break existing code, so it has emitted warnings for the new error cases since 1.4 to give crate authors time to adapt. The details of what is changing are subtle; read the RFC for more.
  • Several bugs in the compiler's visibility calculations were fixed. Since this was found to br...
Read more
Loading

Rust 1.6.0

10 Sep 08:08
@rustbot rustbot
1.6.0
c30b771

Choose a tag to compare

View all tags
Rust 1.6.0

Language

  • The #![no_std] attribute causes a crate to not be linked to the standard library, but only the core library, as described in RFC 1184. The core library defines common types and traits but has no platform dependencies whatsoever, and is the basis for Rust software in environments that cannot support a full port of the standard library, such as operating systems. Most of the core library is now stable.

Libraries

Cargo

  • Cargo will look in $CARGO_HOME/bin for subcommands by default.
  • Cargo build scripts can specify their dependencies by emitting the rerun-if-changed key.
  • crates.io will reject publication of crates with dependencies that have a wildcard version constraint. Crates with wildcard dependencies were seen to cause a variety of problems, as described in RFC 1241. Since 1.5 publication of such crates has emitted a warning.
  • cargo clean accepts a --release flag to clean the release folder. A variety of artifacts that Cargo failed to clean are now correctly deleted.

Misc

Compatibility Notes

Loading

Rust 1.5.0

10 Sep 08:08
@rustbot rustbot
1.5.0
3d7cd77

Choose a tag to compare

View all tags
Rust 1.5.0
  • ~700 changes, numerous bugfixes

Highlights

Breaking Changes

Language

  • When evaluating expressions at compile-time that are not compile-time constants (const-evaluating expressions in non-const contexts), incorrect code such as overlong bitshifts and arithmetic overflow will generate a warning instead of an error, delaying the error until runtime. This will allow the const-evaluator to be expanded in the future backwards-compatibly.
  • The improper_ctypes lint no longer warns about using isize and usize in FFI.

Libraries

Read more
Loading

Rust 1.4.0

10 Sep 05:53
@rustbot rustbot
1.4.0
8ab8581

Choose a tag to compare

View all tags
Rust 1.4.0
  • ~1200 changes, numerous bugfixes

Highlights

  • Windows builds targeting the 64-bit MSVC ABI and linker (instead of GNU) are now supported and recommended for use.

Breaking Changes

Language

Libraries

Miscellaneous

Loading

Rust 1.3.0

10 Sep 08:08
@rustbot rustbot
1.3.0
9a92aaf

Choose a tag to compare

View all tags
Rust 1.3.0
  • ~900 changes, numerous bugfixes

Highlights

  • The new object lifetime defaults have been turned on after a cycle of warnings about the change. Now types like &'a Box<Trait> (or &'a Rc<Trait>, etc) will change from being interpreted as &'a Box<Trait+'a> to &'a Box<Trait+'static>.
  • The Rustonomicon is a new book in the official documentation that dives into writing unsafe Rust.
  • The Duration API, has been stabilized. This basic unit of timekeeping is employed by other std APIs, as well as out-of-tree time crates.

Breaking Changes

Language

Libraries

Misc

  • Rust can now, with some coercion, produce programs that run on Windows XP, though XP is not considered a supported platform.
  • Porting Rust on Windows from the GNU toolchain to MSVC continues (1, 2, 3, 4). It is still not recommended for use in 1.3, though should be fully-functional in the 64-bit 1.4 beta.
  • On Fedora-based systems installation will properly configure the dynamic linker.
  • The compiler gained many new extended error descriptions, which can be accessed with the --explain flag.
  • The dropck pass, which checks that destructors can't access destroyed values, has been rewritten. This fixes ...
Read more
Loading

Rust 1.2.0

10 Sep 05:53
@rustbot rustbot
1.2.0
082e476

Choose a tag to compare

View all tags
Rust 1.2.0
  • ~1200 changes, numerous bugfixes

Highlights

Breaking Changes

Language

  • Patterns with ref mut now correctly invoke DerefMut when matching against dereferenceable values.

Libraries

  • The Extend trait, which grows a collection from an iterator, is implemented over iterators of references, for String, Vec, LinkedList, VecDeque, EnumSet, BinaryHeap, VecMap, BTreeSet and BTreeMap. RFC.
  • The iter::once function returns an iterator that yields a single element, and iter::empty returns an iterator that yields no elements.
  • The matches and rmatches methods on str return iterators over substring matches.
  • Cell and RefCell both implement Eq.
  • A number of methods for wrapping arithmetic are added to the integral types, wrapping_div, wrapping_rem, wrapping_neg, wrapping_shl, wrapping_shr. These are in addition to the existing wrapping_add, wrapping_sub, and wrapping_mul methods, and alternatives to the Wrapping type.. It is illegal for the default arithmetic operations in Rust to overflow; the desire to wrap must be explicit.
  • The {:#?} formatting specifier displays the alternate, pretty-printed form of the Debug formatter. This feature was actually introduced prior to 1.0 with little fanfare.
  • fmt::Formatter implements fmt::Write, a fmt-specific trait for writing data to formatted strings, similar to io::Write.
  • fmt::Formatter adds 'debug builder' methods, debug_struct, debug_tuple, debug_list, debug_set, debug_map. These are used by code generators to emit implementations of Debug.
  • str has new to_uppercase and to_lowercase methods that convert case, following Unicode case mapping.
  • It is now easier to handle poisoned locks. The PoisonError type, returned by failing lock operations, exposes into_inner, get_ref, and get_mut, which all give access to the inner lock guard, and allow the poisoned lock to continue to operate. The is_poisoned method of RwLock and Mutex can poll for a poisoned lock without attempting to take the lock.
  • On Unix the FromRawFd trait is implemented for Stdio, and AsRawFd for ChildStdin, ChildStdout, ChildStderr. On Windows the FromRawHandle trait is implemented for Stdio, and AsRawHandle for ChildStdin, ChildStdout, ChildStderr.
  • io::ErrorKind has a new variant, InvalidData, which indicates malformed input.

Misc

Loading

Rust 1.1.0

10 Sep 08:07
@rustbot rustbot
1.1.0
35ceea3

Choose a tag to compare

View all tags
Rust 1.1.0
  • ~850 changes, numerous bugfixes

Highlights

  • The std::fs module has been expanded to expand the set of functionality exposed:
    • DirEntry now supports optimizations like file_type and metadata which don't incur a syscall on some platforms.
    • A symlink_metadata function has been added.
    • The fs::Metadata structure now lowers to its OS counterpart, providing access to all underlying information.
  • The compiler now contains extended explanations of many errors. When an error with an explanation occurs the compiler suggests using the --explain flag to read the explanation. Error explanations are also available online.
  • Thanks to multiple improvements to type checking, as well as other work, the time to bootstrap the compiler decreased by 32%.

Libraries

Misc

Loading

Rust 1.0.0

10 Sep 08:07
@rustbot rustbot
1.0.0
a59de37

Choose a tag to compare

View all tags
Rust 1.0.0
  • ~1500 changes, numerous bugfixes

Highlights

  • The vast majority of the standard library is now #[stable]. It is no longer possible to use unstable features with a stable build of the compiler.
  • Many popular crates on crates.io now work on the stable release channel.
  • Arithmetic on basic integer types now checks for overflow in debug builds.

Language

Libraries

Misc

  • Many errors now have extended explanations that can be accessed with the --explain flag to rustc.
  • Many new examples have been added to the standard library documentation.
  • rustdoc has received a number of improvements focused on completion and polish.
  • Metadata was tuned, shrinking binaries by 27%.
  • Much headway was made on ecosystem-wide CI, making it possible to compare builds for breakage.
Loading

Rust 1.0.0-alpha.2

10 Sep 08:08
@rustbot rustbot
1.0.0-alpha.2
522d09d

Choose a tag to compare

View all tags
Rust 1.0.0-alpha.2

  • ~1300 changes, numerous bugfixes

  • Highlights

    • The various I/O modules were overhauled to reduce unnecessary abstractions and provide better interoperation with the underlying platform. The old io module remains temporarily at std::old_io.
    • The standard library now participates in feature gating, so use of unstable libraries now requires a #![feature(...)] attribute. The impact of this change is described on the forum. RFC.

  • Language

    • for loops now operate on the IntoIterator trait, which eliminates the need to call .iter(), etc. to iterate over collections. There are some new subtleties to remember though regarding what sort of iterators various types yield, in particular that for foo in bar { } yields values from a move iterator, destroying the original collection. RFC.
    • Objects now have default lifetime bounds, so you don't have to write Box<Trait+'static> when you don't care about storing references. RFC.
    • In types that implement Drop, lifetimes must outlive the value. This will soon make it possible to safely implement Drop for types where #[unsafe_destructor] is now required. Read the gorgeous RFC for details.
    • The fully qualified ::X syntax lets you set the Self type for a trait method or associated type. RFC.
    • References to types that implement Deref<U> now automatically coerce to references to the dereferenced type U, e.g. &T where T: Deref<U> automatically coerces to &U. This should eliminate many unsightly uses of &*, as when converting from references to vectors into references to slices. RFC.
    • The explicit closure kind syntax (|&:|, |&mut:|, |:|) is obsolete and closure kind is inferred from context.
    • Self is a keyword.

  • Libraries

    • The Show and String formatting traits have been renamed to Debug and Display to more clearly reflect their related purposes. Automatically getting a string conversion to use with format!("{:?}", something_to_debug) is now written #[derive(Debug)].
    • Abstract OS-specific string types, std::ff::{OsString, OsStr}, provide strings in platform-specific encodings for easier interop with system APIs. RFC.
    • The boxed::into_raw and Box::from_raw functions convert between Box<T> and *mut T, a common pattern for creating raw pointers.

  • Tooling

  • Misc

    • Rust is tested against a LALR grammar, which parses almost all the Rust files that rustc does.
Loading

Rust 1.0.0-alpha

10 Sep 05:53
@rustbot rustbot
1.0.0-alpha
44a287e

Choose a tag to compare

View all tags
Rust 1.0.0-alpha

  • ~2400 changes, numerous bugfixes

  • Highlights

    • The language itself is considered feature complete for 1.0, though there will be many usability improvements and bugfixes before the final release.
    • Nearly 50% of the public API surface of the standard library has been declared 'stable'. Those interfaces are unlikely to change before 1.0.
    • The long-running debate over integer types has been settled: Rust will ship with types named isize and usize, rather than int and uint, for pointer-sized integers. Guidelines will be rolled out during the alpha cycle.
    • Most crates that are not std have been moved out of the Rust distribution into the Cargo ecosystem so they can evolve separately and don't need to be stabilized as quickly, including 'time', 'getopts', 'num', 'regex', and 'term'.
    • Documentation continues to be expanded with more API coverage, more examples, and more in-depth explanations. The guides have been consolidated into The Rust Programming Language.
    • "Rust By Example" is now maintained by the Rust team.
    • All official Rust binary installers now come with Cargo, the Rust package manager.

  • Language

    • Closures have been completely redesigned to be implemented in terms of traits, can now be used as generic type bounds and thus monomorphized and inlined, or via an opaque pointer (boxed) as in the old system. The new system is often referred to as 'unboxed' closures.
    • Traits now support associated types, allowing families of related types to be defined together and used generically in powerful ways.
    • Enum variants are namespaced by their type names.
    • where clauses provide a more versatile and attractive syntax for specifying generic bounds, though the previous syntax remains valid.
    • Rust again picks a fallback (either i32 or f64) for uninferred numeric types.
    • Rust no longer has a runtime of any description, and only supports OS threads, not green threads.
    • At long last, Rust has been overhauled for 'dynamically-sized types' (DST), which integrates 'fat pointers' (object types, arrays, and str) more deeply into the type system, making it more consistent.
    • Rust now has a general range syntax, i..j, i.., and ..j that produce range types and which, when combined with the Index operator and multidispatch, leads to a convenient slice notation, [i..j].
    • The new range syntax revealed an ambiguity in the fixed-length array syntax, so now fixed length arrays are written [T; N].
    • The Copy trait is no longer implemented automatically. Unsafe pointers no longer implement Sync and Send so types containing them don't automatically either. Sync and Send are now 'unsafe traits' so one can "forcibly" implement them via unsafe impl if a type confirms to the requirements for them even though the internals do not (e.g. structs containing unsafe pointers like Arc). These changes are intended to prevent some footguns and are collectively known as opt-in built-in traits (though Sync and Send will soon become pure library types unknown to the compiler).
    • Operator traits now take their operands by value, and comparison traits can use multidispatch to compare one type against multiple other types, allowing e.g. String to be compared with &str.
    • if let and while let are no longer feature-gated.
    • Rust has adopted a more uniform syntax for escaping unicode characters.
    • macro_rules! has been declared stable. Though it is a flawed system it is sufficiently popular that it must be usable for 1.0. Effort has gone into future-proofing it in ways that will allow other macro systems to be developed in parallel, and won't otherwise impact the evolution of the language.
    • The prelude has been pared back significantly such that it is the minimum necessary to support the most pervasive code patterns, and through generalized where clauses many of the prelude extension traits have been consolidated.
    • Rust's rudimentary reflection has been removed, as it incurred too much code generation for little benefit.
    • Struct variants are no longer feature-gated.
    • Trait bounds can be polymorphic over lifetimes. Also known as 'higher-ranked trait bounds', this crucially allows unboxed closures to work.
    • Macros invocations surrounded by parens or square brackets and not terminated by a semicolon are parsed as expressions, which makes expressions like vec![1i32, 2, 3].len() work as expected.
    • Trait objects now implement their traits automatically, and traits that can be coerced to objects now must be object safe.
    • Automatically deriving traits is now done with #[derive(...)] not #[deriving(...)] for consistency with other naming conventions.
    • Importing the containing module or enum at the same time as items or variants they contain is now done with self instead of mod, as in use foo::{self, bar}
    • Glob imports are no longer feature-gated.
    • The box operator and box patterns have been feature-gated pending a redesign. For now unique boxes should be allocated like other containers, with Box::new.

  • Libraries

    • A series of efforts to establish conventions for collections types has resulted in API improvements throughout the standard library.
    • New APIs for error handling provide ergonomic interop between error types, and new conventions describe more clearly the recommended error handling strategies in Rust.
    • The fail! macro has been renamed to panic! so that it is easier to discuss failure in the context of error handling without making clarifications as to whether you are referring to the 'fail' macro or failure more generally.
    • On Linux, OsRng prefers the new, more reliable getrandom syscall when available.
    • The 'serialize' crate has been renamed 'rustc-serialize' and moved out of the distribution to Cargo. Although it is widely used now, it is expected to be superseded in the near future.
    • The Show formatter, typically implemented with #[derive(Show)] is now requested with the {:?} specifier and is intended for use by all types, for uses such as println! debugging. The new String formatter must be implemented by hand, uses the {} specifier, and is intended for full-fidelity conversions of things that can logically be represented as strings.

  • Tooling

    • Flexible target specification allows rustc's code generation to be configured to support otherwise-unsupported platforms.
    • Rust comes with rust-gdb and rust-lldb scripts that launch their respective debuggers with Rust-appropriate pretty-printing.
    • The Windows installation of Rust is distributed with the MinGW components currently required to link binaries on that platform.

  • Misc

    • Nullable enum optimizations have been extended to more types so that e.g. Option<Vec<T>> and Option<String> take up no more space than the inner types themselves.
    • Work has begun on supporting AArch64.
Loading