rust-lang/rust: dual licensed, trademark reserved, built by a bot

The productivity case points at four other repositories

The Why Rust section credits advanced tooling, and then links out for all of it. The package manager and build tool is Cargo at rust-lang/cargo, the auto-formatter is rustfmt at rust-lang/rustfmt, the linter is Clippy at rust-lang/rust-clippy, and editor support is rust-analyzer at rust-lang/rust-analyzer. None of them lives here. Consequence: the Rust toolchain is a set of repositories with independent release schedules, so a compiler, a formatter, a linter, and a language server can be at four different versions on your machine, and pinning them is your job rather than the project's. Inside this tree the same tools appear as workspace members, src/tools/clippy and src/tools/rustfmt among them.

Source installation is described as not recommended

There is no install command in this README, and that is a decision rather than an oversight. Quick Start tells you to read the Installation chapter of The Book at doc.rust-lang.org, and the Installing from Source section says that if you really want to install from source, though this is not recommended, see INSTALL.md. Consequence: a reader who expects a curl line or a package name here will not find one, and the repository's own framing is a warning rather than an invitation. If you are evaluating Rust, follow the Book. If you are building a compiler, read INSTALL.md and then the rustc-dev-guide, which the contributing section names as the place with a detailed explanation of the compiler architecture.

The build runs through a Python wrapper and a config you create

The machinery at the root explains the shape of a bootstrap. There is a configure script, a bootstrap.example.toml rather than a bootstrap.toml, and three forms of the build wrapper: x, x.py, and x.ps1, so Unix and Windows contributors type different names for the same entry point. The workspace also excludes src/bootstrap, which is the code doing the bootstrapping. Consequence: the repository ships bootstrap.example.toml rather than a ready bootstrap.toml, so any custom build settings are yours to write. The build system is a Python program with shell and PowerShell front ends, not a Makefile.

Two codegen backends sit outside the workspace on purpose

The exclude list in Cargo.toml is short and pointed. It leaves out build, compiler/rustc_codegen_cranelift, compiler/rustc_codegen_gcc, src/bootstrap, tests/rustdoc-gui, and obj, and obj carries the comment that it hardcodes the fact that CI uses /checkout/obj, attributed in the file to a contributor's handle (eddyb). Consequence: the alternative code generators are deliberately not part of the default workspace, so an experiment with a different backend is a separate exercise rather than a cargo flag, and one exclusion in the workspace manifest encodes an assumption about a CI directory layout. Anyone building outside that layout is working against a comment in the file rather than against a documented rule.

Two licences, BSD-like portions, and names you may not use

The License section is precise and the repository metadata is narrower. Rust is primarily distributed under the terms of both the MIT license and the Apache License version 2.0, with portions covered by various BSD-like licenses, with LICENSE-APACHE, LICENSE-MIT, and COPYRIGHT for details, while the repository's own licence field records only Apache-2.0. The machinery behind that is public too: a LICENSES/ directory, license-metadata.json, REUSE.toml, and a workspace tool for collecting licence metadata and generating the copyright file. Then the trademark section, where the Rust Foundation owns and protects the Rust and Cargo trademarks and logos. Consequence: a scanner reading the field gives you a narrower grant than you have, and using the Rust and Cargo names or logos is governed by the Rust trademark policy.

bors merges the pull request, triagebot handles the queue

The contributing section is short, and the configuration files do the describing. There is rust-bors.toml and triagebot.toml at the top level, alongside CONTRIBUTING.md, CODE_OF_CONDUCT.md, and AGENTS.md, with the rustc-dev-guide offered for the architecture. Consequence: the repository configures bots for merging (rust-bors.toml) and triage (triagebot.toml) rather than describing a purely manual process.

A JavaScript toolchain exists, and it is not the project

The root carries a package.json with four dependencies, browser-ui-test, es-check, eslint, and typescript, alongside a yarn.lock, next to a Cargo.toml and a Cargo.lock. Two package managers in one tree is not a mistake here. Consequence: a developer who lands in this repository from package.json, or from a search for the repository's JavaScript, will conclude they are in the wrong place, because the JavaScript is tooling such as browser-ui-test, es-check and eslint rather than part of the language build. The same split shows up in formatting, with a .clang-format for the C and C++ pieces and a rustfmt.toml for the Rust.

Releases arrive on a six week rhythm with point releases

The version history is regular. 1.98.1 shipped on 2026-09-03, 1.99.0 on 2026-10-01, and 1.99.1 on 2026-10-16, with the last push landing on 2026-11-02 and a RELEASES.md at the root. Consequence: the version you pin has a known shelf life, roughly six weeks before the next minor, and point releases like 1.99.1 show that a minor line is still being patched after it ships. Because the release is a tag on a repository rather than a package you can hold, a build that pins a version is pinning a commit as much as a number, and the exact patch matters when you are chasing a diagnostic change.

Editorial conclusion

Take this repository if you want to read how a production compiler and standard library are actually built, or if you are contributing to the language itself and can live inside a bot driven merge queue. Do not take it as a place to install Rust, because the README sends you to the Book for that and describes source installation as not recommended. Before you rely on anything here, check two things. The licence per file rather than per repository, since the field naming Apache-2.0 understates a dual MIT and Apache grant with BSD-like portions and a managed COPYRIGHT file. The trademark rules, because the Rust Foundation owns the Rust and Cargo names and logos, which constrains what you may call a fork.

Frequently asked questions

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes