# How Dependencies Are Managed in the macro-inc/macro Rust Project

> Discover how the macro-inc/macro Rust project manages dependencies across 80 crates using a Cargo workspace, centralized versions, and xtask automation for efficient development.

- Repository: [Macro/macro](https://github.com/macro-inc/macro)
- Tags: internals
- Published: 2026-08-15

---

**The macro-inc/macro repository uses a Cargo workspace with centralized `[workspace.dependencies]` in the root [`Cargo.toml`](https://github.com/macro-inc/macro/blob/main/Cargo.toml) to coordinate versions across approximately 80 crates, supplemented by automated tooling via `xtask` and a `workspace-hack` crate for build stability.**

The macro-inc/macro project is a large-scale Rust monorepo where dependency management requires strict consistency across dozens of interconnected services. Understanding how this repository handles version pinning, feature flags, and automated maintenance provides a blueprint for managing complex Rust workspaces.

## Centralized Workspace Dependency Control

All dependency versions in the macro-inc/macro project are defined in a single source of truth: the `[workspace.dependencies]` table in the root [`Cargo.toml`](https://github.com/macro-inc/macro/blob/main/Cargo.toml). This approach eliminates version drift and ensures that every crate in the workspace uses identical library versions.

The workspace configuration explicitly declares versions, Git sources, and feature flags for all shared dependencies. For example, AWS SDK crates are pinned to specific versions with default features disabled to minimize compilation overhead:

```toml

# Root Cargo.toml

[workspace.dependencies]
aws-sdk-s3 = "1.132.0"
tokio = { version = "1.43.0", features = ["macros", "rt-multi-thread"] }
serde = { version = "1.0.214", features = ["derive"] }

```

This centralization means that when a security patch or version update is needed, developers modify only the root [`Cargo.toml`](https://github.com/macro-inc/macro/blob/main/Cargo.toml), and the change propagates automatically to all 80+ member crates.

## Inheriting Dependencies in Member Crates

Individual crates within the workspace inherit dependencies from the central table without redeclaring version numbers. In [`crates/bots/Cargo.toml`](https://github.com/macro-inc/macro/blob/main/crates/bots/Cargo.toml) and other member manifests, dependencies reference the workspace definition using implicit inheritance:

```toml

# crates/bots/Cargo.toml

[package]
name = "bots"
version = "0.1.0"
edition = "2024"

[dependencies]

# Inherits tokio from workspace.dependencies without version specification

tokio = { workspace = true }
serde = { workspace = true }

```

If a specific crate requires a different version or additional features not defined at the workspace level, it can override the default by specifying the full dependency details in its local [`Cargo.toml`](https://github.com/macro-inc/macro/blob/main/Cargo.toml). However, the macro-inc/macro codebase rarely uses this exception, as the centralized list covers the vast majority of use cases.

## Automated Dependency Graph Maintenance with xtask

The repository includes a dedicated `xtask` sub-project located at `tooling/xtask` that automates dependency metadata regeneration. The `xtask_deps` crate (`tooling/xtask/crates/xtask_deps`) utilizes the **hakari** crate to maintain the workspace's dependency closure map and regenerate the `workspace-hack` configuration.

This automation ensures that cargo's resolver maintains a stable, reproducible dependency graph across different development environments and CI pipelines.

### The workspace-hack Crate

Located at [`crates/workspace-hack/Cargo.toml`](https://github.com/macro-inc/macro/blob/main/crates/workspace-hack/Cargo.toml), this dummy crate forces cargo to eagerly resolve all workspace dependencies during the initial compilation phase. The workspace-hack pattern improves build stability for CI environments and supports offline builds by ensuring the entire dependency graph is calculated upfront rather than lazily during individual crate compilation.

To manually regenerate the dependency closure map and update the workspace-hack, developers run:

```bash
cargo run -p xtask_deps -- --output ./target/deps.json

```

## Developer Workflow and Tooling Integration

The project integrates dependency management into daily workflows through **just** commands. The `justfile` at the repository root provides standardized tasks that invoke xtask scripts to validate dependency consistency:

- **`just build`** – Compiles the workspace while respecting the centralized dependency versions
- **`just clippy`** – Runs linting across all crates with consistent dependency resolution
- **Dependency updates** – Running `cargo update` and `cargo check` through xtask validates that the workspace dependency graph remains consistent after modifications

This tooling integration ensures that dependency changes are never committed without verification against the workspace-wide configuration.

## Summary

- The macro-inc/macro repository manages dependencies through a Cargo workspace with centralized version control in `[workspace.dependencies]` at the root [`Cargo.toml`](https://github.com/macro-inc/macro/blob/main/Cargo.toml).
- All 80+ member crates inherit dependency versions automatically, ensuring consistency across services while allowing local overrides when necessary.
- The `xtask_deps` utility in `tooling/xtask/crates/xtask_deps` automates maintenance of the dependency graph using the hakari crate.
- The `workspace-hack` crate (`crates/workspace-hack`) forces eager dependency resolution for stable CI and offline builds.
- Developer workflows use `just` commands to validate dependency consistency before committing changes.

## Frequently Asked Questions

### How do I add a new dependency to the macro-inc/macro workspace?

Add the dependency to the `[workspace.dependencies]` table in the root [`Cargo.toml`](https://github.com/macro-inc/macro/blob/main/Cargo.toml) with the exact version and required features. Then reference it in your crate's [`Cargo.toml`](https://github.com/macro-inc/macro/blob/main/Cargo.toml) using `dependency-name = { workspace = true }`. This ensures the new dependency is available to all crates while maintaining a single source of truth for version numbers.

### What is the purpose of the workspace-hack crate in this repository?

The workspace-hack crate acts as a dummy member that forces cargo to resolve the entire workspace dependency graph eagerly rather than lazily. This improves build stability in CI environments and supports scenarios requiring offline builds, as all dependencies are resolved during the initial compilation phase rather than during individual crate builds.

### How does the xtask tooling help with dependency management?

The `xtask_deps` crate located at `tooling/xtask/crates/xtask_deps` uses the hakari library to regenerate the workspace's dependency closure map and update the workspace-hack configuration. This automation ensures that changes to the dependency graph are accurately reflected across the workspace without manual intervention, reducing the risk of resolution conflicts.

### Can individual crates use different versions of the same dependency?

Yes, individual crates can override workspace defaults by specifying the full dependency details (including version) in their local [`Cargo.toml`](https://github.com/macro-inc/macro/blob/main/Cargo.toml). However, the macro-inc/macro codebase rarely uses this capability, as the centralized `[workspace.dependencies]` table is designed to provide consistent versions across all services to prevent compatibility issues.