My Complete Rust Development Setup on Debian 13

A complete reference inventory of my Rust development environment on Debian 13, including Rustup toolchains, targets, components, Cargo-installed tools, compiler and linker ecosystem, project inventory, Rust AI/web/GUI experiments, Cargo configuration, and disk usage.

$ cat table_of_contents.txt

Last reviewed: September 23, 2026 (after a full rustup update and my first cargo audit run)

I built this post as a permanent reference for my Rust development environment on Debian 13.

Rather than reconstructing my Rust installation from scratch every time I want to know what is installed, where it lives, which toolchains I have, which Cargo utilities I installed, or which Rust projects I have been experimenting with, this page records the setup in one place.

The goal is not merely to list commands. It is to document the structure of the environment so I understand what each part is doing.

Note: ~ means my home directory throughout this page.

1. The Big Picture

My Rust environment is based on Rustup, rather than Debian’s system rustc and cargo packages.

Debian 13
│
├── Rustup
│   ├── stable
│   ├── beta
│   └── nightly  ← default/active
│
├── Cargo
│   ├── Rust project dependencies
│   ├── Cargo registry
│   ├── Git dependencies
│   └── Cargo-installed applications
│
├── Compilation ecosystem
│   ├── GCC
│   ├── Clang
│   ├── LLVM
│   └── system linker
│
├── Targets
│   ├── x86_64 Linux
│   └── WebAssembly
│
└── Rust projects
    ├── basic learning
    ├── Axum
    ├── Leptos
    ├── Burn
    ├── AI/ML
    ├── GUI
    ├── Polars
    ├── Makepad
    └── other experiments

This is more than a single Rust installation. It is a fairly substantial Rust development laboratory.

2. Rust Versions

Versions as of the September 23, 2026 rustup update:

ACTIVE (nightly, default)
rustc          1.100.0-nightly (6eeff9a52 2026-09-23)
cargo          1.100.0-nightly (98a09e7e7 2026-09-21)
rust-analyzer  1.100.0-nightly (6eeff9a 2026-09-23)

STABLE
rustc          1.98.1 (48a229cea 2026-09-01)   ← updated from 1.97.1
               (1.99 becomes stable October 1, 2026)

BETA
rustc          1.99.0-beta.7 (aa0593682 2026-09-19)

RUSTUP
rustup         1.29.1 (d95a37b6a 2026-08-13)

Cargo’s date lags rustc by a couple of days. That is normal: Cargo is developed in its own repository and synced into the Rust build periodically.

The Rustup default host is:

x86_64-unknown-linux-gnu

The active and default toolchain is:

nightly-x86_64-unknown-linux-gnu

So when I type rustc or cargo without selecting a toolchain, Rustup sends the request to nightly. To use another channel for one command, I add +stable or +beta:

cargo +stable build
rustc +beta --version

To refresh everything, one command updates all three toolchains and every component inside them:

rustup update

3. Rustup Toolchains

I have three Rust toolchains installed:

stable-x86_64-unknown-linux-gnu
beta-x86_64-unknown-linux-gnu
nightly-x86_64-unknown-linux-gnu

Stable

The normal production-oriented Rust release. A new stable version ships every six weeks.

Beta

The upcoming release, tested for six weeks before it becomes stable. I installed beta on September 23, 2026 to look at Rust 1.99 before its October 1 release.

Nightly

The development version, rebuilt every day, containing experimental or newly introduced functionality. Nightly is my deliberate default. It only moves forward when I run rustup update.

There are no Rustup directory overrides configured:

rustup override list
→ no overrides

So no project directory is silently switching me to another Rust version.

4. Installed Rust Targets

Native Linux

x86_64-unknown-linux-gnu

The normal 64-bit Linux target for my Debian machine.

WebAssembly

wasm32-unknown-unknown

Installed on Stable and Nightly, and important for my Leptos work.

So my installation can compile both:

Rust → native Linux executable
Rust → WebAssembly

Targets are installed per toolchain. Beta does not have the WebAssembly target.

5. Rust Components

Stable

cargo
clippy
rust-analyzer
rust-docs
rust-src
rust-std-wasm32-unknown-unknown
rust-std-x86_64-unknown-linux-gnu
rustc
rustfmt

Beta

cargo
clippy
rust-docs
rust-std-x86_64-unknown-linux-gnu
rustc
rustfmt

Nightly

cargo
clippy
rust-analyzer
rust-docs
rust-src
rust-std-wasm32-unknown-unknown
rust-std-x86_64-unknown-linux-gnu
rustc
rustfmt

The rust-analyzer lesson

rust-analyzer was originally installed on Stable only. That caused a problem: the rust-analyzer command in ~/.cargo/bin is a Rustup proxy that follows the default toolchain. With Nightly as the default, it failed:

$ rust-analyzer --version
error: Unknown binary 'rust-analyzer' in official toolchain 'nightly-x86_64-unknown-linux-gnu'.

The fix:

rustup component add rust-analyzer --toolchain nightly

Lesson: components belong to individual toolchains, and they have to be installed on the one I actually use. Now rust-analyzer comes from the same nightly build as my compiler, and rustup update keeps both in step.

6. Where Rust Lives

Rustup home       ~/.rustup
Cargo home        ~/.cargo
Rust executables  ~/.cargo/bin

Examples in ~/.cargo/bin include:

cargo
rustc
rustup
rustfmt
rust-analyzer
clippy-driver

These are found through my PATH.

My .bashrc adds Cargo to the PATH directly:

export PATH="$HOME/.cargo/bin:$PATH"

and also sources:

"$HOME/.cargo/env"

My .profile also sources "$HOME/.cargo/env".

Note: .bashrc does the same job twice, since ~/.cargo/env already adds ~/.cargo/bin to the PATH. It is harmless, but one of the two lines could go.

There is no special Rust/Cargo environment configuration exported, such as:

RUSTFLAGS
RUSTC_WRAPPER
CARGO_TARGET_*
RUSTUP_*

My Conda (base) environment does not interfere. which rustc cargo points to ~/.cargo/bin.

7. Rust Executable Resolution

rustc  → ~/.cargo/bin/rustc
cargo  → ~/.cargo/bin/cargo
rustup → ~/.cargo/bin/rustup

This is what I expect from a Rustup-managed installation.

The files in that directory are Rustup’s entry points (proxies). Rustup decides which installed toolchain actually supplies the requested tool, which is exactly why the rust-analyzer problem in section 5 happened.

8. Cargo-Installed Applications

Installed with cargo install:

ToolVersionPurpose
bacon3.25.0background Rust checker/build tool
cargo-audit0.22.2audits Rust dependencies for known security vulnerabilities
cargo-generate0.23.14generates projects from templates
cargo-leptos0.3.7Leptos development/build tooling
cargo-nextest0.9.143advanced Rust test runner
cargo-seek0.2.0Cargo/crate search utility
create-gpui-app0.1.5GPUI application generator
evcxr_repl0.21.1interactive Rust REPL
just1.55.1command runner/build automation tool
makepad-example-ironfish1.0.0Makepad/Ironfish-related application
topcoat-cli0.5.0Topcoat command-line tooling

Their executables:

bacon
cargo-audit
cargo-generate
cargo-leptos
cargo-nextest
cargo-seek
cargo-topcoat
create-gpui-app
evcxr
just
makepad-example-ironfish
topcoat

Rustup-managed commands in the same directory:

cargo
cargo-clippy
cargo-fmt
cargo-miri
clippy-driver
rls
rust-analyzer
rustc
rustdoc
rustfmt
rust-gdb
rust-gdbgui
rustup

Note: rls is a leftover. RLS was the old Rust language server, replaced by rust-analyzer years ago.

9. Size of the Rust Installation

Approximately (measured before the September 23 update, which replaced rather than added toolchain files):

~/.rustup/toolchains       4.9 GB
~/.cargo/registry          2.2 GB
~/.cargo/git               384 MB
~/.cargo/bin               225 MB

Total                      ~7.7 GB

This does not include the target directories of individual projects, which add many more gigabytes (see section 28).

10. Rustup Toolchain Disk Usage

beta       1.5 GB
nightly    1.7 GB
stable     1.7 GB

Total      ~4.9 GB

Three complete toolchains cost substantially more space than one. I am recording this rather than deleting anything, because these installations are part of my learning and testing environment.

11. Cargo Registry

About 2.2 GB:

index       173 MB
cache       371 MB
src         1.6 GB

src is the largest part because Cargo keeps downloaded crate source code locally. This is also where compiler warnings about other people’s code point to, for example ~/.cargo/registry/src/... in section 33.

12. Cargo Git Cache

About 384 MB, almost all in ~/.cargo/git/db.

This holds dependencies fetched directly from Git repositories instead of crates.io, and is particularly relevant to the Zed/GPUI ecosystem.

13. Rust Compiler and Linker Ecosystem

The system also has:

/usr/bin/gcc
/usr/bin/clang
/usr/bin/ld

There is no separate /usr/bin/lld in the PATH.

The active Rust compiler reports its own bundled LLVM:

$ rustc -vV | grep LLVM
LLVM version: 23.1.1

(Updated from 23.1.0 with the September 23, 2026 nightly.)

Debian also has LLVM/Clang 18 and 19 installed, but Rust does not use them internally. Rust’s bundled LLVM moves independently of Debian’s.

14. Debian Compiler Environment

Installed packages include multiple versions of:

GCC       12, 13, 14, 15
Clang     18, 19
LLVM      18, 19
libclang

plus cross-compilation packages for:

MinGW / Windows
RISC-V
x86-64

This is more than a basic Rust-learning workstation. It is a fairly extensive native compilation environment.

15. Rust Projects

Some projects are tiny learning exercises. Others are framework experiments with very large dependency trees.

~/angr
~/async_test
~/awesome-rust
~/awesome-rust-list
~/Cargo.toml
~/claw-code/rust
~/conrod_demo
~/iced_counter
~/iced_project
~/ironfish_ipc_client_rs
~/learn-rust
~/makepad
~/my-leptos-app
~/polonius_test
~/relm4_project
~/rust-deque-practice
~/rust_practice
~/rust_test
~/rust_projects/polars_test
~/rust_projects/rust_ai
~/slint_working
~/topcoat_hello

Under ~/Projects:

~/Projects/burn-demo
~/Projects/gpui-demo
~/Projects/leptos-demo

There are also many Rust projects under ~/Documents/GitHub, including larger open-source repositories involving Makepad, Yew, Zed, WebAssembly and other ecosystems.

16. Basic Rust Learning Projects

~/rust-deque-practice
~/rust_practice
~/rust_test
~/learn-rust
~/polonius_test

Topics covered so far:

  • ownership and collections
  • VecDeque
  • Rust editions
  • generics and language features
  • compiler experiments
  • Polonius
  • basic Cargo projects

My rust-deque-practice project demonstrated a VecDeque ending with:

["Ace"]

17. Rust Editions in Use

My projects use three editions: 2018, 2021, and 2024. An older project may behave differently from a new Rust 2024 project.

awesome-rust        → edition 2018
async_test          → edition 2021
my-leptos-app       → edition 2021
leptos-demo         → edition 2021
learn-rust          → edition 2024
rust-deque-practice → edition 2024
burn-demo           → edition 2024
rust_ai             → edition 2024
topcoat_hello       → edition 2024

18. Axum and Tokio

async_test uses:

axum
tokio
serde
sqlx      (SQLite)
reqwest

A top-level Cargo project uses:

axum
tokio
serde
serde_json
tower
tower-http
rayon

Together they cover HTTP servers, async Rust, routing, JSON, middleware, database access, HTTP clients, and parallel computation.

19. Leptos

Leptos is one of the major pieces of my Rust learning path, and I have one project from each generation.

Older: ~/my-leptos-app (Leptos 0.6, Actix)

leptos
leptos_meta
leptos_router
leptos_actix
actix-web
wasm-bindgen

Features: csr, hydrate, ssr.

Newer: ~/Projects/leptos-demo (Leptos 0.8, Axum)

leptos 0.8
leptos_router 0.8
leptos_axum 0.8
leptos_meta 0.8
axum 0.8
tokio
wasm-bindgen

The two differ in more than version. They use different server backends (Actix vs. Axum), which turned out to matter for security (see section 33).

20. WebAssembly

WebAssembly is a deliberate part of this environment. The Leptos projects use it for their browser-side code.

Rust source
     │
     ├── native Linux
     │
     └── WebAssembly
              │
              └── browser application

This is why I keep both the wasm32-unknown-unknown target and the related Cargo tooling.

21. Burn Machine Learning

~/Projects/burn-demo uses:

burn 0.21.0   (wgpu feature)
itertools
rayon

It produced:

[[3,4],[5,6]]

The debug build directory is about 3.8 GB, mostly in target/debug/deps, target/debug/build, and target/debug/incremental. There is no release build yet.

22. Rust AI/ML Experiment

~/rust_projects/rust_ai is only about 84 KB of source, but its dependencies are ambitious:

Candle (candle-core, candle-nn) → Rust-native ML/tensor work
Linfa                           → machine learning
ndarray                         → numerical arrays
ort                             → ONNX Runtime model inference
tokenizers                      → NLP/model tokenization
serde, serde_json               → serialization
anyhow                          → error handling

It is primarily source and dependency configuration so far, not a large compiled build.

23. Polars

~/rust_projects/polars_test uses polars 0.54.4 with the lazy and strings features.

The project is about 9.4 GB, almost all of it build output:

target/debug        9.4 GB
target/debug/deps   9.1 GB
target/debug/build  350 MB

This is the clearest example in my environment of how a data-science dependency tree creates enormous compilation artifacts.

24. GPUI and Zed

~/Projects/gpui-demo takes GPUI directly from the Zed repository:

https://github.com/zed-industries/zed

with Wayland and X11 support. It is about 6.7 GB:

target/debug     5.2 GB
target/release   1.5 GB

It also explains part of the Cargo Git cache.

25. Makepad

~/makepad is a substantial source tree with many internal crates, for example:

makepad-code-editor
makepad-draw
makepad-platform
makepad-widgets
makepad-xr

It covers Wayland, OpenGL, WebAssembly, Apple and Android/JNI platform interfaces, graphics, fonts, and image formats (SVG, WebP, JPEG, PNG, GIF).

Its release profile is tuned for small, fast binaries:

opt-level = z
lto = true
codegen-units = 1
panic = abort
strip = true

This is advanced GUI and graphics territory, not a beginner project.

26. GUI Framework Experiments

Iced     ~/iced_counter, ~/iced_project   Iced 0.12 (wgpu)    ~1.7 GB each
Conrod   ~/conrod_demo                     conrod + piston     ~1.2 GB
Relm4    ~/relm4_project                   relm4 0.11          ~1.4 GB
Slint    ~/slint_working                   slint 1.6           ~3.4 GB

These sizes are overwhelmingly build artifacts, not source code.

27. Other Rust Experiments

  • ~/ironfish_ipc_client_rs: an IPC client experiment using Serde JSON.
  • ~/topcoat_hello: uses topcoat 0.5.0 and tokio.
  • ~/rue/third-party: a large third-party dependency workspace (anyhow, libc, mimalloc, regex, serde, thiserror, toml, tracing, rayon, smallvec, syn, proptest, sha2, and more).
  • ~/claw-code/rust: a multi-crate workspace with deliberately strict linting, including unsafe_code = "forbid".

28. Cargo Build Artifacts

Cargo project size does not tell me how much source code I have.

Cargo.toml   a few KB
src/         a few KB
Cargo.lock   tens/hundreds of KB
target/      several GB

The largest:

polars_test     ~9.4 GB
gpui-demo       ~6.7 GB
burn-demo       ~3.8 GB
my-leptos-app   ~3.7 GB
leptos-demo     ~3.4 GB
slint_working   ~3.4 GB

This is why my Rust environment consumes tens of gigabytes even though the source code is relatively small.

29. Cargo Target Directories Found

~/async_test
~/awesome-rust
~/conrod_demo
~/iced_counter
~/iced_project
~/ironfish_ipc_client_rs
~/learn-rust
~/my-leptos-app
~/polonius_test
~/Projects/burn-demo
~/Projects/gpui-demo
~/Projects/leptos-demo
~/relm4_project
~/rust-deque-practice
~/rust_projects/polars_test
~/rust_test
~/slint_working
~/target
~/topcoat_hello
~/voicebox/tauri/src-tauri
~/.ZAP/hud

Some of these are Rust applications embedded inside larger projects.

30. Cargo Configuration

There is no global Cargo configuration at ~/.cargo/config.toml or ~/.cargo/config.

There are many project-specific configurations, for example under ~/Documents/GitHub/, ~/makepad/, ~/polonius_test/, ~/rue/, and ~/zed/.

Downloaded crates also carry their own .cargo/config.toml files. Those are not my configuration.

~/.cargo/config.toml          → user-wide Cargo configuration
project/.cargo/config.toml    → project-specific configuration
~/.cargo/registry/src/...     → belongs to downloaded crates

31. Configuration Summary

Rustup-managed installation       YES
Global Cargo config               NOT FOUND
Rustup overrides                  NONE
Default toolchain                 NIGHTLY
Stable installed                  YES (1.98.1)
Beta installed                    YES (1.99.0-beta.7)
Nightly installed                 YES (2026-09-23 build)
Native Linux target               YES
WebAssembly target                YES (Stable, Nightly)
rust-analyzer                     YES, Stable and Nightly
Clippy                            YES
Rustfmt                           YES
Rust source                       YES
Cargo Git cache                   YES
Cargo registry                    YES
Last rustup update                2026-09-23
Last cargo-audit                  2026-09-23 (my-leptos-app)

32. My Rust Learning Direction

Rust fundamentals
       ↓
collections / ownership / language experiments
       ↓
Tokio + async
       ↓
Axum
       ↓
Leptos + WebAssembly
       ↓
GUI frameworks
       ↓
GPUI / Makepad
       ↓
Burn
       ↓
Rust AI / ML

I am using Rust as a platform for learning several areas at once: systems programming, web development, WebAssembly, GUI development, async programming, data processing, machine learning, AI inference, and security-related tooling.

33. Security-Relevant Rust Tooling

The most important security tool here is cargo-audit, which checks every dependency in a project’s Cargo.lock against the RustSec Advisory Database of known problems in Rust crates. It is the Rust equivalent of the dependency scanning that services like Amazon Inspector do for Lambda functions and container images.

I also have Rust projects involving angr, IPC, networking, HTTP, database access, and AI/ML, which makes this environment part of my home cybersecurity lab. It is a learning environment, not a production one.

First cargo-audit run: my-leptos-app (September 23, 2026)

I audited my oldest project, ~/my-leptos-app (Leptos 0.6 on Actix).

BEFORE cargo update     1 vulnerability, 7 warnings (283 crates)
AFTER  cargo update     1 vulnerability, 6 warnings (289 crates)

Vulnerability (remaining)
  h2 0.3.27   RUSTSEC-2026-0258   denial-of-service, low severity
  chain:      h2 ← actix-http 3.x ← actix-web / leptos_actix
  fix:        h2 >= 0.4.16 only; actix-http 3.x still requires h2 0.3

Warnings (remaining)
  unmaintained   instant, paste, proc-macro-error, proc-macro-error2
  unsound        lru 0.11.1 (two advisories)

Fixed by cargo update
  chacha20 0.10.1 (yanked) → 0.10.2

The steps I used:

cargo audit                          # find problems
cargo tree -i h2 --all-features      # who pulls in h2?
cargo update --dry-run               # what would an update change?
cp Cargo.lock Cargo.lock.bak         # back up before changing anything
cargo update                         # apply the update
cargo audit                          # confirm the result
cargo check --features ssr           # confirm it still compiles

Lessons:

  • cargo audit reads the whole Cargo.lock, but cargo tree shows only the active features. cargo tree -i h2 found nothing until I added --all-features, because h2 is only used by the ssr (server) feature. A scanner can flag code that a given build never compiles, and checking that is how to tell real risk from noise.
  • cargo update --dry-run showed that h2 would not move, so a normal update could not fix the vulnerability.
  • The one link responsible is actix-http. Upgrading Leptos alone would not help if the project stays on Actix.
  • The risk is accepted for a local learning project that is not exposed to the network. The real fix is Leptos 0.8 on Axum, as in ~/Projects/leptos-demo.

Future-incompatibility warnings

The build also reported code in two dependencies that a future version of Rust will reject:

  • attribute-derive-macro 0.9.2: “trailing semicolon in macro used in expression position” (rust-lang issue #79813). This is the Rust 1.99 change that extends the macro semicolon lint to macros from other crates. Fixed versions (0.10.x) exist, but Leptos 0.6 requires 0.9.
  • proc-macro-error2 2.0.1: error E0365, re-exporting the private proc_macro crate (rust-lang issue #127909). This crate is unmaintained, so no fix is coming.

To see the details:

cargo report future-incompatibilities --id 1

The new nightly Cargo also warned that console_error_panic_hook is unused. That is only true for the server build. The crate is browser-side code for the hydrate feature, so I kept it.

Conclusion: my-leptos-app stays as a historical reference. An unpatchable vulnerability, unmaintained dependencies, and future compiler errors all point to Leptos 0.8 for new work.

34. The Most Important Paths to Remember

Installation:

~/.rustup
~/.cargo
~/.cargo/bin
~/.cargo/registry
~/.cargo/git

Projects:

~/Projects
~/rust_projects
~/Documents/GitHub
~/makepad
~/learn-rust
~/claw-code
~/rue
~/polonius_test

35. Quick Reference Card

SYSTEM
------
Debian 13
x86_64 Linux

RUST
----
rustc 1.100.0-nightly (2026-09-23)
stable 1.98.1 / beta 1.99.0-beta.7
rustup 1.29.1
LLVM 23.1.1 (bundled)

TOOLCHAINS
----------
stable
beta
nightly ← default/active

TARGETS
-------
x86_64-unknown-linux-gnu
wasm32-unknown-unknown

COMPONENTS
----------
cargo
clippy
rustfmt
rust-src
rust-docs
rust-analyzer (Stable, Nightly)
native std
WASM std

CARGO TOOLS
-----------
bacon
cargo-audit
cargo-generate
cargo-leptos
cargo-nextest
cargo-seek
create-gpui-app
evcxr
just
makepad-example-ironfish
topcoat

INSTALLATION SIZE
-----------------
~7.7 GB
  ~/.rustup          ~4.9 GB
  ~/.cargo/registry  ~2.2 GB
  ~/.cargo/git       ~384 MB
  ~/.cargo/bin       ~225 MB

MAJOR PROJECT AREAS
-------------------
Rust fundamentals, Tokio, Axum, Leptos, WebAssembly,
Burn, Candle, Linfa, ONNX Runtime, Tokenizers, Polars,
GPUI, Makepad, Iced, Conrod, Relm4, Slint

LARGE BUILD DIRECTORIES
-----------------------
polars_test     ~9.4 GB
gpui-demo       ~6.7 GB
burn-demo       ~3.8 GB
my-leptos-app   ~3.7 GB
leptos-demo     ~3.4 GB
slint_working   ~3.4 GB

CONFIGURATION
-------------
No global ~/.cargo/config.toml
No Rustup overrides
Rust installed through Rustup
Nightly is default
Last rustup update: 2026-09-23
my-leptos-app audit: 1 low-severity vuln (h2, accepted)

36. What I Should Say Next Time

When I ask an AI assistant for Rust help, I can point to this page and say:

“Use my Rust Setup Reference as the baseline. Tell me what is relevant to this problem and only ask me to verify things that may have changed.”

That is much more efficient than doing a complete Rust inventory every time.

37. Final Perspective

My Debian machine has a fairly mature Rust development environment. It is not just rustc + cargo. It is a complete ecosystem: multiple release channels, native and WebAssembly targets, compiler tooling, security auditing, testing tools, and web, GUI, graphics, machine-learning and AI inference frameworks, plus many experimental projects.

The most important architectural fact:

Rustup owns the toolchains, Cargo owns the dependency and build ecosystem, and my individual projects own their compiled target directories.

      MY RUST ENVIRONMENT

            Rustup
              │
  ┌───────────┼───────────┐
  │           │           │
stable      beta       nightly
                          │
                          ▼
                        rustc
                          │
          ┌───────────────┼───────────────┐
          │               │               │
        Linux           WASM          Cargo tools
          │               │               │
          └───────────────┼───────────────┘
                          │
                        Cargo
                          │
         ┌────────────────┼────────────────┐
         │                │                │
      registry         Git cache        projects
                                            │
              ┌───────────┼───────────┐
              │           │           │
            Web          GUI          AI/ML
            Rust        Rust         Rust
              │           │           │
           Leptos     GPUI/Makepad    Burn
              │           │           │
            WASM       graphics       Candle/
                                        Linfa/
                                        ONNX

This page is the persistent reference point for my Rust environment as it evolves.