Plugins & Dynamic Loading

Advanced ~40 min read

Go's plugin package enables building extensible applications that can load code dynamically at runtime. Create modular architectures, support third-party extensions, and implement hot-reload functionality for development and production environments.

Platform Support:

✓ Linux (full support)
✓ macOS (full support)
❌ Windows (not supported)
⚠️ Requires same Go version for plugin and main app

Plugin Interface Design

Define clear interfaces that plugins must implement:

Output

Click Run to execute your code

Interface Design Tips:

Keep interfaces focused and minimal
Include metadata (name, version, author)
Provide lifecycle methods (Initialize, Shutdown)
Version your plugin API

Plugin Implementation

Implement the plugin interface in separate packages:

package main

import "fmt"

// EnglishGreeter implements the GreeterPlugin interface
type EnglishGreeter struct{}

func (g *EnglishGreeter) Info() PluginInfo {
	return PluginInfo{
		Name:    "English Greeter",
		Version: "1.0.0",
		Author:  "Example Author",
	}
}

func (g *EnglishGreeter) Initialize() error {
	fmt.Println("English Greeter plugin initialized")
	return nil
}

func (g *EnglishGreeter) Shutdown() error {
	fmt.Println("English Greeter plugin shutdown")
	return nil
}

func (g *EnglishGreeter) Greet(name string) string {
	return fmt.Sprintf("Hello, %s!", name)
}

func (g *EnglishGreeter) Description() string {
	return "Greets in English"
}

// SpanishGreeter implements the GreeterPlugin interface
type SpanishGreeter struct{}

func (g *SpanishGreeter) Info() PluginInfo {
	return PluginInfo{
		Name:    "Spanish Greeter",
		Version: "1.0.0",
		Author:  "Example Author",
	}
}

func (g *SpanishGreeter) Initialize() error {
	fmt.Println("Spanish Greeter plugin initialized")
	return nil
}

func (g *SpanishGreeter) Shutdown() error {
	fmt.Println("Spanish Greeter plugin shutdown")
	return nil
}

func (g *SpanishGreeter) Greet(name string) string {
	return fmt.Sprintf("¡Hola, %s!", name)
}

func (g *SpanishGreeter) Description() string {
	return "Greets in Spanish"
}

// Plugin symbol that will be looked up
var GreeterPlugin GreeterPlugin

func init() {
	// This would be set to either EnglishGreeter or SpanishGreeter
	// depending on which plugin is being built
	GreeterPlugin = &EnglishGreeter{}
}

Output

Click Run to execute your code

Building Plugins:

# Build a plugin
go build -buildmode=plugin -o greeter.so plugin.go

# The .so file can be loaded at runtime
# Must be built with same Go version as main app

Loading Plugins

Use the plugin package to load and use plugins:

package main

import (
	"fmt"
)

func main() {
	fmt.Println("Plugin Loader Demo")
	fmt.Println("==================\n")

// Note: This is a demonstration of the plugin loading API
	// Actual plugin loading requires building plugins separately

fmt.Println("Loading a plugin:")
	fmt.Println("  1. Build plugin: go build -buildmode=plugin -o greeter.so plugin.go")
	fmt.Println("  2. Load plugin: plugin.Open(\"greeter.so\")")
	fmt.Println("  3. Lookup symbol: p.Lookup(\"GreeterPlugin\")")
	fmt.Println("  4. Type assert: greeter := symbol.(GreeterPlugin)")
	fmt.Println("  5. Use plugin: greeter.Greet(\"World\")")
	fmt.Println()

// Example plugin loading code (would work with actual .so file)
	fmt.Println("Example Code:")
	fmt.Println(`
	// Load the plugin
	p, err := plugin.Open("greeter.so")
	if err != nil {
		log.Fatal(err)
	}
	
	// Look up the exported symbol
	symbol, err := p.Lookup("GreeterPlugin")
	if err != nil {
		log.Fatal(err)
	}
	
	// Assert the symbol to the plugin interface
	greeter, ok := symbol.(GreeterPlugin)
	if !ok {
		log.Fatal("Invalid plugin type")
	}
	
	// Initialize the plugin
	if err := greeter.Initialize(); err != nil {
		log.Fatal(err)
	}
	
	// Use the plugin
	message := greeter.Greet("World")
	fmt.Println(message)
	
	// Get plugin info
	info := greeter.Info()
	fmt.Printf("Plugin: %s v%s\n", info.Name, info.Version)
	
	// Shutdown the plugin
	greeter.Shutdown()
	`)

fmt.Println("\nPlugin System Benefits:")
	fmt.Println("  ✓ Extend applications without recompiling")
	fmt.Println("  ✓ Third-party extensions")
	fmt.Println("  ✓ Hot-swappable functionality")
	fmt.Println("  ✓ Modular architecture")

fmt.Println("\nLimitations:")
	fmt.Println("  ⚠ Linux/macOS only (not Windows)")
	fmt.Println("  ⚠ Must use same Go version")
	fmt.Println("  ⚠ Cannot unload plugins")
	fmt.Println("  ⚠ Shared dependencies must match")

fmt.Println("\nBuild Commands:")
	fmt.Println("  # Build plugin")
	fmt.Println("  go build -buildmode=plugin -o myplugin.so plugin.go")
	fmt.Println()
	fmt.Println("  # Build main app")
	fmt.Println("  go build -o app main.go")
	fmt.Println()
	fmt.Println("  # Run")
	fmt.Println("  ./app")
}

Output

Click Run to execute your code

Plugin Loading Steps:

Open plugin file with plugin.Open()
Lookup exported symbol with Lookup()
Type assert to plugin interface
Initialize and use the plugin

Plugin Manager

Manage multiple plugins with a plugin manager:

package main

import (
	"fmt"
	"path/filepath"
	"plugin"
	"time"
)

// PluginManager manages loaded plugins
type PluginManager struct {
	plugins map[string]*LoadedPlugin
}

// LoadedPlugin represents a loaded plugin
type LoadedPlugin struct {
	Path     string
	Plugin   *plugin.Plugin
	LoadTime time.Time
	Instance GreeterPlugin
}

// NewPluginManager creates a new plugin manager
func NewPluginManager() *PluginManager {
	return &PluginManager{
		plugins: make(map[string]*LoadedPlugin),
	}
}

// LoadPlugin loads a plugin from the given path
func (pm *PluginManager) LoadPlugin(path string) error {
	// Open the plugin
	p, err := plugin.Open(path)
	if err != nil {
		return fmt.Errorf("failed to open plugin: %w", err)
	}

// Lookup the symbol
	symbol, err := p.Lookup("GreeterPlugin")
	if err != nil {
		return fmt.Errorf("failed to lookup symbol: %w", err)
	}

// Type assert
	greeter, ok := symbol.(GreeterPlugin)
	if !ok {
		return fmt.Errorf("invalid plugin type")
	}

// Initialize
	if err := greeter.Initialize(); err != nil {
		return fmt.Errorf("failed to initialize plugin: %w", err)
	}

// Store the loaded plugin
	name := filepath.Base(path)
	pm.plugins[name] = &LoadedPlugin{
		Path:     path,
		Plugin:   p,
		LoadTime: time.Now(),
		Instance: greeter,
	}

return nil
}

// GetPlugin retrieves a loaded plugin by name
func (pm *PluginManager) GetPlugin(name string) (GreeterPlugin, bool) {
	loaded, ok := pm.plugins[name]
	if !ok {
		return nil, false
	}
	return loaded.Instance, true
}

// ListPlugins returns all loaded plugin names
func (pm *PluginManager) ListPlugins() []string {
	names := make([]string, 0, len(pm.plugins))
	for name := range pm.plugins {
		names = append(names, name)
	}
	return names
}

// ShutdownAll shuts down all loaded plugins
func (pm *PluginManager) ShutdownAll() {
	for _, loaded := range pm.plugins {
		loaded.Instance.Shutdown()
	}
}

func main() {
	fmt.Println("Plugin Manager Demo")
	fmt.Println("===================\n")

// Create plugin manager
	manager := NewPluginManager()
	defer manager.ShutdownAll()

// This demonstrates the plugin manager API
	// In a real application, you would load actual .so files

fmt.Println("Plugin Manager Features:")
	fmt.Println("  • Load plugins dynamically")
	fmt.Println("  • Track loaded plugins")
	fmt.Println("  • Retrieve plugins by name")
	fmt.Println("  • Graceful shutdown")
	fmt.Println()

fmt.Println("Example Usage:")
	fmt.Println(`
	manager := NewPluginManager()
	
	// Load plugins
	manager.LoadPlugin("plugins/english.so")
	manager.LoadPlugin("plugins/spanish.so")
	
	// Use a plugin
	if greeter, ok := manager.GetPlugin("english.so"); ok {
		message := greeter.Greet("World")
		fmt.Println(message)
	}
	
	// List all plugins
	for _, name := range manager.ListPlugins() {
		fmt.Println("Loaded:", name)
	}
	
	// Shutdown all
	manager.ShutdownAll()
	`)

fmt.Println("\nPlugin Discovery:")
	fmt.Println("  • Scan plugin directory")
	fmt.Println("  • Load plugins matching pattern")
	fmt.Println("  • Validate plugin interfaces")
	fmt.Println("  • Handle load failures gracefully")

fmt.Println("\nBest Practices:")
	fmt.Println("  ✓ Define clear plugin interfaces")
	fmt.Println("  ✓ Version your plugin API")
	fmt.Println("  ✓ Handle plugin errors gracefully")
	fmt.Println("  ✓ Provide plugin metadata")
	fmt.Println("  ✓ Document plugin requirements")
}

Output

Click Run to execute your code

Plugin Manager Features:

Load plugins from directory
Track loaded plugins
Handle load failures gracefully
Provide plugin discovery
Manage plugin lifecycle

Hot Reload

Implement hot-reload for development and dynamic updates:

package main

import (
	"fmt"
	"os"
	"plugin"
	"time"
)

// HotReloadManager manages hot-reloadable plugins
type HotReloadManager struct {
	pluginPath string
	plugin     *plugin.Plugin
	greeter    GreeterPlugin
	lastMod    time.Time
}

// NewHotReloadManager creates a new hot reload manager
func NewHotReloadManager(path string) *HotReloadManager {
	return &HotReloadManager{
		pluginPath: path,
	}
}

// Load loads or reloads the plugin
func (hrm *HotReloadManager) Load() error {
	// Check if file exists
	info, err := os.Stat(hrm.pluginPath)
	if err != nil {
		return fmt.Errorf("plugin file not found: %w", err)
	}

// Check if plugin needs reloading
	if hrm.lastMod.Equal(info.ModTime()) {
		return nil // No changes
	}

// Shutdown old plugin if exists
	if hrm.greeter != nil {
		hrm.greeter.Shutdown()
	}

// Load new plugin
	p, err := plugin.Open(hrm.pluginPath)
	if err != nil {
		return fmt.Errorf("failed to load plugin: %w", err)
	}

// Lookup symbol
	symbol, err := p.Lookup("GreeterPlugin")
	if err != nil {
		return fmt.Errorf("failed to lookup symbol: %w", err)
	}

// Type assert
	greeter, ok := symbol.(GreeterPlugin)
	if !ok {
		return fmt.Errorf("invalid plugin type")
	}

// Initialize
	if err := greeter.Initialize(); err != nil {
		return fmt.Errorf("failed to initialize: %w", err)
	}

// Update state
	hrm.plugin = p
	hrm.greeter = greeter
	hrm.lastMod = info.ModTime()

fmt.Printf("Plugin loaded/reloaded at %s\n", time.Now().Format(time.RFC3339))

return nil
}

// CheckAndReload checks for changes and reloads if needed
func (hrm *HotReloadManager) CheckAndReload() error {
	info, err := os.Stat(hrm.pluginPath)
	if err != nil {
		return err
	}

if info.ModTime().After(hrm.lastMod) {
		fmt.Println("Plugin file changed, reloading...")
		return hrm.Load()
	}

return nil
}

// GetGreeter returns the current greeter instance
func (hrm *HotReloadManager) GetGreeter() GreeterPlugin {
	return hrm.greeter
}

func main() {
	fmt.Println("Hot Reload Demo")
	fmt.Println("===============\n")

fmt.Println("Hot Reload Concept:")
	fmt.Println("  1. Watch plugin file for changes")
	fmt.Println("  2. Detect modification time changes")
	fmt.Println("  3. Reload plugin when changed")
	fmt.Println("  4. Shutdown old instance")
	fmt.Println("  5. Initialize new instance")
	fmt.Println()

fmt.Println("Example Implementation:")
	fmt.Println(`
	manager := NewHotReloadManager("plugin.so")
	
	// Initial load
	if err := manager.Load(); err != nil {
		log.Fatal(err)
	}
	
	// Watch for changes
	ticker := time.NewTicker(1 * time.Second)
	defer ticker.Stop()
	
	for range ticker.C {
		// Check and reload if changed
		if err := manager.CheckAndReload(); err != nil {
			log.Println("Reload error:", err)
			continue
		}
		
		// Use the current plugin
		greeter := manager.GetGreeter()
		if greeter != nil {
			message := greeter.Greet("World")
			fmt.Println(message)
		}
	}
	`)

fmt.Println("\nHot Reload Strategies:")
	fmt.Println()
	fmt.Println("1. File Watcher:")
	fmt.Println("   • Use fsnotify or similar")
	fmt.Println("   • React to file system events")
	fmt.Println("   • Immediate reload on change")
	fmt.Println()

fmt.Println("2. Polling:")
	fmt.Println("   • Check modification time periodically")
	fmt.Println("   • Simple to implement")
	fmt.Println("   • Slight delay in detection")
	fmt.Println()

fmt.Println("3. Signal-based:")
	fmt.Println("   • Reload on SIGHUP or custom signal")
	fmt.Println("   • Manual control")
	fmt.Println("   • Predictable timing")
	fmt.Println()

fmt.Println("Challenges:")
	fmt.Println("  ⚠ Cannot unload old plugin from memory")
	fmt.Println("  ⚠ Must manage state transitions")
	fmt.Println("  ⚠ Handle in-flight requests")
	fmt.Println("  ⚠ Version compatibility")

fmt.Println("\nUse Cases:")
	fmt.Println("  • Development hot-reload")
	fmt.Println("  • A/B testing")
	fmt.Println("  • Feature flags")
	fmt.Println("  • Dynamic configuration")
	fmt.Println("  • Plugin updates without downtime")
}

Output

Click Run to execute your code

Hot Reload Limitations:

Cannot unload plugins from memory
Old plugin code remains in memory
Must manage state transitions carefully
Handle in-flight requests appropriately

Plugin Use Cases

1. Extensible Applications

Allow third-party developers to extend your application:

Text editors with language support plugins
Build systems with custom task plugins
API gateways with custom middleware

2. Feature Flags

Enable/disable features without recompiling:

A/B testing different implementations
Gradual feature rollout
Customer-specific features

3. Development Workflow

Improve development experience:

Hot-reload during development
Test different implementations
Rapid prototyping

Best Practices

Plugin Design:

✓ Define clear, stable interfaces
✓ Version your plugin API
✓ Provide comprehensive documentation
✓ Include example plugins
✓ Handle errors gracefully

Plugin Loading:

✓ Validate plugin compatibility
✓ Handle load failures
✓ Provide fallback behavior
✓ Log plugin operations
✓ Implement timeouts

Exercise: Plugin-Based Calculator

Task: Build a calculator that loads operation plugins dynamically.

Requirements:

Define Operation interface
Implement plugins for +, -, *, /
Load plugins from directory
Execute operations dynamically

Show Solution

// operation.go - Interface
package main

type Operation interface {
    Name() string
    Execute(a, b float64) (float64, error)
}

// add_plugin.go - Addition plugin
package main

type AddOperation struct{}

func (op *AddOperation) Name() string {
    return "add"
}

func (op *AddOperation) Execute(a, b float64) (float64, error) {
    return a + b, nil
}

var Operation Operation = &AddOperation{}

// Build: go build -buildmode=plugin -o add.so add_plugin.go

// main.go - Calculator
package main

import (
    "fmt"
    "log"
    "plugin"
)

func main() {
    // Load plugin
    p, err := plugin.Open("add.so")
    if err != nil {
        log.Fatal(err)
    }
    
    // Lookup symbol
    symbol, err := p.Lookup("Operation")
    if err != nil {
        log.Fatal(err)
    }
    
    // Type assert
    op, ok := symbol.(Operation)
    if !ok {
        log.Fatal("Invalid operation type")
    }
    
    // Execute
    result, err := op.Execute(10, 5)
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("%s(10, 5) = %.2f\n", op.Name(), result)
}

Summary

Plugins enable extensible applications
plugin.Open() loads plugin files
Lookup() finds exported symbols
Type assertion converts to interface
Build mode -buildmode=plugin
Linux/macOS only (not Windows)
Same Go version required
Cannot unload plugins
Hot reload possible with care
Use cases - extensions, features, development

Congratulations!

You've completed all advanced Go topics! You now have a comprehensive understanding of memory management, escape analysis, CGO integration, unsafe operations, compiler optimization, and plugin systems. You're ready to build high-performance, extensible Go applications for production use!

Previous Compiler & Linker Flags

Next All Tutorials

Plugin Interface Design

Plugin Implementation

Loading Plugins

Plugin Manager

Hot Reload

Plugin Use Cases

1. Extensible Applications

2. Feature Flags

3. Development Workflow

Best Practices

Exercise: Plugin-Based Calculator

Summary

Congratulations!

Enjoying these tutorials?