TL;DR
Get the latest gadgets delivered free with Prime
- Fast, free delivery on millions of items
- Prime Video, Amazon Music and more included
- Member-only deals all year
Google’s Rust Style Guide sets rules for writing and organizing Rust code, with a scope that extends well beyond formatting to APIs, ownership and implementation choices. Google says the guidance aims to improve readability, maintainability and consistency, while supporting large-scale code changes; other codebases may decide how strictly to apply it.
Google’s Rust Style Guide sets shared rules for how the company’s developers should write, organize and design Rust code, covering API choices and implementation practices as well as formatting. The document says Rust is used across Google projects and is intended to improve consistency within and between codebases, though adoption and enforcement may differ among teams.
The guide describes style as more than how code looks. Its rules address crate and file organization, imports, ownership and borrowing, function inputs and outputs, error reporting, traits, generics, concurrency, documentation, unsafe code and testing. It recommends following public Rust conventions where they do not conflict with Google’s guidance, and says most formatting rules are handled automatically by rustfmt.
Among its specific recommendations, the document favors borrowing over deep copies, named fields over tuples in many cases, and deriving standard traits where possible. It advises developers to prefer pattern matching to checking and then unwrapping, use expect rather than unwrap in the situations covered by the guide, and avoid unclear iterator chains when direct iteration is easier to read. Some rules are labeled for particular environments, including Chrome and Fuchsia.
The guide says its scope extends beyond Google’s own code. It was developed in consultation with other codebases, including Android and Chromium, which the document says intend to begin applying it. The guide cautions that those projects may set their own expectations for how strictly its rules are followed; it does not give a single adoption timetable or uniform enforcement policy.
A common guide can give developers and reviewers a shared basis for decisions that otherwise recur in code reviews, from import choices to the shape of public APIs. Google says readability and maintainability take priority over making code quicker to write, on the grounds that software is expected to remain in use for long periods.
The document also connects consistency to large-scale changes, which Google says are common in its codebases. Similar patterns across projects can make broad automated edits easier to carry out. For developers working across teams, the guide may reduce variation, but its practical effect will depend on which projects adopt it and how their local rules interact with it.
As an affiliate, we earn on qualifying purchases.
How the Guide Sets Its Scope
The guide frames its rules around several goals: readability, maintainability, support for automation, compatibility with wider Rust conventions and avoiding rules that do not provide a tangible benefit. It says Google’s recommendations should generally align with the public Rust style rules and Rust API Guidelines, except where the Google document deliberately takes a different approach.
That qualification matters because the guide is not simply a formatting manual. It includes organizational and design recommendations, such as preferring small crates, avoiding glob imports and keeping APIs in appropriate modules. It also contains environment-specific guidance—for example, restrictions on async code or starting threads are marked for Chrome, rather than presented as universal Rust rules for every project.
The source document identifies Google’s Rust use in google3, Android, ChromeOS, Fuchsia and Chrome. It says the rules are intended to support consistency across those settings, while recognizing that codebases outside Google may have their own adoption practices.
As an affiliate, we earn on qualifying purchases.
Adoption Varies by Codebase
The guide does not establish a single compliance schedule for Android, Chromium or other external codebases. It says those projects intend to start applying the guidance but may differ in how strictly they expect teams to follow it. The source also does not quantify how widely the rules are already in use or describe enforcement mechanisms across projects.
Some recommendations are explicitly tagged for particular environments, so readers should not assume every rule applies to every Google Rust project. The document’s stated scope and project-specific labels are the available indicators; team-level implementation details are not specified in the supplied material.
As an affiliate, we earn on qualifying purchases.
Project Teams Set Local Practice
The next step described by the guide is for Android, Chromium and other consulted codebases to begin applying it according to their own requirements. The document says further information may be added as those projects adopt the guidance, but it does not announce a date for that update.
For developers, the practical next step is to check the guide’s scope labels and the rules used by their own project, rather than treating every recommendation as universal. Google’s document presents itself as a shared reference for coding and review; how consistently that reference shapes day-to-day work remains dependent on local adoption.
Rust ownership and borrowing reference
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
Key Questions
What is Google’s Rust Style Guide?
It is a set of Google recommendations for writing Rust code. It covers formatting, code organization, API design and implementation, among other topics.
Is the guide only about formatting?
No. The document says most formatting conventions are handled by rustfmt, while the guide also addresses ownership, imports, errors, traits, concurrency, documentation and testing.
Does every rule apply to every project?
No. Some recommendations are marked for specific environments, including Chrome and Fuchsia. The guide also says other codebases may set their own expectations for how strictly to apply it.
Why did Google publish the guidance?
Google says it aims to improve readability, maintainability and consistency, support large-scale code changes, and reduce repeated disagreements over style.
When will Android and Chromium adopt it?
The guide says those codebases intend to start applying it, but it provides no specific timetable and says adoption strictness may vary.
Source: hn
Halloween Picks
halloween
As an affiliate, we earn on qualifying purchases.
