Software projects often rely on multiple tools to maintain consistent code formatting. Each language has its own ecosystem, its own commands, and sometimes its own integration requirements.
For a project combining Rust, TypeScript, JavaScript, JSON, CSS or GraphQL, this can quickly become repetitive.
At BezotCorp, we're developing Standardizer, an open-source command-line tool written in Rust, with a simple objective:
Bring different standardization tools together behind a common interface, without replacing the tools that already work well.
The first public version focuses on code formatting and Git integration.
Why Standardizer?
Modern development environments already have excellent specialized tools.
For example:
-
rustfmtformats Rust code. -
Biomehandles formatting across several web development languages.
The problem isn't necessarily the quality of these tools. It's the fragmentation of how we interact with them.
Each tool has its own commands, configuration and supported formats. As projects grow, maintaining a consistent workflow across different technologies becomes more complicated.
Standardizer approaches this differently: rather than implementing another formatter, it delegates work to existing specialized tools.
This provides a common entry point while preserving their respective capabilities.
Getting started
Standardizer is available on crates.io.
Install it using Cargo:
cargo install standardizer
You can also download a prebuilt executable from the project's GitHub Releases page.
Once installed, navigate anywhere inside a Git repository and run:
standardizer check
This command checks supported files for formatting issues without modifying them.
To apply formatting corrections:
standardizer fix
Standardizer delegates the work to the appropriate formatter and stages the files it actually modifies.
Two commands, one entry point.
Supported tools and formats
The current release integrates two formatting engines.
Rustfmt
Rust source files are processed using rustfmt, the standard formatting tool of the Rust ecosystem.
Biome
Biome handles supported formats from the JavaScript and web development ecosystem, including:
- JavaScript and JSX
- TypeScript and TSX
- JSON and JSONC
- CSS
- GraphQL
Standardizer selects the appropriate tool according to the file type.
The routing configuration is embedded in the distributed executable, so projects don't need to create an additional routing file.
What happens when a tool is missing?
Standardizer is designed to work with the tools relevant to each project.
For example, you shouldn't have to install Biome merely because Standardizer supports it.
When an external formatter isn't available, Standardizer reports a warning and skips the corresponding processing instead of making that formatter a mandatory dependency for every project.
Git-aware processing
One of the important design choices behind Standardizer is its integration with Git.
Formatting tools can sometimes modify files that a developer isn't ready to include in a commit.
Standardizer takes the repository's index state into account.
It processes regular files whose working-tree content matches the Git index.
It skips:
- Untracked files
- Deleted files
- Files with unstaged modifications
- Partially staged files
It also refuses to run when unresolved conflicts exist in the Git index.
When running standardizer fix, only files actually changed by Standardizer are staged.
The objective is to respect the developer's existing Git workflow instead of indiscriminately formatting the entire working directory.
This is particularly useful when working on multiple changes simultaneously.
A broader vision
Formatting is only the starting point.
The long-term ambition behind Standardizer is to provide a unified interface for different aspects of software standardization, potentially including:
- Formatting
- Linting
- Compliance checks
- Additional specialized validation tools
These are future directions, not features claimed to be available in the current release.
The idea is to create an extensible foundation where existing tools can remain specialized while developers benefit from a more consistent way to invoke them.
Standardizer Common
Alongside the executable, we're also publishing standardizer-common, a Rust library supporting the Standardizer ecosystem.
Both projects are available independently on crates.io, with their own documentation and versioning.
This separation reflects an important principle in our development approach at BezotCorp: building reusable components rather than coupling everything to a single executable.
Open source and contributions
Standardizer is developed openly under the Apache License 2.0.
You can explore the source code, review the implementation, report issues or contribute through GitHub.
Resources:
- Standardizer on GitHub
- Standardizer on crates.io
- Standardizer Common on crates.io
- Standardizer Common documentation
- Releases and downloads
About BezotCorp
BezotCorp is an independent software initiative exploring software engineering, artificial intelligence, simulation, video games and experimental technologies.
Rust is at the heart of many of our projects, alongside open-source technologies and a commitment to building reusable, transparent and maintainable software.
We believe technology should be something we can understand, shape and experiment with.
Imagine. Create. Experiment.
Discover our projects at bezotcorp.com or explore our repositories on GitHub.
What does your current formatting workflow look like?
Do you prefer dedicated commands for each tool, or would a common interface make your development workflow easier?
We'd be interested in hearing how other developers approach this challenge.
Top comments (0)