Glance is a self-hostable web application designed as a customizable dashboard (startpage) that aggregates information from various sources into widgets. Built in Go, it features a modular widget architecture where each widget type (e.g., RSS, weather, clock) implements a common interface, allowing users to create personalized pages with multiple columns and widgets. The application serves HTML pages with embedded static assets (CSS, JS, images) and uses Go templates for server-side rendering, enhanced by a comprehensive set of template functions. Client-side JavaScript adds interactivity for dynamic updates, masonry layouts, and popovers. The system relies on a YAML-driven configuration (`glance.yml`) that supports variable substitution, file includes, and defines pages, columns, and widget settings. Data fetching is handled by centralized HTTP utilities with caching and user-agent rotation to avoid blocking external services. A theming system generates CSS variables from HSL-based configuration, enabling light/dark modes and custom themes. Optional authentication secures the dashboard, and the application includes diagnostic and CLI tools for maintenance. While the project demonstrates strong engineering in areas like request deduplication (singleflight), flexible configuration, and reusable template functions, it faces challenges due to its extensive widget proliferation (30+ types), coupling between frontend and backend logic, and reliance on an outdated Go version (1.26.6) which is no longer supported, indicating moderate technical drift. Despite these issues, Glance remains a popular and functional solution for personal dashboards.
coca is a static code analysis and refactoring CLI tool written in Go, designed to assess code quality, detect bad smells, analyze dependencies, and support migration tasks (specifically Spring MVC to Spring Boot). It operates as a monolithic command-line application using the Clean Architecture pattern, with distinct layers for domain models, application logic, and infrastructure. The tool supports multiple languages including Java, Go, Python, JavaScript, TypeScript, and Groovy, leveraging ANTLR for parsing and generating ASTs for analysis. The system's primary function is to scan codebases for technical debt, architectural issues, and API definitions, outputting results in various formats (JSON, CSV, Graphviz). It includes features for bad smell detection (e.g., Long Method, Large Class), test smell analysis, and dependency usage evaluation. The architecture is modular, allowing individual analysis features to be executed independently, though the tool itself is a single binary. While the codebase demonstrates solid engineering practices with a clean separation of concerns and reusable domain models, it exhibits technical drift in its dependency ecosystem. The Go version specified (1.23) is ahead of current stable releases, and several core dependencies (e.g., spf13/cobra, gomega) are significantly outdated, creating a mismatch between the code's stated requirements and the available ecosystem versions. This suggests the project is either in a transitional state or relies on specific, potentially unstable, dependency versions.
This is a large Go and TypeScript project for managing and monitoring network devices, specifically MikroTik routers. It has a web interface, role-based access control, and supports features like backups, settings management, and notifications.
Geek-AI is a self-hosted, full-stack AI content-generation platform rather than a research project. The Go/Gin backend (api/) exposes REST and SSE endpoints for chat, image generation, video generation, music generation, PPT creation, and WeChat official account integration, while the Vue 3 frontend (web/) provides desktop (Element Plus), mobile (Vant), and admin interfaces. The system does not train models; it aggregates third-party AI providers, including OpenAI-compatible chat APIs, MidJourney, DALL-E, Jimeng, Suno, Luma, Sora, Veo, Kling, MiniMax, and Wan. The architecture is a deployable monolith with a service layer, GORM/MySQL persistence, Redis-backed queues for asynchronous generation jobs, LevelDB for temporary data, and a suite of provider abstractions for storage, SMS, payment, moderation, and video generation. Key entry points are api/main.go (Uber FX dependency injection), web/src/main.js, and docker/docker-compose.yaml. Authentication uses JWT sessions in Redis, and monetization is built in with credit/power billing, recharge products, orders, redeem codes, invite rewards, and payment providers including Alipay, WeChat Pay, Stripe, and EPay. The codebase contains several genuinely reusable patterns: a storage-agnostic uploader manager, a generic Redis task queue, adapter interfaces for heterogeneous video providers, and schema-driven frontend parameter forms. At the same time, there is meaningful technical drift: duplicated desktop/mobile frontend implementations, large god-components such as ChatPlus.vue, hardcoded credentials in docker configuration, placeholder moderation providers, and no frontend unit tests. The project is actively maintained and production-oriented, but reuse should focus on the isolated abstractions rather than the application shell.
This repository provides a high-precision IP geolocation HTTP API focused on mainland China, capable of resolving IP addresses to province/city/district level using a custom GeoCN database. The server is written in Go, uses MaxMind GeoLite2 databases for ASN and city-level data, and supplements with a custom MMDB for Chinese administrative divisions. It is deployed as a single binary via Docker, with a CI pipeline that weekly rebuilds the image with updated databases. The codebase is monolithic but well-organized, with environment variable configuration, proper error handling, and clean JSON responses. It is primarily an application, not a data research project, though it ships supporting data files for division codes and ASN metadata.
This repository provides a native printing solution for the reMarkable tablet. It consists of a Go-based daemon that listens on TCP port 9100 for incoming print jobs, processes them to extract the PDF data and job name, and saves the document to the reMarkable's filesystem along with metadata. The solution includes CUPS integration via a PPD file and a filter script to send print jobs to the device. The daemon supports systemd socket activation for efficient resource usage. The code is straightforward and functional, focusing on doing one thing well.
Haaukins is a cybersecurity training and Capture The Flag (CTF) platform developed at Aalborg University. It orchestrates isolated lab environments for teams, combining Docker containers and VirtualBox VMs to deliver challenges. The system is built as a set of gRPC microservices: a central daemon manages event lifecycle, team assignments, and challenge verification; a store service provides persistence; and an exercise service defines challenge configurations. Participants access labs via a web frontend (Amigo) using browser-based RDP (Guacamole) or WireGuard VPN. The daemon also handles DNS/DHCP per lab subnet, real-time scoreboards via WebSocket, and keylogging for monitoring. The CLI client (hkn) allows administrators to manage events, teams, and exercises. The architecture is modular with clean interfaces for virtualization (Docker/VirtualBox) and storage (in-memory with hooks or gRPC backend), though some components show tight coupling and aging dependencies.
Telecrawl is a Go CLI application that imports Telegram Desktop's `tdata` session data and creates encrypted, versioned backups. It reads the local Telegram Desktop data directory (platform-specific paths for macOS/Linux), parses the tdata format, and stores chat archives in a SQLite-backed store with merge/restore/tombstone semantics. The CLI exposes commands for import, backup, restore, search, and media reference handling. It runs as a Docker image with a non-root user, read-only tdata mount, and persistent /data volume. Architecturally, it is a monolith with a `cmd/telecrawl` entry point delegating to `internal/cli`, which orchestrates importers (`tdata`, `postbox`) and the `internal/store` persistence layer. The store handles schema migrations, snapshot merging, and search. Backup uses a Git remote pattern with safety guards against path overlaps. The codebase includes CI workflows, release automation, and security checks. Maintenance is active with frequent dependency bumps and CI. However, the store package is large and mixes concerns, and tdata/postbox importers are format-specific and may break if Telegram changes its data format. Hardcoded platform paths and schema backfill migrations are drift risks. Despite some data-audit scripts and fixture data, the dominant character is a CLI application.
g3nd is the official demo/showcase application for the g3n Go 3D game engine. It is a single Go binary that presents a windowed GUI (built on the engine's own immediate-mode GUI system) with a categorized demo tree. Users select demos that exercise the engine's capabilities: glTF/glb loading, PBR materials, animations (skinning, morph targets), audio (OpenAL), particle systems, post-processing shaders, and GUI widgets (tables, trees, sliders, form boxes, dock layouts). The application registers demos via Go's `init()` side-effect pattern: each demo package imports itself and calls `app.DemoMap["category.name"] = &struct{}{}`. The core `App` struct manages the scene graph, camera, orbit controls, and per-frame `Update` dispatch. The repository also vendors a large set of test assets (glTF sample models, Blender files, audio, textures) under `data/`. The architecture is a classic Go application: `main.go` imports all demo packages for their registration side effects, then delegates to `app.Create().Run()`. The `app` package owns the window, GUI, and demo lifecycle. Each demo implements a minimal `IDemo` interface (`Start`, `Update`, `Cleanup`). The `util` package provides reusable GUI helpers (file selectors, light meshes). The demos are grouped by category: animation, audio, experimental physics, geometry, GUI, light, loader, material, other, shader, texture. The code is idiomatic Go with clean separation, but some demos are marked experimental and the engine dependency is a pseudo-version that may drift.
This repository is the build system for AvyOS, a Linux distribution that compiles all packages from source using a custom Go-based tool called 'ignite'. The system defines hundreds of YAML recipes under `elements/` for building the kernel, system libraries, desktop environments (KDE, GNOME, Xfce, Sway, etc.), development toolchains, and applications. The ignite tool handles dependency resolution, source fetching, containerized builds (via bubblewrap), and image generation (ISO, disk images, OSTree commits). The architecture is a declarative recipe system with reusable includes, patch management, and a web dashboard for monitoring builds. Key entry points are the `ignite` CLI and the YAML recipe files. External dependencies include upstream source tarballs, patches, and a custom build environment. The repository also includes configuration for secure boot, A/B updates, and live ISO booting. While the codebase is well-structured and demonstrates significant engineering effort, it is a personal project with limited documentation, many TODO comments, and potential drift due to custom kernel versioning and future-dated Go version requirements.
This repository is a collection of standalone example applications demonstrating features of the Gin web framework for Go. It includes over 30 examples covering routing, middleware, authentication, file uploads, WebSocket, server-sent events, gRPC integration, OpenTelemetry, and more. Each example is a self-contained Go program with its own main.go and dependencies. The codebase serves as a learning resource and reference for Gin patterns, but is not a cohesive production system. Many examples are simple and straightforward, though some demonstrate non-trivial patterns like rate limiting, struct-level validation, and concurrent room management.
Focalboard is a self-hosted project management application offering board/card-based work organization similar to Trello. The architecture consists of a Go backend server providing REST/WebSocket APIs, a React/TypeScript frontend with Redux state management, and native desktop clients (macOS Swift, Windows WPF, Linux) that embed the web UI. Key features include boards with multiple views (table/kanban/calendar/gallery), customizable properties, real-time collaboration, import/export from external tools (Trello, Asana, Notion), sharing capabilities, and Mattermost plugin compatibility. Data is stored in SQL databases (SQLite/MySQL/PostgreSQL) with schema migrations. The repository exhibits a maintenance warning indicating the project is currently not maintained despite recent commits, suggesting stale status with potential dependency drift.
kubectl-df-pv is a kubectl plugin that displays disk usage (like the Unix `df` command) for Kubernetes Persistent Volumes. It retrieves storage metrics from each node's kubelet stats/summary endpoint and presents them in a color-coded, human-readable table. The tool handles concurrent node queries using goroutines and channels, supports filtering by namespace, and allows users to select which columns to display (including inode information). It auto-converts byte sizes to IEC binary prefixes (Ki, Mi, Gi, Ti) and colorizes usage percentages (red > 75%, yellow < 25%, green otherwise). The codebase is a single Go binary using Cobra for CLI parsing, client-go for Kubernetes API interaction, and go-pretty for table rendering. It is a well-structured, focused utility that solves a specific operational need for Kubernetes administrators. While the core logic is solid, the project is relatively simple and does not exhibit exceptional architectural depth or highly reusable components beyond basic byte formatting.
Upstat is a self-hosted, open-source status monitoring and uptime tracking tool. The system consists of a Go (Fiber v2) backend API and a Next.js 15 web dashboard, deployed via Docker Compose with support for both PostgreSQL and SQLite databases. The backend periodically pings configurable HTTP endpoints, records heartbeats, calculates uptime percentages, and manages incidents triggered by status transitions. It integrates with multiple notification channels (Discord, Slack, Telegram, Ntfy, Gotify) and provides public status pages with real-time latency charts. The frontend uses shadcn/ui components, React Hook Form with Zod validation, and a custom client fetch wrapper for authenticated API calls. The monorepo also includes a documentation site (Fumadocs) and a static landing page. While the architecture is well-structured with clear separation of concerns (controllers, routes, models, utils), the codebase shows signs of technical drift including outdated dependencies, hardcoded secrets in Docker Compose files, committed SQLite database artifacts, and documentation inconsistencies between the manual API docs and generated OpenAPI spec. The project is functional and suitable for small to medium deployments but would benefit from dependency updates and cleanup before production use.
This repository is the Go Cloud Development Kit (Go CDK), a multi-cloud SDK that provides portable, driver-based abstractions for common cloud services including blob storage, pub/sub messaging, document stores, runtime configuration variables, secrets management, and SQL databases (MySQL/PostgreSQL). The architecture follows a consistent pattern: each service defines a driver interface (e.g., `driver.Bucket`, `driver.Topic`, `driver.Collection`) and a portable wrapper that adds error handling, retries, OpenTelemetry instrumentation, and a URL-based opener multiplexer (`URLMux`). Concrete drivers exist for Google Cloud Platform (GCS, Pub/Sub, Firestore, Cloud SQL, KMS), Amazon Web Services (S3, SNS/SQS, DynamoDB, Parameter Store, Secrets Manager, KMS), Microsoft Azure (Blob Storage, Service Bus, Key Vault), and local/testing backends (in-memory, filesystem). The project also includes sample applications (guestbook, order processing, CLI tools), a Hugo-based documentation website, and extensive conformance test suites that use recorded HTTP/gRPC interactions for deterministic replay testing. The codebase demonstrates strong architectural patterns (driver abstraction, URL-based resource opening, batcher for pub/sub, codec for document stores) and comprehensive observability via OpenTelemetry. However, the code uses a non-standard Go dialect (e.g., `import` with quoted strings, `type` for interfaces, `var` for variables) that is not standard Go, which significantly limits tooling support, contributor familiarity, and reusability outside this project. Many drivers and internal utilities are tightly coupled to this custom language, making extraction difficult. The project appears to be in alpha status with several incomplete features, TODOs, and a large dependency surface across multiple cloud SDKs, indicating a high maintenance burden. The last commit date is in the future (2026-10-01), which is likely erroneous, but the overall activity suggests the project may have slowed or been abandoned.
pdfcpu is a comprehensive PDF processing library and command-line tool. It provides a full suite of operations including validation, optimization, encryption, digital signing (PAdES/CAdES), form filling, watermarking, page imposition (booklet, n-up), content extraction, and PDF creation from JSON. The architecture is a monolithic library with a clear separation between a public API layer (`pkg/api/`), CLI command definitions (`pkg/cli/`), core processing logic (`pkg/pdfcpu/`), and a robust validation engine (`pkg/pdfcpu/validate/`). It implements a staged output pattern for safe file writes and a context-based cancellation system. While the feature set and test coverage are exceptional, the codebase is written in a non-standard Go dialect (using `func`, `type`, `var` keywords and a `go 1.25.0` module version), which represents a significant technical drift risk and limits its maintainability by the broader Go ecosystem. Despite this, it contains several genuinely reusable, well-crafted components such as its LZW codec, safe math utilities, path sanitizer, and BER/DER parser.
This repository is a curated collection of recipes and tools for Go development, organized into categories such as testing, dependencies, code visualization, code generation, refactoring, errors, build, assembly, deployment, execution, monitoring, benchmarking, documentation, security, static analysis, and guides. The actual codebase is minimal: a Go module with a three-line main.go that generates the README.md from a structured YAML file (page.yaml) using the mdpage library. The primary value is the content itself, which serves as a reference for Go developers to discover and utilize various tools and techniques. The project is actively maintained, with up-to-date dependencies and a simple CI workflow for markdown link validation.
This is the OpenIM SDK Core, a cross-platform instant messaging client SDK written in Go. It provides the core messaging functionality—send/receive messages, manage conversations, groups, friends, user profiles, and file uploads—for the OpenIM ecosystem. The SDK communicates with an OpenIM server via HTTP REST and WebSocket long connections, and persists data locally using SQLite (native) or IndexedDB (WebAssembly). It features robust incremental synchronization, a callback-driven architecture for event handling, and extensive support for multiple platforms (iOS, Android, Windows, macOS, Linux, Web). The codebase demonstrates solid engineering practices with generic sync engines, caching utilities, and a comprehensive integration test suite. However, it also contains notable code duplication (dual native/WASM storage implementations), incomplete WASM stubs, some panic-based error handling, and alpha-stage dependencies, which prevent it from being exceptional. Overall, it is a functional, actively maintained SDK with reusable patterns for incremental sync and WebSocket connection management.
Agentspan is a comprehensive, multi-language agent orchestration platform built on top of Orkes Conductor. It provides SDKs in Python, TypeScript, Java, and C# for defining, running, and deploying AI agents with rich features: tools, guardrails, multi-agent strategies (handoff, sequential, parallel, router, swarm, plan-execute), streaming, human-in-the-loop, code execution in sandboxes, credential management, and scheduling. The architecture follows a server/client pattern where agent definitions compile to Conductor workflows, with a Java/Spring Boot server, a Go CLI with a Bubble Tea TUI, and a React/Material-UI web interface for visual workflow editing and execution monitoring. The repository is archived (read-only) as of August 2026, with its active development having merged into the Orkes Conductor repository. Despite being archived, the codebase represents a mature, well-crafted multi-agent runtime with extensive examples, comprehensive testing, and clean abstractions across all supported languages. The SDKs demonstrate consistent design patterns—agent composition via strategies, tool registration via decorators/annotations, guardrail chains with composable termination conditions, and thread-safe credential injection—making the codebase a valuable reference for building agent orchestration systems.
GoBelieveIO/im_service is an instant messaging (IM) server infrastructure implemented in Go. It provides real-time peer-to-peer messaging, group chat (including super groups for large audiences), and chat rooms. The system is designed for clustered deployment and consists of three separate processes: `im` (access server handling client TCP/WebSocket connections), `ims` (storage server using append-only file logs with in-memory indexes), and `imr` (router server coordinating message delivery between access servers). Authentication is token-based (Redis or JWT). Message storage is per-user file-based with efficient offline message synchronization via sync keys. The codebase includes a custom binary protocol over TCP/WebSocket, a Redis-backed pub/sub mechanism for group events and relationship changes, and MySQL for group and friend data. This is a production-grade system (as indicated by its star count) with comprehensive benchmark tools and Python integration tests. However, the repository appears to be in a maintenance-stale state with no recent commits and some deprecated message types.