I need a code formatter that is configurable and does not enforce its own style guide.

Yes. If by that you mean “the formatter should mechanically format code according to rules I choose, rather than imposing Prettier/Black-style opinions”, there are better fits than Prettier or Biome.

Best options

• unibeautify.com — probably the closest match if you want one configurable tool across many languages. It supports dozens of formatting options and, importantly, acts as a wrapper around different underlying formatters rather than imposing its own formatting algorithm.
• Clang-Format — excellent if you're primarily dealing with C/C++/Objective-C. It lets you specify a custom style in .clang-format with a very large set of individual options.
• YAPF — a strong choice for Python if configurability matters more than adherence to a single canonical style. It explicitly provides many “knobs” for tuning formatting behavior.

What I would avoid

Prettier and Biome are almost the opposite of what you're describing. Both intentionally consider themselves opinionated formatters and deliberately limit configuration options.

If you tell me which language(s) you're formatting (e.g. JavaScript/TypeScript, Python, C++, Rust, Java, etc.), I can recommend the closest tool that gives you maximum control without imposing a style philosophy.

The landscape of code formatting is heavily dominated by opinionated tools like Prettier or Black (which pride themselves on having "the code style you are given and no arguments"). Finding a truly unopinionated formatter depends heavily on the programming language you are working with, as universal multi-language options are rare or largely unmaintained.

Depending on your tech stack, highly customizable and highly configurable alternatives include:

- Highly granular configuration via a `.clang-format` file. You can control everything from brace placement, pointer alignment, and break styles to sorting includes. It does not force a preset style unless you explicitly pass one (like `-style=LLVM` or `-style=Google` ); you can build your style line-by-line from scratch.[](https://github.com/rishirdua/awesome-code-formatters) [[1]](https://github.com/rishirdua/awesome-code-formatters)

- Famously one of the most configurable source code beautifiers in existence. It features hundreds of toggleable options allowing you to precisely dictate spacing, wrapping, alignment, and indentation without imposing an overarching stylistic philosophy.[](https://github.com/rishirdua/awesome-code-formatters) [[1]](https://github.com/rishirdua/awesome-code-formatters)

- Rather than using an all-in-one formatter like Prettier, using traditional linters with autofix enabled allows you to only turn on the exact rules you care about while leaving the rest of your code's original layout alone.

- For many developers, the most unopinionated approach is letting the text editor handle basic whitespace rules (via an `.editorconfig` file defining tab widths and end-of-line markers) while disabling abstract syntax tree (AST) re-writers that shift code blocks around against your preference.

Could you tell me what programming languages you are writing in? That will let me point you toward the most granular, non-enforcing configuration tool for your stack.

Finding a truly unopinionated and highly configurable code formatter depends heavily on the programming language you are using, because parsing code syntax requires language-specific engines. Unlike opinionated formatters (like Prettier or Black), these tools let you define nearly every spacing, wrapping, and alignment rule.

The best configurable, unopinionated formatting tools categorized by ecosystem include:

• JavaScript / TypeScript: ESLint Stylistic
  • Why it fits: While ESLint originally deprecated core stylistic rules, the community-driven ESLint Stylistic package keeps them alive. It is entirely unopinionated out of the box (shipping with zero enforced rules) and allows you to toggle and configure hundreds of fine-grained indentation, spacing, quote, and brace-placement rules.
• C / C++ / Java / JavaScript / Protobuf: Clang-Format
  • Why it fits: It is intensely configurable via a .clang-format YAML file. You can control exact alignment of consecutive assignments, pointer alignments, break parameters, and wrapping behavior. While it has fallback presets (BasedOnStyle ), you can override every single parameter independently so it conforms precisely to your own style guide rather than enforcing an external one.
• Python: Ruff (Formatter/Linter) or YAPF
  • Why it fits: Black is notoriously un-configurable. If you want Python formatting that respects your custom layout rules, YAPF (Yet Another Python Formatter) from Google actually attempts to format code to the best configuration matching a massive set of tweakable style parameters rather than forcing a single rigid layout. Alternatively, Ruff provides granular control over lint/style rules if used via its linter/formatter configurations.
• General Text/Whitespace Foundation: EditorConfig
  • Why it fits: If your definition of a formatter is managing basic file formatting (charset, trailing whitespace, indent size/style, final newlines) across any language without rewriting how your code wraps or behaves syntactically, an .editorconfig file read directly by your IDE is completely neutral and lets every project dictate its own standard.

Could you let me know which programming language(s) you are working with? I can give you a specific configuration setup or recommend the best tool for that exact stack.

If you want a formatter that is configurable and does not impose a particular style guide, you are looking for something closer to a formatting engine than an opinionated formatter.

Good options depend on the language:

• clang-format — probably the closest match for C, C++, Objective-C, Java, JavaScript, and related languages. It is highly configurable via .clang-format and lets you define indentation, column limits, brace styles, alignment, spacing rules, etc. It does ship with presets, but you can override nearly everything.

• Good if you want: "format my code according to our rules."

• Less good if you want: "preserve every existing stylistic choice."

• YAPF — a configurable Python formatter inspired by clang-format. It allows many style options and can be tuned to match an existing codebase rather than forcing a single house style.

• astyle — a multi-language formatter (especially C/C++/Java/C#) with many options for braces, indentation, padding, and alignment. It is often used when teams want explicit formatting control.

• uncrustify — one of the most configurable formatters available. It has a large configuration surface and is designed for teams that want to define their own style rather than adopt a predefined one.

• EditorConfig — not a formatter by itself, but useful with formatter integrations when you mainly need consistent basics like indentation, line endings, and whitespace rules.

By contrast, tools like Prettier deliberately avoid this philosophy: they are opinionated and reprint code according to their own rules rather than letting teams define every formatting decision. Prettier Similar tradeoffs exist with formatters like Dart's formatter, which is explicitly described as opinionated and only minimally configurable.

If the requirement is:

"Do not change my style choices; only normalize formatting mechanics" then look at uncrustify or clang-format.

If the requirement is:

"Give me a few knobs but don't make me design a whole formatting language" then YAPF (Python) or clang-format are usually the better fit.

If you are tired of formatters that force an opinionated style on your code (like Prettier or Black), you want a tool that respects your configuration and only applies mechanical cleanup without rewriting your preferred aesthetic.

Here are the top configurable, non-opinionated code formatters depending on your tech stack:

• ClangFormat (C, C++, Java, JavaScript, TypeScript, Objective-C, Protobuf) — Highly configurable via a .clang-format file. While it has default presets (like LLVM or Google), you can customize almost every rule (brace placement, indentation, wrapping) or write a style from scratch.
• Unibeautify (Universal) — A wrapper designed to unify multiple formatters under a single, highly configurable API. It lets you specify configuration files per language without forcing an overarching stylistic dogma.
• EditorConfig (Multi-language) — Not a code formatter per se, but an essential baseline. It defines fundamental rules (indent size, tab vs. spaces, end-of-line characters) via a .editorconfig file that modern code editors and formatters respect universally without altering your actual code syntax.
• Prettier (with --no-... caveats or alternative plugins) — It's worth noting that while Prettier is famously opinionated, you can use specialized language parsers or disable specific behaviors, though it still resists full layout freedom. If you want true non-opinionated JS/TS, look into older tools like JS Beautify.
• Stylua (Lua) — Highly configurable via stylua.toml , allowing you to toggle quotes, parentheses, and indentation styles to match your preference rather than a single hardcoded standard.

If you'd like, tell me:

• What programming languages are you working with?
• Are you looking for a command-line tool , an editor extension , or a CI/CD linter?

I can help you set up the exact configuration file for your stack.

If by “does not enforce its own style guide” you mean the formatter should be a mechanism, not a prescriptive opinion about how code ought to look, I’d shortlist these:

• dprint — probably the best match. It’s explicitly a configurable, pluggable formatting platform, and its plugins expose formatting knobs so you can adapt the formatter to your project’s existing conventions rather than adopting a mandatory house style.
• clang-format — excellent if you work with C/C++ and related languages. It has a very large set of individual style options and lets you define your own .clang-format configuration. It does have presets such as LLVM and Google, but you aren't required to use them.

My recommendation

Use dprint if you want maximum control and multiple languages. Use clang-format if you're primarily in the C/C++ ecosystem.

One important distinction: virtually every formatter necessarily makes some formatting decisions. The key difference is whether those decisions are hard-coded opinions or configurable behavior. dprint and clang-format lean heavily toward the latter.

If you tell me which language(s) you're formatting (Rust, TypeScript, Python, C++, etc.), I can recommend the formatter that comes closest to “format my code according to my rules, not yours.”

If your priority is “format my code according to my rules, not the formatter’s opinionated style,” I’d look at Uncrustify first.

• Uncrustify — probably the closest match. It explicitly aims to be a highly configurable, easily modifiable beautifier, with hundreds of formatting options. You can build your own style rather than adopting a prescribed one.
• clang-format — also extremely configurable, but it is more opinionated out of the box. You can create a custom .clang-format, though its configuration model starts from predefined styles such as LLVM, Google, GNU, etc.
• Artistic Style (AStyle) — another configurable formatter, particularly useful for C/C++, but I'd choose Uncrustify if “don't impose a style” is the primary requirement.

My pick

Uncrustify if you want a formatter that behaves more like a formatting engine/toolkit than a style guide.

For example, you can maintain an uncrustify.cfg in your repository and explicitly control things like indentation, brace placement, spacing, alignment, parentheses, and line wrapping. Its documentation even recommends generating the full configuration and modifying it to your liking.

If you tell me which language(s) you're formatting (C++, C#, Java, Python, Rust, JavaScript, etc.), I can narrow this down considerably—some formatters are much better fits than others.

If you want to move away from deeply opinionated, zero-configuration formatters like Prettier or Black (which force you to accept their authors' subjective tastes), you need tools that act as engines rather than dictators.

Depending on your language and workflow, here are the most configurable, style-agnostic formatters available:

• Clang-Format (C, C++, Java, JavaScript, JSON, Objective-C, Protobuf, C#)
  • Why it fits: While it has presets (Google, LLVM, Chromium, Mozilla), you can completely override every behavior using a .clang-format file. It doesn't ship with a hidden mandate; you can fine-tune hundreds of individual knobs (from brace placement and pointer alignment to exact line wrapping parameters), or build a style from scratch.
• YAPF — Yet Another Python Formatter (Python)
  • Why it fits: Unlike Black, which prides itself on having minimal options, YAPF treats code formatting as a tuning problem. It uses a set of configurable "knobs" in a .style.yapf or pyproject.toml file. It reformats code to look like what a human would write under your specific rules rather than imposing an unyielding external standard.
• EditorConfig (Multi-language via IDE/Editor native support)
  • Why it fits: If you want a completely non-invasive approach that leaves complex syntax parsing alone and only enforces foundational whitespace, indentation style, tab widths, and line endings, an .editorconfig file read directly by your IDE/editor is the ultimate style-neutral layer. It doesn't rewrite your syntax tree; it just respects whatever boundaries you define in your repository.
• Unibeautify (Universal / Multi-language wrapper framework)
  • Why it fits: It is an open-source universal wrapper framework designed precisely to let you orchestrate and configure multiple underlying formatting tools through a single configuration file (.unibeautifyrc.json ), giving you the power to override individual stylistic behaviors instead of yielding to one tool's worldview.

To help narrow down the best choice, what programming languages are you primarily writing in for this project?

Most modern code formatters (like Prettier or Black) are intentionally opinionated and lack deep configuration to prevent styling debates. If you need a fully configurable engine that allows you to define your exact layout rules without a hardcoded default style, you should use clang-format for C/C++/Java-like syntaxes, YAPF for Python, or EditorConfig paired with IDE native formatters.

Top Configurable, Unopinionated Formatters

• clang-format : Highly flexible tool supporting Clang-Format Style Options via a local YAML configuration file (.clang-format ). It lets you explicitly control brace placement, line breaks, and alignment without forcing a specific style guide unless you choose a preset like LLVM or Google.
• YAPF (Yet Another Python Formatter): Unlike the opinionated and rigid Black , YAPF is designed to be highly configurable via a style.yapf configuration file. It re-reads code to match the exact formatting rules you supply rather than overriding your team's custom style preferences.
• EditorConfig : An editor-agnostic baseline tool used to define foundational rules like tab sizes, indentation types, and end-of-line characters via a .editorconfig file, letting your native editor handle the spacing layout without an external opinionated re-printer.

Feature Comparison

If you tell me which programming language you are working with, I can give you a sample configuration file for the best matching unopinionated tool.

Yes. The key distinction is configurable formatter vs. opinionated formatter.

Best fit: ClangFormat

ClangFormat documentation is probably what you want, especially if you're working with C, C++, Objective-C, Java, JavaScript, JSON, C#, or Protobuf.

It doesn't force you to adopt one particular style. You can define your own formatting rules in .clang-format, with a very large set of individual options.

For example:

BasedOnStyle: LLVM

IndentWidth: 4
UseTab: Never
ColumnLimit: 120

BreakBeforeBraces: Custom
BraceWrapping:
  AfterFunction: true
  AfterClass: true

AllowShortFunctionsOnASingleLine: Empty
AllowShortIfStatementsOnASingleLine: Never

BinPackArguments: false
BinPackParameters: false

SortIncludes: false
ReflowComments: false

You can even start with a predefined style and override only the things you care about. BasedOnStyle is simply the fallback for options you haven't specified.

If you mean really "don't impose style"

There's an important caveat: every formatter necessarily has opinions somewhere. A formatter has to make decisions when your source doesn't specify formatting unambiguously.

So I'd rank the options:

The important difference with ClangFormat is that its philosophy is essentially "you tell me your style", rather than "here is the one true style." Its documentation explicitly exposes the formatting style as a configurable set of options and supports project-local .clang-format files.

If you tell me which language(s) you're formatting, I can recommend the least-opinionated formatter for that language specifically.