Prettier

Prettier is an opinionated code formatter that parses source code and reprints it from scratch to enforce a consistent, project-wide visual style. By transforming code into an abstract syntax tree and applying a recursive document printing process, it eliminates manual style debates and ensures that all source files adhere to a unified appearance.

The project is distinguished by its extensible, plugin-based architecture, which decouples language-specific parsing logic from the core engine. This modular design allows for uniform style enforcement across diverse programming languages and complex, mixed-content files where code is embedded within other languages. It also provides robust support for configuration-driven workflows, allowing teams to resolve hierarchical settings across directory trees and share standardized rule sets through reusable configuration packages.

Beyond its core formatting engine, the tool integrates into the entire development lifecycle. It offers programmatic APIs and command-line utilities for file discovery, change detection, and verification, alongside native support for editor-based formatting on save. The system also facilitates integration with linting workflows and continuous integration pipelines, enabling automated style enforcement through pre-commit hooks and status checks that ensure only properly formatted code enters version control.

Features

Extensible Parsers - Supports modular parsing logic, enabling the addition of new languages through pluggable architecture.
Parser Engines - Transforms source code into abstract syntax trees to facilitate uniform visual reprinting.
In-Place Formatters - Overwrites source files directly to apply consistent visual styling across an entire codebase.
Pretty Printing Algorithms - Calculates optimal line breaks and indentation by traversing syntax trees against a defined print width.
Multi-Language Formatters - Maintains a uniform appearance across diverse programming languages and embedded content within a single project.
Formatting Rule Definitions - Enforces project-wide visual consistency by applying declarative rules to source code.
Abstract Syntax Tree Parsers - Analyzes code structure via abstract syntax trees to perform automated, consistent reformatting.
Developer Authoring Interfaces - Exposes a plugin interface for developers to register custom parsers and extend support for specialized file types.
Code Formatters - Parses source code and reprints it from scratch to ensure a consistent, project-wide visual style.
Configuration Resolution - Resolves project-specific formatting settings by traversing directory trees to locate configuration files.
Build Tools and Tooling - Opinionated code formatter for consistent style.
Code Quality Tools - Opinionated multi-language code formatter.
Quality Assurance - Opinionated code formatter.
Testing and Quality Assurance - Opinionated code formatter for consistent style.
Web Frameworks - Opinionated code formatter.
Editor Integrations - Connects directly into editor workflows to perform automatic style fixes on save or via command shortcuts.
Editor Formatting Integrations - Integrates into development environments to trigger automatic formatting according to project rules during the daily workflow.
Formatting Automations - Automates code styling during editing, commits, or CI processes to eliminate manual formatting debates.
CI Formatting Checks - Automates style verification within continuous integration pipelines to detect and fix formatting violations.
Configuration Cascade Resolutions - Determines final formatting rules by cascading settings from multiple hierarchical sources and command-line overrides.
Hierarchical Configuration Resolvers - Merges hierarchical settings to apply standardized formatting while respecting project-specific overrides and local adjustments.
Incremental Processing Caches - Improves performance by caching file hashes and configuration states to skip redundant processing.
Vim Plugins - Enables manual formatting commands and automatic file-save triggers directly within the editor interface.
Embedded Code Formatters - Handles code snippets embedded within other languages by loading specialized parser plugins for mixed content.
Cursor Position Mapping - Translates cursor positions from unformatted input to the corresponding location in the formatted output to preserve editing context.
Language Support Definitions - Registers new languages by mapping specific identifiers to the parsers required for correct syntax interpretation.
Incremental Build Caches - Caches formatting results based on file metadata to skip redundant processing of unchanged files during build cycles.
Formatting Rules - Configures trailing comma behavior in multi-line structures to enhance diff readability and simplify long-term code maintenance.
Browser Formatting - Executes code formatting logic within browser environments by loading standalone libraries and language plugins.
Formatting Constraints - Sets maximum line length constraints to balance code readability with the display limits of modern development environments.
Indentation Settings - Defines specific indentation widths to maintain a uniform visual structure across all project files.
Quote Style Configurations - Standardizes string literal quotes by automatically adjusting them to preferred styles for cleaner, more readable code.
Semicolon Configuration Rules - Regulates the inclusion of semicolons at the end of statements to ensure consistent syntax across the entire codebase.
Pre-commit Hooks - Triggers automatic formatting on staged files during the commit process to ensure only clean code enters version control.
File Pattern Resolvers - Expands glob patterns and directory paths while automatically respecting exclusion rules to identify target files.
Conflict Resolution Strategies - Disables conflicting linting rules to prevent overlapping behavior between formatting and static analysis tools.
Configuration Distribution Packages - Bundles shared formatting configurations for distribution via registries to simplify setup across multiple environments.
Shareable Configurations - Facilitates the adoption of standardized formatting rules through shareable configuration packages that allow for local project adjustments.
Configuration Overrides - Applies custom formatting options to specific file subsets or directories to accommodate unique requirements within larger project structures.
File Metadata Inspection - Identifies appropriate parsers based on file paths and determines ignore status through metadata inspection.
Team Configuration Standards - Standardizes formatting rules across multiple independent projects to ensure consistent development patterns throughout an entire organization.
Continuous Integration Quality Controls - Validates code style compliance within automated pipelines to prevent unformatted code from entering the version control history.
Formatting and Linting Pipelines - Chains formatting and linting operations into unified workflows to ensure both style and syntax are corrected in a single pass.
Formatting Checkers - Checks source code against defined rules to programmatically report whether files require formatting without modifying them.

dprint/dprint

3,795View on GitHub

dprint is a multi-language code formatter that applies consistent styling across various programming languages using a pluggable architecture. It functions as a unified project style management tool, a command-line interface for continuous integration style enforcement, and a Language Server Protocol implementation for real-time formatting in editors. The project is distinguished by a WebAssembly-based plugin system that loads sandboxed formatting logic from URLs or file paths. It further extends its capabilities through a process-based tool integration that wraps external command-line interf

standard/standard

29,431View on GitHub

Standard is a suite of static analysis tools for JavaScript, comprising a linter, formatter, and a predefined style guide. It functions as a static code analyzer that scans source code for style violations and potential errors without executing the program. The project provides an automatic code fixer that rewrites source code to resolve formatting issues and enforce syntax consistency. It implements a standardized set of rules for JavaScript formatting and syntax to ensure a uniform appearance across different projects. The system covers a wide range of static analysis capabilities, includi

stylelint/stylelint

11,484View on GitHub

Stylelint is a static code analysis tool and linter for CSS and style-like languages. It identifies errors, enforces coding conventions, and operates as a PostCSS plugin to validate stylesheets during build pipelines. The project distinguishes itself through support for non-standard syntaxes, including preprocessor parsing for SCSS and Less, and the ability to extract and lint embedded styles from JavaScript, HTML, and template literals. It features an automated fixing system that programmatically corrects repairable styling violations to ensure consistency. The system provides a plugin arch

eslint/eslint

27,349View on GitHub

This project is a static analysis engine designed to identify patterns, enforce coding standards, and automate code quality improvements in software projects. By parsing source code into structured abstract syntax trees, it enables deep programmatic inspection and the automated remediation of identified programming issues. The engine functions as a pluggable linting framework, allowing developers to extend its core capabilities through a modular architecture. Users can inject custom rules, parsers, and processors to support non-standard file formats or domain-specific logic. This extensibilit

prettierprettier

Features