Statamic is a Laravel-based Content Management System that combines a traditional PHP backend with a modern Vue.js frontend powered by Inertia.js. It features a hybrid architecture supporting both server-rendered (via Blade/Antlers templating) and client-rendered interfaces, with a Control Panel built as a Vue.js SPA-like experience. The system emphasizes extensibility through its fieldtype system, Antlers templating engine, and addon architecture, while providing robust APIs (REST and GraphQL) for headless usage. Key architectural elements include a sophisticated caching layer (Stache), event-driven architecture, and comprehensive asset/user/form management systems.
shadcn/ui is a React component library and CLI tool that provides beautifully designed, copy-paste UI components for building modern web applications. The repository is a monorepo containing a Next.js documentation site (apps/v4) that showcases hundreds of components, examples, blocks, and a design system customizer, along with a CLI package (packages/shadcn) for scaffolding components into user projects. The architecture is organized around multiple style bases (React Aria, Base UI, Radix UI) and a registry system that defines components, hooks, utilities, and blocks as typed JSON items. Key entry points include the CLI commands (add, init, build, migrate, search, view) and the Next.js app routes for documentation, examples, blocks, charts, and the interactive design system creator. External dependencies include React, Tailwind CSS, various UI primitives (react-aria-components, @base-ui/react, @radix-ui/react-*), Recharts for charts, next-themes for dark mode, and several icon libraries (lucide, tabler, hugeicons, phosphor, remixicon). Data flows involve fetching registry items from a remote or local source, transforming them (import rewriting, CSS variable injection, RTL adaptation), and adding them to the user's project. The design system customizer encodes configuration into compact base62 preset codes that can be shared and applied.
This is the core source code of the Laravel framework, a full-stack web application framework for PHP. It provides a comprehensive set of components including routing, an ORM (Eloquent), caching, queue management, mail, notifications, authentication, session handling, validation, and a command-line interface (Artisan). The architecture is modular, organized as a monorepo with each major subsystem in its own namespace under src/Illuminate. Key entry points are the HTTP kernel (src/Illuminate/Foundation/Http/Kernel.php), the console kernel (src/Illuminate/Foundation/Console/Kernel.php), and the Application class (src/Illuminate/Foundation/Application.php). Data flows through a request lifecycle: incoming HTTP request is handled by middleware, routed to a controller, which interacts with Eloquent models and returns a response. Queues and events provide asynchronous processing. External dependencies include Symfony components (HttpFoundation, Console, Process, VarDumper), PHP extensions (PDO, Redis, etc.), and optional cloud services (AWS S3, DynamoDB, etc.). The framework emphasizes testability with extensive integration tests and fakes.
Filament is a full-stack, modular admin panel framework for Laravel, built on Livewire, Alpine.js, and Tailwind CSS. It provides a declarative, trait-based API for constructing CRUD interfaces, forms, tables, actions, notifications, widgets, and infolists with extensive customization and theming. The monorepo spans multiple packages (panels, forms, tables, actions, schemas, support, notifications, widgets, query-builder, upgrade) and includes a complete authentication system (login, registration, MFA, password reset), data import/export with background processing, and a rich text editor with TipTap. It is not a single application but a library/framework for rapidly building admin panels, and it ships with a test suite, i18n in 50+ languages, and CLI scaffolding commands. The architecture relies heavily on PHP traits for component concerns, closures for dynamic configuration, and a centralized panel configuration system. Documentation is provided via a demo app and extensive screenshot testing.
This is a mature, well-crafted Laravel package that provides a server-side processing engine for jQuery DataTables. It translates DataTables AJAX requests (search, sort, paginate) into efficient database queries using Eloquent ORM, the Query Builder, or in-memory Collections. The architecture is clean: a factory (`DataTables`) selects the appropriate engine (`EloquentDataTable`, `QueryDataTable`, `CollectionDataTable`, `PaginatorDataTable`, `ApiResourceDataTable`) based on the input source. Each engine extends `DataTableAbstract`, which orchestrates the full lifecycle: count, filter, order, paginate, and transform results into the JSON format expected by DataTables. The package demonstrates strong software engineering practices: dependency injection, macroable traits, extensive test coverage (integration and unit), and defense-in-depth against SQL injection via column name validation. It is actively maintained with frequent releases and a responsive issue tracker.
This is a PHP library for Laravel that provides a fluent API to build Eloquent queries from HTTP request query parameters, enabling filtering, sorting, including relationships, and selecting fields. It is implemented as a wrapper around Laravel's Eloquent Builder, parsing query string parameters like 'filter', 'sort', 'include', and 'fields' to dynamically modify the underlying query. The architecture consists of a central QueryBuilder class that delegates to specialized concerns (FiltersQuery, SortsQuery, AddsIncludesToQuery, AddsFieldsToQuery) and uses a set of pluggable filter, sort, and include implementations that implement defined interfaces. External dependencies are limited to Laravel's illuminate packages and spatie/laravel-package-tools. The library is widely used and well-tested, with extensive documentation.
Monica is an open source personal relationship management system (PRM) built with Laravel and Vue.js that functions as a 'CRM for your friends and family'. The system features comprehensive contact management, relationship tracking, activity logging (notes, calls, tasks), life event tracking, document management, and journaling capabilities. It implements a modular domain-driven architecture with clear separation between backend services, view helpers for data preparation, and frontend components. The application includes CardDAV synchronization for external contact sync, multi-vault/user support, notification systems (email/Telegram), reporting features, and extensive internationalization (27+ languages). Built with modern Laravel practices including service contracts, queueable jobs, event-driven architecture, and comprehensive testing.
This repository is a Laravel package that provides comprehensive geographical data (countries, states, cities, timezones, currencies, languages) and IP geolocation functionality. It implements a facade-based interface (`World::countries()`) and RESTful API endpoints (`/api/countries`, etc.) for accessing the data, which is stored in JSON files and seeded into database tables via Artisan commands. The package includes localization support for over 20 languages, configurable modules, caching mechanisms, and middleware for automatic locale and geolocation handling. The architecture follows Laravel conventions with service providers, controllers, models, migrations, and seeders, while employing an Action pattern to separate query logic, transformation, and business rules.
This repository is a Laravel-specific wrapper library for the core Spatie Menu package. Its primary function is to provide a fluent PHP interface for generating HTML navigation menus within Laravel applications. It extends the base menu functionality by integrating Laravel's routing system, URL generation helpers, Blade view rendering, and the Gate authorization system. The architecture follows standard Laravel package conventions, utilizing a Service Provider for IoC binding and a Facade for static access. The system operates by accepting route names, controller actions, or raw URLs as input, processing them through Laravel's routing and URL helpers, and outputting rendered HTML strings. It handles edge cases such as active state detection based on the current request URL and conditional rendering based on user permissions. The codebase is tightly coupled to the Laravel ecosystem (illuminate/* packages) but maintains a clean separation between the core menu logic (in the spatie/menu dependency) and the Laravel-specific glue code. Maintenance is evidenced by recent commits and a changelog tracking support for Laravel versions 8 through 13, indicating active adaptation to framework updates. The codebase enforces strict coding standards via PHP CS Fixer and utilizes Pest for testing, ensuring consistency and reliability. It is a high-quality utility library designed for reuse in any Laravel project requiring dynamic navigation menus.
This is a Laravel package that provides a simple, flexible way to define and render breadcrumbs in Laravel applications. It allows developers to define breadcrumb trails using closures in a dedicated file (routes/breadcrumbs.php by default), supporting parent-child relationships, route-bound breadcrumbs, custom data, before/after callbacks, and macros. The package generates a collection of breadcrumb objects and renders them using Blade views, with built-in templates for Bootstrap 4/5, Bulma, Foundation 6, JSON-LD structured data, Materialize, Tailwind CSS, and UIkit. The architecture consists of a Manager singleton that orchestrates registration and rendering, a Generator class that recursively builds the breadcrumb trail by calling user-defined closures, and a Facade for convenient access. The codebase is well-structured, thoroughly tested (30+ test files), and includes helpful exception handling with Laravel Ignition solutions. It is actively maintained and supports Laravel 10 through 13 with PHP 8.1+.
SheafUI is a UI component library designed for Laravel applications built with the TALL stack (Tailwind CSS, Alpine.js, Livewire, and Laravel Blade). It provides over 60 reusable components that developers can install via a CLI command and then fully own and customize. The components follow a copy-paste philosophy, meaning once installed, they are part of the project and can be modified freely. The library emphasizes developer experience, consistency, and flexibility, with each component documented and designed to work seamlessly with Laravel's ecosystem. The architecture is a collection of independent Blade components, each encapsulated in its own directory with its own Blade templates, configuration, and documentation. Key patterns include a global modal state management system using Alpine.js, a responsive layout system with persistent sidebar state, and extensible form inputs using Blade slots for prefixes, suffixes, and actions. The repository is actively maintained with recent commits and shows low technical drift, indicating it keeps pace with its dependencies.
ProjectSend is a self-hosted secure file sharing platform built as a modular Laravel application with an Inertia.js + React frontend. The codebase is organized into domain modules — Files, Clients, Groups, Identity, Comments, Notifications, Audit, Platform, and Api — each containing controllers, services, policies, models, and event hooks. Staff members upload and share files with clients or groups, manage roles and permissions, enforce download limits, expire or version files, and monitor activity through a detailed audit log. Clients access their own portal with four switchable themes (default, compact, drive, gallery), and public share links support additional presentation themes with pagination, previews, and controlled downloads. The application is a monolith with strong modular boundaries rather than microservices. Authentication supports local accounts, LDAP, social login/SSO via OIDC, two-factor authentication, CAPTCHA, and password policies. A REST API protected by Sanctum tokens offers scoped abilities, RFC 7807 problem details, polling-based pagination, and an OpenAPI contract that is drift-tested against the live route surface. Background jobs handle zip downloads, email digests, thumbnails, file cleanup, and scheduled maintenance. The system persists settings, activity logs, notification preferences, and upload metadata in a relational database, while file payloads can be stored on local disks, S3-compatible storage, or Google Cloud Storage. The code is notably security-conscious: secrets are encrypted at rest, old input flashing excludes credentials, CSRF cookie naming is customized to avoid collisions, download paths are never exposed in API responses, and regression tests cover disclosure boundaries, permission scoping, token revocation, and account erasure. The test suite is extensive, using Pest feature tests to exercise permissions, file lifecycle edge cases, version chains, comment visibility, API contracts, and authentication flows. The architecture favors event-based extension points and registry patterns, making modules independently testable and partially reusable, though the project remains an application rather than a framework or library. Overall this is a well-crafted, actively maintained application with clean engineering practices, clear separation of concerns, and unusually thorough security regression coverage. Its main complexity is the large surface area of interchangeable themes, editions, authentication backends, and storage drivers, which creates some ongoing drift risk, but current CI, recent commits, and dependency management show the project is keeping pace with its ecosystem.
This is a production Laravel application that powers the real-time office dashboard at Spatie (dashboard.spatie.be). It displays a rotating set of screens on a wall-mounted TV, showing team member statuses, GitHub/Packagist statistics, climate data, cookie club ratings, now-playing music, Officient calendar attendance, Oh Dear uptime alerts, and product analytics from Fathom. The architecture is a monolith built on Laravel 12 with Livewire 4 for reactive components, Tailwind CSS 4 for styling, and Pusher/WebSockets for real-time updates. Key entry points are the main dashboard route (/) and webhook endpoints for now-playing songs and Oh Dear alerts. Data flows from external APIs (Fathom, GitHub, Packagist, Slack, Officient, Apple Music, Last.fm, climate sensors, Cookie Club) into database-backed tile stores, which are polled by Livewire components. The system includes a screen scheduler with conditional visibility, a weekplanning overlay, and a deploy-status endpoint for automatic page reloads. The codebase is well-structured, follows Laravel conventions, and includes comprehensive tests. While the dashboard is tailored to Spatie's internal use, many components (Fathom analytics service, forecast calculator, path normalizer, screen availability checker, weekplanning logic) are cleanly abstracted and could be reused in other dashboard or analytics projects.
This is a Laravel package that monitors scheduled tasks by logging their start, finish, failure, and skip events to a database table. It provides three Artisan commands: `schedule-monitor:sync` to register tasks from the scheduler into a `monitored_scheduled_tasks` table, `schedule-monitor:list` to display their status with visual indicators for late or failed runs, and `schedule-monitor:verify` to check connectivity with the Oh Dear monitoring service. The package integrates deeply with Laravel's scheduling system through event subscribers (`ScheduledTaskEventSubscriber`, `BackgroundCommandListener`) that listen to core scheduler events and update the database accordingly. It also optionally syncs tasks with Oh Dear, pinging external endpoints on task start, finish, or failure, using a queued job (`PingOhDearJob`) with configurable retry logic and custom job support. The architecture is clean and follows Laravel package conventions: a service provider registers macros on scheduler events, configurable model bindings allow custom model classes, and a singleton (`MonitoredScheduledTasks`) stores per-task monitoring configurations (like custom names, grace times, and opt-out flags) using an in-memory array keyed by object hash. While the package is tightly coupled to Laravel's console scheduler and cannot be extracted as a standalone library, its internal patterns—such as the polymorphic `Task` hierarchy (CommandTask, JobTask, ClosureTask, ShellTask) and the `Payload` strategy for building Oh Dear ping data—demonstrate strong software design.
Laravel Visits is a Laravel package that provides visit tracking functionality for Eloquent models. It implements a counter system with IP-based deduplication, period-based tracking (day, week, month, year), and visitor metadata collection (country, referrer, OS, language). The architecture features a pluggable data engine abstraction supporting both Redis and Eloquent/database storage, with traits separating concerns like listing, period handling, recording, and setting configuration. The package integrates with Laravel via a service provider and offers a simple helper function for accessing visit tracking capabilities on any model.
Bagisto is a production-ready open-source eCommerce platform built on Laravel with a modular monolith architecture. It provides a complete admin panel and storefront for managing multi-channel, multi-locale, multi-currency online stores. The system supports a wide range of product types (simple, configurable, bundle, grouped, downloadable, virtual, booking), payment gateways (Stripe, PayPal, Razorpay, PayU, PhonePe, PayGlocal), marketing promotions (cart rules, catalog rules), full-page caching, Elasticsearch integration, GDPR compliance, EU withdrawal management, RMA (returns), data import/export, and AI-powered features (MagicAI). The architecture is event-driven with listeners for cache invalidation, notifications, and indexing. The admin panel uses Vue 3 components with Blade templates, while the storefront is built with Tailwind CSS and Vue. The codebase is organized into ~40+ packages under packages/Webkul/, each with its own models, repositories, migrations, translations, and tests. Key entry points include the admin routes (packages/Webkul/Admin/src/Routes/web.php), shop routes (packages/Webkul/Shop/src/Routes/), and the installer wizard. The system relies on MySQL, Redis, Elasticsearch, and various external payment/shipping APIs. The core framework (Concord) provides facades for core services, ACL, menu, system config, and Elasticsearch. The DataGrid system offers a reusable abstraction for listing and filtering entities across the admin panel. Notable engineering highlights include the CurrencyFormatter trait for locale-aware currency display, the MediaFileName helper for safe file upload handling, the ForgetsPages trait for full-page cache invalidation, and the DynamicMailTransport for configurable email delivery. The event-driven architecture with listeners and the repository pattern are consistently applied across all modules.
solidtime is an open-source time tracking application designed for freelancers and agencies. It provides a full-stack solution with a PHP backend (using a custom Laravel-like framework with strict typing) and a Vue 3 frontend served via Inertia.js. The system supports multi-tenant organizations with role-based permissions (Owner, Admin, Employee, Placeholder), project and task management, client and tag tracking, billable rates, goals, and detailed reporting with export to CSV, PDF, ODS, and XLSX. It also includes importers for Toggl, Clockify, Harvest, and generic CSV formats, as well as a native solidtime format. The architecture is a monolith with a RESTful API (versioned under /api/v1) and web controllers driven by Inertia.js. The backend uses a custom PHP framework that resembles Laravel but employs non-standard syntax (declare strict_types, use traits, fn closures). Key entry points include API controllers for time entries, projects, clients, tags, goals, reports, and import/export; console commands for administrative tasks, telemetry, and database consistency checks; and a Filament admin panel for CRUD operations. The frontend is built with Vue 3, Pinia stores, TanStack Query for caching, and a shared UI component library (packages/ui) that provides reusable primitives like dialogs, selects, calendars, and context menus. Data flows center around time entries, which are created via a timer or manual entry, associated with projects, tasks, clients, and tags, and aggregated for reporting and goal tracking. The system uses PostgreSQL as its primary database, with Redis for caching and queueing. External dependencies include a mail driver (Mailpit in dev), storage drivers (local/S3), and optional services like Gotenberg for PDF rendering and Paddle for subscriptions. The codebase is extensively tested with PHPUnit (unit/feature), Vitest (JS unit), and Playwright (E2E), and includes CI/CD pipelines for building, linting, and testing.
Xboard is a production-grade proxy/VPN subscription management panel built on Laravel 11/12 with Octane (Swoole) for high performance. It manages the full lifecycle of proxy service subscriptions: user registration and authentication, plan selection, order processing with coupon and gift card support, payment integration via a plugin system (Alipay, BTCPay, Coinbase, etc.), and real-time node synchronization through a Workerman WebSocket server. The system generates subscription configurations for multiple client applications (Clash, Surge, Loon, Shadowrocket, SingBox, etc.) using a pluggable protocol abstraction layer. It includes an admin panel with full CRUD for servers, users, orders, tickets, and statistics, plus a Telegram bot plugin for user self-service. The architecture follows Laravel best practices with service classes, form request validation, queue jobs (Horizon), Redis caching, and a custom plugin system that supports both payment gateways and feature extensions. The codebase is well-structured with clean abstractions, though it has a large migration history and some Chinese comments. The project is in limited new feature development mode but actively maintained for critical fixes and security updates.
Collision is a PHP library that provides beautiful error reporting for CLI applications, particularly integrated with Laravel, PHPUnit, and Pest. It wraps the Whoops error handler to render exceptions with syntax-highlighted code snippets, stack traces, and solution suggestions. Additionally, it includes a custom PHPUnit/Pest test printer that outputs test results with color-coded summaries, warnings, and slow-test profiling. The library is built on top of Symfony Console, Termwind, and Whoops, and is designed as a drop-in replacement for default error handling in Laravel's artisan commands and PHPUnit test runners. The codebase is well-structured with clear separation of concerns: core error rendering (Provider, Handler, Writer), terminal styling (ConsoleColor, Highlighter), argument formatting (ArgumentFormatter), code coverage reporting (Coverage), and framework-specific adapters (Laravel service provider, PHPUnit event subscribers). The PHPUnit adapter demonstrates advanced event-driven architecture by hooking into PHPUnit's event system to produce a rich, compact test output.
This repository is a Laravel package (library) that extends the native Illuminate\Support\Collection with over 50 additional macros, such as `chunkBy`, `transpose`, `validate`, `weightedRandom`, and a `try`/`catch` proxy. It is built and maintained by Spatie and is one of the most popular collection macro libraries in the Laravel ecosystem. The architecture is straightforward: a service provider (`CollectionMacroServiceProvider`) registers each macro as a closure on the Collection class at boot time. Each macro is defined as a separate invokable class in the `src/Macros/` directory, making the codebase modular and easy to test. There is no persistent state, database, or external service integration; the package operates purely in-memory on Collection objects. The primary entry point is the service provider auto-discovered by Laravel's package discovery. External dependencies are minimal (`illuminate/support` for the base Collection class, and optionally `amphp/parallel-functions` for the `parallelMap` macro). The code exhibits high craftsmanship: macros are concise, well-documented with docblocks, and each has dedicated Pest tests. Notable patterns include the `CatchableCollectionProxy` helper, which implements a fluent try/catch mechanism on collections using reflection for exception type matching, and the `WeightedRandom` macro with a clean weighted selection algorithm. The codebase is actively maintained, supporting Laravel 12 and 13 with PHP 8.2-8.5, and shows no signs of technical drift. It is not an application or service; it is a reusable library that can be dropped into any Laravel project to enrich collection operations.