Rust Packages

In Rust, packages are a collection of one or more crates that collectively provide a set of functionality. Packages are defined by a Cargo.toml file located in the root directory. The Cargo.toml file specifies the package’s name, version, dependencies, and other metadata.

A package can contain multiple crates. Each crate can be either a library or a binary.

A library is a reusable piece of code that can be linked into other programs, whereas a binary is a standalone executable that can be run.

Packages are generally organized around a single, top-level crate that defines the main functionality of the package. Other crates in the package providing supporting functionality.

For example, a package might have a core crate that provides primary functionality and a utils crate providing additional utilities.

Packages are built and managed using Rust’s package manager, Cargo. Cargo can automatically download and manage dependencies, build and test packages, and publish packages to the package repository.

Packages and crates are both published to

Packages and Crates

A crate within a package is defined by for binary executables or file for libraries. We will cover both and below:

The file is the default entry point for a binary executable crate.

When we create a new binary crate using cargo new, Cargo automatically generates a file in the src directory of the crate. typically contains the main() function, which is the starting point of the binary executable. The main() function is where the program starts execution, and it typically contains the code that initializes the application, processes inputs, performs computations, and produces outputs.

It is also possible to define the main() function in a separate file and specify it as the entry point in the Cargo.toml file using the [[bin]] section. However for most simple projects, using as the entry point is the most straightforward approach.

While is the default entry point for an executable, is the default entry point for a library. We can create a new library crate using:

 cargo new <crate-name> --lib

When we create a new library, Cargo automatically generates a file in the src directory of the crate.

The file contains the code that defines the public API of the library. This typically involves defining one or more modules and the functions, structs, enums, and traits that they contain, and allows other Rust code to use it.

Here’s an example of a basic file in Rust:

pub mod utils {
    pub fn add(x: i32, y: i32) -> i32 {
        x + y

This code defines a public module called utils, which contains a public function called add(). add() takes two i32 values as arguments and returns their sum. Other Rust code can use this function by importing the utils module and then calling the add() function.

We can also define a library crate without using a file. Instead, you can define the public API in separate modules and specify them in the Cargo.toml file using the [[lib]] section. However, using as the entry point is the simplest and most straightforward approach for most library crates.