fart_style

SmartTabs-enabled Dart formatter. Solely a fork of dart_style that uses tabs for indentation and spaces for alignment.

What is SmartTabs?

SmartTabs is an indentation philosophy that separates two concerns:

Purpose Character Why
Block indentation Tabs (\t) Semantic nesting (classes, methods, blocks, collections)
Alignment Spaces ( ) Visual alignment (wrapped expressions, initializers)

This separation allows each developer to view code at their preferred tab width (2, 4, 8 spaces) while maintaining pixel-perfect alignment:

// With tab width = 2         // With tab width = 4         // With tab width = 8
class Foo {                   class Foo {                   class Foo {
  void bar() {                    void bar() {                        void bar() {
    print('hi');                      print('hi');                            print('hi');
  }                               }                                   }
}                             }                             }

The alignment spaces remain constant regardless of tab width, so wrapped expressions always line up correctly.

Installation

dart pub add dev:fart_style

Quick Start

Command Line

# Format a file in place
dart run fart_style:format my_file.dart

# Format a directory recursively
dart run fart_style:format lib/

# Preview changes without modifying files
dart run fart_style:format --output=show my_file.dart

# Validate formatting (useful for CI)
dart run fart_style:format --output=none --set-exit-if-changed .

As a Library

import 'package:fart_style/fart_style.dart';

void main() {
  final formatter = DartFormatter(
    languageVersion: DartFormatter.latestLanguageVersion,
  );

  var formatted = formatter.format('''
    class MyClass{void method(){print("hello");}}
  ''');

  print(formatted);
}

Using as a Library

Basic Formatting

import 'package:fart_style/fart_style.dart';

void main() {
  final formatter = DartFormatter(
    languageVersion: DartFormatter.latestLanguageVersion,
  );

  // Format a complete compilation unit (file)
  String formatted = formatter.format('''
    library my_library;
    
    class MyClass {
      void method() { print("hello"); }
    }
  ''');

  // Format a single statement
  String statement = formatter.formatStatement('var x = 1 + 2 + 3;');
}

Configuration Options

final formatter = DartFormatter(
  // Required: Dart language version for parsing
  languageVersion: DartFormatter.latestLanguageVersion,
  
  // Optional: Maximum line width (default: 100)
  pageWidth: 80,
  
  // Optional: Tab width for line-length calculations (default: 4)
  // This affects when lines wrap, not how code is indented
  tabWidth: 4,
  
  // Optional: Leading indentation in tabs (default: 0)
  indent: 2,
  
  // Optional: Trailing comma handling
  trailingCommas: TrailingCommas.automate, // or .preserve
  
  // Optional: Experimental language features
  experimentFlags: ['inline-class'],
);

Tracking Selection

For editor integration, track cursor position through formatting:

var source = SourceCode(
  'var x=1+2;',
  selectionStart: 4,
  selectionLength: 1,
);

var result = formatter.formatSource(source);
print(result.text);             // Formatted code
print(result.selectionStart);   // Updated cursor position
print(result.selectionLength);  // Updated selection length

Error Handling

try {
  formatter.format('invalid { code');
} on FormatterException catch (e) {
  print('Syntax error: ${e.message()}');
}

Configuration

Configuration Reference

pageWidth (default: 100)

The maximum line length (in columns) before the formatter wraps code to the next line.

// With pageWidth: 40
var result = someFunction(
    argument1,
    argument2,
);

// With pageWidth: 120
var result = someFunction(argument1, argument2);

The formatter tries to keep lines at or below this width. When a line would exceed pageWidth, it splits across multiple lines.

tabWidth (default: 4)

The visual width of a tab character when calculating line length. This affects when lines wrap, not how code is indented.

Since fart_style uses tabs for indentation, a tab character (\t) needs a column width for line-length calculations:

→   void foo()    // Tab counts as 4 columns, so "void" starts at column 5

Why it matters: If you view code at tab width 8 but the formatter uses tabWidth: 4, lines may appear longer than expected. Setting tabWidth to match your editor ensures wrapping decisions align with what you see.

Note: tabWidth does NOT change the output. It only affects the formatter's internal line-length math.

indent (default: 0)

Leading indentation added to the entire output, measured in tabs.

// indent: 0
class Foo {
	void bar() {}
}

// indent: 2 (adds 2 tabs to every line)
		class Foo {
			void bar() {}
		}

Useful when formatting code snippets that will be embedded in an already-indented context.

trailingCommas (default: automate)

Controls how trailing commas affect formatting:

Value Behavior
automate Formatter adds/removes trailing commas based on whether it splits the construct
preserve A trailing comma forces splitting; formatter adds but never removes them 
// automate: formatter decides based on fit
var list = [1, 2, 3];           // Fits on one line, no trailing comma
var list = [
	veryLongElement,
	anotherLongElement,
];                              // Split across lines, trailing comma added

// preserve: user's trailing comma forces split
var list = [
	1,
	2,
	3,
];                              // Kept split because input had trailing comma

languageVersion

The Dart language version used for parsing. This affects which syntax features are recognized:

// Version 3.0+ supports records
var point = (x: 1, y: 2);

// Older versions don't recognize record syntax

Usually determined automatically from your pubspec.yaml or package config. Can be set to latest to use the newest supported version.

experimentFlags

Enables experimental Dart features that aren't yet stable:

DartFormatter(
	languageVersion: DartFormatter.latestLanguageVersion,
	experimentFlags: ['inline-class', 'macros'],
)

How pageWidth and tabWidth Interact

The formatter calculates line length by counting each tab as tabWidth columns:

pageWidth: 80, tabWidth: 4

→   void foo(int a, int b) { ... }
    ↑                              
    4 columns (1 tab × 4)          
        ↑
        + 30 characters = 34 total columns
        
34 < 80 → fits on one line

If tabWidth were 8, the same line would calculate as 38 columns (8 + 30).

analysis_options.yaml

Configure formatting options in your project's analysis_options.yaml:

formatter:
  page_width: 100
  tab_width: 4
  trailing_commas: automate  # or: preserve

Inline Width Comments

Override page width for a single file:

// dart format width=80

class MyClass {
  // This file uses 80 column width
}

Format Regions

Disable formatting for specific sections:

void main() {
  // dart format off
  var matrix = [
    [1, 0, 0],
    [0, 1, 0],
    [0, 0, 1],
  ];
  // dart format on
  
  print(matrix);
}

CLI Reference

Usage: dart run fart_style:format [options] <files or directories...>

Options:
  -h, --help                 Show usage information
  -v, --version              Show version
  -o, --output               Output mode: write, show, json, none
                             (default: write)
  -l, --line-length          Page width for formatting
                             (default: 100)
  --indent=<n>               Add <n> tabs of leading indentation
  --set-exit-if-changed      Return exit code 1 if changes needed
  --fix                      Apply all style fixes
  --[no-]trailing-commas     Add/remove trailing commas (default: add)

Common Workflows

# Format everything in lib/ and test/
dart run fart_style:format lib/ test/

# CI validation (fails if unformatted code exists)
dart run fart_style:format --output=none --set-exit-if-changed .

# Preview without writing
dart run fart_style:format --output=show lib/

# Format with custom line width
dart run fart_style:format --line-length=80 lib/

# Add 2 tabs of leading indent (for embedding code)
dart run fart_style:format --indent=2 snippet.dart

Using with dprint

You can use fart_style with dprint via the exec plugin.

1. Download the Native Binary

Download the appropriate binary for your platform from Releases and add it to your PATH.

Platform Binary
Linux x86_64 fart_style-linux-x86_64.tar.gz
Linux ARM64 fart_style-linux-aarch64.tar.gz
macOS Intel fart_style-darwin-x86_64.zip
macOS Apple Silicon fart_style-darwin-aarch64.zip
Windows x86_64 fart_style-windows-x86_64.zip

2. Configure dprint

Add to your dprint.json:

{
  "exec": {
    "commands": [{
      "command": "fart_style --stdin-name {{file_path}}",
      "exts": ["dart"]
    }]
  },
  "plugins": [
    "https://plugins.dprint.dev/exec-0.5.0.json"
  ]
}

3. Run dprint

# Format all Dart files
dprint fmt

# Check formatting
dprint check

Configuration Options

You can pass additional flags to fart_style in the command:

{
  "exec": {
    "commands": [{
      "command": "fart_style --stdin-name {{file_path}} --page-width 80",
      "exts": ["dart"]
    }]
  },
  "plugins": [
    "https://plugins.dprint.dev/exec-0.5.0.json"
  ]
}

Available flags:

  • --page-width <n> - Maximum line width (default: 100)
  • --tab-width <n> - Tab width for line-length calculations (default: 4)
  • --trailing-commas <mode> - automate or preserve (default: automate)
  • --language-version <version> - Dart language version (e.g., 3.0, latest)

Changes from dart_style

Feature dart_style fart_style
Indentation Spaces only SmartTabs (tabs + spaces)
Block indent 2 spaces 1 tab
Expression alignment 2-4 spaces 4 spaces
Tab width (for calculations) N/A Configurable (default: 4)
Default page width 80 100
--indent parameter Number of spaces Number of tabs
SmartTabs toggle N/A Always enabled

Indentation Types

Context dart_style fart_style
Block body (class, method, if) 2 spaces 1 tab
Cascade (..method()) 2 spaces 1 tab
Assignment RHS (=, :, =>) 4 spaces 4 spaces
Expression continuation 4 spaces 4 spaces
Infix operators (+, &&, is) 4 spaces 4 spaces
Constructor initializer (:) 4 spaces 4 spaces
Subsequent initializers 2 spaces 2 spaces

Test Status

Status Count Notes
✅ Passing 5,249 Core formatting logic works correctly
⚠️ Expected mismatches 3,360 Test expectations use space-based output

The formatter is fully functional. The "failing" tests are expected output format mismatches — the tests were written for space-based indentation and need updating to expect SmartTabs output. The actual formatting logic is correct.

Credits

This project is a fork of dart_style, the official Dart formatter created by the Dart project authors.

License

BSD 3-Clause License

Copyright 2014, the Dart project authors.

See LICENSE for the full license text.

For SmartTabs-specific questions or issues, please file an issue in this repository.

For general Dart formatting questions, see the dart_style FAQ.

Libraries

fart_style