Infrahub is a full-stack infrastructure data management platform that provides a unified data model for network, cloud, and infrastructure resources. It features schema-first graph-based data modeling (using Neo4j), version control for data via branching and proposed changes, automation through generators and transforms, and integration capabilities via APIs, webhooks, and SDKs. The backend is built with Python/FastAPI, Prefect for workflow orchestration, and uses Neo4j as the primary graph database. The frontend is a React/TypeScript application with TanStack Query and Jotai for state management. The system supports IPAM, diff computation, artifact generation, and role-based access control, targeting infrastructure teams seeking repeatable, validated workflows for infrastructure as a service.
Ray.Di is a dependency injection and aspect-oriented programming (AOP) framework for PHP, inspired by Google Guice. It provides a module-based DI container that supports constructor, setter, and property injection via PHP 8 attributes, along with method interception for AOP cross-cutting concerns. The core architecture centers on AbstractModule for defining bindings, a Container for storing resolved dependencies, and an Injector that weaves aspects and manages object lifetimes (prototype/singleton). The framework supports advanced features like provider binding, contextual injection, multibinding (collections), assisted injection, null-object binding, and circular dependency detection. It includes a composition-time provenance log (BindingLog) for debugging binding precedence and produces a bindings.md diagnostics artifact. The codebase is mature and thoroughly tested (100% branch coverage), with extensive contract tests that pin observable semantics.
DoctrineBundle is a Symfony bundle that integrates Doctrine DBAL and ORM into Symfony applications. It provides dependency injection configuration (YAML/XML/PHP), autowiring of connections and entity managers, console commands for schema management, a web profiler data collector, and middleware support. The bundle uses compiler passes and PHP 8 attributes to automatically register custom types, entity listeners, middlewares, and repository services. It is a mature, well-tested integration layer that bridges Symfony's container with Doctrine's persistence layer, enabling standard CRUD and advanced ORM workflows. The architecture follows Symfony bundle conventions with clean separation of concerns (DependencyInjection, Mapping, Middleware, Repository, Command).
Suwayomi-JUI is a multiplatform manga reader application built with Kotlin Multiplatform, targeting Android, Desktop, and iOS. It functions as a client for the Suwayomi-Server backend, communicating via GraphQL (Apollo) and REST (Ktor) to manage a personal manga library, download content for offline reading, and provide a customizable reading experience. The architecture follows a clean layered structure: core utilities, data layer (repositories and network clients), domain layer (business logic and use cases), and presentation layer (UI with Jetpack Compose/SwiftUI). Key features include library management with categorization, extension/plugin support, download queue management, reading interface with various navigation modes, backup/restore functionality, and comprehensive settings. The application employs dependency injection via custom annotations, reactive programming with Kotlin Flows and coroutines, and a cross-platform preference storage system. It is actively maintained with recent commits and demonstrates strong engineering practices in modularity and platform abstraction.
SyncClipboard is a cross-platform clipboard synchronization application that enables real-time sharing of clipboard content (text, images, files) across devices. It features a modular architecture with desktop clients built on Avalonia (cross-platform) and WinUI3 (Windows-native), backed by an ASP.NET Core server with SignalR for real-time updates. The application includes clipboard history management, network-aware profile switching, and enhanced functionality like pinned items and preview panels. Key architectural patterns include MVVM, dependency injection, adapter patterns for server backends, and robust error handling with configurable retry mechanisms.
wsldl is an advanced WSL (Windows Subsystem for Linux) distribution launcher and installer. It provides a CLI tool that manages WSL instances: installing, configuring, running commands, backing up, and cleaning up Linux distributions on Windows. The architecture is a single binary with a command dispatcher pattern, where each subcommand (install, run, config, backup, clean, etc.) is implemented as a separate package with its own 'command.go' and 'help.go' files. The system depends on Windows-specific WSL APIs via the `wsllib-go` and `wslreglib-go` libraries, with platform-conditional stubs for non-Windows builds. The codebase demonstrates strong engineering practices: dependency injection for testability, clear separation of concerns, comprehensive unit tests (over 2000 lines of tests), and a mock-based testing strategy for the WSL API. The CLI supports interactive and non-interactive usage, path translation between Windows and WSL paths, and integration with Windows Terminal and Fluent Terminal.
The DuckDuckGo Android repository is a privacy-focused mobile browser application featuring tracker blocking, ad blocking, password management, VPN protection, and AI chat capabilities. It employs a modular architecture with feature-specific modules (app, browser, autofill, sync, privacy-*, network-protection, etc.) built using modern Android Jetpack components. The codebase utilizes Dependency Injection via Dagger/Hilt with Anvil annotations for code generation, follows MVVM patterns with ViewModels and LiveData/Flow, and implements a robust plugin system via @ContributesPluginPoint annotations for extensibility. Feature flags control gradual rollouts and A/B testing, while Room databases handle local persistence for settings, credentials, and usage statistics. The application emphasizes user privacy through encrypted storage, tracker detection networks, and transparent privacy dashboards.
Iris is a mature, full-featured Go web framework providing a comprehensive set of tools for building web applications and APIs. The core is a monolithic HTTP framework with a trie-based router, middleware pipelines, MVC pattern support, dependency injection via the 'hero' package, websocket integration, session management, caching, i18n, and a rich set of built-in middleware. The codebase is organized into clear packages (context, router, mvc, sessions, middleware, view, etc.) and includes hundreds of examples demonstrating common patterns. While the framework is heavily reflection-based in some areas (dependency injection, MVC activation), the architecture is well-structured and the components are generally reusable. The project shows active development (though some examples use deprecated go-bindata) and maintains a healthy release cycle.
Stream Chat Swift is an iOS/macOS SDK for building real-time chat and messaging applications. It provides a modular architecture separating core networking (StreamChat), UI components (StreamChatUI), and shared utilities (StreamChatCommonUI). The SDK supports features like channels, messages, reactions, threads, polls, attachments, typing indicators, and presence. It uses Combine for reactive programming, Core Data for persistence, and WebSocket for real-time communication. The repository includes demo applications, example implementations (SlackClone, MessengerClone, etc.), and extensive testing infrastructure. The SDK follows protocol-oriented programming with dependency injection via Appearance and Components providers, enabling high customization.
Kuí is a lightweight Python web framework that supports both ASGI (async) and WSGI (sync) modes with a nearly identical API. It provides type-safe parameter binding via typing_extensions.Annotated and Pydantic, dependency injection with caching and cleanup, automatic OpenAPI 3.1.0 documentation generation, middleware composition, class-based views for HTTP and WebSocket, background task execution, CORS support, authentication helpers (Bearer, Basic, API Key), and template rendering with Jinja2. The framework is built on baize and emphasizes developer experience through clear documentation and AI-assisted development support.
Utopia HTTP is a PHP MVC-based framework for building web applications. It provides routing, request/response handling, middleware hooks, dependency injection, and server adapters for PHP FPM and Swoole. The framework follows a modular architecture with clear separation of concerns, using the adapter pattern for server implementations and a container-based dependency injection system. Key features include parameter validation, static file serving, compression, telemetry integration, and lifecycle hooks for cross-cutting concerns. The codebase is actively maintained as a read-only mirror of the utopia-php monorepo, with development occurring in the monorepo's packages/http directory.
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.
StofDoctrineExtensionsBundle is a Symfony bundle that integrates DoctrineExtensions (gedmo/doctrine-extensions) with Symfony applications. It provides dependency injection configuration, event listeners, and tools for using Doctrine behavioral extensions like Tree, Translatable, Sluggable, Timestampable, Blameable, Loggable, Sortable, Softdeleteable, Uploadable, and Reference Integrity. The bundle follows Symfony best practices with proper dependency injection, compiler passes for service configuration, and adapters for Symfony-specific components like security token storage and request stack. It handles the complex integration between Symfony's service container and Doctrine's event system, allowing developers to easily configure and use Doctrine extensions in their Symfony projects.
Threema Android is a secure messaging application with end-to-end encryption using NaCl/libsodium. It features a modular architecture following clean architecture principles with separation into app, domain, data, and common layers. The app uses MVVM with ViewModels and StateFlow/LiveData, dependency injection via Koin, and Kotlin coroutines for asynchronous operations. Key functionality includes text/media messaging, voice/video calls, group chats, polls, contact management, backup/restore, multi-device synchronization, and availability status indicators. The application supports multiple build variants for different distribution channels (Google Play, Huawei AppGallery, F-Droid, Threema Shop) and includes enterprise features for business users. It relies on SQLCipher for encrypted local storage, implements custom CSP/D2M protocols for server communication, and provides web client functionality for desktop access.
Splat is a cross-platform .NET utility library that provides a lean abstraction layer for dependency injection (service location), logging, bitmap loading, color handling, and application performance monitoring. It is part of the ReactiveUI ecosystem and is designed to work across .NET Framework, .NET Core, Xamarin, and modern .NET (including NativeAOT). The library offers multiple DI container adapters (Autofac, DryIoc, Ninject, SimpleInjector, Microsoft.Extensions.DependencyInjection), logging backends (Serilog, NLog, Log4Net, Microsoft.Extensions.Logging, Exceptionless), and bitmap loaders (SkiaSharp, WPF, Android native, Cocoa). The core service location includes several resolver implementations with different performance characteristics, including a modern lock-free generic-first resolver optimized for AOT. The logging abstraction supports allocation-free typed arguments and composable wrappers. While the library is well-tested and actively maintained, some adapter packages are marked as alpha/prototype and a few components rely on reflection or platform-specific code that may drift.
Framefox is a full-stack Python web framework built on FastAPI and SQLModel, designed for building modern web applications with a focus on developer productivity. It follows an MVC architecture with clean separation of concerns, featuring a robust dependency injection container, comprehensive security system (including JWT, OAuth, CSRF protection, and brute force prevention), form handling and validation, session management, and a powerful CLI for code generation. The framework includes built-in profiling and debugging tools, task queuing capabilities, and email services. Its architecture emphasizes SOLID principles, with well-defined layers for controllers, services, repositories, and entities, making it suitable for both traditional web applications and API-driven projects.
BookWith is a next-generation e-reader application that enhances traditional book reading with AI capabilities. The system allows users to upload and read EPUB books, annotate text, interact with an AI chatbot for contextual questions about the content, and generate AI-powered podcasts from book material. The architecture follows a client-server model with a Next.js/React frontend and a FastAPI/Python backend, employing domain-driven design principles. Key features include a multi-layer memory system for maintaining conversation context, semantic search via Weaviate vector database, and integration with external AI services like Gemini and Google Cloud Text-to-Speech. The frontend uses modern React patterns with Zustand/Jotai for state management, Tailwind CSS for styling, and shadcn/ui-inspired components. The backend utilizes PostgreSQL for relational data, implements clean architecture with separate domain/application/infrastructure layers, and provides a well-structured API with automatic OpenAPI schema generation.
summer-rs is a Rust application framework inspired by Spring Boot, built on top of Axum. It provides a comprehensive plugin system for web servers, scheduled jobs, stream processing, gRPC, database access, messaging, and observability. The framework uses procedural macros for declarative routing, dependency injection, component registration, and configuration. It features automatic route discovery via the `inventory` crate, TOML-based configuration with environment variable interpolation, and a modular architecture with over 16 official plugins. The codebase is actively maintained, with examples covering common use cases and a documentation site.
Goravel is a full-featured web application framework for Go that follows Laravel-inspired patterns and conventions. It provides a comprehensive set of tools for building web applications including HTTP routing, controllers, middleware, ORM, authentication, authorization, caching, queues, events, scheduling, and more. The framework uses a service container with facade pattern for easy access to services while maintaining testability, and employs service providers for modular bootstrapping of application components. The architecture is modular monolith with clear separation of concerns: application logic in app/, configuration in config/, routes in routes/, database migrations in database/migrations/, and tests in tests/. Entry points include main.go for application startup and artisan for CLI commands. The framework integrates with popular Go libraries like Gin for HTTP routing, GORM for ORM, and OpenTelemetry for observability.
FoalTS is a full-featured Node.js/TypeScript web framework structured as a monorepo with modular packages (core, CLI, JWT, TypeORM, GraphQL, storage, social auth, etc.). The framework provides declarative routing via decorators, a hook system for middleware/validation/authorization, dependency injection, and built-in support for OpenAPI, GraphQL, WebSockets, and file storage. Under the hood it uses Express, AJV, and TypeORM, with session stores for Redis, MongoDB, and SQL databases. The CLI generates projects, controllers, entities, and REST APIs, and includes upgrade commands across major versions. The codebase demonstrates solid engineering: thorough unit/e2e tests (over 2100 tests), documentation-as-tests, and a consistent pattern of abstract services (Store, Disk, Logger) resolved via configuration. Key reusable patterns include the hook/decorator system for validation and authentication, the abstract OAuth2 provider base class, and the CLI generator template engine. However, some deprecations (e.g., hashPassword→PasswordService) and outdated Docker images in development config indicate moderate technical drift. The project is actively maintained with frequent releases, daily CI on Node 22/24, and a well-documented upgrade path.