0Pricing
Learn Rust Coding · Lesson

Managing Dependencies with Crates

Understand how Cargo manages external crates (libraries) and how to publish your own for community use.

Managing Dependencies with Crates is a free Learn Rust Coding lesson on CoddyKit — lesson 2 of 3. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Learn Rust Coding learning path, one of 3 lessons in the course, and your progress syncs across the web and the CoddyKit app.

What are Crates & Cargo?

In Rust, a crate is the fundamental unit of compilation and distribution. Think of it as a package or a library that contains your code.

Cargo is Rust's official package manager and build system. It handles everything from creating new projects to managing dependencies, compiling code, and running tests. It's your best friend for Rust development!

The `Cargo.toml` File

Every Rust project managed by Cargo has a Cargo.toml file in its root directory. This is your project's manifest file, written in TOML (Tom's Obvious, Minimal Language).

It defines metadata about your project and, most importantly, lists its dependencies.

Project Configuration

The [package] section in Cargo.toml holds essential information about your crate:

  • name: Your crate's name.
  • version: Its current version.
  • edition: Which Rust edition to use (e.g., 2021).
  • authors: Who created it.

These details are crucial, especially if you plan to publish your crate.

Adding Dependencies

To use external libraries (other crates) in your project, you list them under the [dependencies] section in Cargo.toml.

When you build your project, Cargo automatically downloads and compiles these dependencies from crates.io, Rust's central package registry.

Dependency Syntax

Here's how you declare a dependency in your Cargo.toml:

[dependencies] rand = "0.8.5"

This tells Cargo to fetch version 0.8.5 of the rand crate. You can also specify version ranges or local paths.

Using a Crate: Example

Let's add the rand crate to generate a random number. First, ensure rand = "0.8.5" is in your [dependencies]. Then, use it in your code:

use rand::Rng; // Import the Rng trait

fn main() {
  let mut rng = rand::thread_rng(); // Create a random number generator
  let n: u8 = rng.gen_range(1..=10); // Generate a number between 1 and 10 (inclusive)
  println!("Your random number is: {}", n);
}

The `Cargo.lock` File

After building with dependencies, Cargo creates a Cargo.lock file. This file records the exact versions of all direct and transitive dependencies used in your project.

It ensures that everyone working on the project uses the same dependency versions, leading to reproducible builds across different environments.

Updating Dependencies

Over time, your dependencies might release new versions with bug fixes or new features. To update them, you use the cargo update command.

This command checks crates.io for newer versions that match the version requirements in your Cargo.toml and updates Cargo.lock accordingly.

Publishing Your Own Crate

Want to share your awesome Rust code with the community? You can publish your own crate to crates.io!

Before publishing, make sure your Cargo.toml has proper metadata like description, license, and repository links.

Publishing Commands

The process is straightforward:

  1. Log in: Use cargo login <token> with an API token from crates.io.
  2. Publish: Run cargo publish from your project's root directory.

Cargo will perform checks, package your code, and upload it, making it available for others to use!

Quick Check: Cargo & Crates

Which of the following statements about Rust's package management with Cargo are true?

Recap: Managing Dependencies

You've learned how Cargo is essential for managing Rust projects and their dependencies!

  • Crates are reusable code packages.
  • Cargo.toml defines your project and its dependencies.
  • Cargo.lock ensures reproducible builds.
  • You can publish your own crates to crates.io.

This powerful system makes sharing and reusing code in Rust incredibly efficient and reliable.

Frequently asked questions

Is the “Managing Dependencies with Crates” lesson free?

Yes — the full text of “Managing Dependencies with Crates” is free to read here on the web, and the Learn Rust Coding course includes 3 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Learn Rust Coding course, upgrade to CoddyKit PRO.

What will I learn in “Managing Dependencies with Crates”?

Understand how Cargo manages external crates (libraries) and how to publish your own for community use. You practise Learn Rust Coding with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Learn Rust Coding?

No prior experience is required. Learn Rust Coding on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 3, so you can start here or from the beginning and move at your own pace.

How long does the “Managing Dependencies with Crates” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Learn Rust Coding lesson?

Yes. Every Learn Rust Coding lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Organizing Code with Modules
  2. Managing Dependencies with Crates
  3. Robust Error Handling with `Result`
← Back to Learn Rust Coding