Laravel Pint

What is Laravel Pint

Laravel Pint is a code style fixer built on top of PHP CS Fixer. It’s designed to work with zero configuration and automatically formats code to follow Laravel’s coding style. By automating the “coding style review comments” that so often come up in team development, you can focus code review on what really matters.

Installation

Newly created Laravel applications include Pint out of the box. For older projects, install it with Composer.

composer require laravel/pint --dev

How to run it

Basic usage

Automatically fixes all .php files in the project.

./vendor/bin/pint

You can also target specific files or directories.

./vendor/bin/pint app/Models
./vendor/bin/pint app/Models/User.php

Available options

Option	Description
`--test`	Only detects style errors without modifying files. Returns a non-zero exit code if errors are found
`--dirty`	Only targets files with uncommitted changes in Git
`--diff=[branch]`	Only targets files that differ from the specified branch
`--repair`	Fixes style errors and returns a non-zero exit code if any fixes were made
`--parallel`	Improves performance with parallel execution mode (experimental)
`--max-processes=4`	Combined with `--parallel`, specifies the maximum number of processes
`-v`	Shows detailed information about the changes
`--config`	Specifies the path to the `pint.json` file to use
`--preset`	Specifies the preset to use

# Check only, without modifying files
./vendor/bin/pint --test

# Only target uncommitted files
./vendor/bin/pint --dirty

# Parallel execution
./vendor/bin/pint --parallel

Configuration

You can customize behavior by creating a pint.json file at the root of your project.

{
    "preset": "laravel"
}

You can also explicitly specify the path to the configuration file.

./vendor/bin/pint --config vendor/my-company/coding-style/pint.json

Presets

A preset is a set of rules. The default is the laravel preset, which applies rules optimized for Laravel projects.

Preset	Description
`laravel`	Laravel’s recommended coding style (default)
`psr12`	The PSR-12 coding standard
`per`	PER Coding Style
`symfony`	Symfony’s coding style
`empty`	No rules. Define rules individually

# Specify a preset from the command line
./vendor/bin/pint --preset psr12

Customizing rules

You can enable or disable individual rules in pint.json. For the available rules, see the PHP CS Fixer Configurator.

{
    "preset": "laravel",
    "rules": {
        "simplified_null_return": true,
        "array_indentation": false,
        "new_with_parentheses": {
            "anonymous_class": true,
            "named_class": true
        }
    }
}

Excluding files and folders

You can exclude specific folders from being checked.

{
    "exclude": [
        "my-specific/folder"
    ]
}

To exclude by file name pattern, use notName.

{
    "notName": [
        "*-my-file.php"
    ]
}

To exclude by specific file path, use notPath.

{
    "notPath": [
        "path/to/excluded-file.php"
    ]
}

Recommended settings

Here’s an example of a pint.json configuration that works well in real-world development.

{
    "preset": "laravel",
    "rules": {
        "no_unused_imports": false,
        "strict_comparison": true,
        "declare_strict_types": true
    }
}

The reasons for adding each rule:

Rule	Effect
`no_unused_imports`	When set to `false`, keeps unused `use` statements instead of removing them. Pint’s default is `true` (removes them), so this setting is not needed in ordinary Laravel projects
`strict_comparison`	Converts `==` to `===` and `!=` to `!==` to prevent bugs from unexpected type juggling
`declare_strict_types`	Automatically adds `declare(strict_types=1);` at the top of the file to increase type safety

strict_comparison and declare_strict_types enforce type-strict code, so the initial fix volume can be large when adding them to an existing project. Introducing them from the start is recommended for new projects.

no_unused_imports is a setting for package development. Pint’s default is true (removes unused use statements), so this setting itself is unnecessary in ordinary Laravel projects. In package development, patterns that turn features on/off by importing traits or interfaces are common, so it’s convenient to keep false as the default and switch to true for individual packages as appropriate.

Setting up scripts in composer.json

By registering scripts for Pint in composer.json, you can run it with just composer pint.

{
    "scripts": {
        "pint": "./vendor/bin/pint",
        "pint:test": "./vendor/bin/pint --test"
    }
}

Once registered, you can run it as follows:

# Auto-fix the code
composer pint

# Check only (no fixing)
composer pint:test

In CI environments, use composer pint:test to detect style violations without modifying files. The --test option returns a non-zero exit code if errors are found, so it can be used for CI pass/fail checks.

Automatic execution with GitHub Actions

You can use GitHub Actions to automatically fix and commit code style on every push.

Set workflow permissions

In your GitHub repository, go to Settings > Actions > General > Workflow permissions and enable “Read and write permissions.”

Create the workflow file

Create .github/workflows/lint.yml.

name: Fix Code Style

on: [push]

jobs:
  lint:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: true
      matrix:
        php: [8.4]

    steps:
      - name: Checkout code
        uses: actions/checkout@v5

      - name: Setup PHP
        uses: shivammathur/setup-php@v2
        with:
          php-version: ${{ matrix.php }}
          tools: pint

      - name: Run Pint
        run: pint

      - name: Commit linted files
        uses: stefanzweifel/git-auto-commit-action@v6

This workflow runs Pint on every push and automatically commits any files that were fixed for style violations.

Since fixes happen before pull request review, the number of style-related review comments decreases. When rolling out to a team, run Pint on all files locally first, then add the workflow to avoid extra commits.

Architecture

Database

Eloquent

Security

Events

Mail and Notifications

Payments

Asynchronous Processing

Real-time Communication

Scheduling

Cache and Optimization

Internationalization

Files and Storage

Debugging and Monitoring

Console and CLI

Performance

Frontend

AI Development

Development Environment

What is Laravel Pint

Installation

How to run it

Basic usage

Available options

Configuration

Presets

Customizing rules

Excluding files and folders

Recommended settings

Setting up scripts in composer.json

Automatic execution with GitHub Actions

​What is Laravel Pint

​Installation

​How to run it

​Basic usage

​Available options

​Configuration

​Presets

​Customizing rules

​Excluding files and folders

​Recommended settings

​Setting up scripts in composer.json

​Automatic execution with GitHub Actions

What is Laravel Pint

Installation

How to run it

Basic usage

Available options

Configuration

Presets

Customizing rules

Excluding files and folders

Recommended settings

Setting up scripts in composer.json

Automatic execution with GitHub Actions