codesnips
toml 9 lines · 1 tab

Cargo workspaces for multi-crate projects

Marcus Chen Jan 2026
1 tab 
[workspace]
members = [
    "server",
    "client",
    "common",
]

[workspace.dependencies]
tokio = { version = "1", features = ["full"] }
1 file · toml Explain with highlit

For larger projects, I organize code into multiple crates within a Cargo workspace. The root Cargo.toml lists workspace members, and each crate has its own dependencies and Cargo.toml. This lets you split code into libraries and binaries, share code between crates, and build everything with one cargo build. Changes to a crate only rebuild that crate and its dependents. I use workspaces for microservices (shared common crate), CLIs with plugins, or libraries with separate test harnesses. The workspace also deduplicates dependencies: if two crates use tokio, they share the same version. This pattern scales well and keeps build times reasonable even for large codebases.

Related snips

rust 
struct Config<'a> {
    name: &'a str,
    value: &'a str,
}

fn parse_config(line: &str) -> Config {

Lifetime annotations for flexible borrowing in structs

rust lifetimes borrowing
by Marcus Chen 1 tab
rust 
use crossbeam::channel::unbounded;
use std::thread;

fn main() {
    let (tx, rx) = unbounded();

Crossbeam for advanced concurrent data structures

rust concurrency lock-free
by Marcus Chen 1 tab
rust 
use tracing::{info, instrument};

#[instrument]
fn process_request(user_id: u64) {
    info!(user_id, "Processing request");
    // Work happens here

tracing for structured logging and distributed tracing

rust observability tracing
by Marcus Chen 1 tab
rust 
use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

Channels (mpsc) for message passing between threads

rust concurrency channels
by Marcus Chen 1 tab
rust 
use clap::Parser;

#[derive(Parser, Debug)]
#[command(author, version, about)]
struct Args {
    #[arg(short, long)]

clap for CLI argument parsing with derive macros

rust cli clap
by Marcus Chen 1 tab
rust 
macro_rules! create_function {
    ($func_name:ident) => {
        fn $func_name() {
            println!("Called {}", stringify!($func_name));
        }
    };

Declarative macros (macro_rules!) for code generation

rust macros metaprogramming
by Marcus Chen 1 tab

Share this code

Here's the card — post it anywhere.

Cargo workspaces for multi-crate projects — share card
Link copied