Kimai is a self-hosted, open-source time-tracking application built with PHP 8.3+ and Symfony 6/7. It provides a full-featured web interface and REST API for recording timesheets, managing projects/customers/activities, generating invoices, exporting data (PDF, XLSX, CSV, HTML), and producing reports. The architecture follows a classic Symfony monolith with Doctrine ORM, Twig templating, and Webpack Encore for frontend assets. It supports multi-user, multi-timezone, multi-language, LDAP/SAML authentication, two-factor authentication, and a plugin system via tagged services and compiler passes. The codebase is heavily event-driven, with over 70 domain events and subscribers, and includes a rich set of dashboard widgets, custom form types, and validation constraints. The repository is actively maintained with frequent commits, extensive test coverage (PHPUnit), and continuous integration pipelines.
Binance Grid Trader is a cryptocurrency trading bot that implements grid trading strategies for Binance Spot and Futures markets. The application features a modular architecture with separate layers for exchange gateways, event processing, strategy management, and user interface. It provides both a graphical interface built with PyQt5 and script-based execution modes for running trading strategies without UI. The system connects to Binance via REST and WebSocket APIs to receive market data and execute trades based on configurable grid strategies.
This is the official Tableau MCP server, a TypeScript application that bridges AI assistants with Tableau Cloud, Tableau Server, and Tableau Desktop via the Model Context Protocol (MCP). It exposes a comprehensive set of tools covering content exploration (workbooks, views, datasources), administration (users, flows, extract refresh tasks, jobs, license reclamation), advanced analytics (Pulse metrics, insights, knowledge graph), and human-in-the-loop confirmation workflows. The server is available in three variants: a web variant running over HTTP with OAuth 2.1 support (PKCE, token rotation, client registration), a desktop variant communicating with the local Tableau Desktop Agent over stdio, and a combined variant. Its architecture is modular: a core server layer registers tools and prompts against an MCP SDK instance, tools delegate to a Zodios-based Tableau REST API client or the desktop agent API, and cross-cutting concerns like authentication, feature gates, telemetry, and session stores are provided through pluggable provider interfaces. The codebase demonstrates strong engineering practices with extensive unit/e2e tests, typed schemas via Zod, consistent error handling patterns, and a clear separation between web and desktop concerns.
This is an Android application that turns a smartphone into an SMS/MMS gateway. It exposes a local REST API (Ktor-based HTTP server) for sending and receiving messages, supports cloud server integration via Firebase and Server-Sent Events, and provides webhook delivery, end-to-end encryption (RSA-OAEP + AES-GCM), and device key rotation. The architecture is modular: foreground services (SSE, ping, local server), WorkManager workers for background tasks (message sending, webhook queue processing, inbox upload, settings sync), a Room database for persistence, and Koin for dependency injection. The codebase is well-structured with event-driven communication via a custom EventBus, a validated state machine for message lifecycle, encrypted storage, and rich UI fragments. It supports SMS, MMS, and data SMS, with inbound message capture via broadcast receivers and content observers.
Mail-Archiver is a production-grade ASP.NET Core 10 web application for archiving emails from IMAP, Microsoft 365 (Graph), and local imports (MBOX, EML). It provides a full MVC UI for searching, viewing, exporting, restoring, and managing archived emails, alongside a read-only REST API (v1) and a Model Context Protocol (MCP) server for AI agent integration. The system features background job processing for sync, batch operations, deduplication, retention policies, and audit exports, all backed by PostgreSQL with full-text search. Authentication supports local password (PBKDF2), OpenID Connect, and API keys, with two-factor authentication and role-based access control. The codebase is well-structured with clear separation of concerns: provider-specific services (IMAP, Graph, Mbox), shared utilities, and a core service layer. Extensive unit and integration tests (xUnit) cover critical paths, and Docker Compose provides a reproducible test environment. While some technical debt exists (raw SQL in core services, in-memory job tracking, German comments in places), the overall architecture is solid and the reusable components (static helpers, deduplication strategies, background job patterns) demonstrate high craftsmanship.
This repository is a CLI tool and Python library that generates modern, typed Python HTTP client libraries from OpenAPI 3.0 and 3.1 specifications. The system parses an OpenAPI document (YAML or JSON), validates it against Pydantic models of the OpenAPI schema, and then converts the parsed structure into an internal representation of endpoints, models, and properties. Using Jinja2 templates, it generates a complete Python package with attrs-based model classes, httpx-based sync/async endpoint functions, a Client class with authentication support, and packaging metadata (Poetry, PDM, uv, or setup.py). The generated code is fully typed and includes serialization/deserialization methods, error handling, and support for complex OpenAPI features like allOf, oneOf, discriminated unions, enums, circular references, and custom content types. The architecture is a monolithic Python package with clear separation of concerns: a CLI entry point (typer), a configuration system (YAML/JSON config files with class overrides), a parser module that converts OpenAPI schemas into a property type hierarchy (StringProperty, IntProperty, UnionProperty, ModelProperty, etc.), and a template rendering engine. The parser uses a protocol-based design for property types, making it extensible. The system also includes a vendored copy of the openapi-schema-pydantic library for schema validation. Security is a key concern, with features like UntrustedString to prevent code injection in generated output and fuzz testing that generates random OpenAPI documents with dangerous strings. The project has extensive testing: unit tests for all parser components, end-to-end snapshot tests using golden records, functional tests that execute the generated code, integration tests against a live test server, and property-based fuzz testing. The generated client libraries are production-ready, using modern Python features like `from __future__ import annotations`, `|` union syntax, StrEnum/IntEnum, and the UNSET sentinel for optional fields. The tool is configurable via CLI flags and config files, supporting custom templates, post-generation hooks, and various packaging backends.
Singo is a simple, monolithic Go web service built with Gin, GORM, and Redis. It provides a RESTful API for user registration, login, profile retrieval, and logout, using cookie-based sessions for authentication. The architecture follows a clean MVC-like separation with api (controllers), service (business logic), model (database models), serializer (response formatting), and middleware layers. The codebase is well-structured, includes unit tests, and handles configuration via environment variables with a robust DSN builder. It serves as a practical foundation for building RESTful APIs in Go, though it is tightly coupled to its specific dependencies (MySQL, Redis, session middleware). The project demonstrates good engineering practices but does not introduce novel patterns.
This is a NestJS boilerplate for building RESTful APIs with TypeScript, PostgreSQL, TypeORM, and modern DevOps practices. The system provides a modular backend architecture with authentication (JWT), user management, post management, email verification via BullMQ queues, health checks, Swagger API documentation, and comprehensive testing setup. It follows NestJS best practices with clear separation of concerns across modules for auth, users, posts, health, and background jobs. Key features include cursor-based and offset-based pagination, internationalization (i18n), Redis caching, security headers via Helmet, and environment-based configuration management. The codebase demonstrates strong engineering practices with reusable utilities for password handling, configuration validation, and sophisticated cursor pagination that could be extracted to other projects with minimal modification.
MediaCMS is a production-grade, self-hosted video and media content management platform built as a Django monolith with a React frontend. In production it ingests video, audio, image, and PDF uploads via a chunked Fine Uploader flow, transcodes video through FFmpeg into multiple MP4/HLS renditions matched by configurable encoding profiles, streams them through a customized video.js player, and supports subtitles (manual upload and Whisper transcription), chapter markers, video trimming/editing, playlists, comments with mention notifications, likes, reports, and PostgreSQL full-text search. It ships a REST API under /api/v1/, an editor/manager admin UI, RSS feeds with Yahoo Media RSS extensions, and a small Click-based CLI. The backend is organized into Django apps (files, users, actions, rbac, lti, saml_auth, identity_providers, migrationservice, uploader) with DRF serializers/views, Celery workers for encoding and notifications, Redis as broker, and Nginx serving protected media through an auth_request subrequest. A significant portion is education/LMS-focused: an LTI 1.3 tool provider with deep linking, SAML authentication, RBAC groups mapped to categories, Moodle filter and TinyMCE plugins, and a migration service that imports media, captions, and users from Kaltura, Panopto, and YouTube with quiet-hours scheduling and encrypted credentials. This gives the repository a mild data-pipeline flavor through the migration service, but its dominant character is a full web application. Engineering quality is strong for an open-source Django project: extensive pytest coverage across API, permissions, LTI, SAML, RBAC, migration providers, and pipeline tasks; a large Jest suite for frontend components, hooks, and stores; semantic-release and pre-commit CI; and a clean provider abstraction for migration sources. Weaknesses include legacy webpack-built minified bundles checked into static/, a mix of JSX and TSX across the frontend, duplicated iOS player code between the video-editor and chapters-editor tools, several TODO/FIXME markers, and version-sensitive external dependencies (yt-dlp, Moodle, LTI). Overall it is an actively maintained codebase with several genuinely reusable components, though it carries moderate legacy debt in its frontend tooling.
DefectDojo is a Django-based vulnerability management platform that aggregates, deduplicates, and tracks security findings from over 200 security scanners (SAST, DAST, SCA, container, cloud, infrastructure). The system ingests scan reports via a standardized parser interface, normalizes findings into a core data model (Product, Engagement, Test, Finding, Location), and provides advanced features such as risk-based prioritization, SLA management, JIRA/GitHub integration, notifications (Slack, Teams, email), role-based access control, and customizable reporting. The architecture is a Django monolith with a REST API (v2 using DRF, v3 using Ninja in alpha), Celery for async task processing (imports, deduplication, JIRA sync, SLA expiry), PostgreSQL with full-text search and audit logging via pghistory, and a containerized deployment with Docker Compose. Key entry points include the parser factory (dojo/tools/factory.py), API viewsets, and management commands. The codebase demonstrates strong software engineering patterns such as a modular parser contract, an abstract location manager for feature-flag-driven migration, and an authorization filter registry, but carries technical debt from a dual API surface and an incomplete migration to a new location model.
This repository is the official documentation for the Binance Spot Exchange APIs. It provides comprehensive specifications for REST, WebSocket, FIX, and SBE (Simple Binary Encoding) protocols, covering trading, market data, account management, and user data streams. The documentation includes detailed endpoint references, authentication methods (HMAC, RSA, Ed25519), order types, filters, error codes, and FAQs. It also contains versioned SBE XML schemas for code generation and lifecycle management JSON files. While not an application itself, it serves as the authoritative reference for developers building trading bots, market-making systems, and integration tools for Binance Spot. The repository is well-structured with bilingual (English/Chinese) support and separate documentation for production, testnet, and demo environments.
GFast is a full-stack, modular admin panel built with GoFrame v2.10 and Vue3. It provides a RESTful API backend for managing users, roles, departments, menus, dictionaries, configuration, logs, and system monitoring. The architecture follows a layered pattern: API definitions (api/v1), controllers (internal/app/*/controller), business logic (internal/app/*/logic), data access objects (dao), and service interfaces. Authentication uses JWT (gfast-token) and authorization uses Casbin with RBAC. Caching is abstracted via gfast-cache supporting memory or Redis. The system includes a code generator, scheduled tasks, and an OpenAPI/Swagger endpoint. External dependencies include MySQL, Redis, Casbin, and ip2region for IP geolocation.
This is a monolithic Spring Boot web application built with Kotlin that implements a blog engine. The application serves both HTML pages via Mustache templates and provides a REST API for articles and users. It uses Spring Data JDBC for data access with an H2 database, and includes sample data initialization. The architecture follows standard Spring MVC patterns with controllers handling web and API requests, repositories for data access, and configuration properties for externalized settings. The code demonstrates idiomatic Kotlin usage with extension functions, data classes, and proper null safety.
This repository is a Spring Boot training/courseware package rather than a production service. It consists of five independent, runnable Spring Boot applications under com.kousenit (demo, restclient, persistence, shopping, springai), accompanied by lab workbooks (labs.md, advanced-labs.md), course slides (slides.md), and CI workflows. The code demonstrates current-generation Spring and Spring Boot patterns: MVC and REST controllers, Java records for DTOs, RestClient and HTTP interfaces, JdbcClient and JPA data access, AOP aspects, RFC 7807 exception handling, and Spring AI chat clients. Although the dominant character is application code, it is educational example code, not a deployed system.
FreeAPI is an open-source API hub that provides free REST APIs for learning and demonstration purposes. The backend is a monolithic Express.js application with MongoDB, offering a range of endpoints: static public data (cats, dogs, quotes, etc.), kitchen-sink features (HTTP methods, status codes, cookies, redirects), and full-featured CRUD applications (ecommerce, social media, chat, todo) with authentication (JWT, OAuth via Google/GitHub), real-time chat via Socket.IO, file uploads, email notifications, and payment integration (Razorpay, PayPal). The codebase is well-structured with reusable utilities (asyncHandler, ApiError, pagination helpers), modular validators, and seeding scripts. It also includes multiple React/Vite frontend examples (ecommerce with Redux, chat with Socket.IO, todo app, status code quiz) that demonstrate best practices in consuming APIs. The project is clearly a learning resource and demo platform, not a production service.
Grocy is a self-hosted web application for household inventory and chores management. It provides a monolithic PHP backend (Slim 4, custom MVC) with a SQLite database, server-rendered Blade templates, and a JavaScript frontend (jQuery, Bootstrap 4, DataTables, FullCalendar). The system tracks stock (purchases, consumption, inventory, transfers), manages shopping lists, recipes, meal plans, chores, batteries, tasks, and equipment. It exposes a REST API for programmatic access, supports barcode scanning (including custom Grocycode format), external barcode lookup plugins, webhook-based label printing, multi-user permissions, and extensive localization via gettext. The codebase demonstrates solid engineering with a service layer, generic API controllers, feature flags, and a plugin system, but relies on an older frontend stack and a custom framework that may hinder contributor onboarding.
Katbin is a pastebin service (pastebin/paste.rs-style) built on Cloudflare Workers with Hono, D1 (SQLite) via Drizzle ORM, and a Vite + React frontend styled with Tailwind CSS. It supports paste creation with syntax highlighting (highlight.js), markdown rendering, raw paste access, and configurable expiration. The service includes usage analytics with documented visitor limits, differentiated rate limiting (missing raw pastes are limited separately from existing ones), and admin routes that enforce authentication before executing any queries. Deployment is fully automated via GitHub Actions with separate production and staging environments, including D1 migration management through wrangler. The codebase demonstrates strong engineering practices: type-safe database access, careful analytics implementation with explicit visitor limit documentation, and security-conscious route design. The test suite covers API error handling, analytics edge cases, and rate limiting behavior.
Flask-AppBuilder is a rapid application development framework built on top of Flask. It provides automatic CRUD generation from SQLAlchemy models, a comprehensive role-based security system with multiple authentication backends (database, LDAP, OAuth, SAML, OpenID, remote user), REST API generation with OpenAPI/Swagger, chart views, i18n, and a widget-based UI system. The architecture follows a Flask extension pattern with an AppBuilder class that registers views, menus, and permissions. It includes a security manager that handles authentication, authorization, and user management. The framework is used by major projects like Apache Superset and Apache Airflow. Key components: The security manager provides a pluggable authentication system with role-based access control, permission discovery, and API key management. The model views (ModelView, ModelRestApi) automatically generate CRUD interfaces and REST endpoints from SQLAlchemy models with filtering, sorting, and pagination. The framework includes a widget system for customizing list/show/form rendering, and a chart view system for Google Charts integration. The codebase is well-structured with clear separation of concerns, but shows some technical drift: outdated Bootstrap 3 UI, vendored JavaScript libraries, deprecated chart classes, and old translation files. The core security and CRUD functionality is actively maintained and production-ready.
Ganymede is a media management system focused on archiving and managing Twitch content (VODs, live streams, clips) with a Go backend using Ent ORM, Echo framework, and River job queue, and a Next.js frontend with Mantine UI. It provides video archiving, playlist management, user authentication, API keys, and administrative interfaces. The system processes media through a pipeline involving yt-dlp, FFmpeg, and TwitchDownloaderCLI, storing metadata in PostgreSQL and files on disk. It includes features like chat archiving, chapter detection, muted segment detection, and rule-based playlist automation.
Xen Orchestra is a comprehensive management platform for XenServer/XCP-ng virtualization environments. It provides a web UI (legacy React and modern Vue 3), a REST API, CLI tools, and a backup system. The architecture is a monorepo with multiple packages: server-side plugins (authentication, performance alerts, SDN controller, backups), frontend apps (xo-web React, @xen-orchestra/web Vue 3, @xen-orchestra/lite lightweight), and shared libraries (filesystem abstractions, VHD manipulation, cron parsing, audit logging, etc.). The backend communicates with XenServer hosts via the Xen API (XAPI), while the frontend connects via WebSocket/JSON-RPC or REST. Backup operations can be executed remotely via a proxy. Key data flows involve the web UI sending commands through WebSocket to the server, which translates them into XAPI calls. Backup jobs are scheduled via cron and executed by the backup runner system, streaming VM disks to remote storage. Audit events are logged with cryptographic chaining for tamper evidence. The system includes an MCP server for AI-assisted management. The repo demonstrates high engineering quality in many packages with clean abstractions for async operations, event-driven collections, and modular plugin systems, though it contains legacy components and some incomplete transitions to newer architectures.