Rustfmt: The Essential Guide for Code Consistency and Productivity

rust-lang/rustfmt

rustfmt is the official code formatter for the Rust programming language. Its core purpose is to automatically reformat your Rust code according to a set of standardized style guidelines, making your code consistent, readable, and maintainable.

From a software engineer's perspective, rustfmt is incredibly helpful because it

Enforces Consistency
It eliminates bikeshedding (time spent debating formatting rules) by applying a single, agreed-upon style across your entire codebase and team. This makes navigating different files much easier.

Improves Readability
Consistent formatting, especially for things like indentation, line wrapping, and spacing, drastically reduces cognitive load when reading code, allowing developers to focus on the logic, not the presentation.

Streamlines Code Reviews
When formatting is automated, code reviews can focus solely on the logic, algorithms, and architecture of the code, rather than minor style violations. This saves a lot of time and makes reviews more productive.

Standardizes the Ecosystem
Since it's the official tool, using rustfmt ensures your code adheres to the common style used across the broader Rust community, making it easier for others to contribute to your projects.

Fortunately, rustfmt is typically included with the Rust toolchain if you installed Rust using rustup, which is the recommended way. You likely already have it!

You can verify that rustfmt is installed by running this command in your terminal

rustfmt --version

If it's missing (which is rare if you use rustup), you can install it manually

rustup component add rustfmt

To format a single Rust file (e.g., src/main.rs), navigate to your project directory and run

rustfmt src/main.rs

To format your entire project, you usually run this command from the project root

cargo fmt

The cargo fmt command is a convenient wrapper that finds all Rust files in your project and runs rustfmt on them. This is the preferred way to use it.

As a software engineer, the best way to introduce rustfmt to your team is by making it a mandatory step in your development workflow and Continuous Integration (CI) process.

Pre-commit Hook
Integrate rustfmt into a pre-commit hook (using tools like husky or pre-commit). This automatically formats code before it's committed, ensuring no unformatted code ever makes it to the repository.

CI Check
Add a step to your CI pipeline that checks if the code is properly formatted. You can run cargo fmt -- --check. If the code isn't formatted, the CI pipeline fails, preventing unformatted code from being merged.

While rustfmt aims for a minimal configuration approach, you can customize some aspects using a configuration file named rustfmt.toml in your project root.

Here is an example of a configuration file where we might tweak a couple of common options

# Maximum width of a line, in characters.
# The default is 100. Let's set it to 120 for wider screens.
max_width = 120

# Whether to put a space around binary operators.
# The default is 'Always'.
spaces_around_ranges = true

# Use 'Always' to force all items to have a trailing comma, even in single-line lists.
# This helps with cleaner diffs when adding new items.
trailing_comma = "Always"

Imagine you have this slightly inconsistently formatted code in src/lib.rs

// Code BEFORE rustfmt
pub fn calculate_area ( length : f64 , width : f64 ) -> f64
{
    let area = length * width ;

    if area > 100.0 { println ! ( "Large area!" ) ; }

    return area
}

Now, when you run cargo fmt, rustfmt automatically corrects the spacing, indentation, and uses standard Rust conventions for control flow and returns.

// Code AFTER rustfmt
pub fn calculate_area(length: f64, width: f64) -> f64 {
    let area = length * width;

    if area > 100.0 {
        println!("Large area!");
    }

    area // Rust convention: omit 'return' for the final expression
}