Murex is a cross-platform shell and scripting language designed as a more readable, safe, and type-aware alternative to Bash. In production it works as both an interactive REPL (with autocomplete, hint text, preview panes, spellchecking, and job control) and a scripting interpreter with a custom expression language, typed pipelines, exception handling (try/catch/trypipe), multi-scope variables, a built-in unit test framework, event hooks (onPrompt, onKeyPress, onFileSystemChange, onSignalReceived), an HTTP client, and a package/module manager. The defining architectural feature is that data in pipelines carries type metadata: JSON, YAML, CSV, TOML, XML, S-expressions, HCL and more are first-class structured objects with registered Marshal/Unmarshal/ReadArray/ReadMap/ReadIndex hooks, so builtins like alter, tabulate, count, and jsplit operate on structured data rather than raw text. The implementation is Go (with a JS/WASM interpreter variant), organized around lang/ (parser, expression engine, process lifecycle), shell/ (interactive terminal layer), builtins/ (roughly 200 commands, data type adapters, pipes, and event handlers), config/ (profile-driven runtime configuration), and utils/ (standalone helper libraries).
Trayscale is an unofficial GTK4/Libadwaita desktop GUI for the Tailscale VPN daemon, targeting Linux (no official Linux GUI exists). It provides a system tray status icon, a full Libadwaita window for managing peers, exit nodes, Mullvad exit nodes, Taildrop file transfers, profiles, and connection state. The architecture is a single Go binary using gotk4 bindings to GTK4 and Libadwaita. It communicates with the local tailscaled via Tailscale's local API and IPN bus watcher for real-time status updates. The codebase demonstrates solid Go engineering: clean separation of concerns (tsutil client layer, UI layer, tray, datatypes), use of modern Go features (generics, iterators, slices, maps), and comprehensive tests for the core polling and search logic. While not a reusable library, several internal packages (peersearch, autosave, listmodels) are well-isolated and could be extracted.
Onedump is a Go-based CLI tool for database administration, specializing in backup, restore, and migration workflows. It supports MySQL (with a zero-dependency native dumper and mysqldump) and PostgreSQL (via pg_dump), and can persist backups to local files, AWS S3, Google Drive, Dropbox, or SFTP endpoints. The architecture follows a clean pipeline pattern: YAML configuration drives concurrent job execution, each job uses a dumper interface to stream database content through gzip compression and fan-out to multiple storage backends. Beyond core backup, it includes advanced features: MySQL binlog streaming to S3 with checksum-based deduplication, point-in-time restore via binlog replay, a MySQL slow query log parser with query masking and deduplication, and a resumable/concurrent SFTP file transfer utility with exponential backoff. The codebase is well-structured, heavily tested, and uses modern Go idioms, making it suitable as a reference for building database-adjacent infrastructure tooling.
This repository is a comprehensive Go library for geometric data structures and operations. It provides implementations of OGC-standard geometry types (Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon, GeometryCollection) with support for 2D, 3D, and measured dimensions. The library includes algorithms for computational geometry (area, centroid, convex hull, line intersection, etc.) and encoders/decoders for formats like WKT, WKB, GeoJSON, KML, and IGC. Architecture is modular: core `geom` package defines types and interfaces, `xy`/`xyz` packages handle planar/spatial algorithms, `encoding/*` packages manage format serialization, and utilities like `transform` and `sorting` offer reusable helpers. Command-line tools for IGC parsing and PostGIS integration demonstrate practical usage. The code emphasizes clean separation of concerns, interface-driven design, and thorough testing including property-based and fuzzing tests.
This is a small, focused Go library that automatically sets the GOMEMLIMIT environment variable for Go applications based on the Linux cgroup memory limit. It provides a simple side-effect import (import _ "github.com/KimMachineGun/automemlimit") that configures the Go runtime memory limit to a configurable fraction (default 90%) of the cgroup limit, or alternatively offers a programmatic API via memlimit.Set() with options for custom providers, ratios, minimum limits, and periodic refresh. The library handles both cgroup v1 and v2, correctly resolving the effective memory limit from the cgroup hierarchy, including handling of conflicting mounts, unlimited memory sentinels, and fallback to system memory. It is not a hybrid; it is purely an application library.
go-actor is a Go library implementing the Actor model for concurrent programming. It provides core abstractions: Actor (with Start/Stop), Worker (defining work via DoWork), and Mailbox for message passing. The library enables building concurrent systems without mutexes by leveraging goroutines and channels. Key features include non-blocking message sends (by default), combinable actors for collective lifecycle management, and pluggable mailbox modes (internal queue or Go channel wrapper). The design emphasizes zero-overhead composition, graceful shutdown, and compatibility with Go's scheduler. The codebase is well-tested, actively maintained, and follows modern Go practices with rigorous CI/linting.
This is a monorepo of first-party middleware and service implementations for the Fiber web framework (v3). It provides production-grade authentication (JWT, PASETO, SPNEGO/Kerberos), authorization (Casbin, OPA), observability (OpenTelemetry, Prometheus, New Relic, Sentry, custom monitor/uptime dashboards), real-time communication (WebSocket, Socket.IO v5), Web Application Firewall (Coraza), resilience patterns (circuit breaker, CPU load shedding), structured logging (zap, zerolog), internationalization, hCaptcha verification, Swagger UI/OpenAPI docs, profiling (fgprof), and Testcontainers integration for testing. Each package lives in its own Go module under v3/, following a consistent Config+New() pattern and includes extensive test coverage with benchmarks. The architecture is library-oriented: components are imported by Fiber applications, not run standalone. The codebase demonstrates strong engineering practices: config validation at construction, atomic concurrency patterns, lock-free read paths, and protocol-level optimizations (e.g., zero-copy Socket.IO codec, WebSocket write coalescing). Some packages show signs of technical drift (e.g., paseto uses a deprecated library, socketio has mutable package globals), but overall the repository is actively maintained with weekly releases and automated dependency updates.
This is a Go library implementing the SPIFFE Workload API for workload identity management and secure communication. It provides client libraries to fetch X.509-SVIDs, JWT-SVIDs, and trust bundles from a Workload API agent (typically SPIRE). The library offers high-level TLS dial/listen functions (spiffetls) with various authentication modes (mTLS, TLS with JWT), supporting both Unix sockets and Windows named pipes. Core packages include spiffeid (SPIFFE ID parsing and matching), svid (SVID parsing and validation), bundle (trust bundle management), workloadapi (Workload API client and credential source watchers), and federation (remote trust domain bundle fetching). The architecture is modular with clear interfaces (Source, Authorizer, Logger, Backoff) that allow swapping backends. The code is well-tested with extensive unit tests and integration test helpers. Experimental features include WIT-SVIDs and a Broker API. This library is a critical component for any workload that needs SPIFFE-based identity in a zero-trust environment.
This repository provides a generic-based dependency injection framework for Go, called 'kod' (Killer Of Dependency), along with a CLI tool for code generation, component registration, and dependency graph validation. It features a rich interceptor chain for cross-cutting concerns (retry, validation, tracing, rate limiting, circuit breakers, etc.), and includes a comprehensive test suite and examples. The codebase also incorporates an extensive set of AI agent skills for software development workflows (grilling, code review, TDD, domain modeling) from the mattpocock/skills ecosystem. The primary value is the DI framework that leverages Go generics to provide compile-time safety for component wiring, with generated boilerplate code. The architecture is modular with clear separation of core, interceptors, internal utilities, and tests. It is actively maintained with modern Go features.
GEO Optimizer is a Go library for Generative Engine Optimization that improves content visibility in AI search engines. It features a layered architecture with LLM abstraction, rule-based content scoring, and pluggable optimization strategies. The system optimizes content through a pipeline that applies strategies like structure enhancement, schema generation, and FAQ creation, using LLMs to generate optimized content while tracking improvements through scoring mechanisms. Key design patterns include the strategy interface for interchangeable optimizations and modular separation of concerns in the scoring system.
Union is a hyper-efficient zero-knowledge infrastructure layer for cross-chain interoperability, implementing IBC (Inter-Blockchain Communication) with light clients for Cosmos, Ethereum, Sui, StarkNet, Gno, and many other chains. The system comprises a Cosmos SDK blockchain (uniond), a zero-knowledge prover (galoisd) for Groth16 proofs, a modular relayer (voyager) with plugin-based architecture, CosmWasm smart contracts for IBC and asset transfers (UCS03), EVM Solidity contracts, and a TypeScript SDK for programmatic interaction. The frontend is a Svelte 5 application (app2) providing a transfer interface, explorer, dashboard, and staking UI, while documentation is served via an Astro site. The architecture is a multi-language monorepo with Rust as the dominant language for core libraries and relayer modules, Go for the Cosmos SDK chain and prover, TypeScript for SDKs and frontend, and Solidity/Move for smart contracts. Key design patterns include a trait-based light client interface (IbcClient), a plugin system for relayer modules (voyager_sdk), functional effect management in TypeScript (Effect-TS), and derive macros for encoding (model, ssz, ethabi). The codebase demonstrates high craftsmanship in its type-safe encoding primitives, storage abstractions (depolama), and persistent queue (pg-queue), though it suffers from some code duplication across SDK versions and generated protobuf drift risks.
PhotoPrism is a self-hosted photo management server that indexes, organizes, and serves personal photo and video collections. In production, it extracts EXIF/XMP/IPTC metadata, generates thumbnails and previews, transcodes videos, performs AI-powered object/face recognition and NSFW detection, and provides a web UI for browsing, searching, sharing, and editing media. It also supports WebDAV access, OAuth2/OIDC authentication, and multi-instance clustering. The architecture is a monolithic Go application with a REST API (Gin framework) and a Vue.js frontend. It uses a relational database (MariaDB/MySQL or SQLite) via GORM. Background workers handle indexing, face recognition, place detection, and cleanup. It integrates with external tools: FFmpeg for video transcoding, libvips for image processing, TensorFlow/ONNX for AI models, and exiftool for metadata extraction. The frontend communicates via REST and WebSocket. Key entry points include the CLI (cmd/photoprism/photoprism.go) with subcommands for import, index, search, and user management, and the API layer (internal/api) exposing endpoints for photos, albums, labels, faces, places, and vision. The indexing pipeline scans configured directories, extracts metadata, generates thumbnails, runs AI models, and stores results in the database. The system also supports background sync with remote WebDAV services and backup/restore. External dependencies include FFmpeg, exiftool, libvips, TensorFlow, ONNX Runtime, Darktable, RawTherapee, yt-dlp, and various Go libraries. It can optionally integrate with OpenAI/Ollama for vision captioning. The codebase is large and mature, with extensive utility packages and a well-organized module structure.
Lux is a fast and simple video downloader CLI tool written in Go. It supports downloading videos, images, and audio from over 40 websites including YouTube, Bilibili, TikTok, Instagram, Twitter, and many Chinese streaming platforms. The tool operates as a single binary with a rich set of command-line options for selecting quality, downloading playlists, resuming interrupted downloads, multi-threaded downloading, and integration with aria2 for RPC-based downloads. Architecturally, Lux follows a plugin-based extractor pattern. Each supported website has its own extractor module under `extractors/`, registered via `init()` functions into a global map keyed by domain. The main entry point is `main.go`, which parses CLI flags via `urfave/cli` and dispatches to the appropriate extractor. Extracted video metadata (streams, quality, size) is passed to the downloader, which handles HTTP requests, progress bars, file merging via ffmpeg, and optional subtitle embedding. Key data flows: URL input → domain detection → extractor selection → HTML/API scraping → stream metadata extraction → downloader (single or multi-threaded) → file output. External dependencies include ffmpeg for merging and subtitle embedding, and various third-party Go libraries for HTTP requests, HTML parsing, JavaScript execution (for TikTok signing), and progress bars. The codebase is well-organized with clear separation of concerns, extensive test coverage for individual extractors, and CI workflows that run weekly to verify extractor functionality. While many extractors rely on fragile regex-based scraping of HTML pages, the overall architecture is solid and the downloader implements robust features like resume support and configurable retry logic.
SpotiFLAC-Mobile is a cross-platform mobile application (Android and iOS) that enables users to download and play high-fidelity music in lossless formats such as FLAC and DSD. It operates through an extension-based architecture where community-provided plugins supply download sources, metadata, lyrics, and cover art. The application integrates with streaming services like Deezer, Tidal, Qobuz, and Spotify via these extensions, handling authentication, rate limiting, and content resolution. The system is built on a multi-language stack: a core Rust backend handles audio processing, metadata tagging, library management, and network communication; a Flutter (Dart) frontend provides the user interface; and platform-specific code in Kotlin (Android) and Swift (iOS) bridges native features like file system access, USB audio output, and system audio routing. The Rust backend is exposed to mobile languages via UniFFI-generated bindings. Key data flows include: extension-based download orchestration with cancellation and progress reporting, audio file finalization (metadata embedding, ReplayGain scanning, cover art insertion), incremental library scanning with SQLite persistence, and multi-provider lyrics fetching with caching. The application also features hi-res audio authenticity verification using STFT analysis, direct USB audio output for bit-perfect playback, and a comprehensive extension management system with sandboxed JavaScript runtimes. External dependencies include FFmpeg for audio conversion, libusb for USB audio transport, and various web APIs (Deezer, MusicBrainz, LRCLib, Apple Music, etc.) for metadata and lyrics enrichment. The project demonstrates strong engineering practices with extensive unit and integration tests, a modular crate architecture, and reusable patterns for cancellation, progress tracking, and caching.
Finicky is a macOS application that acts as a smart default browser handler. It intercepts URL open requests from the operating system and routes them to different browsers based on user-defined rules written in JavaScript or TypeScript, or via a simpler JSON rules file. The application is built as a hybrid of Go (using a custom Go-like language with Objective-C interop) and a Svelte-based web UI embedded via WKWebView. It includes a JavaScript virtual machine (goja) to evaluate user configuration scripts, supports URL rewriting, short URL resolution, browser profile detection, and provides a graphical configuration and testing interface. The codebase is well-structured with separate packages for the config API (TypeScript, compiled to JS), the UI (Svelte), and the core macOS app (Go/Objective-C). It demonstrates strong engineering practices including caching, debouncing, and comprehensive testing.
This is a Go client library for the Slack API, providing comprehensive coverage of Slack's REST API, Real-Time Messaging (RTM) over WebSocket, Socket Mode for event-driven interactions, and the Block Kit for rich interactive messages. It enables developers to build Slack apps, bots, and integrations with full access to Slack's platform features including messaging, files, admin functions, workflows, and more. The library is organized into several packages: `slack` (main client with all API methods), `socketmode` (WebSocket client for Socket Mode), `slackevents` (Events API parsing), `slacktest` (mock server for testing), and `internal` (backoff, error handling). It uses a functional options pattern for API calls, context propagation for cancellation, and a pluggable retry system. The Block Kit is implemented with builder patterns and custom JSON serialization for type-safe block construction. Key entry points include `slack.New(token)` to create a client, `socketmode.NewClient` for WebSocket connections, and `slackevents.ParseEvent` for Events API payloads. The library handles authentication, rate limiting, pagination, and error responses. External dependencies are minimal, relying primarily on the Go standard library and a WebSocket library for real-time communication.
easyjson is a Go library and code generator that produces specialized, reflection-free JSON marshal/unmarshal code for Go structs. It achieves 4–5× faster serialization than the standard `encoding/json` by generating type-specific encoder/decoder functions at compile time. The architecture consists of a CLI tool (`easyjson/main.go`) that parses Go source files, extracts struct annotations (`//easyjson:json`), and generates `_easyjson.go` files implementing `easyjson.Marshaler`/`Unmarshaler` interfaces. The runtime library provides a fast JSON lexer (`jlexer`), writer (`jwriter`), buffer pool (`buffer`), optional types (`opt`), and helpers for unknown fields, string interning, and zero-copy parsing. The project includes extensive benchmarks comparing against ffjson, jsoniter, and go/codec, and a comprehensive test suite covering edge cases like omitempty, snake_case, embedded types, and custom key types.
WiiUDownloader is a cross-platform desktop application written in Go that downloads Wii U games, updates, DLC, and demos directly from Nintendo's CDN servers. It is the primary open-source replacement for the abandoned Wii U USB Helper. The application provides a GTK3-based GUI (via gotk3) on all three major platforms, with a command-line core library. Key features include automatic decryption using embedded common keys and title keys derived from PBKDF2, resume-capable downloads with SHA-256 segment verification via a journal file, hash-tree validation for hashed content, FST/U8 archive extraction, and a queue-based batch download system. The architecture cleanly separates the core download/decryption logic (root package) from the GUI (cmd/WiiUDownloader), with reusable internal format parsers for TMD, FST, and U8. No title keys are required; the system generates tickets and certificates on the fly. The project is actively maintained, with recent commits and CI/CD pipelines producing Windows, macOS, and Linux builds.
gologin is a well-tested Go library that turns OAuth1 and OAuth2 authorization flows into chainable net/http handlers. In production it lets a web app register LoginHandler and CallbackHandler for providers (GitHub, Google, Facebook, Bitbucket, Twitter, Tumblr) and then read the authenticated user or access token from the request context in the success handler. It also provides a Twitter TokenHandler for native mobile token login. The architecture is a set of primitive handlers (state, login, callback) that communicate via context, with provider packages composing those primitives and adding a user-fetching step; session management stays orthogonal to authentication. The oauth2 subpackage implements RFC 6749 state-parameter CSRF protection with short-lived secure cookies, while the oauth1 subpackage splits request-token acquisition, auth redirect, temporary-secret persistence, and access-token callback so providers with different secret requirements reuse the same pieces. Provider packages are intentionally thin wrappers around the generic handlers and call provider APIs (go-github, go-twitter, sling, google.golang.org/api) to fetch User objects. The code is thoroughly unit-tested with httptest mocks and includes runnable examples for GitHub, Google, and Twitter. Maintenance is active and the dependency manifests are current, though a few provider endpoints lag behind platform APIs (Facebook still targets Graph API v2.9 and Twitter targets v1.1 verify_credentials), so those specific integrations may need updates. The generic OAuth1/OAuth2 machinery remains solid and portable.
Quamina is a high-performance Go library for matching patterns against JSON events. It uses a custom NFA/DFA automaton approach internally, supporting exact strings, shell-style wildcards, and a subset of I-Regexp (RFC 9485). Patterns are defined as JSON objects with field/value constraints, and the library provides a concise API to add patterns and efficiently retrieve matches for events. The core is a compact `smallTable` data structure for byte-transition tables, with optimizations like incremental epsilon closures and table-pointer deduplication to keep matching near O(1) for exact patterns. Quamina is version 2.0.1, has zero runtime dependencies, and includes extensive benchmarks and a research subdirectory for performance analysis. It is intended as an embedded library for real-time event classification (e.g., routing, log analysis) rather than a standalone service.