Awesome Go

Libraries for building sophisticated Terminal User Interfaces (TUIs) and enhanced command-line outputs in Go:

TUI Frameworks and Architectures

• bubbletea: A Go framework to build terminal apps based on The Elm Architecture.
• bubbles: TUI components designed for use with bubbletea.
• bubble-table: An interactive table component for bubbletea.
• phoenix: A high-performance TUI framework with Elm-inspired architecture and zero-allocation event system.
• go-tui: A declarative terminal UI framework with templ-like templates and flexbox layout.
• gocui: A minimalist library for creating Console User Interfaces.
• termbox-go: A library for creating cross-platform text-based interfaces.
• loom: A signal-based reactive components framework for building TUIs.

UI Components and Layouts

• mpb: Multi progress bar for terminal applications.
• progressbar: A basic thread-safe progress bar for all OSs.
• uiprogress: Flexible library to render progress bars.
• spinner: Easily provide a terminal spinner with options.
• yacspin: Yet Another CLI Spinner package.
• simpletable, tabby, table, and uitable: Various libraries for rendering tabular data in the terminal.
• fx: A terminal JSON viewer and processor.
• termdash and termui: Terminal dashboards inspired by termui and blessed-contrib.

Styling, Colors, and Visuals

• lipgloss: Declaratively define styles for color, format, and layout in the terminal.
• termenv: Advanced ANSI style and color support.
• aurora: ANSI terminal colors supporting fmt.Printf/Sprintf.
• pterm: Beautify console output with many combinable components.
• asciigraph: Create lightweight ASCII line graphs in command line apps.
• vhs: Generate terminal GIFs from code for documentation and tutorials.
• box-cli-maker: Render highly customizable boxes in the terminal.
• chroma16: Generate a 16-color terminal palette from a single seed color.
• marker: Match and mark strings for colorful terminal outputs.

A collection of libraries for managing application configuration. Common patterns include:

• Environment Variable Parsing: Tools like env (caarlos0), envconfig (vrischmann), and kelseyhightower/envconfig focus on unmarshaling environment variables into Go structs.
• Multi-source Loading: Libraries such as viper, koanf, confita, and zerocfg allow loading configuration from multiple sources (files, ENV, flags) with defined precedence.
• File Format Support: Many libraries support standard formats like JSON, YAML, TOML, INI, and HCL (e.g., go-ini, hjson, gookit/config).
• Cloud & External Integration: Specialized providers exist for AWS (e.g., go-aws-ssm, go-ssm-config), Azure (azureappconfiguration), Consul (go-external-config/consul), and Vault (go-external-config/vault).
• CLI & Flag Integration: Tools like kong and nfigure provide robust command-line parsing that integrates with configuration files.

The following libraries are available for managing application configuration in Go, ranging from simple environment variable parsers to complex multi-source managers supporting JSON, YAML, TOML, and cloud providers.

Key Categories

Environment Variable Focused

• caarlos0/env: Parse environment variables to Go structs (with defaults).
• kelseyhightower/envconfig: Manage configuration data from environment variables.
• godotenv: Load environment variables from .env files (Go port of Ruby's dotenv).
• typenv: Minimalistic, zero-dependency, typed environment variables.

Multi-Source & Advanced Configuration

• viper: A comprehensive configuration solution with "fangs."
• koanf: Lightweight and extensible; supports JSON, TOML, YAML, env, and command line.
• confita: Load configuration in cascade from multiple backends into a struct.
• kong: Command-line parser supporting complex structures and additional sources like YAML, JSON, or TOML.

Cloud & External Providers

• azureappconfiguration: Consume data from Azure App Configuration.
• go-aws-ssm: Fetch parameters from AWS System Manager - Parameter Store.
• go-external-config: Spring-inspired management with support for AWS, Consul, and Vault via sub-packages.

A collection of libraries for generating various types of unique identifiers in Go:

• Standard UUIDs (RFC 4122):

  • google/uuid: Based on RFC 4122 and DCE 1.1.
  • gofrs/uuid: Actively maintained fork of satori/uuid; supports creation and parsing.
  • agext/uuid: Supports UUIDv1 with fast or cryptographic-quality random node identifiers.
  • jakehl/goid: Generates and parses RFC4122 compliant V4 UUIDs.
  • ashwingopalsamy/uuidcheck: Validates UUIDs against RFC 4122 and converts UUIDv7 to UTC timestamps.

• High-Performance & Specialized IDs:

  • rekby/fastuuid: Fast generation of UUIDv4 as strings or bytes.
  • sdrapkin/guid: Fast cryptographically safe Guid generator (~10x faster than uuid).
  • twharmon/gouid: Generates cryptographically secure random string IDs with a single allocation.
  • aidarkhanov/nanoid: Tiny and efficient unique string ID generator.
  • oklog/ulid: Implementation of Universally Unique Lexicographically Sortable Identifiers (ULID).
  • muyo/sno: Compact, sortable, and fast unique IDs with embedded metadata.
  • rs/xid: Globally unique ID generator designed for safe use in server code.
  • edwingeng/wuid: Extremely fast globally unique number generator.

General-purpose tools to assist in the Go development lifecycle:

• Visualization & Debugging:

  • go-callvis: Visualizes the call graph of a Go program using the dot format.
  • goast-viewer: A web-based visualizer for the Go AST.
  • godbg: Implements a dbg! macro (similar to Rust) for quick debugging.
  • gotutor: An online Go debugger and visualizer.
  • govisual: A zero-config HTTP request visualizer and debugger for local web development.
  • go-size-analyzer: Analyzes and visualizes the size of dependencies in compiled binaries.

• API & Documentation:

  • go-swagger: Implementation of Swagger 2.0 for RESTful APIs.
  • docs: Automatically generates RESTful API documentation aligned with OpenAPI specifications.
  • go-template-playground: Interactive environment to test Go templates.
  • gotemplate.io: Online tool to preview text/template templates live.

• Dependency & Module Management:

  • go-mod-outdated: Finds outdated dependencies in Go projects.
  • modver: Compares two module versions to determine required semver changes.
  • gomodrun: Executes and caches binaries included in go.mod files.

• Other Utilities:

  • richgo: Enhances go test output with text decorations.
  • roumon: Monitors the state of active goroutines via CLI.
  • rts: Generates Go structs from server responses (Response To Struct).
  • typex: Examines Go types and their transitive dependencies, with export options for TypeScript.

The following libraries are available for audio manipulation, playback, and processing in Go:

Playback and Low-level Audio

• beep: Simple library for audio playback and manipulation.
• Oto: Low-level library for playing sound across multiple platforms.
• malgo: Mini audio library.
• PortAudio: Go bindings for the PortAudio audio I/O library.
• go-mpris: Client for mpris dbus interfaces.

Encoding and Decoding

• flac: Native Go FLAC encoder/decoder.
• gaad: Native Go AAC bitstream parser.
• id3v2: ID3 decoding and encoding library.
• minimp3: Lightweight MP3 decoder.

Processing and Conversion

• go-resample: Pure-Go (no cgo) audio sample-rate converter.
• GoAudio: Native Go Audio Processing Library.
• gosamplerate: Bindings for libsamplerate.

Specialized Audio/Music

• music-theory: Music theory models in Go.
• voxrai-ai: AI voice agents using STT → LLM → TTS pipelines over WebSocket and WebRTC.

The Awesome Go repository provides a curated list of tools for various testing needs in Go, including:

• General Testing Frameworks: BDD-style frameworks like ginkgo, godog (Cucumber), goblin (Mocha-like), and GoConvey (with web UI).
• Assertions and Matchers: Libraries for expressive assertions such as testify, gomega (Rspec-like), is (minimalist), and go-cmp (value comparison).
• HTTP and API Testing: Tools for testing REST/HTTP services like httpexpect, frisby, apitest, and go-vcr (record/replay).
• Database Testing: Utilities for managing test databases, including dbcleaner, testcontainers-go (container-based dependencies), and go-sqlmock.
• Snapshot Testing: Tools for verifying data against snapshots like cupaloy and go-snaps.
• Mutation and Coverage Testing: Tools to improve test quality like go-mutesting and go-test-coverage.
• Fuzzing: Randomized testing systems like go-fuzz and Tavor.