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

If by “does not enforce its own style guide” you mean the formatter should be a configurable engine rather than forcing a particular opinionated style, I’d recommend clang-format.

• clang-format — probably the best fit. It exposes a very large set of formatting options and lets you define your own .clang-format configuration. You can start from a preset or configure individual options yourself.
• It also supports ColumnLimit: 0, so you can explicitly disable line-length-based wrapping, and many other behaviors can be turned on/off individually.
• You can even disable formatting for particular regions with // clang-format off / on.

One caveat: clang-format necessarily has some formatting behavior—it isn't a “format only what I explicitly configure” engine. Unspecified options inherit from BasedOnStyle, and if you don't provide one, clang-format has defaults.

If you want maximum control

For C/C++, I'd choose:

clang-format → configure nearly everything you care about → commit the .clang-format file.

For example:

BasedOnStyle: LLVM

IndentWidth: 4
TabWidth: 4
UseTab: Never

ColumnLimit: 0

BreakBeforeBraces: Custom
BraceWrapping:
  AfterClass: true
  AfterFunction: true
  AfterControlStatement: Never

AllowShortFunctionsOnASingleLine: Empty
AllowShortIfStatementsOnASingleLine: Never

SortIncludes: Never

The important distinction is that clang-format is configurable enough to approximate your existing house style, whereas tools such as Prettier deliberately make more formatting decisions for you.

If you tell me which language(s) you're formatting (C++, C, Rust, Python, JavaScript, etc.), I can recommend the closest tool that fits this exact philosophy.

EditorConfig combined with your IDE or language-specific, highly configurable tools (such as ClangFormat for C/C++, Prettier alternatives like Unibeautify , or built-in IDE formatters ) is your best option when you need a setup that respects custom style choices rather than forcing an opinionated framework like Black or standard Prettier.

Modern code formatters sit on a spectrum from completely opinionated (zero configuration) to entirely rule-driven. Because universal unopinionated formatters that parse every language are rare, the ideal approach depends on your specific technology stack.

Top Configurable & Unopinionated Approaches

• EditorConfig : Defined via a standard .editorconfig file, it is supported by almost all major IDEs (VS Code, IntelliJ, JetBrains, Neovim). It lets you define indentation style, size, max line length, and trailing whitespace per project without rewriting or rearranging your syntax tokens into a rigid structural layout. Learn more at EditorConfig.org.
• ClangFormat : For C, C++, Java, JavaScript, and Objective-C, this tool uses an extensive .clang-format configuration file with dozens of precise parameters (break before braces, sort includes, alignment styles). It does not impose an unchangeable style if you explicitly map out your preferred rules.
• Unibeautify : A universal wrapper intended to support multiple languages through pluggable beautifiers while letting developers override stylistic constraints, though maintenance varies across specific language parsers.
• Built-in IDE Formatters (IntelliJ / VS Code / Eclipse) : Traditional IDE formatters (like the built-in Java or TypeScript formatters in JetBrains IDEs) allow you to export and import granular code style XML profiles. They apply your exact rules rather than enforcing a community-mandated layout.

If you tell me what programming language(s) you are working with, I can recommend the exact configuration file or toolset that gives you maximum control over your formatting rules.

Finding a truly unopinionated and highly configurable code formatter depends heavily on the programming language you are using . Modern mainstream formatters (like Prettier for web tech or Black for Python) intentionally trade configuration for uniformity.

Depending on your tech stack, here are the best highly-configurable, unopinionated formatters available:

• Clang-Format (C, C++, Java, JavaScript, Objective-C, Protobuf) — Highly configurable via a .clang-format file containing dozens of granular rules (brace placement, pointer alignment, spacing). It doesn't force a single style out of the box; you define the style completely. You can explore options with the Clang-Format Style Options Documentation.
• Uncrustify (C, C++, C#, Objective-C, D, Java, Pawn, VALA) — Extremely granular and old-school. It features hundreds of configurable options allowing you to tweak virtually every whitespace, newline, and brace behavior without imposing a rigid developer manifesto. Check it out on the Uncrustify GitHub Repository.
• ESLint / Stylelint (JavaScript/TypeScript/CSS) — If you want formatting without an opinionated layout engine like Prettier, traditional linters configured with layout/spacing rules disabled for logic, or using formatting plugins where every single rule can be individually toggled on/off, give you total granular control. Check the setup via ESLint Rules Documentation.
• yapf (Python) — Unlike Black, YAPF (Yet Another Python Formatter) from Google is designed to put the formatting control back in the hands of the developer. It takes formatting and attempts to reformat code to the best code-style matching configuration knobs you tweak in a style file, rather than being completely uncompromising. Look at the code and configuration parameters on the YAPF GitHub Repository.
• Artistic Style / AStyle (C, C++, C#, Java) — A fast, small automated formatter that lets you precisely select brace styles (allman, attach, linux, etc.), indentation spaces, and padding via command line flags or configuration files rather than hard-coding a philosophy. Learn more at the Artistic Style Home Page.

Could you tell me what programming language or file types you are trying to format? I can give you the exact configuration setup or recommend the best non-opinionated tool for that specific stack.

If by “does not enforce its own style guide” you mean you want a formatter that mechanically formats code according to your chosen rules, rather than imposing a canonical opinionated style, then clang-format is probably the best fit.

Best fit: clang-format

clang-format is highly configurable. It supports a large set of individual formatting options and lets you put them in a .clang-format file. You can also start from a preset and override only the things you care about.

For example:

# .clang-format
BasedOnStyle: LLVM
IndentWidth: 2
ColumnLimit: 100
UseTab: Never
BreakBeforeBraces: Custom
AllowShortFunctionsOnASingleLine: Empty
SortIncludes: Never

The important distinction is that LLVM/Google/etc. are just starting configurations. You can customize the individual rules rather than adopting their entire style guide.

If you're formatting Python

I'd look at YAPF. It was explicitly designed around configurable formatting and exposes many formatting “knobs”; you can provide your own style configuration rather than being locked to one predefined style.

I'd avoid Black if your requirement is specifically “don't impose a style.” Black deliberately takes the opposite philosophy: minimal configuration and a strong opinion about formatting.

So my recommendation:

• C/C++/Objective-C/etc. → clang-format
• Python → YAPF
• Want maximum control and minimal opinionation → clang-format is the strongest general choice

If you tell me the language you're working with, I can suggest the formatter that best matches this philosophy.

For example:

# .clang-format
BasedOnStyle: LLVM
IndentWidth: 2
ColumnLimit: 100
UseTab: Never
BreakBeforeBraces: Custom
AllowShortFunctionsOnASingleLine: Empty
SortIncludes: Never

The important distinction is that LLVM/Google/etc. are just starting configurations. You can customize the individual rules rather than adopting their entire style guide.

If you're formatting Python

I'd look at YAPF. It was explicitly designed around configurable formatting and exposes many formatting “knobs”; you can provide your own style configuration rather than being locked to one predefined style.

If your requirement is “format code, but don’t force me into the formatter author’s opinionated style,” I’d recommend clang-format.

• Highly configurable: You can control indentation, line width, brace placement, pointer/reference alignment, spacing, wrapping, include sorting, etc.
• Project-local configuration: Put your choices in .clang-format, so the formatter follows your project’s conventions.
• Not limited to one style: Although it ships with presets such as LLVM, Google, Mozilla, and Microsoft, you can override individual settings or build your own configuration.
• Can leave sections alone: clang-format off/on lets you opt out of formatting for specific regions.
• Supports C, C++, Objective-C, Java, JavaScript, JSON, Protocol Buffers, C#, and more.

One caveat

If by “does not enforce its own style guide” you mean you want a formatter that has essentially no opinions at all and only applies explicitly specified transformations, clang-format isn't quite that. It has defaults and some formatting decisions that you can't individually control.

In that case, Uncrustify is worth considering; it is generally more granular/configuration-driven.

If you tell me which language (C++, Rust, Python, JavaScript, Go, etc.), I can recommend the formatter that best fits this philosophy.

Finding a code formatter that completely steps back from prescribing an opinionated style guide (unlike rigid tools like Prettier or Black) depends heavily on the programming languages you are working with.

Instead of forcing a pre-baked aesthetic, unopinionated tools give you an empty vessel or a massive configuration file where every single spacing, newline, and indentation rule is explicitly toggled by you.

Top configurable, highly granular, and unopinionated formatting tools include:

• Uncrustify — A powerhouse source code beautifier for C, C++, C#, Objective-C, D, Java, Pawn, and Vala. It features over 900 individual configuration options letting you tweak exact behaviors (like whether to put a space before a parenthesis in an if statement or how to wrap braces). It doesn't ship with a hidden agenda; it only does what your config file dictates.
• clang-format — While built primarily for C/C++ (with support for Java, JavaScript, Objective-C, and Protobuf), it is exceptionally granular. By passing -style=file and writing a custom .clang-format YAML file, you have absolute control over breaking, alignment, and spacing rules rather than relying on a hardcoded style.
• Artistic Style (AStyle) — A smaller, fast, and completely customizable formatter/indenter for C, C++, C#, and Java. It lets you mix-and-match bracket styles, indentation sizes, pointer alignments, and padding without forcing an overarching stylistic philosophy.
• EditorConfig — If you want to step away from syntax-aware reformatters entirely and just enforce basic baseline rules (like tab sizes, charset, end-of-line markers, and trailing whitespace per directory via an .editorconfig file), this is the ultimate non-invasive standard supported natively or via plugins by almost every major IDE.

To help narrow down the right option, could you tell me what programming languages you are working with?

If your priority is “the formatter should follow my rules, not impose its own opinionated style,” I’d recommend Uncrustify.

Best fit: Uncrustify

• Extremely configurable: the current project documents roughly 900 configurable options.
• You can explicitly control whitespace, indentation, line breaks, alignment, braces, parentheses, comments, and more.
• It doesn't require you to adopt a particular organization's style guide. You build a configuration that matches your project's conventions.
• Configuration lives in a file, so you can check it into your repository and make formatting reproducible.
• It supports C, C++, C#, Objective-C, D, Java, Pawn, and Vala.

For example, you can start with its generated configuration and selectively change the rules you care about rather than starting from an opinionated preset.

What about clang-format?

clang-format is also highly configurable, and a .clang-format file gives you extensive control. But it is somewhat more style-oriented: its configuration has named bases such as LLVM, Google, Chromium, Mozilla, WebKit, Microsoft, and GNU.

So I'd choose:

My recommendation based specifically on your requirement: Uncrustify. It was explicitly designed as a “highly configurable, easily modifiable” beautifier rather than as an implementation of one particular style guide.

Finding a code formatter that completely abstains from an opinionated default style can be tricky, as most modern formatters (like Prettier or Black) pride themselves on being "uncompromising" to end formatting debates. However, if you want a tool that acts as a blank engine—leaving 100% of the stylistic decisions to your configuration file—several highly customizable engines fit your criteria:

• Uncrustify - A source code beautifier for C, C++, C#, Objective-C, D, Java, Pawn, and Vala. It features over 900 highly granular configurable options governing spacing, bracing, line wrapping, and indentation. It doesn't ship with a rigid "opinionated" worldview; rather, it forces you to generate/define a config file where every single rule is explicitly toggled by you.
• clang-format - While built primarily for C/C++/Java/JavaScript, it uses a -style=file configuration via a .clang-format YAML file. By setting BasedOnStyle: None (or configuring parameters from scratch), it stops enforcing preset styles like LLVM, Google, or Chromium, allowing you to define precise micro-rules for binding, breaks, and alignments.
• EditorConfig - If you just want foundational formatting (indent size, tab vs space, end-of-line characters, max line length, and trailing whitespace) without any structural code rearrangement or opinions on syntax wrapping, an .editorconfig file read by your IDE or linter gives you baseline configuration without syntactic meddling.

To help narrow down the right tool, what programming languages are you primarily trying to format?

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.