# Source: https://github.com/golangci/golangci-lint/blob/master/docs/src/docs/welcome/install.mdx

---
title: "Install"
---

## CI installation

Most installations of `golangci-lint` are performed for CI.

It's important to have reproducible CI: don't start to fail all builds at the same time.
With golangci-lint this can happen if you use option `--enable-all` and a new linter is added
or even without `--enable-all` when one upstream linter is upgraded.

**IMPORTANT**: It's highly recommended installing a specific version of golangci-lint available on the [releases page](https://github.com/golangci/golangci-lint/releases).

### GitHub Actions

We recommend using [our GitHub Action](https://github.com/golangci/golangci-lint-action) for running `golangci-lint` in CI for GitHub projects.

It's [fast and uses smart caching](https://github.com/golangci/golangci-lint-action#performance) inside,
and it can be much faster than the simple binary installation.

![Log output of the action](./colored-line-number.png)

Also, the action creates GitHub annotations for found issues (you don't need to dig into build log to see found by `golangci-lint` issues):

![GitHub annotations of the action](./annotations.png)

### GitLab CI

GitLab provides a [guide for integrating golangci-lint into the Code Quality widget](https://docs.gitlab.com/ci/testing/code_quality/#golangci-lint).
A simple quickstart is their [CI component](https://gitlab.com/explore/catalog/components/code-quality-oss/codequality-os-scanners-integration), which can be used like this:

```yaml .gitlab-ci.yml
include:
  - component: $CI_SERVER_FQDN/components/code-quality-oss/codequality-os-scanners-integration/golangci@1.0.1
```

Note that you [can only reference components in the same GitLab instance as your project](https://docs.gitlab.com/ci/components/#use-a-component)

### Other CI

Here is the other way to install golangci-lint:

```sh
# binary will be $(go env GOPATH)/bin/golangci-lint
curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/HEAD/install.sh | sh -s -- -b $(go env GOPATH)/bin {.LatestVersion}

# or install it into ./bin/
curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/HEAD/install.sh | sh -s {.LatestVersion}

# In Alpine Linux (as it does not come with curl by default)
wget -O- -nv https://raw.githubusercontent.com/golangci/golangci-lint/HEAD/install.sh | sh -s {.LatestVersion}

golangci-lint --version
```

It is advised that you periodically update the version of `golangci-lint` as the project is under active development
and is constantly being improved. For any problems with `golangci-lint`, check out recent [GitHub issues](https://github.com/golangci/golangci-lint/issues) and update if needed.

## Local Installation

[![Packaging status](https://repology.org/badge/vertical-allrepos/golangci-lint.svg)](https://repology.org/project/golangci-lint/versions)

### Binaries

```sh
# binary will be $(go env GOPATH)/bin/golangci-lint
curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/HEAD/install.sh | sh -s -- -b $(go env GOPATH)/bin {.LatestVersion}

golangci-lint --version
```

On Windows, you can run the above commands with Git Bash, which comes with [Git for Windows](https://git-scm.com/download/win).

### Linux

Golangci-lint is available inside the majority of the package managers.

### macOS

#### Brew

Note: brew can use a non-expected version of Go to build the binary,
so we recommend either using our binaries or be sure of the version of Go used to build.

You can install a binary release on macOS using [brew](https://brew.sh/):

```sh
brew install golangci-lint
brew upgrade golangci-lint
```

Note: Previously we used a [Homebrew tap](https://github.com/golangci/homebrew-tap). We recommend using official formula instead of the tap, but sometimes the most recent release
isn't immediately available via Homebrew core due to manual updates that need to occur from Homebrew core maintainers. In this case, the tap formula, which is updated automatically,
can be used to install the latest version of `golangci-lint`:

```sh
brew tap golangci/tap
brew install golangci/tap/golangci-lint
```

#### MacPorts

It can also be installed through [MacPorts](https://www.macports.org/)
The MacPorts installation mode is community driven, and not officially maintained by golangci team.

```sh
sudo port install golangci-lint
```

### Windows

#### Chocolatey

You can install a binary on Windows using [chocolatey](https://community.chocolatey.org/packages/golangci-lint).

```sh
choco install golangci-lint
```

#### Scoop

You can install a binary on Windows using [scoop](https://scoop.sh).

```sh
scoop install main/golangci-lint
```

The scoop package is not officially maintained by golangci team.

### Docker

```sh
docker run --rm -v $(pwd):/app -w /app golangci/golangci-lint:{.LatestVersion} golangci-lint run -v
```

Preserving cache between consecutive runs:
```sh
docker run --rm -v $(pwd):/app -v ~/.cache/golangci-lint/{.LatestVersion}:/root/.cache -w /app golangci/golangci-lint:{.LatestVersion} golangci-lint run -v
```

Colored output:
```sh
docker run -t --rm -v $(pwd):/app -w /app golangci/golangci-lint:{.LatestVersion} golangci-lint run -v
```

### Install from Sources

Using `go install`/`go get`, "tools pattern", and `tool` command/directives installations aren't guaranteed to work.

We recommend using binary installation.

These installations aren't recommended because of the following points:

1. These installations compile golangci-lint locally. The Go version used to build will depend on your local Go version.
2. Some users use the `-u` flag for `go get`, which upgrades our dependencies. The resulting binary was not tested and is not guaranteed to work.
3. When using the "tools pattern" or `tool` command/directives, the dependencies of a tool can modify the dependencies of another tool or your project. The resulting binary was not tested and is not guaranteed to work.
4. We've encountered issues with Go module hashes due to the unexpected recreation of dependency tags.
5. `go.mod` replacement directives don't apply transitively. It means a user will be using a patched version of `golangci-lint` if we use such replacements.
6. It allows installation from the main branch, which can't be considered stable.
7. It's slower than binary installation.

```sh
go install github.com/golangci/golangci-lint/cmd/golangci-lint@{.LatestVersion}
```

## Next

[Quick Start: how to use `golangci-lint`](/welcome/quick-start/).