golangci-lint

Visit Website

Introduction

golangci-lint is a fast linters runner for Go. The README sums it up: it runs linters in parallel, uses caching, supports YAML configuration, integrates with all major IDEs, and includes over a hundred linters.

Go has many excellent single-purpose analysers, such as staticcheck, errcheck, govet, gosec, revive and ineffassign. Running them separately means repeated parsing and type checking. golangci-lint loads the program once and shares that work across linters, which is why a full run on a large codebase is practical in CI.

Version 2 introduced a new configuration format with linters and formatters sections and presets such as standard. Formatters including gofmt, gofumpt, goimports and gci can be run and checked through the same tool. Issues can be limited to new code with --new-from-rev or --new-from-merge-base, so a team can adopt strict linters on an existing codebase without fixing everything first.

Output formats include text, JSON, Checkstyle, JUnit, SARIF and code-climate, and there is an official GitHub Action. Many linters support automatic fixes through --fix.

In the quality loop golangci-lint is the standard static gate for Go projects. It complements go vet and the compiler, and pairs with govulncheck for vulnerability checks.

The source code is at golangci/golangci-lint on GitHub under the GPL-3.0 licence, with about 19,500 stars; the most recent commit was on 11 November 2026.

Adoption usually goes best in three steps. First, run golangci-lint with its default linters on the whole repository and record the findings without failing the build. Second, enable the new-from-rev or new-from-merge-base style options so that only issues in changed code fail pull requests; this stops a large backlog of old warnings from blocking every change. Third, add linters one at a time, such as gosec for security-sensitive code, errorlint for error wrapping or revive for style, and agree on each with the team before turning it on.

Configuration lives in a single .golangci.yml, which makes the linter set reviewable like any other code. Pin the golangci-lint version in CI, because new releases add linters and checks that can suddenly change results. Caching the analysis between runs keeps pull request checks fast even in large monorepos, and the GitHub Action handles that caching for you.

For teams moving from separate tools, golangci-lint replaces a collection of scripts that ran go vet, staticcheck and others individually, giving one command, one output format and one place to suppress false positives with //nolint comments that name the linter and give a reason.

Finally, make output useful in reviews: annotations on pull requests, or reviewdog-style inline comments, put findings next to the changed lines, which is where developers are most likely to fix them.

Features

1. 100+ linters: staticcheck, errcheck, govet, gosec, revive and many more.
2. Parallel and cached: Shared loading and caching for speed.
3. Formatters: gofmt, gofumpt, goimports and gci.
4. New-code mode: Report only issues introduced since a revision.
5. Presets: Enable sensible groups of linters.
6. Auto-fix: --fix for supported linters.
7. Many output formats: JSON, Checkstyle, JUnit, SARIF and others.
8. GitHub Action: Official action with caching.
9. Exclusions: Fine-grained rules for paths, linters and text.
10. IDE integration: Works with major Go editors.

Pros

1. One tool for Go linting: Replaces many separate analyser runs.
2. Adoption-friendly: New-code mode avoids big-bang cleanups.
3. Free to use: Open source under the GPL-3.0 licence, so the core tool costs nothing to use.
4. Actively maintained: The repository had commits as recent as 11 November 2026.
5. Community: About 19,500 GitHub stars.

Cons

1. Configuration churn: Version 2 changed the config format.
2. Linter overlap: Enabling too many linters creates duplicate findings.
3. Memory use: Large repositories need generous CI resources.
4. GPL licence: The runner is GPL-3.0, which matters to some organisations.

Usage and Links (Example)

# .golangci.yml
version: "2"
linters:
  default: standard
  enable: [gosec, revive, errorlint]
formatters:
  enable: [gofumpt, goimports]

golangci-lint run --new-from-merge-base=main ./...
golangci-lint fmt

Practical tips:

1. Start from the standard preset and add linters one at a time.
2. Use new-code mode in CI for legacy repositories.
3. Cache ~/.cache/golangci-lint between CI runs.

Resources:

• golangci-lint website
• GitHub repository

Pricing

golangci-lint is free and open source under the GPL-3.0 licence.

Recommended for?

1. Every Go project that wants more than go vet.
2. Large Go monorepos needing fast, shared analysis.
3. Teams adopting strict linters incrementally.

Conclusion

golangci-lint is the de facto lint gate for Go, combining over a hundred analysers in one fast run.

Begin with a preset, use new-code mode for older repositories, and cache results in CI.

On CheckOps, golangci-lint is filed under the Release & CI gates stage. Related tools listed here include gosec, govulncheck, Semgrep, reviewdog, MegaLinter and SonarQube. When comparing them, weigh the licence, the languages and platforms each supports, whether it is self-hosted or managed, and how cleanly it slots into your existing CI pipeline. Details on this page were checked against the official website, documentation and repository on 11 November 2026.