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

> The main source repository for the Rust compiler, standard library, and documentation, where the productivity story points at four other repositories, source installs are explicitly discouraged, merges go through bors, and the code is under both MIT and Apache-2.0 while the names Rust and Cargo stay with the Rust Foundation.

**rust-lang/rust** — Rust combines memory safety with systems-level control, without requiring a garbage collector.

- Repository: https://github.com/rust-lang/rust
- Website: https://www.rust-lang.org
- Stars: 119,169 · Forks: 16,683
- Language: Rust
- License: Apache-2.0
- Published: 2026-08-08 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/rust-lang-rust

## 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, and the top level carries a .gitmodules file, so a clone without submodules initialised leaves those paths empty.

## 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: a first local build starts by copying an example configuration and editing it, and a build that looks like it should work out of the box will not, because the settings that control stages and toolchain paths 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 initials. 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 a fork may not be named Rust or carry the logo.

## 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, AGENTS.md, and CLAUDE.md, with the rustc-dev-guide offered for the architecture. Consequence: the human part of getting a change in is reviewing a build that has already passed, not deciding whether to merge, and an issue is triaged by a bot before a person sees it. It also means the cost of a contribution is a green CI run against a compiler build, which is why the contributor docs spend their length on the build rather than on the review.

## A JavaScript toolchain exists, and it is not the project

The root carries a package.json with four devDependencies, 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 exists to test the compiler's browser interface rather than to build any part of the language. 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.97.1 shipped on 2026-07-16, 1.98.0 on 2026-08-20, and 1.98.1 on 2026-09-03, with the last push to main landing on 2026-09-25 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.98.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.

## 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 three 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 NOTICE. The trademark rules, because the Rust Foundation owns the Rust and Cargo names and logos, which constrains what you may call a fork. And your submodules, since the workspace lists tool paths that a plain clone leaves empty, which is the first surprise for anyone building locally.

## FAQ

### What is Rust language used for?

The README names critical services, embedded devices, and easy integration with other languages as the performance targets. It also credits a rich type system and an ownership model with ensuring memory and thread safety and reducing bugs at compile time, and describes the language as needing no garbage collector.

### Why is Rust Lang called Rust?

The repository does not explain the name. It describes itself as the main source code repository for Rust, containing the compiler, standard library, and documentation, and links the project website at rust-lang.org.

### Is Rust Lang safe?

That is the project's own reliability claim: a rich type system and an ownership model ensure memory and thread safety, reducing bugs at compile-time rather than at run time. The README presents it as a property of the language and does not offer a benchmark or an audit behind it.

### Is Rust language free to use?

Yes under its licence terms. Rust is primarily distributed under both the MIT license and the Apache License version 2.0, with portions covered by various BSD-like licenses, while the Rust Foundation owns and protects the Rust and Cargo trademarks and logos, so using the names is a separate question from using the code.

## Sources

- [Official documentation](https://www.rust-lang.org)
- [Official README](https://github.com/rust-lang/rust#readme)
- [Project repository](https://github.com/rust-lang/rust)
- [Release notes](https://github.com/rust-lang/rust/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/rust-lang-rust