How to Format Rust: A Practical Guide

Formatting Rust code means applying consistent indentation, spacing, line breaks, and source-code layout so that the program is easier to read and maintain. Rust has an established formatting workflow centered around rustfmt, which automates many of these decisions.

A formatter does not change the underlying purpose of your program. Its job is to make source code follow consistent formatting conventions. This is especially useful when multiple developers work on the same Rust project.

Formatting should be distinguished from compilation, testing, linting, and debugging. A neatly formatted Rust program can still contain logic errors or fail to compile.

rustfmt is the standard Rust formatting tool. It is commonly used through Cargo in Rust projects and can format source files according to the project's applicable formatting configuration.

A common command is cargo fmt, which formats the Rust code in a Cargo project. This makes formatting part of the normal Rust development workflow rather than a separate manual cleanup task.

Rust editors and IDEs can also integrate with rustfmt, allowing code to be formatted automatically or on demand.

Consistent formatting makes Rust source easier to scan, particularly when working with nested expressions, pattern matching, generic types, traits, lifetimes, and long function signatures.

Automated formatting also reduces arguments about whitespace and indentation. Developers can rely on the formatter instead of manually maintaining a project-wide visual style.

For teams, consistent formatting can produce cleaner diffs and make code reviews easier because unrelated formatting differences are reduced.

Here is an intentionally compressed Rust example with inconsistent spacing:

The formatted version separates statements and uses consistent indentation and spacing:

1. Open the Rust source file or Cargo project you want to format.

2. Make sure your current work is saved and preferably tracked in version control so formatting changes can be reviewed.

3. For a Cargo project, use the Rust formatting workflow, commonly cargo fmt.

4. Review the resulting changes rather than assuming every formatting operation should be accepted without inspection.

5. If the project has formatting configuration, make sure the formatter is using the project's intended configuration.

6. Run cargo check, cargo test, or the project's normal validation commands after formatting when appropriate.

7. Commit the formatting changes separately when doing so makes code review easier.

Rust functions can contain parameters, return types, generic parameters, where clauses, expressions, and nested blocks. Automatic formatting helps keep these declarations readable.

Function signatures that are short can remain on one line, while longer declarations may be expanded by the formatter to improve readability.

Rust structs commonly place each field on its own line. This becomes particularly helpful when a struct contains many fields or when field types are complex.

Struct literals also benefit from consistent indentation, especially when they contain nested values.

Enums and match expressions are important parts of Rust programming. Match arms can become difficult to scan when expressions contain nested logic, so consistent indentation is valuable.

Rust formatting tools help maintain a predictable layout even when match expressions become more complex.

Traits define shared behavior in Rust, while impl blocks provide implementations. Formatting keeps methods inside these blocks consistently indented and separates declarations clearly.

Rust projects often use modules and use statements to organize dependencies. Keeping module declarations and imports consistently formatted makes the top of a source file easier to understand.

Formatting and dependency management are separate concerns. A formatter can arrange source layout, but it should not be confused with Cargo's role in managing project dependencies.

Rust control-flow statements use braces and expressions in ways that benefit from consistent indentation. Nested if statements, loops, and blocks can quickly become difficult to read when manually formatted.

Automated formatting makes nested control flow predictable and helps visually separate conditions from the statements they control.

Closures are frequently used with iterators and collection methods in Rust. Short closures can remain compact, while more complex closures may need multiple lines.

Consistent formatting is particularly helpful when closures contain conditions, blocks, or multiple chained operations.

Rust uses macros such as println!, format!, vec!, and custom declarative or procedural macros. Macro calls often resemble function calls, but their syntax can contain additional complexity.

A Rust formatter can format supported Rust syntax around macro invocations, while the behavior of a custom macro remains the responsibility of the macro implementation.

Generic types and lifetime annotations can make Rust declarations visually dense. Consistent formatting helps separate generic parameters, references, bounds, and return types.

When a declaration becomes long, formatting tools can improve its structure without requiring developers to manually decide where every line should break.

Rust supports ordinary comments as well as documentation comments such as /// and //! . Documentation comments can become part of generated API documentation, so they should describe the intended public interface clearly.

A formatter can normalize the surrounding source layout, but it cannot determine whether documentation is accurate, complete, or useful.

Keep comments close to the code they explain and avoid comments that merely restate obvious syntax.

Rust projects can use formatting configuration when a team needs to control supported formatting behavior. A project-level configuration helps developers and automated systems use the same expectations.

Before changing formatting settings, check the project's existing configuration and development conventions. Unexpected configuration changes can create large diffs across an otherwise stable codebase.

Formatting and linting have different purposes in Rust. rustfmt focuses on source formatting, while Clippy provides additional linting and suggestions intended to identify patterns that may be improved.

A formatter does not determine whether an expression is idiomatic, efficient, secure, or logically correct. Those questions require compilation, testing, code review, and other analysis tools.

A practical Rust workflow can therefore use formatting together with cargo check, cargo test, and linting rather than treating formatting as a complete quality check.

An online code formatter can be convenient when you need to quickly inspect or clean up Rust source without configuring a local environment.

Paste supported Rust code into the formatter, select Rust if the interface requires a language selection, run the formatting operation, and review the output before copying it back into your project.

Online tools can differ from the official rustfmt implementation. When exact rustfmt compatibility is important, use the Rust toolchain as the final reference.

Rust development in VS Code can be configured to use Rust tooling for formatting. When the editor is connected to the appropriate Rust language tooling, formatting can be triggered manually or configured as part of the save workflow.

The exact editor configuration can vary depending on the Rust extension and project setup. If a repository already has formatting conventions, follow those conventions rather than introducing a conflicting editor configuration.

One common mistake is manually adjusting whitespace throughout a project instead of relying on rustfmt. Automated formatting exists specifically to reduce this repetitive work.

Another mistake is assuming that formatting and linting are interchangeable. rustfmt can organize the appearance of source code, but it does not replace Clippy or compiler diagnostics.

It is also easy to format only one file when a project-wide formatting pass is needed. For Cargo projects, consider the appropriate project-level formatting workflow.

Finally, do not assume that an arbitrary online formatter produces exactly the same output as rustfmt. Verify important source with the official toolchain when compatibility matters.

Format Rust code before committing changes, during development, before code review, and whenever a project contains inconsistent source layout.

Many teams integrate formatting into their editor or automated development workflow. The important goal is to make formatting predictable so developers do not need to spend code-review time discussing minor whitespace differences.

MartTools includes a Code Formatter for cleaning up supported source code directly in the browser. If you are working with Rust, you can use it to inspect formatting when Rust is supported by the current formatter configuration.

For exact Rust formatting, especially in a production project, rustfmt remains the authoritative tool to compare against. This is useful when an online formatter and the official Rust toolchain produce different results.

When using an online formatter with private source code, review the service's privacy expectations before submitting proprietary or confidential code.

Before committing formatted Rust code, check that imports and modules remain correct, functions and methods are readable, structs and enums have clear layouts, match expressions are properly structured, closures are easy to scan, comments remain useful, and the project still compiles and passes its tests.

Use automated formatting consistently. A shared formatting workflow reduces unnecessary style differences and allows Rust code reviews to focus more closely on behavior and design.