How to integrate external custom analyzers with golangci-lint without building a custom binary?

[kritikaa309-hash]

Summary

The Module Plugin System documentation describes plugin support but does not clearly explain whether external Go modules can be dynamically loaded by the standard golangci-lint binary, or if a custom build is required.

I have developed a collection of 106 custom go/analysis linters hosted on Bitbucket, covering:

• Concurrency safety patterns
• Database query optimization
• Performance anti-patterns
• Domain-specific coding standards

These linters are structured as a Go module following the go/analysis framework.

Current Implementation

Module Structure

custom-linter/ ├── plugin/ │ ├── plugin.go │ └── plugin_test.go ├── concurrency/ │ ├── goroutinelocation.go │ └── loopvariable.go ├── database/ │ ├── querypatterns.go │ └── indexoptimization.go ├── performance/ │ └── allocations.go └── go.mod 

Plugin Package Implementation

// plugin/plugin.go package plugin import ( "golang.org/x/tools/go/analysis" "bitbucket.org/yourworkspace/custom-linter/concurrency" "bitbucket.org/yourworkspace/custom-linter/database" "bitbucket.org/yourworkspace/custom-linter/performance" ) // New returns all custom analyzers for integration with golangci-lint func New() []*analysis.Analyzer { return []*analysis.Analyzer{ concurrency.GoroutineLocationAnalyzer, concurrency.LoopVariableAnalyzer, database.QueryPatternsAnalyzer, database.IndexOptimizationAnalyzer, performance.AllocationsAnalyzer, // ... 101 more analyzers } } // AnalyzerPlugin implements the golangci-lint plugin interface type AnalyzerPlugin struct{} func (*AnalyzerPlugin) GetAnalyzers() []*analysis.Analyzer { return New() }

Example Analyzer

// concurrency/goroutinelocation.go package concurrency import ( "go/ast" "golang.org/x/tools/go/analysis" "golang.org/x/tools/go/analysis/passes/inspect" "golang.org/x/tools/go/ast/inspector" ) var GoroutineLocationAnalyzer = &analysis.Analyzer{ Name: "goroutinelocation", Doc: "checks for goroutines in restricted locations like migrations", Run: run, Requires: []*analysis.Analyzer{inspect.Analyzer}, } func run(pass *analysis.Pass) (interface{}, error) { insp := pass.ResultOf[inspect.Analyzer].(*inspector.Inspector) nodeFilter := []ast.Node{(*ast.GoStmt)(nil)} insp.Preorder(nodeFilter, func(n ast.Node) { pass.Reportf(n.Pos(), "goroutinelocation: goroutines not allowed here") }) return nil, nil }

Standalone Binary (Working)

// cmd/linter/main.go package main import ( "bitbucket.org/yourworkspace/custom-linter/plugin" "golang.org/x/tools/go/analysis/multichecker" ) func main() { multichecker.Main(plugin.New()...) } 

✅ This works perfectly as a standalone tool.

Attempted golangci-lint Integration

.golangci.yml Configuration

linters-settings: custom: custom-linter: path: bitbucket.org/yourworkspace/custom-linter/plugin description: Custom static analysis tools original-url: bitbucket.org/yourworkspace/custom-linter linters: enable: - errcheck - govet - custom-linter 

Result

$ golangci-lint run ./... 

Expected: Both golangci-lint's built-in linters and all 106 custom analyzers execute.

Actual: Only golangci-lint's built-in linters run. Custom analyzers are not discovered.

Verification

$ golangci-lint linters | grep custom-linter # No output - custom linters not recognized

Current Workaround

#!/bin/bash golangci-lint run ./... ./bin/custom-linter ./...

This works but requires:

• Two separate commands
• Two separate outputs
• Additional CI/CD configuration
• Manual result aggregation

Questions

Dynamic Loading Capability

Can the standard golangci-lint binary dynamically load external Go modules as plugins?

• If YES: What is the correct configuration? Documentation lacks a working example.
• If NO: Please clarify in the docs that a custom build of golangci-lint is required.

Module Plugin System Definition

What does "Module Plugin System is recommended" mean in practice?

A) A way to structure analyzers that golangci-lint can dynamically import
B) A pattern for organizing code when building a custom golangci-lint binary
C) Something else

Current docs suggest (A), but behavior indicates (B).

Plugin Interface Requirements

Is the AnalyzerPlugin interface and New() function sufficient for golangci-lint to discover external plugins?

type AnalyzerPlugin struct{} func (*AnalyzerPlugin) GetAnalyzers() []*analysis.Analyzer { return []*analysis.Analyzer{ /* analyzers */ } }

Or are additional steps required?

Comparison Table:

Approach	Dynamic Loading	Custom Build Required	Maintenance
Module Plugin	No	Yes	High
Go Plugin (.so)	Yes	No	Very High
Standalone	N/A	No	Low

Environment

$ golangci-lint --version golangci-lint has version 2.6.2 built with go1.25.3 $ go version go version go1.25.4 linux/amd64

Related Documentation

• Module Plugin System
• Go Plugin System
• Contributing New Linters

Impact

Clarifying this would help teams:

• Understand the effort needed for custom linter integration
• Choose the right approach for their use case
• Set correct expectations about maintenance
• Decide between standalone tools vs. full integration

Thank you!

[ldez]

Your message is a copy-paste of a generated message from ChatGPT.

I don't appreciate that.

1. Your comparison table is wrong.
2. The usage of the plugins is explained inside the doc.
3. Your configuration is wrong
4. I was forced to reformat your message and remove all the elements related to ChatGPT to understand what you mean

What does "Module Plugin System is recommended" mean in practice?

This means that we recommend using the plugin system based on modules.

Can the standard golangci-lint binary dynamically load external Go modules as plugins?

No

If NO: Please clarify in the docs that a custom build of golangci-lint is required.

No, because it's already explicitly explained inside the doc.

---

Read the documentation instead of using an AI:

• https://golangci-lint.run/docs/plugins/module-plugins/
• https://github.com/golangci/example-plugin-module-linter

Or ask an AI to get the answer to your AI questions.