Build Tags and Conditional Compilation in Golang

// +build tag1 tag2

package main

//go:build tag1 && tag2

package main

// +build linux

package main

import "fmt"

func main() {
    fmt.Println("This code only compiles on Linux")
}

// +build windows

package main

import "fmt"

func main() {
    fmt.Println("This code only compiles on Windows")
}

# Build for Linux
go build -tags linux

# Build for Windows
go build -tags windows

# Build without any tags (neither file will be included)
go build

// +build linux darwin
// Include on Linux OR Darwin (macOS)

// +build !windows
// Include on any platform EXCEPT Windows

// +build linux,amd64
// Include on Linux AND amd64 architecture

// +build linux darwin,!cgo
// Include on (Linux OR Darwin) AND NOT cgo

//go:build (linux || darwin) && !cgo

// +build go1.18
// Only compile with Go 1.18 or later

//go:build go1.19 && (linux || darwin)

//go:build !(go1.17 && windows)

// file: path_unix.go
// +build linux darwin

package main

import "path/filepath"

func getConfigPath() string {
    return filepath.Join(os.Getenv("HOME"), ".config", "app")
}

// file: path_windows.go
// +build windows

package main

import "path/filepath"

func getConfigPath() string {
    return filepath.Join(os.Getenv("APPDATA"), "app")
}

// file: main.go
package main

import "fmt"

func main() {
    configPath := getConfigPath()
    fmt.Printf("Config path: %s\n", configPath)
}

// file: logging_debug.go
// +build debug

package logging

import "fmt"

func Log(message string) {
    fmt.Printf("[DEBUG] %s\n", message)
}

// file: logging_release.go
// +build !debug

package logging

func Log(message string) {
    // No-op in release
}

// file: main.go
package main

import "./logging"

func main() {
    logging.Log("This is a log message")
}

# Debug build
go build -tags debug

# Release build
go build

// file: database.go
package database

import "fmt"

func Connect() {
    fmt.Println("Connecting to database...")
}

// file: database_test.go
// +build integration

package database

import "testing"

func TestDatabaseConnection(t *testing.T) {
    Connect()
    // Integration test code
}

# Run unit tests only
go test

# Run integration tests
go test -tags integration

// file: features.go
package features

var PremiumFeatures = false

// file: premium.go
// +build premium

package features

func init() {
    PremiumFeatures = true
}

// file: premium_features.go
// +build premium

package features

func PremiumFunction() {
    // Premium feature implementation
}

// file: gpu_acceleration.go
//go:build (linux || darwin) && (amd64 || arm64) && !nogpu

package main

func useGPUAcceleration() {
    // GPU-accelerated code for supported platforms
}

// file: generics_go118.go
//go:build go1.18

package main

func PrintSlice[T any](s []T) {
    for _, v := range s {
        fmt.Println(v)
    }
}

// file: generics_legacy.go
//go:build !go1.18

package main

func PrintSlice(s interface{}) {
    // Reflection-based implementation for older Go versions
    // ...
}

// file: math_amd64.go
// +build amd64

package math

func FastSqrt(x float64) float64 {
    // AMD64-specific assembly or optimized implementation
    return x * 0.5 // Simplified example
}

// file: math_generic.go
// +build !amd64

package math

import "math"

func FastSqrt(x float64) float64 {
    return math.Sqrt(x)
}

// Good
// +build integration
// +build premium
// +build debug

// Avoid
// +build a
// +build test1

// Good
//go:build linux

// Avoid complex expressions in filenames
//go:build (linux && amd64) || (darwin && arm64)

// Package doc comment should mention build tags
//
// This package provides GPU acceleration.
// Build with -tags gpu to enable GPU features.
package gpu

// In your CI/CD, test different tag combinations
go build -tags "debug premium"
go build -tags "integration"
go test -tags "integration"

// In go.mod
module github.com/user/project

// In code
// +build enterprise

package enterprise

// Enterprise-specific features

# Build with vendored dependencies and tags
go build -mod=vendor -tags premium

{
    "go.buildTags": "debug",
    "go.testTags": "integration"
}

.PHONY: build-dev build-prod

build-dev:
	go build -tags "debug dev" -o bin/app-dev

build-prod:
	go build -tags "production release" -ldflags="-s -w" -o bin/app-prod

// file: syscall_unix.go
// +build linux darwin

package sys

func GetPID() int {
    return os.Getpid()
}

// file: syscall_windows.go
// +build windows

package sys

func GetPID() int {
    return os.Getpid() // Different implementation if needed
}

// file: plugins.go
package plugins

type Plugin interface {
    Name() string
    Execute()
}

// file: plugin_database.go
// +build with_db

package plugins

type DatabasePlugin struct{}

func (p *DatabasePlugin) Name() string { return "database" }
func (p *DatabasePlugin) Execute() { /* DB operations */ }

// file: plugin_cache.go
// +build with_cache

package plugins

type CachePlugin struct{}

func (p *CachePlugin) Name() string { return "cache" }
func (p *CachePlugin) Execute() { /* Cache operations */ }

# Verbose build output
go build -x

# Check what tags are recognized
go build -tags "nonexistent" 2>&1 | grep "build constraints exclude all"

# List files that would be included
go list -tags "debug" ./...

# Check tag syntax
// +build debug  # Old syntax
//go:build debug # New syntax (Go 1.17+)

// This is allowed - Go will pick the appropriate file based on tags
// file1.go: // +build linux
// file2.go: // +build windows

// Avoid
// +build debug
// +build !debug

// Use different tags or restructure code

//go:build (linux || darwin) && go1.19
// +build linux darwin
// +build go1.19

package modern_unix

// +build ignore

package ignored

// This file is never compiled

//go:generate go run generate.go
// +build tools

package tools

// This file is only for build tools

name: Build
on: [push, pull_request]

jobs:
  build:
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
        tags: ["", "debug", "premium"]
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Set up Go
      uses: actions/setup-go@v4
      with:
        go-version: '1.21'
    
    - name: Build
      run: go build -tags "${{ matrix.tags }}" -o app-${{ matrix.os }}-${{ matrix.tags }}
    
    - name: Test
      run: go test -tags "${{ matrix.tags }}" ./...

# Build stage
FROM golang:1.21-alpine AS builder

WORKDIR /app
COPY . .

# Build with tags
RUN go build -tags "production release" -ldflags="-s -w" -o app .

# Runtime stage
FROM alpine:latest
COPY --from=builder /app/app /usr/local/bin/
CMD ["app"]

// +build debug

package main

func debugLog(msg string) {
    fmt.Printf("[DEBUG] %s\n", msg)
}

// This function only exists in debug builds
// In release builds, calls to debugLog are removed by the compiler

# Compare binary sizes
go build -tags "debug" -o app-debug
go build -o app-release

ls -lh app-debug app-release

// Old syntax
// +build linux darwin
// +build go1.18

// New syntax (Go 1.17+)
//go:build (linux || darwin) && go1.18