GoReleaser

https://goreleaser.com/
Admin
GoReleaser is a release automation tool that simplifies building, packaging, and releasing Go...
Tokens:117,846
Snippets:1,238
Trust Score:9.7
Update:1 month ago
Show doc for...
Tokens:
Raw
### Full Azure Pipeline YAML example

Source: https://goreleaser.com/customization/ci/azurepipelines

A complete pipeline configuration including Go installation, testing, and release steps.

```yaml
# customize trigger to your needs
trigger:
  branches:
    include:
      - main
      - refs/tags/*

variables:
  GO_VERSION: "1.27"

pool:
  vmImage: ubuntu-latest

jobs:
  - job: Test
    steps:
      - task: GoTool@0
        inputs:
          version: "$(GO_VERSION)"
        displayName: Install Go

      - bash: go test ./...
        displayName: Run Go Tests

  - job: Release
    # only runs if Test was successful
    dependsOn: Test
    # only runs if pipeline was triggered from a branch.
    condition: and(succeeded(), startsWith(variables['Build.SourceBranch'], 'refs/tags'))
    steps:
      - task: GoTool@0
        inputs:
          version: "$(GO_VERSION)"
        displayName: Install Go

      - task: goreleaser@0
        inputs:
          version: "latest"
          distribution: "goreleaser"
          args: ""
          workdir: "$(Build.SourcesDirectory)"
```

--------------------------------

### Install Package via GoFish

Source: https://goreleaser.com/blog/homebrew-gofish

Commands to add the rig and install the binary using GoFish.

```bash
gofish rig add https://github.com/dirien/goreleaser-rig
gofish install github.com/dirien/goreleaser-rig/goreleaser-brew-fish
```

--------------------------------

### Install Package via Homebrew

Source: https://goreleaser.com/blog/homebrew-gofish

Commands to add the tap and install the binary using Homebrew.

```bash
brew tap dirien/goreleaser-tap
brew install goreleaser-brew-fish
```

--------------------------------

### Install Flatpak Runtimes and SDKs

Source: https://goreleaser.com/customization/package/flatpak

Install the necessary Flatpak runtimes and SDKs on your build machine before running GoReleaser.

```bash
flatpak install flathub \
  org.freedesktop.Platform/x86_64/24.08 \
  org.freedesktop.Sdk/x86_64/24.08 \
  org.freedesktop.Platform/aarch64/24.08 \
  org.freedesktop.Sdk/aarch64/24.08
```

--------------------------------

### Configure Homebrew extra install instructions

Source: https://goreleaser.com/customization/publish/homebrew_formulas

Adds additional installation steps without overriding the primary install logic.

```yaml
extra_install: |
  bash_completion.install "completions/foo.bash" => "foo"
  man1.install "man/foo.1.gz"
  # ...
```

--------------------------------

### Example NSIS Script

Source: https://goreleaser.com/customization/package/nsis

A sample NSIS script template that utilizes GoReleaser variables for installation paths and binary management.

```nsi
!define APP_NAME "{{ .ProjectName }}"
!define APP_VERSION "{{ .Version }}"

OutFile "{{ .Name }}.exe"
!include "MUI2.nsh"

Name "${APP_NAME} ${APP_VERSION}"
InstallDir "{{ .ProgramFiles }}\${APP_NAME}"
RequestExecutionLevel admin

!insertmacro MUI_PAGE_WELCOME
!insertmacro MUI_PAGE_LICENSE "LICENSE"
!insertmacro MUI_PAGE_DIRECTORY
!insertmacro MUI_PAGE_INSTFILES
!insertmacro MUI_PAGE_FINISH
!insertmacro MUI_LANGUAGE "English"

Section "Main Section" SEC01
  SetOutPath "$INSTDIR"
  File "{{ .Binary }}"
  CreateDirectory "$SMPROGRAMS\${APP_NAME}"
  CreateShortcut "$SMPROGRAMS\${APP_NAME}\${APP_NAME}.lnk" "$INSTDIR\{{ .Binary }}"
  WriteUninstaller "$INSTDIR\uninstall.exe"
SectionEnd

Section "Uninstall"
  Delete "$INSTDIR\{{ .Binary }}"
  Delete "$INSTDIR\uninstall.exe"
  RMDir "$INSTDIR"
  Delete "$SMPROGRAMS\${APP_NAME}\${APP_NAME}.lnk"
  RMDir "$SMPROGRAMS\${APP_NAME}"
SectionEnd
```

--------------------------------

### Basic Custom Publisher Configuration

Source: https://goreleaser.com/customization/publish/publishers

A simple example of how to configure a custom publisher with a name and a command.

```yaml
publishers:
  - name: my-publisher
    cmd: custom-publisher -version={{ .Version }} {{ abs .ArtifactPath }}
```

--------------------------------

### Scoop Installation Commands

Source: https://goreleaser.com/customization/publish/scoop

These shell commands demonstrate how a user can add a Scoop bucket and install an application using the generated manifest. The first command adds the repository containing the manifest, and the second installs the specified application.

```sh
scoop bucket add org https://github.com/org/repo.git
scoop install org/drumroll
```

--------------------------------

### Configure Installation Scripts

Source: https://goreleaser.com/customization/package/nfpm

Define scripts to execute at various stages of the package installation process using template-supported paths.

```yaml
scripts:
  preinstall: "scripts/preinstall.sh"
  postinstall: "scripts/postinstall.sh"
  preremove: "scripts/preremove.sh"
  postremove: "scripts/postremove.sh"
```

--------------------------------

### Example GoReleaser Configuration

Source: https://goreleaser.com/blog/azure-devops-multi-platform

A base configuration file for GoReleaser with default build settings.

```yaml
# This is an example .goreleaser.yml file with some sensible defaults.
# Make sure to check the documentation at https://goreleaser.com
before:
  hooks:
    # You may remove this if you don't use go modules.
    - go mod tidy
builds:
  - env:
      - CGO_ENABLED=0
    goos:
      - linux
      - darwin
```

--------------------------------

### Example of Custom Publisher Execution

Source: https://goreleaser.com/customization/publish/publishers

Illustrates the actual command executed by the custom publisher based on the templated configuration.

```bash
custom-publisher -product=goreleaser -version=1.0.0 goreleaser_1.0.0_linux_amd64.zip
```

--------------------------------

### Install Cosign via GitHub Actions

Source: https://goreleaser.com/blog/supply-chain-security

Add this step to your GitHub Actions workflow to install the Cosign binary.

```yaml
- uses: sigstore/cosign-installer@v2.1.0 # installs cosign
```

--------------------------------

### Install Cosign via Homebrew

Source: https://goreleaser.com/blog/supply-chain-security

Use this command to install Cosign on macOS systems.

```bash
$ brew install cosign
```

--------------------------------

### Go Builder Configuration Options

Source: https://goreleaser.com/customization/builds/builders/go

Example configuration for builder selection, target-specific overrides, and custom Go binary paths.

```yaml
# Builder allows you to use a different build implementation.
    # Valid options are: `go`, `rust`, `zig`, `bun`, `deno`, `node`, `uv`,
    # `poetry`, and `prebuilt` (pro-only).
    #
    # Default: 'go'.
    builder: prebuilt

    # Overrides allows to override some fields for specific targets.
    # This can be specially useful when using CGO.
    #
    # Attention: you need to set at least goos and goarch, otherwise it won't
    # match anything.
    overrides:
      - goos: darwin
        goarch: amd64
        goamd64: v1
        goarm: ""
        goarm64: ""
        gomips: ""
        go386: ""
        goriscv64: ""
        goppc64: ""
        ldflags:
          - foo
        tags:
          - bar
        asmflags:
          - foobar
        gcflags:
          - foobaz
        env:
          - CGO_ENABLED=1

    # Set a specific go binary to use when building.
    # It is safe to ignore this option in most cases.
    #
    # Default: "go".
    # Templates: allowed.
    # Deprecated: use `tool` instead.
    gobinary: "go1.13.4"
```

--------------------------------

### Scoop Configuration Example

Source: https://goreleaser.com/customization/publish/scoop

This is a comprehensive example of the `scoop` section in a GoReleaser configuration file. It demonstrates various options for customizing Scoop manifest generation, including name, URL template, directory, use format, commit message template, homepage, description, license, skip upload behavior, persist settings, pre/post-install commands, dependencies, shortcuts, and GoAMD64 version.

```yaml
scoops:
  - # Name of the recipe
    #
    # Default: the project name.
    # Templates: allowed.
    name: myproject

    # URL which is determined by the given Token (github or gitlab)
    #
    # Default:
    #   GitHub: 'https://github.com/<repo_owner>/<repo_name>/releases/download/{{ .Tag }}/{{ .ArtifactName }}'
    #   GitLab: 'https://gitlab.com/<repo_owner>/<repo_name>/-/releases/{{ .Tag }}/downloads/{{ .ArtifactName }}'
    #   Gitea: 'https://gitea.com/<repo_owner>/<repo_name>/releases/download/{{ .Tag }}/{{ .ArtifactName }}'
    # Templates: allowed.
    url_template: "http://github.mycompany.com/foo/bar/releases/{{ .Tag }}/{{ .ArtifactName }}"

    # Directory inside the repository to put the scoop.
    #
    # Note that while scoop works if the manifests are in a directory, 
    # 'scoop bucket list' will show 0 manifests if they are not in the root
    # directory.
    # In short, it's generally better to leave this empty.
    directory: Scoops

    # Which format to use.
    #
    # Valid options are:
    # - 'msi':     msi installers (requires the MSI pipe configured) {{< g_inline_pro >}}
    # - 'nsis':    nsis installers (requires the NSIS pipe configured) {{< g_inline_pro >}}
    # - 'archive': archives (only if format is zip),
    #
    # This feature is only available in GoReleaser Pro.
    # Default: 'archive'.
    use: msi

    # The project name and current git tag are used in the format string.
    #
    # Templates: allowed.
    commit_msg_template: "Scoop update for {{ .ProjectName }} version {{ .Tag }}"

    # Your app's homepage.
    #
    # Templates: allowed.
    # Default: inferred from global metadata.
    homepage: "https://example.com/"

    # Your app's description.
    #
    # Templates: allowed.
    # Default: inferred from global metadata.
    description: "Software to create fast and easy drum rolls."

    # Your app's license
    #
    # Default: inferred from global metadata.
    license: MIT

    # Setting this will prevent goreleaser to actually try to commit the updated
    # manifest leaving the responsibility of publishing it to the user.
    # If set to auto, the release will not be uploaded to the scoop bucket
    # in case there is an indicator for prerelease in the tag e.g. v1.0.0-rc1
    #
    # Templates: allowed.
    skip_upload: true

    # Persist data between application updates
    persist:
      - "data"
      - "config.toml"

    # An array of commands to be executed before an application is installed.
    pre_install: ["Write-Host 'Running preinstall command'"]

    # An array of commands to be executed after an application is installed.
    post_install: ["Write-Host 'Running postinstall command'"]

    # An array of dependencies.
    depends: ["git", "foo"]

    # A two-dimensional array of string, specifies the shortcut values to make available in the startmenu.
    # The array has to contain an executable/label pair. The third and fourth element are optional.
    shortcuts: [["drumroll.exe", "drumroll"]]

    # GOAMD64 to specify which amd64 version to use if there are multiple versions
    # from the build section.
    #
    # Default: 'v1'.
    goamd64: v3

{{% g_include file="includes/repository.md" %}}
```

--------------------------------

### Configure Homebrew post-install script

Source: https://goreleaser.com/customization/publish/homebrew_formulas

Specifies actions to perform after the main installation process completes.

```yaml
post_install: |
	etc.install "app-config.conf"
  # ...
```

--------------------------------

### Sign binaries with Cosign

Source: https://goreleaser.com/customization/sign/binary_sign

Configuration example for using Cosign to sign binaries, requiring a key and password environment variable.

```yaml
binary_signs:
  - cmd: cosign
    stdin: "{{ .Env.COSIGN_PWD }}"
    args:
      - "sign-blob"
      - "--key=cosign.key"
      - "--output-signature=${signature}"
      - "${artifact}"
      - "--yes" # needed on cosign 2.0.0+
```

--------------------------------

### Configure Winget publisher settings

Source: https://goreleaser.com/customization/publish/winget

Example configuration block for the Winget publisher in GoReleaser.

```yaml
author: "Carlos Becker"

# Setting this will prevent goreleaser to actually try to commit the updated
# package - instead, it will be stored on the dist directory only,
# leaving the responsibility of publishing it to the user.
#
# If set to auto, the release will not be uploaded to the repository
# in case there is an indicator for prerelease in the tag e.g. v1.0.0-rc1
#
# Templates: allowed.
skip_upload: true

# Release notes.
#
# If you want to use the release notes generated by GoReleaser, use
# `{{.Changelog}}` as the value.
#
# Templates: allowed.
release_notes: "{{.Changelog}}"

# Release notes URL.
#
# Templates: allowed.
release_notes_url: "https://foo.bar/changelog/{{.Version}}"

# Installation notes.
#
# {{< g_inline_version "v2.9" >}}
# Templates: allowed.
installation_notes: "Information on how to install. Can also be a URL"

# Tags.
#
# GoReleaser converts all tags to lowercase and replace
# spaces with hyphens (-) as per winget's best practices.
tags:
  - golang
  - cli

# Package dependencies.
#
# Templates: allowed.
dependencies:
  - package_identifier: Foo.Bar
    minimum_version: 1.2.3
```

--------------------------------

### Configure Rust build with cargo-cross

Source: https://goreleaser.com/customization/builds/builders/rust

Minimal configuration example for using cargo-cross as the build tool.

```yaml
builds:
  - # Use cargo cross:
    builder: rust
    tool: cross
    command: build
    targets:
      - x86_64-apple-darwin
      - x86_64-pc-windows-gnu
```

--------------------------------

### Configure Deno builder in .goreleaser.yaml

Source: https://goreleaser.com/customization/builds/builders/deno

Example configuration for the Deno builder, specifying targets, entry points, and custom flags.

```yaml
builds:
  # You can have multiple builds defined as a yaml list
  - #
    # ID of the build.
    #
    # Default: Project name.
    id: "my-build"

    # Use deno.
    builder: deno

    # Binary name.
    # Can be a path (e.g. `bin/app`) to wrap the binary in a directory.
    #
    # Default: Project name.
    binary: program

    # List of targets to be built, in Deno's format.
    #
    # See: https://docs.deno.com/runtime/reference/cli/compile/#supported-targets
    # Default: [ "x86_64-pc-windows-msvc", "x86_64-apple-darwin", "aarch64-apple-darwin", "x86_64-unknown-linux-gnu", "aarch64-unknown-linux-gnu" ]
    targets:
      - x86_64-unknown-linux-gnu
      - aarch64-unknown-linux-gnu
      - x86_64-pc-windows-msvc
      - x86_64-apple-darwin
      - aarch64-apple-darwin

    # Path to project's (sub)directory containing the code.
    # This is the working directory for the `deno compile` command(s).
    #
    # Default: '.'.
    dir: my-app

    # Main entry point.
    #
    # Default: 'main.ts'.
    main: "file.ts"

    # Set a specific deno binary to use when building.
    # It is safe to ignore this option in most cases.
    #
    # Default: 'deno'.
    # Templates: allowed.
    tool: "deno-canary"

    # Sets the command to run to build.
    #
    # Default: 'compile'.
    command: not-build

    # Custom flags.
    #
    # Templates: allowed.
    # Default: [].
    flags:
      - --allow-read
      - --allow-net

    # Custom environment variables to be set during the builds.
    # Invalid environment variables will be ignored.
    #
    # Default: os.Environ() ++ env config section.
    # Templates: allowed.
    env:
      - FOO=bar

    # Hooks can be used to customize the final binary,
    # for example, to run generators.
    #
    # Templates: allowed.
    hooks:
      pre: ./foo.sh
      post: ./script.sh {{ .Path }}

    # If true, skip the build.
    # Useful for library projects.
    skip: false
```

--------------------------------

### Multi-Binary Build Configuration

Source: https://goreleaser.com/customization/builds/builders/go

Example of defining multiple build targets within a single GoReleaser configuration file.

```yaml
builds:
  - main: ./cmd/cli
    id: "cli"
    binary: cli
    goos:
      - linux
      - darwin
      - windows

  - main: ./cmd/worker
    id: "worker"
    binary: worker
    goos:
      - linux
      - darwin
      - windows

  - main: ./cmd/tracker
    id: "tracker"
    binary: tracker
    goos:
      - linux
      - darwin
      - windows
```

--------------------------------

### Verify GoReleaser Release Logs

Source: https://goreleaser.com/blog/homebrew-gofish

Example output observed in the logs after running the release process.

```text
  • homebrew tap formula
           • pushing formula=Formula/goreleaser-brew-fish.rb repo=dirien/goreleaser-tap
  • gofish fish food cookbook
           • pushing food=Food/goreleaser-brew-fish.lua repo=dirien/goreleaser-rig
```

--------------------------------

### Configure Bun builder in .goreleaser.yaml

Source: https://goreleaser.com/customization/builds/builders/bun

Example configuration for the Bun builder, including targets, entry points, and custom flags.

```yaml
builds:
  # You can have multiple builds defined as a yaml list
  - #
    # ID of the build.
    #
    # Default: Project name.
    id: "my-build"

    # Use bun.
    builder: bun

    # Binary name.
    # Can be a path (e.g. `bin/app`) to wrap the binary in a directory.
    #
    # Default: Project name.
    binary: program

    # List of targets to be built, in Bun's format.
    #
    # See: https://bun.sh/docs/bundler/executables
    # The `bun-` prefix is added automatically.
    # Default: [ "linux-x64-modern", "linux-arm64", "darwin-x64", "darwin-arm64", "windows-x64-modern" ]
    targets:
      - linux-x64-modern
      - darwin-arm64

    # Path to project's (sub)directory containing the code.
    # This is the working directory for the `bun build` command(s).
    #
    # Default: '.'.
    dir: my-app

    # Main entry point.
    #
    # Default: extracted from package.json or `.`.
    main: "file.ts"

    # Set a specific bun binary to use when building.
    # It is safe to ignore this option in most cases.
    #
    # Default: "bun".
    # Templates: allowed.
    tool: "bun-nightly"

    # Sets the command to run to build.
    #
    # Default: build.
    command: not-build

    # Custom flags.
    #
    # Templates: allowed.
    # Default: ["--compile"].
    flags:
      - --minify

    # Custom environment variables to be set during the builds.
    # Invalid environment variables will be ignored.
    #
    # Default: os.Environ() ++ env config section.
    # Templates: allowed.
    env:
      - FOO=bar

    # Hooks can be used to customize the final binary,
    # for example, to run generators.
    #
    # Templates: allowed.
    hooks:
      pre: ./foo.sh
      post: ./script.sh {{ .Path }}

    # If true, skip the build.
    # Useful for library projects.
    skip: false
```

--------------------------------

### Configure RWX release pipeline

Source: https://goreleaser.com/customization/ci/rwx

Defines a full release pipeline with git cloning, Go installation, and GoReleaser execution.

```yaml
on:
  github:
    push:
      if: ${{ event.git.tag != '' }}
      init:
        commit-sha: ${{ event.git.sha }}

base:
  image: ubuntu:24.04
  config: rwx/base 1.0.2

tasks:
  - key: code
    call: git/clone 2.0.7
    with:
      repository: https://github.com/YOUR-ORG/YOUR-REPO.git
      ref: ${{ init.commit-sha }}
      github-token: ${{ github.token }}
      preserve-git-dir: true
      fetch-full-depth: true

  - key: go
    call: golang/install 1.2.0
    with:
      go-version: "1.27"

  - key: goreleaser
    run: |
      arch="$(uname -m)"
      [ "$arch" = "aarch64" ] && arch="arm64"
      curl -fsSL "https://github.com/goreleaser/goreleaser/releases/download/${VERSION}/goreleaser_Linux_${arch}.tar.gz" \
        | sudo tar -xz -C /usr/local/bin goreleaser
    env:
      VERSION: v2.15.4

  - key: release
    use: [code, go, goreleaser]
    cache: false
    run: goreleaser release --clean
    env:
      GITHUB_TOKEN: ${{ github.token }}
```

--------------------------------

### Implement Hello World server

Source: https://goreleaser.com/blog/azure-devops-multi-platform

Create a basic HTTP server using the Gorilla Mux router that listens on a configurable port.

```go
package main

import (
	"log"
	"net/http"
	"os"
	"strings"

	"github.com/gorilla/mux"
)

const (
	// Port is the port the server will listen on
	Port = "8080"
)

func HelloWorldHandler(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("Hello World!"))
}

func main() {
	r := mux.NewRouter()
	r.HandleFunc("/", HelloWorldHandler)
	port := os.Getenv("PORT")
	if port == "" {
		port = Port
	}
	for _, env := range os.Environ() {
		if strings.HasPrefix(env, "TEST") {
			log.Printf("%s", env)
		}
	}
	log.Println("Listening on port " + port)
	log.Fatal(http.ListenAndServe(":"+port, r))
}
```

--------------------------------

### Initialize Project Directory

Source: https://goreleaser.com/blog/goreleaser-ko

Create and enter a new directory for the Go project.

```bash
$ mkdir -p goreleaser-with-ko
$ cd goreleaser-with-ko
```

--------------------------------

### Initialize Go Module and Main File

Source: https://goreleaser.com/blog/goreleaser-ko

Initialize a Go module and create a basic main.go file for the application.

```bash
go mod init github.com/<username>/goreleaser-with-ko
cat <<EOF > main.go
package main

import (
  "fmt"
  "os"
)
var (
  // Version is the current version of the application.
  Version = "main"
)
func main() {
  fmt.Fprintf(os.Stdout, "GoReleaser supports ko! Version: %s", Version)
}
EOF
```

--------------------------------

### Generated Scoop Manifest Example

Source: https://goreleaser.com/customization/publish/scoop

This JSON object represents a generated Scoop app manifest. It includes version information, architecture-specific download URLs and binaries, and the application's homepage. This manifest is used by Scoop to install and manage the application.

```json
{
  "version": "1.2.3",
  "architecture": {
    "64bit": {
      "url": "https://github.com/user/drumroll/releases/download/1.2.3/drumroll_1.2.3_windows_amd64.tar.gz",
      "bin": "drumroll.exe",
      "hash": "86920b1f04173ee08773136df31305c0dae2c9927248ac259e02aafd92b6008a"
    },
    "32bit": {
      "url": "https://github.com/user/drumroll/releases/download/1.2.3/drumroll_1.2.3_windows_386.tar.gz",
      "bin": "drumroll.exe",
      "hash": "283faa524ef41987e51c8786c61bb56658a489f63512b32139d222b3ee1d18e6"
    }
  },
  "homepage": "https://example.com/"
}
```

--------------------------------

### Configure Go builds in .goreleaser.yaml

Source: https://goreleaser.com/customization/builds/builders/go

A comprehensive example showing all available fields for the builds section, including target OS/architecture, flags, and environment variable templates.

```yaml
builds:
  # You can have multiple builds defined as a yaml list
  - #
    # ID of the build.
    #
    # Default: Project name.
    id: "my-build"

    # Path to main.go file or main package.
    # Notice: when used with `gomod.proxy`, this must be a package.
    # If you set it to a ellipsis path (e.g. './...'), GoReleaser will find all
    # 'main' functions and build them all on a single command. {{< g_inline_version "v2.15" >}}
    #
    # Default: `.`.
    main: ./cmd/my-app

    # Binary name.
    # Can be a path (e.g. `bin/app`) to wrap the binary in a directory.
    #
    # Default: Project name.
    binary: program

    # Custom flags.
    #
    # Templates: allowed.
    flags:
      - -tags=dev
      - -v

    # Custom asmflags.
    # For more info refer to: https://pkg.go.dev/cmd/go#hdr-Compile_packages_and_dependencies
    # and https://pkg.go.dev/cmd/asm
    #
    # Templates: allowed.
    asmflags:
      - -D mysymbol
      - all=-trimpath={{.Env.GOPATH}}

    # Custom gcflags.
    # For more info refer to: https://pkg.go.dev/cmd/go#hdr-Compile_packages_and_dependencies
    # and https://pkg.go.dev/cmd/compile
    #
    # Templates: allowed.
    gcflags:
      - all=-trimpath={{.Env.GOPATH}}
      - ./dontoptimizeme=-N

    # Custom ldflags.
    # For more info refer to: https://pkg.go.dev/cmd/go#hdr-Compile_packages_and_dependencies
    # and https://pkg.go.dev/cmd/link
    #
    # Default: '-s -w -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.Date}} -X main.builtBy=goreleaser'.
    # Templates: allowed.
    ldflags:
      - -s -w -X main.build={{.Version}}
      - ./usemsan=-msan

    # Custom Go build mode.
    # For more info refer to: https://pkg.go.dev/cmd/go#hdr-Build_modes
    #
    # Valid options:
    # - `c-shared`
    # - `c-archive`
    # - `pie`
    buildmode: c-shared

    # Custom build tags templates.
    # For more info refer to: https://pkg.go.dev/cmd/go#hdr-Build_constraints
    tags:
      - osusergo
      - netgo
      - static_build
      - feature

    # Custom environment variables to be set during the builds.
    # Invalid environment variables will be ignored.
    # For more info refer to: https://pkg.go.dev/cmd/go#hdr-Environment_variables
    #
    # Default: os.Environ() ++ env config section.
    # Templates: allowed.
    env:
      - CGO_ENABLED=0
      # complex, templated envs:
      - >-
        {{- if eq .Os "darwin" }}
          {{- if eq .Arch "amd64"}}CC=o64-clang{{- end }}
          {{- if eq .Arch "arm64"}}CC=aarch64-apple-darwin20.2-clang{{- end }}
        {{- end }}
        {{- if eq .Os "windows" }}
          {{- if eq .Arch "amd64" }}CC=x86_64-w64-mingw32-gcc{{- end }}
        {{- end }}

    # GOOS list to build for.
    # For more info refer to: https://pkg.go.dev/cmd/go#hdr-Environment_variables
    #
    # Default: [ 'darwin', 'linux', 'windows' ].
    goos:
      - freebsd
      - windows

    # GOARCH to build for.
    # For more info refer to: https://pkg.go.dev/cmd/go#hdr-Environment_variables
    #
    # Default: [ '386', 'amd64', 'arm64' ].
    goarch:
      - amd64
      - arm
      - arm64

    # GOARM to build for when GOARCH is arm.
    # For more info refer to: https://pkg.go.dev/cmd/go#hdr-Environment_variables
    # and https://go.dev/wiki/MinimumRequirements#microarchitecture-support
    #
    # You can also select the floating-point ABI explicitly (since Go 1.22): {{< g_inline_version "v2.17" >}}
    #   - 6,softfloat
    #   - 6,hardfloat
    #   - 7,softfloat
    #   - 7,hardfloat
    #
    # Only one ABI per GOARM version is supported: building the same version with
    # two ABIs (e.g. `7` and `7,softfloat`, or `7,softfloat` and `7,hardfloat`)
    # is an error, as they are indistinguishable once packaged. GOARM 5 is
    # soft-float only, so `5,hardfloat` is rejected (plain `5` is already soft).
    #
    # When using `ignore`, match the exact form: `goarm: 7` ignores only a bare
    # `7` target, not `7,softfloat`.
    #
    # Default: [ 6 ].
    goarm:
      - 6
      - 7

    # GOAMD64 to build when GOARCH is amd64.
    # For more info refer to: https://pkg.go.dev/cmd/go#hdr-Environment_variables
    # and https://go.dev/wiki/MinimumRequirements#microarchitecture-support
    #
    # Default: [ 'v1' ].
    goamd64:
      - v2
      - v3
```

--------------------------------

### Configure Homebrew custom install script

Source: https://goreleaser.com/customization/publish/homebrew_formulas

Overrides the default installation logic for the Homebrew formula.

```yaml
install: |
  bin.install "some_other_name"
  bash_completion.install "completions/foo.bash" => "foo"
  # ...
```

--------------------------------

### Test application locally

Source: https://goreleaser.com/blog/azure-devops-multi-platform

Build the binary, create the container image, and run it to verify functionality.

```bash
GOOS=linux GOARCH=amd64 go build -o goreleaser-container-example .
docker buildx build --platform linux/amd64 -t goreleaser-container-example .
docker run -p 8080:8080 goreleaser-container-example
```

```bash
2023/01/10 10:49:31 Listening on port 8080
```

```bash
curl localhost:8080
Hello World!
```

--------------------------------

### Configure Templated Installation Scripts

Source: https://goreleaser.com/customization/package/nfpm

Define templated scripts for package installation, a feature exclusive to GoReleaser Pro.

```yaml
templated_scripts:
  preinstall: "scripts/preinstall.sh"
  postinstall: "scripts/postinstall.sh"
  preremove: "scripts/preremove.sh"
  postremove: "scripts/postremove.sh"
```

--------------------------------

### Configure Windows NSIS installer

Source: https://goreleaser.com/blog/goreleaser-v2.14

Specify the path to a custom NSIS script file for Windows installer generation.

```yaml
nsis:
  - script: ./path/to/script.nsis
```

--------------------------------

### Initialize Docker Buildx Builder

Source: https://goreleaser.com/customization/package/dockers_v2

Commands to create and configure a multi-platform capable builder on Linux.

```sh
docker buildx create --name=goreleaser --use
docker run --privileged --rm tonistiigi/binfmt --install all
```

--------------------------------

### Configure macOS .pkg installer

Source: https://goreleaser.com/blog/goreleaser-v2.14

Define the identifier for a macOS .pkg installer within the GoReleaser configuration file.

```yaml
pkgs:
  - identifier: org.example.foo
```

--------------------------------

### Configure Build Tool and Command

Source: https://goreleaser.com/customization/builds/builders/go

Set the Go binary path and the specific build command to execute.

```yaml
tool: "go1.13.4"
```

```yaml
command: test
```

--------------------------------

### Initialize GoReleaser Configuration

Source: https://goreleaser.com/blog/goreleaser-ko

Generate the initial .goreleaser.yml configuration file.

```bash
# it will create the .goreleaser.yml configuration file
```

--------------------------------

### macOS Pkg Configuration

Source: https://goreleaser.com/customization/package/pkg

Configure the creation of macOS .pkg installers. Specify package ID, name, artifact usage, installation location, and scripts.

```yaml
pkgs:
  - id: foo
    name: 'myproject{{ if ne .Arch "all" }}-{{.Arch}}{{ end }}'
    ids:
      - foo
      - bar
    use: binary
    if: '{{ eq .Arch "arm64" }}'
    identifier: com.example.myapp
    install_location: /usr/local/bin
    scripts: ./scripts
    replace: true
    mod_timestamp: "{{ .CommitTimestamp }}"
```

--------------------------------

### Initialize GoReleaser configuration

Source: https://goreleaser.com/blog/goreleaser-ko

Generates the default .goreleaser.yaml configuration file.

```bash
$ goreleaser init
• Generating .goreleaser.yaml file
• config created; please edit accordingly to your needs file=.goreleaser.yaml
```

--------------------------------

### Example Shell Script for Makeself

Source: https://goreleaser.com/blog/goreleaser-v2.12

A simple shell script to execute the program after extraction.

```sh
#!/bin/sh
./myprogram $*
```

--------------------------------

### Full Custom Publisher Configuration Example

Source: https://goreleaser.com/customization/publish/publishers

A comprehensive configuration for a custom publisher, including name, artifact IDs, filtering, checksums, metadata, signatures, working directory, command, environment variables, disabling, extra files, templated extra files, and output.

```yaml
publishers:
  - #
    # Unique name of your publisher. Used for identification
    name: "custom"

    # IDs of the artifacts you want to publish
    ids:
      - foo
      - bar

    # Allows to further filter the artifacts.
    #
    # Artifacts that do not match this expression will be ignored.
    #
    # {{< g_inline_pro >}}
    # {{< g_inline_version "v2.5" >}}
    # Templates: allowed.
    if: '{{ eq .Os "linux" }}'

    # Publish checksums.
    checksum: true

    # Upload metadata.json and artifacts.json.
    meta: true

    # Publish signatures.
    signature: true

    # Working directory in which to execute the command
    dir: "/utils"

    # Command to be executed
    cmd: custom-publisher -product={{ .ProjectName }} -version={{ .Version }} {{ .ArtifactPath }}

    # Environment variables
    env:
      - API_TOKEN=secret-token

    # Whether to disable this particular upload configuration.
    #
    # Templates: allowed.
    disable: "{{ if .IsNightly }}true{{ end }}"

    # You can publish extra pre-existing files.
    # The filename published will be the last part of the path (base).
    # If another file with the same name exists, the last one found will be used.
    #
    # Templates: allowed.
    extra_files:
      - glob: ./path/to/file.txt
      - glob: ./glob/**/to/**/file/**/*
      - glob: ./glob/foo/to/bar/file/foobar/override_from_previous
      - glob: ./single_file.txt
        name_template: file.txt # note that this only works if glob matches 1 file only

    # Additional templated extra files to published.
    # Those files will have their contents pass through the template engine,
    # and its results will be published.
    #
    # This feature is only available in GoReleaser Pro.
    # Templates: allowed.
    templated_extra_files:
      - src: LICENSE.tpl
        dst: LICENSE.txt

    # This allows you to use the output of your custom publisher in templates
    # later, for instance, in the release notes.
    #
    # The example bellow can be used with '{{ index .Outputs "foo.deb" }}'
    # (assuming artifact name is 'foo.deb').
    #
    # Templates: allowed.
    # {{< g_inline_version "v2.11" >}}
    output: "check-{{ .ArtifactName }}"
```

--------------------------------

### Initialize GoReleaser Configuration

Source: https://goreleaser.com/blog/azure-devops-multi-platform

Generates the initial .goreleaser.yaml configuration file in the project root.

```bash
goreleaser init
```

--------------------------------

### GoReleaser upload output

Source: https://goreleaser.com/blog/cloud-native-storage

Example console output showing the artifact upload process during a release.

```text
  ...
   • publishing
   • blobs
   • uploading path=quick-bites/0.1/quick-bites_0.1_checksums.txt
   • uploading path=quick-bites/0.1/quick-bites_0.1_darwin_amd64.tar.gz
   • uploading path=quick-bites/0.1/quick-bites_0.1_linux_arm64.tar.gz
   • uploading path=quick-bites/0.1/quick-bites_0.1_darwin_arm64.tar.gz
   • uploading path=quick-bites/0.1/quick-bites_0.1_linux_amd64.tar.gz
   • uploading path=quick-bites/0.1/quick-bites_0.1_linux_386.tar.gz
   • uploading path=quick-bites/0.1/quick-bites_0.1_checksums.txt
   • uploading path=quick-bites/0.1/quick-bites_0.1_checksums.txt
   • uploading path=quick-bites/0.1/quick-bites_0.1_linux_386.tar.gz
   • uploading path=quick-bites/0.1/quick-bites_0.1_linux_amd64.tar.gz
   • uploading path=quick-bites/0.1/quick-bites_0.1_linux_arm64.tar.gz
   • uploading path=quick-bites/0.1/quick-bites_0.1_linux_amd64.tar.gz
   • uploading path=quick-bites/0.1/quick-bites_0.1_darwin_amd64.tar.gz
   • uploading path=quick-bites/0.1/quick-bites_0.1_darwin_arm64.tar.gz
   • uploading path=quick-bites/0.1/quick-bites_0.1_linux_386.tar.gz
   • uploading path=quick-bites/0.1/quick-bites_0.1_linux_arm64.tar.gz
   • uploading path=quick-bites/0.1/quick-bites_0.1_darwin_arm64.tar.gz
   • uploading path=quick-bites/0.1/quick-bites_0.1_darwin_amd64.tar.gz
   • release succeeded after 22.63s
  ...
```

--------------------------------

### Configure Zig builder in .goreleaser.yaml

Source: https://goreleaser.com/customization/builds/builders/zig

Example configuration for the Zig builder, demonstrating how to specify targets, custom flags, and build hooks.

```yaml
builds:
  # You can have multiple builds defined as a yaml list
  - #
    # ID of the build.
    #
    # Default: Project name.
    id: "my-build"

    # Use zig.
    builder: zig

    # Binary name.
    # Can be a path (e.g. `bin/app`) to wrap the binary in a directory.
    #
    # Default: Project name.
    binary: program

    # List of targets to be built, in Zig's format.
    # Default: [ "x86_64-linux", "x86_64-macos", "x86_64-windows", "aarch64-linux", "aarch64-macos" ]
    targets:
      - aarch64-macos
      - x86_64-linux-gnu

    # Path to project's (sub)directory containing the code.
    # This is the working directory for the Zig build command(s).
    #
    # Default: '.'.
    dir: my-app

    # Set a specific zig binary to use when building.
    # It is safe to ignore this option in most cases.
    #
    # Default: "zig".
    # Templates: allowed.
    tool: "zig-nightly"

    # Sets the command to run to build.
    # Can be useful if you want to build tests, for example,
    # in which case you can set this to "test".
    # It is safe to ignore this option in most cases.
    #
    # Default: build.
    command: not-build

    # Custom flags.
    #
    # Templates: allowed.
    # Default: "-Doptimize=ReleaseSafe".
    flags:
      - --release

    # Custom environment variables to be set during the builds.
    # Invalid environment variables will be ignored.
    #
    # Default: os.Environ() ++ env config section.
    # Templates: allowed.
    env:
      - FOO=bar

    # Hooks can be used to customize the final binary,
    # for example, to run generators.
    #
    # Templates: allowed.
    hooks:
      pre: ./foo.sh
      post: ./script.sh {{ .Path }}

    # If true, skip the build.
    # Useful for library projects.
    skip: false
```

--------------------------------

### Example generated Homebrew formula

Source: https://goreleaser.com/customization/publish/homebrew_formulas

A sample Ruby class structure generated by GoReleaser for a Homebrew tap.

```rb
class Program < Formula
  desc "How to use this binary"
  homepage "https://github.com/user/repo"
  version "v1.2.3"

  on_macos do
    url "https://github.com/user/repo/releases/download/v1.2.3/program_v1.2.3_macOs_64bit.zip"
    sha256 "9ee30fc358fae8d248a2d7538957089885da321dca3f09e3296fe2058e7fff74"
  end

  on_linux
    on_intel do
      url "https://github.com/user/repo/releases/download/v1.2.3/program_v1.2.3_Linux_64bit.zip"
      sha256 "b41bebd25fd7bb1a67dc2cd5ee12c9f67073094567fdf7b3871f05fd74a45fdd"
    end
    on_arm do
      if !Hardware::CPU.is_64_bit?
        url "https://github.com/user/repo/releases/download/v1.2.3/program_v1.2.3_Linux_armv7.zip"
        sha256 "78f31239430eaaec01df783e2a3443753a8126c325292ed8ddb1658ddd2b401d"
      end
    end
    on_arm do
      if Hardware::CPU.is_64_bit?
        url "https://github.com/user/repo/releases/download/v1.2.3/program_v1.2.3_Linux_arm64.zip"
        sha256 "97cadca3c3c3f36388a4a601acf878dd356d6275a976bee516798b72bfdbeecf"
      end
    end
  end

  depends_on "git"
  depends_on "zsh" => :optional

  def install
    bin.install "program"
  end

  def post_install
  	etc.install "app-config.conf"
  end
end
```

--------------------------------

### Custom Publisher with Templated Command, Directory, and Environment

Source: https://goreleaser.com/customization/publish/publishers

An advanced example showing templating for command, working directory, and environment variables. The command uses project name, version, and artifact name. The directory is derived from the artifact path, and an environment variable is set using a GoReleaser environment variable.

```yaml
publishers:
  - name: production
    cmd: |
      custom-publisher \
      -product={{ .ProjectName }} \
      -version={{ .Version }} \
      {{ .ArtifactName }}
    dir: "{{ dir .ArtifactPath }}"
    env:
      - TOKEN={{ .Env.CUSTOM_PUBLISHER_TOKEN }}
```

--------------------------------

### Configure Homebrew formula test command

Source: https://goreleaser.com/customization/publish/homebrew_formulas

Defines the command executed by 'brew test' to verify the installed binary.

```yaml
test: |
  system "#{bin}/foo --version"
  # ...
```
Tokens:
Raw