⚡ 70 developer tools, always updated, new upstream releases land in apt within hours. Join the Discord

🎁 The apt mirror needs a subscription. Plans start at €15 a year. See pricing · 🆓 There is an always-free mirror · 🔐 apt returning 401?

Install Latest Rust on Debian

The official Rust stable toolchain, with rustc, cargo, clippy, rustfmt and rust-analyzer

Latest version: 1.100.0 · updated 2026-11-14
SourceVersion
deb.griffo.io1.100.0 ✅
Official Debian1.85.1 🛑
← Back to home
📌 Installing on a specific release? Debian 12 (bookworm) · Debian 13 (trixie) · Debian 14 (forky) · Debian Sid

What is Rust?

Rust is a systems programming language focused on speed, memory safety and reliable concurrency, and this package is the official Rust stable toolchain: the binaries from static.rust-lang.org, exactly what rustup installs, repackaged unmodified. Every build is verified before it is packaged: the release manifest's GPG signature against the Rust release signing key (fingerprint 108F 6620 5EAE B0AA A8DD 5E1C 85AB 96E6 FA1B E5FE), and each tarball's SHA-256 against that manifest. One package, rust-stable, gives you rustc, cargo, rustdoc, rustfmt, clippy, rust-analyzer and the standard library, and it is updated with every stable release, every six weeks plus point releases. Debian and Ubuntu package the same compiler as rustc; the name here is different on purpose, as explained below.

🚀 Why Latest Versions Matter: Rust ships a new stable release every six weeks, and crates move with it: new language features and library APIs get used as soon as they are stable, and a crate that declares a newer rust-version will not build with an older compiler. Debian packages Rust as rustc and cargo, and trixie is frozen at rustc 1.85.1, so a stock system falls further behind with every release. This repository ships Rust 1.100.0 as rust-stable, a complete toolchain that takes the place of the distribution's rustc and cargo and moves forward on every apt upgrade.

⚡ Key Features of Rust

🦀 The Whole Toolchain

rustc, cargo, rustdoc, rustfmt, clippy (cargo clippy), rust-analyzer, the rust-gdb and rust-lldb wrappers, and the standard library for your machine, all from the same release.

🔏 Verified Official Binaries

The exact binaries rustup would download from static.rust-lang.org, repackaged unmodified. The build checks the release manifest's GPG signature and every tarball's SHA-256 before anything is packaged.

👥 One Install for Every User

A single system-wide toolchain shared by all users of the machine, instead of a separate ~/.rustup in every home directory, and updated by apt with the rest of the system.

🧩 Kept Together, Never Mixed

rustc, cargo, the standard library, clippy and rustfmt are a version-locked family. Replacing only rustc would pair a new compiler with an old std, so rust-stable always moves the whole toolchain at once.

🎯 Extra Targets as Packages

Static Linux binaries with rust-stable-std-musl, which brings its own musl, and WebAssembly with wasm32-unknown-unknown, wasm32-wasip1 and wasm32-wasip2, each one apt install away.

📚 Source and Offline Docs

rust-stable-src adds the standard library source that rust-analyzer reads, and rust-stable-doc puts The Book, the std API docs and the Cargo book on disk for offline reading.

🚀 Always ahead of the official archives: Debian and Ubuntu freeze package versions when a release ships. This repository publishes new upstream releases typically within hours. A simple apt upgrade keeps you on the latest version.

📦 Installation from deb.griffo.io

Run the commands

Step 1: Add Repository

sudo install -d -m 0755 /etc/apt/keyrings
curl -fsSL https://deb.griffo.io/EA0F721D231FDD3A0A17B9AC7808B4DD62C41256.asc | sudo gpg --dearmor --yes -o /etc/apt/keyrings/deb.griffo.io.gpg
echo "deb [signed-by=/etc/apt/keyrings/deb.griffo.io.gpg] https://deb.griffo.io/apt $(. /etc/os-release; echo ${DEBIAN_CODENAME:-${UBUNTU_CODENAME:-$VERSION_CODENAME}}) main" | sudo tee /etc/apt/sources.list.d/deb.griffo.io.list > /dev/null
sudo apt update
install -d -m 0755 /etc/apt/keyrings
curl -fsSL https://deb.griffo.io/EA0F721D231FDD3A0A17B9AC7808B4DD62C41256.asc | gpg --dearmor --yes -o /etc/apt/keyrings/deb.griffo.io.gpg
echo "deb [signed-by=/etc/apt/keyrings/deb.griffo.io.gpg] https://deb.griffo.io/apt $(. /etc/os-release; echo ${DEBIAN_CODENAME:-${UBUNTU_CODENAME:-$VERSION_CODENAME}}) main" | tee /etc/apt/sources.list.d/deb.griffo.io.list > /dev/null
apt update
sudo apt install extrepo
sudo extrepo enable griffo
sudo apt update

🆓 There is an always-free mirror. deb-free.griffo.io serves packages free forever, no account, no subscription, at most 2 months behind upstream, security fixes immediately. It currently carries cliamp, Forgejo Runner, Ghostty, lazydocker, Oh My Posh, Uncloud and Zed; Rust is not one of them, so the repository above is the only way to get it today, ask and it can be enrolled.

How the free mirror works →

🧩 About the extrepo option. extrepo is Debian's own tool for external repositories: it writes the sources file and installs the signing key for you, checking the key against signed metadata first. This repository is registered with it as griffo, and the always-free mirror as griffo-free, so on Debian (bookworm, trixie, forky and sid) the commands above are the whole setup.

extrepo sets up the sources file and the key only, so a subscription's credentials still go in /etc/apt/auth.conf.d/deb.griffo.io.conf. Ubuntu is not covered, because extrepo publishes metadata for Debian suites only: there, use the sudo or root commands.

Step 2: Install Rust

# Install the latest stable Rust toolchain
sudo apt install rust-stable

# Verify installation
rustc --version
cargo --version
# Install the latest stable Rust toolchain
apt install rust-stable

# Verify installation
rustc --version
cargo --version
📌 What apt replaces: rust-stable replaces Debian's rustc, cargo, rustfmt, rust-clippy, rust-gdb, rust-lldb, rust-analyzer and rustup packages, and their *-web variants. apt shows what it will remove and asks first. Packages that depend on the distribution's rustc or cargo, such as python3-setuptools-rust or dh-cargo, are removed with them. The system LLVM and clang are not touched, and nothing on a running system depends on the compiler.

Step 3: Your first project

# Create, build and run a new project
cargo new hello && cd hello && cargo run

# Lint it with clippy and format it with rustfmt
cargo clippy
rustfmt src/main.rs

🎯 Basic Usage Examples

Static binaries with musl:

# Add the musl target (it brings its own musl, no musl-tools needed)
sudo apt install rust-stable-std-musl

# Build a fully static Linux binary (aarch64-unknown-linux-musl on arm64)
cargo build --target x86_64-unknown-linux-musl

# ldd confirms it needs no shared libraries
ldd target/x86_64-unknown-linux-musl/debug/hello
# Add the musl target (it brings its own musl, no musl-tools needed)
apt install rust-stable-std-musl

# Build a fully static Linux binary (aarch64-unknown-linux-musl on arm64)
cargo build --target x86_64-unknown-linux-musl

# ldd confirms it needs no shared libraries
ldd target/x86_64-unknown-linux-musl/debug/hello

WebAssembly, source and docs:

# WebAssembly targets, one package each
sudo apt install rust-stable-std-wasm32-unknown-unknown
sudo apt install rust-stable-std-wasm32-wasip1 rust-stable-std-wasm32-wasip2

# Standard library source for rust-analyzer (recommended, so apt adds it by default)
sudo apt install rust-stable-src

# The Book, the std API and the Cargo book, offline under /usr/share/doc/rust-stable-doc/html
sudo apt install rust-stable-doc
# WebAssembly targets, one package each
apt install rust-stable-std-wasm32-unknown-unknown
apt install rust-stable-std-wasm32-wasip1 rust-stable-std-wasm32-wasip2

# Standard library source for rust-analyzer (recommended, so apt adds it by default)
apt install rust-stable-src

# The Book, the std API and the Cargo book, offline under /usr/share/doc/rust-stable-doc/html
apt install rust-stable-doc

Keeping it current:

# Rust updates with the rest of the system, on every stable release
sudo apt update && sudo apt upgrade

# Which version is installed, and which is the newest available
apt policy rust-stable

# Remove it again
sudo apt remove rust-stable
# Rust updates with the rest of the system, on every stable release
apt update && apt upgrade

# Which version is installed, and which is the newest available
apt policy rust-stable

# Remove it again
apt remove rust-stable

🔧 Tool Integrations

The toolchain is laid out like any other system package, so the rest of your setup finds it without configuration:

  • Layout: everything lives under /usr/lib/rust-stable with its own bundled LLVM, and the commands are linked into /usr/bin, so they are on every user's PATH with no shell profile changes
  • Linking: the package depends on a C compiler (gcc or clang) and libc6-dev, which rustc uses to link, so cargo build works straight after the install
  • Editors: rust-analyzer is part of the package, so any editor with a language server client can use it; rust-stable-src lets it navigate into the standard library
  • Debuggers: rust-gdb and rust-lldb start gdb or lldb with Rust's pretty-printers loaded, so Rust types display readably
  • Shell: cargo's man pages and its bash and zsh completions are installed with the package
  • Cross targets: the musl and WebAssembly standard libraries are separate packages, added with apt install instead of rustup target add
  • Documentation: rust-stable-doc installs the HTML docs under /usr/share/doc/rust-stable-doc/html, and everything is also online at doc.rust-lang.org

🚀 Why Choose deb.griffo.io?

📊 Repository Comparison:
  • Official Debian: packages Rust as rustc and cargo, version 1.85.1 in trixie, frozen for the life of the release
  • rustup: the same official binaries, installed separately for each user under ~/.rustup and updated with rustup update rather than apt
  • Building from source: bootstrapping rustc with a previous compiler and building its LLVM, a long and heavy compile
  • deb.griffo.io: latest version with automatic updates

📦 Package Build Repository

The Debian packages are automatically built and maintained in this GitHub repository:

🔗 Related Packages

Also available from deb.griffo.io:

🎯 Perfect for: Rust developers who want one up-to-date toolchain shared by every user on a machine, build servers and CI runners that install their tools with apt, anyone whose crates need a newer compiler than the distribution's rustc, and projects that ship static musl binaries or WebAssembly.

💝 Support This Project

If this repository saves you time and effort, please consider supporting it!

⭐ Star on GitHub 🐦 Share on Twitter

Just after the command? See apt install rust-stable, one page covering Debian and Ubuntu.

📦 Recent releases from this repository

📚 Release-specific install guides

❓ Frequently asked questions

Is Rust in the official Debian repositories?

Yes, but the official Debian archive ships Rust 1.85.1, while this repository serves Rust 1.100.0, rebuilt within hours of each upstream release.

How do I install the latest Rust on Debian?

Add the deb.griffo.io repository once using the instructions above, then run: sudo apt install rust-stable. New releases arrive through the normal sudo apt upgrade.

Are the packages signed and how are they built?

Every package is signed with the repository's GPG key (EA0F721D231FDD3A0A17B9AC7808B4DD62C41256) and built from upstream releases in public GitHub packaging repositories that anyone can inspect.

Which Debian releases are supported?

Debian 12 Bookworm, Debian 13 Trixie, Forky and Sid.