Rust Debugging

mohitmishra786/low-level-dev-skills/skills/rust/rust-debugging

by mohitmishra786bdc58472fa9fNo license253 starsListed Oct 9, 2026Updated Oct 9, 2026Repository updated 3 months ago

Rust debugging skill for systems programming. Use when debugging Rust binaries with GDB or LLDB, enabling Rust pretty-printers, interpreting panics and backtraces, debugging async/await with tokio-console, stepping through no_std code, or using dbg! and tracing macros effectively. Activates on queries about rust-gdb, rust-lldb, RUST_BACKTRACE, Rust panics, debugging async Rust, tokio-console, or pretty-printers.

Instructions onlySoftware Development

AI-generated overview

Guides debugging Rust programs with GDB/LLDB, backtraces, panic triage, async tracing and no_std strategies.

What it does: This skill provides instructions for debugging Rust binaries: building with debug info, using rust-gdb and rust-lldb with Rust pretty-printers, configuring RUST_BACKTRACE, triaging common panic messages, and using the dbg! macro and tracing for structured logging. It also covers async debugging with tokio-console and stepping through no_std code. It produces guidance and command references rather than executable tooling, with a reference file on GDB pretty-printer setup.
When to use it: Use it when investigating Rust crashes, panics or backtraces, when GDB or LLDB pretty-printers are not showing String, Vec or Option values correctly, or when debugging async Tokio tasks and no_std targets.
Requirements: Requires a Rust toolchain with cargo, and debuggers such as GDB or LLDB with the rust-gdb/rust-lldb wrappers. Optional dependencies include the tracing and tracing-subscriber crates, console-subscriber with tokio, and the tokio-console binary. No scripts are shipped; the skill is instructions plus one reference document.

Rust Debugging

Purpose

Guide agents through debugging Rust programs: GDB/LLDB with Rust pretty-printers, backtrace configuration, panic triage, async debugging with tokio-console, and #[no_std] debugging strategies.

Triggers

"How do I use GDB/LLDB to debug a Rust binary?"
"How do I get a full backtrace from a Rust panic?"
"How do I debug async Rust / Tokio?"
"Rust pretty-printers aren't working in GDB"
"How do I debug a Rust panic in production?"
"How do I use dbg! and tracing in Rust?"

Workflow

1. Build for debugging

bash

# Debug build (default) — full debug info, no optimizationcargo build
# Release with debug info (for profiling real workloads)cargo build --release --profile release-with-debug# Or configure in Cargo.toml:# [profile.release-with-debug]# inherits = "release"# debug = true
# Run directlycargo runcargo run -- arg1 arg2

# Debug build (default) — full debug info, no optimizationcargo build
# Release with debug info (for profiling real workloads)cargo build --release --profile release-with-debug# Or configure in Cargo.toml:# [profile.release-with-debug]# inherits = "release"# debug = true
# Run directlycargo runcargo run -- arg1 arg2

2. GDB with Rust pretty-printers

bash

# Use rust-gdb wrapper (sets up pretty-printers automatically)rust-gdb target/debug/myapp
# Or set up manually in ~/.gdbinit:# python# import subprocess, sys# ...

# Use rust-gdb wrapper (sets up pretty-printers automatically)rust-gdb target/debug/myapp
# Or set up manually in ~/.gdbinit:# python# import subprocess, sys# ...

Common GDB session for Rust:

gdb

# Basic(gdb) break main(gdb) run arg1 arg2(gdb) next           # step over(gdb) step           # step into(gdb) continue
# Rust-aware inspection(gdb) print my_string     # Shows String content via pretty-printer(gdb) print my_vec        # Shows Vec elements(gdb) print my_option     # Shows Some(value) or None(gdb) info locals
# Break on panic(gdb) break rust_panic(gdb) break core::panicking::panic
# Backtrace(gdb) bt              # Short backtrace(gdb) bt full         # Full with locals

# Basic(gdb) break main(gdb) run arg1 arg2(gdb) next           # step over(gdb) step           # step into(gdb) continue
# Rust-aware inspection(gdb) print my_string     # Shows String content via pretty-printer(gdb) print my_vec        # Shows Vec elements(gdb) print my_option     # Shows Some(value) or None(gdb) info locals
# Break on panic(gdb) break rust_panic(gdb) break core::panicking::panic
# Backtrace(gdb) bt              # Short backtrace(gdb) bt full         # Full with locals

3. LLDB with Rust pretty-printers

bash

# Use rust-lldb wrapperrust-lldb target/debug/myapp
# Manual setuplldb target/debug/myapp(lldb) command script import /path/to/rust/lib/rustlib/etc/lldb_lookup.py(lldb) command source /path/to/rust/lib/rustlib/etc/lldb_commands

# Use rust-lldb wrapperrust-lldb target/debug/myapp
# Manual setuplldb target/debug/myapp(lldb) command script import /path/to/rust/lib/rustlib/etc/lldb_lookup.py(lldb) command source /path/to/rust/lib/rustlib/etc/lldb_commands

Common LLDB session:

lldb

(lldb) b main::main(lldb) r arg1 arg2(lldb) n              # next (step over)(lldb) s              # step into(lldb) c              # continue(lldb) frame variable # show locals(lldb) p my_string    # print variable with pretty-printer(lldb) bt             # backtrace(lldb) bt all         # all threads

(lldb) b main::main(lldb) r arg1 arg2(lldb) n              # next (step over)(lldb) s              # step into(lldb) c              # continue(lldb) frame variable # show locals(lldb) p my_string    # print variable with pretty-printer(lldb) bt             # backtrace(lldb) bt all         # all threads

4. Backtrace configuration

bash

# Short backtrace (default on panic)RUST_BACKTRACE=1 ./myapp
# Full backtrace with all framesRUST_BACKTRACE=full ./myapp
# With symbols (requires debug build or separate debug info)RUST_BACKTRACE=full ./target/debug/myapp
# Capture backtrace programmaticallyuse std::backtrace::Backtrace;let bt = Backtrace::capture();eprintln!("{bt}");

# Short backtrace (default on panic)RUST_BACKTRACE=1 ./myapp
# Full backtrace with all framesRUST_BACKTRACE=full ./myapp
# With symbols (requires debug build or separate debug info)RUST_BACKTRACE=full ./target/debug/myapp
# Capture backtrace programmaticallyuse std::backtrace::Backtrace;let bt = Backtrace::capture();eprintln!("{bt}");

For release binaries, keep debug symbols in a separate file:

bash

# Build release with debug infocargo build --releaseobjcopy --only-keep-debug target/release/myapp target/release/myapp.debugstrip --strip-debug target/release/myappobjcopy --add-gnu-debuglink=target/release/myapp.debug target/release/myapp

# Build release with debug infocargo build --releaseobjcopy --only-keep-debug target/release/myapp target/release/myapp.debugstrip --strip-debug target/release/myappobjcopy --add-gnu-debuglink=target/release/myapp.debug target/release/myapp

5. Panic triage

rust

// Set a custom panic hook for structured logginguse std::panic;
panic::set_hook(Box::new(|info| {    let backtrace = std::backtrace::Backtrace::force_capture();    eprintln!("PANIC: {info}");    eprintln!("{backtrace}");    // Log to file, send to Sentry, etc.}));

// Set a custom panic hook for structured logginguse std::panic;
panic::set_hook(Box::new(|info| {    let backtrace = std::backtrace::Backtrace::force_capture();    eprintln!("PANIC: {info}");    eprintln!("{backtrace}");    // Log to file, send to Sentry, etc.}));

Common panic patterns:

Panic message	Likely cause
`index out of bounds: the len is N but the index is M`	Array/vec OOB access
`called Option::unwrap() on a None value`	Unwrap on None
`called Result::unwrap() on an Err value`	Unwrap on error
`attempt to subtract with overflow`	Integer underflow (debug build)
`assertion failed`	Failed `assert!` or `assert_eq!`
`stack overflow`	Infinite recursion

Use panic = "abort" in release to get a crash dump instead of unwind.

6. The dbg! macro

rust

// dbg! prints file, line, value and returns the valuelet result = dbg!(some_computation(x));// prints: [src/main.rs:15] some_computation(x) = 42
// Chain multiple valueslet (a, b) = dbg!((compute_a(), compute_b()));
// Inspect inside iterator chainslet sum: i32 = (0..10)    .filter(|x| dbg!(x % 2 == 0))    .map(|x| dbg!(x * x))    .sum();

// dbg! prints file, line, value and returns the valuelet result = dbg!(some_computation(x));// prints: [src/main.rs:15] some_computation(x) = 42
// Chain multiple valueslet (a, b) = dbg!((compute_a(), compute_b()));
// Inspect inside iterator chainslet sum: i32 = (0..10)    .filter(|x| dbg!(x % 2 == 0))    .map(|x| dbg!(x * x))    .sum();

7. Structured logging with tracing

rust

use tracing::{debug, error, info, instrument, warn};
#[instrument]  // Auto-traces function entry/exit with argumentsfn process(id: u64, data: &str) -> Result<(), Error> {    debug!("Processing item");    info!(item_id = id, "Started processing");
    if data.is_empty() {        warn!(item_id = id, "Empty data");        return Err(Error::EmptyData);    }
    error!(item_id = id, err = ?some_result, "Failed");    Ok(())}
// Initialize in maintracing_subscriber::fmt()    .with_env_filter("myapp=debug,warn")    .init();

use tracing::{debug, error, info, instrument, warn};
#[instrument]  // Auto-traces function entry/exit with argumentsfn process(id: u64, data: &str) -> Result<(), Error> {    debug!("Processing item");    info!(item_id = id, "Started processing");
    if data.is_empty() {        warn!(item_id = id, "Empty data");        return Err(Error::EmptyData);    }
    error!(item_id = id, err = ?some_result, "Failed");    Ok(())}
// Initialize in maintracing_subscriber::fmt()    .with_env_filter("myapp=debug,warn")    .init();

8. Async debugging with tokio-console

bash

# Install and run tokio-consolecargo install tokio-consoletokio-console  # Connects to running Rust process at port 6669

# Install and run tokio-consolecargo install tokio-consoletokio-console  # Connects to running Rust process at port 6669

tokio-console shows: task states, waker activity, blocked tasks, poll durations.

For GDB/LLDB command reference and pretty-printer setup, see references/rust-gdb-pretty-printers.md [blocked].

Related skills

Use skills/rust/rustc-basics for debug info flags and build configuration
Use skills/debuggers/gdb for GDB fundamentals
Use skills/debuggers/lldb for LLDB fundamentals
Use skills/rust/rust-sanitizers-miri for memory safety and undefined behaviour

Source and attribution

Source:mohitmishra786/low-level-dev-skillsinskills/rust/rust-debuggingat commitbdc5847

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

Rust Debugging

Rust Debugging

Purpose

Triggers

Workflow

1. Build for debugging

2. GDB with Rust pretty-printers

3. LLDB with Rust pretty-printers

4. Backtrace configuration

5. Panic triage

6. The dbg! macro

7. Structured logging with tracing

8. Async debugging with tokio-console

Related skills

Source and attribution

More from mohitmishra786/low-level-dev-skills

Zig Debugging

Simd Intrinsics

Zig Cross

Rustc Basics

Zig Cinterop

Zig Build System

More in Software Development

Playground

M5 Onboard

Cardputer Buddy

Web Design Guidelines

Vercel React Native Skills

Vercel React Best Practices