Rust Cargo
Tags: rust, programming, tutorial, beginners
Published: 2022-03-20 23:32:54

## What is Cargo

Cargo is Rust’s build system and package manager. Most Rustaceans use this tool to manage their Rust projects because Cargo handles a lot of tasks for you, such as building your code, downloading the libraries your code depends on (dependencies), and building those libraries.

The simplest Rust programs, like the one we’ve written so far, don’t have any dependencies. So if we had built the “Hello, world!” project with Cargo, it would only use the part of Cargo that handles building your code. As you write more complex Rust programs, you’ll add dependencies, and if you start a project using Cargo, adding dependencies will be much easier to do.

## Creating a Project with Cargo

Navigate back to your projects directory (or wherever you store your code). Then, on any operating system, run the following:

```PowerShell
> cargo new hello_cargo
> cd hello_cargo
```

The first command created a new directory called hello_cargo. We’ve named our project hello_cargo, and Cargo creates its files in a directory of the same name.

Cargo will generate two files and one directory for us:

* Cargo.toml file
* src directory with a main.rs file inside

It will also initialize a new Git repository along with a *.gitignore* file. Git files won’t be generated if you run `cargo new` within an existing Git repository; you can override this behavior by using `cargo new --vcs=git`.

### Filename: Cargo.toml

```PowerShell
[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2021"

[dependencies]
```

This file is in the TOML (Tom’s Obvious, Minimal Language) format, which is Cargo’s configuration format.

The first line, `[package]`, is a section heading that indicates that the following statements are configuring a package. As we add more information to this file, we’ll add other sections.

The next three lines set the configuration information Cargo needs to compile your program: the name, the version, and the edition of Rust to use.

The last line, `[dependencies]`, is the start of a section for you to list any of your project’s dependencies. In Rust, packages of code are referred to as *crates*.

### Filename: src/main. rs

```Rust
fn main() {
    println!("Hello, world!");
}
```

Cargo has generated a “Hello, world!” program for you. Cargo expects your source files to live inside the *src* directory. The top-level project directory is just for README files, license information, configuration files, and anything else not related to your code. Using Cargo helps you organize your projects. There’s a place for everything, and everything is in its place.

If you started a project that doesn’t use Cargo, as we did previously with the “Hello, world!” project, you can convert it to a project that does use Cargo. Move the project code into the *src* directory and create an appropriate *Cargo.toml* file.

## Building and Running a Cargo Project

Now let’s look at what’s different when we build and run the “Hello, world!” program with Cargo. From your *hello_cargo* directory, build your project by entering the following command:

```PowerShell
> cargo build
```

This command creates an executable file in *target\debug\hello_cargo.exe* rather than in your current directory. You can run the executable with this command:

```PowerShell
> .\target\debug\hello_cargo.exe
Hello, world!
```

If all goes well, `Hello, world!` should print to the terminal. Running `cargo build` for the first time also causes Cargo to create a new file at the top level: *Cargo.lock*. This file keeps track of the exact versions of dependencies in your project. This project doesn’t have dependencies, so the file is a bit sparse. You won’t ever need to change this file manually; Cargo manages its contents for you.

We just built a project with `cargo build` and ran it with `.\target\debug\hello_cargo.exe`, but we can also use cargo run to compile the code and then run the resulting executable all in one command:

```PowerShell
> cargo run
Hello, world!
```

Cargo also provides a command called `cargo check`. This command quickly checks your code to make sure it compiles but doesn’t produce an executable:

```PowerShell
> cargo check
```

Why would you not want an executable? Often, `cargo check` is much faster than `cargo build`, because it skips the step of producing an executable. If you’re continually checking your work while writing the code, using `cargo check` will speed up the process! As such, many Rustaceans run `cargo check` periodically as they write their program to make sure it compiles. Then they run `cargo build` when they’re ready to use the executable.

* We can build a project using c`argo build`.
* We can build and run a project in one step using `cargo run`.
* We can build a project without producing a binary to check for errors using `cargo check`.
* Instead of saving the result of the build in the same directory as our code, Cargo stores it in the *target/debug* directory.

An additional advantage of using Cargo is that the commands are the same no matter which operating system you’re working on.

## Building for Release

When your project is finally ready for release, you can use cargo build --release to compile it with optimizations. This command will create an executable in *target/release* instead of *target/debug*. The optimizations make your Rust code run faster, but turning them on lengthens the time it takes for your program to compile. This is why there are two different profiles:

* One for development, when you want to rebuild quickly and often
* Another for building the final program you’ll give to a user that won’t be rebuilt repeatedly and that will run as fast as possible.

## Cargo as Convention

With simple projects, Cargo doesn’t provide a lot of value over just using `rustc`, but it will prove its worth as your programs become more intricate. With complex projects composed of multiple crates, it’s much easier to let Cargo coordinate the build.

Even though the `hello_cargo` project is simple, it now uses much of the real tooling you’ll use in the rest of your Rust career. In fact, to work on any existing projects, you can use the following commands to check out the code using Git, change to that project’s directory, and build:

```PowerShell
> git clone example.org/someproject
> cd someproject
> cargo build
```