This repository is a modern PHP package skeleton created by Nuno Maduro. It provides a minimal, opinionated starting point for building PHP libraries, featuring a pre-configured toolchain including Laravel Pint for code style, Pest for testing, PHPStan for static analysis, and Rector for automated refactoring. The actual source contains only a placeholder Example class to verify the setup, while the value lies in the well-organized directory structure, Composer scripts, GitHub Actions workflows (testing across OS and dependency versions), and configuration files that enforce high code quality standards. It is designed to be cloned via `composer create-project` and immediately used for new package development. The repo is actively maintained with no open issues, modern dependency versions, and comprehensive CI coverage.
Xibo CMS is a full-stack digital signage content management system that enables users to create, schedule, and manage content displayed on screens. The backend is built with PHP (Slim framework, Symfony EventDispatcher, Phinx migrations) and exposes RESTful APIs consumed by a modern React/TypeScript SPA frontend (Vite, TanStack Query, Tailwind CSS). It supports player communication via XMR (message relay) and legacy SOAP-based XMDS. Key features include layout and playlist management, media library, scheduling with dayparting and recurrence, reporting (proof of play, bandwidth, session history), OAuth2 authentication, multi-tenancy via folders and permissions, and a widget/module system with connectors. The codebase is large and actively maintained, with extensive frontend tests (Vitest) and Docker-based development/deployment. However, it carries some technical debt from a legacy jQuery/Bootstrap UI that coexists with the modern React frontend, and a high volume of database migrations indicates long evolution.
CakePHP 5.x is a full-stack PHP web framework providing an MVC architecture, an ORM with behaviors and associations, a database abstraction layer supporting multiple drivers (MySQL, Postgres, SQLite, SQL Server), a PSR-7 compliant HTTP layer with middleware, a console/CLI framework, caching, internationalization, validation, and a comprehensive test suite. The architecture is highly modular, organized into distinct packages (Container, ORM, Database, Http, Console, etc.) that communicate via interfaces, events, and dependency injection. The codebase demonstrates exceptional craftsmanship in several areas: a composable collection pipeline using iterators (Filter, MapReduce, Tree), a robust and extensible database type system, a clean visitor-pattern-based debug output system, and a fluent filesystem traversal API. These components are self-contained and highly reusable. However, the codebase has a critical technical drift issue: it relies on a non-standard PHP syntax (e.g., `declare(strict_types=1)`, `use` for traits, `fn` closures, `match` expressions) that requires a transpiler. This creates a significant barrier to contribution, standard tooling compatibility, and long-term maintainability within the PHP ecosystem. Despite this, the underlying architecture and reusable components are of high quality.
This repository is a PHP 5.x polyfill library that provides implementations of the `random_bytes()` and `random_int()` cryptographic functions introduced in PHP 7. The library implements a fallback chain of secure random sources: libsodium extension, /dev/urandom (Unix), mcrypt_create_iv(), and CAPICOM (Windows). It throws exceptions when no secure random source is available rather than falling back to insecure alternatives. The library features modular implementation with separate files for each random source, along with utility functions for mbstring.func_overload-safe string operations and safe integer casting. It includes comprehensive unit tests and maintains compatibility with PHP versions from 5.2 through current versions by disabling itself on PHP 7.0+.
Expose is a command-line tunneling tool written in PHP using the Laravel Zero micro-framework and ReactPHP for asynchronous networking. It acts as an ngrok alternative, allowing developers to expose local HTTP servers and TCP ports to the public internet via a remote server. The application includes a CLI client for sharing sites, a local web dashboard (port 4040) for inspecting requests/responses, and a plugin system for analyzing webhook payloads (e.g., GitHub, Stripe, Paddle). The architecture is a monolith structured around a ReactPHP event loop: the client establishes a WebSocket control connection to the Expose server, authenticates, then creates proxy connections that forward incoming HTTP requests from the server to the local application. The local dashboard is served by an embedded HTTP server and uses a Vue 3 frontend with real-time WebSocket updates. The codebase demonstrates strong craftsmanship in areas like the plugin system, magic authentication flow, and custom terminal output handling, though some components are tightly coupled and the dependency on forked ReactPHP packages introduces moderate technical drift.
SPFtoolbox is a web application for performing DNS and WHOIS lookups. It provides a user-friendly interface to query various DNS record types (A, AAAA, MX, TXT, SPF, DMARC, etc.), check blacklists, verify port connectivity, perform reverse DNS lookups, and retrieve WHOIS information. The application consists of a PHP backend that handles the lookup operations and a JavaScript frontend that manages the user interface and AJAX requests. The backend uses PHP's built-in DNS functions and integrates the phpWhois library for WHOIS queries.
Contributte Datagrid is a mature, full-featured datagrid component for the Nette PHP framework. It provides a rich set of features including filtering, sorting, pagination, inline editing, tree view, CSV export, column hiding, group actions, and aggregation functions. The component is split into a PHP backend (Nette control) and a TypeScript frontend with a plugin-based architecture (Naja AJAX, Bootstrap 5, TomSelect, SortableJS). It abstracts data sources via the IDataSource interface, with implementations for arrays, Dibi, Nette Database, Doctrine ORM/Collections, Nextras ORM, Elasticsearch, and custom API endpoints. State persistence is pluggable through IStateStorage. The library is production-ready, actively maintained with a clear changelog and upgrade guides, but shows some technical debt with long methods, static properties, and deprecated methods. It is not a data research or analytics project; it is a reusable UI component for web applications.
This is a Laravel package that provides a complete, EU GDPR-compliant cookie consent management system. It allows developers to register cookies under predefined or custom categories (essential, analytics, optional), define cookie descriptions, durations, and consent callbacks. The package includes Blade directives and a Facade for easy integration into Laravel views and controllers, as well as a JavaScript library for enhanced UX with AJAX-based consent handling. The architecture is a typical Laravel package: service provider, routes, controllers, views, translations, and a compiled assets pipeline. The backend handles cookie registration, consent storage (via a cookie), and response generation (scripts, cookies). The frontend provides a customizable notice modal with toggleable details and buttons. The package is well-structured with clear separation of concerns using traits for shared functionality (attributes, callbacks, translations, cookie collections). It supports multiple languages and allows full customization of views, styles, and scripts. The codebase is actively maintained, supports Laravel 9-13, and includes a comprehensive test suite.
Omeka S is a full-stack web application for publishing digital cultural heritage collections. Built on the Laminas (Zend) MVC framework with Doctrine ORM, it provides a comprehensive admin interface for managing items, media, item sets, vocabularies, and sites, along with a RESTful JSON-LD API. The system supports linked data (RDF/OWL), IIIF viewers, full-text search, and a plugin/theme architecture for extensibility. It is a mature, well-structured codebase with clear separation of concerns (MVC, adapters, representations, services) but shows signs of technical drift from its Laminas foundation and outdated frontend dependencies like jQuery and CKEditor 4.
AtoM (Access to Memory) is a mature, open-source web application for archival description and access, developed by Artefactual Systems. In production, it manages hierarchical archival descriptions (fonds, series, files, items), authority records, repositories, digital objects, and accessions. It supports multiple archival standards (EAD, EAC, MODS, METS, Dublin Core) and provides multilingual, multi-repository archival description. The application is built on PHP 7/8 with a Symfony 1.x core, Propel ORM for persistence, and Elasticsearch for search indexing, with MySQL/MariaDB as the primary datastore and Gearman for background job processing.
CRMEB is a full-featured open-source e-commerce platform built on ThinkPHP 6 (PHP backend) with separate admin, API, customer service, and external API endpoints. The backend serves a Vue 2 + Element UI admin SPA and a uni-app mobile client for WeChat Mini Programs, H5, and apps. It provides standard e-commerce operations (product, order, user, finance management) along with extensive marketing modules (group buying, flash sales, bargaining, coupons, points, live streaming, lottery, agent/distribution), a DIY page builder, and deep WeChat ecosystem integration (official accounts, mini programs, payment, templates, live). The architecture follows a layered pattern: controllers delegate to services, which use DAOs for data access, with models as ActiveRecord classes. The system includes an event system, asynchronous queue jobs, and WebSocket support via Workerman for real-time notifications. It also features a code generation tool (CRUD) to rapidly scaffold admin modules. While the codebase is large and functional, it contains significant boilerplate, duplicated patterns, and some messy code (e.g., repeated conditions in DAO methods). Reusable components include payment, upload, and SMS abstraction layers following a driver/manager pattern, as well as a queue utility and JWT authentication trait.
mPDF is a mature, feature-rich PHP library for generating PDF documents directly from HTML+CSS input. It operates as a standalone library, instantiated programmatically (e.g., `new \Mpdf\Mpdf()`) and fed HTML strings via `WriteHTML()`. Its architecture is modular, featuring a service container (`ServiceFactory`), a CSS engine (`CssManager`, `CssParser`, `CssMerger`), a tag dispatching system (`Tag.php`, `src/Tag/*`), and a suite of PDF output writers (`Writer/*`). It supports a vast array of PDF features including barcodes, forms, watermarks, tables of contents, bookmarks, PDF/A compliance, encryption, and complex script shaping (Indic, Myanmar, SE Asian). The primary data flow is HTML string -> CSS Parsing -> HTML Tag Processing -> PDF Object Generation -> Output. It relies on external dependencies like FPDI for PDF page import, and optionally GD library for image processing. It includes extensive static data for font metrics, hyphenation patterns (dozens of languages), Unicode character properties, and color names. The library handles local and remote asset fetching (images, CSS, fonts) with configurable security restrictions. **Critical Assessment:** This codebase has a critical, non-obvious flaw: it uses a non-standard PHP dialect. Method signatures use `&$ahtml` (pass-by-reference) and `use Strict;` which are not valid PHP. This means the code cannot be parsed or analyzed by standard PHP tools (IDEs, static analyzers, linters) without a custom preprocessor. The README explicitly acknowledges the library is 'quite dated' and that modern CSS features will not be implemented. The Unicode character database is based on Unicode 6.2.0 (from 2012), which is significantly outdated. While functionally powerful and well-tested for its specific domain, the codebase represents a significant technical liability for any team looking to maintain or extend it. It is best suited for straightforward HTML-to-PDF conversion tasks where its extensive feature set is required, but it should be treated as a black box due to the difficulty of safely modifying its internals.
This repository provides Docker images for Laravel development and CI/CD, with PHP versions 8.3, 8.4, and 8.5. The core artifacts are multi-architecture Dockerfiles that extend official PHP-alpine base images and install a curated set of extensions (Redis, Imagick, Xdebug, etc.) and tools (Composer, Node.js, Yarn, PHP_CodeSniffer, Git, rsync). A GitHub Actions workflow rebuilds images weekly, caching and pushing to DockerHub and GitHub Container Registry. The repo also includes example GitLab CI templates for deploying Laravel applications. It is not a library or framework but a published Docker image build repository, and its main value is providing a standard, pre-configured environment for Laravel projects.
Totum is a self-hosted, low-code/no-code application framework built on PHP 8.3 and PostgreSQL. It functions as a dynamic database and spreadsheet hybrid, allowing users to define data structures (tables, fields) via JSON configuration and implement business logic using a proprietary DSL ('Totum-code'). The system features a modular architecture with a CLI management tool (`bin/totum`), a web-based UI (`http/index.php`), and extensive role-based access control (RBAC). It supports multi-tenancy via schema mapping, external service integration (PDF, Excel, AI), and automated installation via Ansible playbooks for Ubuntu environments. The core logic relies heavily on traits for shared functionality and abstract base classes for table and field handling, creating a flexible but complex codebase. The application is designed for rapid business application construction (CRM, ERP, custom tools) without requiring traditional coding. It stores schema definitions and field configurations in PostgreSQL JSONB columns, enabling runtime structure modification. The calculation engine (`Calculate.php`) parses and executes custom code strings for data validation, formatting, and cross-table logic. While the architecture is robust for its intended purpose, it exhibits signs of technical debt including monolithic frontend JavaScript (`main.js`), hardcoded paths in installation scripts, and reliance on legacy libraries (Chart.js v2, jQuery). The codebase demonstrates significant craftsmanship in its dynamic table engine and calculation DSL, but maintenance requires careful handling of the custom parsing logic and schema migrations.
PHP The Right Way is a static documentation website built with Jekyll, providing authoritative best-practice guidance for PHP developers. The repository contains markdown content files organized into chapters and sub-chapters, a set of Jekyll layouts and includes for rendering, and CSS/LESS stylesheets for presentation. It is not a software application or data pipeline—it is a content-driven site that is compiled into static HTML and hosted on GitHub Pages. The architecture is straightforward: Jekyll processes markdown posts through Liquid templates to produce a multi-page reference guide. There are no runtime PHP scripts, APIs, or executable components; all PHP code examples within the markdown are illustrative snippets for pedagogical purposes.
This repository is a lightweight PHP CLI tool that converts ad-blocking filter lists (primarily from AdGuard's CNAME tracker research and EasyPrivacy) into HOSTS-format blocklists. The core script, converter.php, fetches upstream lists from hardcoded URLs, parses domain entries, and outputs files containing '0.0.0.0 <domain>' lines. The generated .txt files (e.g., AdguardMobileAds.txt, EasyPrivacy3rdParty.txt) are committed to the repository and meant to be consumed by HOSTS-file-based ad blockers on mobile devices. The architecture is intentionally minimal: a single PHP script handles conversion, a shell script (.check.sh) automates periodic updates by committing only when the diff is exactly one line, and a GitHub Actions workflow (php.yml) runs the converter on a schedule. The tool is designed for manual or scheduled regeneration, not as a live service. It relies on upstream AdGuard lists, which introduces a maintenance risk if those sources change format or disappear. The repository is a hybrid of application code and generated data artifacts, but the dominant character is a small utility application. The converter is generic enough to accept custom list names and URLs, making it reusable for other filter-list-to-hosts conversions. However, the conversion is lossy—many filter options (e.g., $domain, $third-party, $redirect) are ignored—and there are no tests or CI validation for the converter logic. The project is functional for its niche but shows signs of technical drift and brittle upstream coupling.
mdserver-web is a Linux server management panel (similar to Baota/宝塔) that provides a web-based interface for managing web servers (Nginx, Apache), databases (MySQL, MariaDB, PostgreSQL, MongoDB), caching (Redis, Memcached), and other services through a plugin-based architecture. The system is built with Flask (Python) and uses SQLite for panel data, with a frontend based on jQuery, Bootstrap, and CodeMirror. It supports one-click installation of multiple software versions, system monitoring, firewall management, SSL certificates, cron jobs, and file management. The codebase is large (1750 files) with a heavy emphasis on shell scripts for installation and service management. While the system is functional and actively maintained, the code quality varies significantly: core Python modules are reasonably structured, but many plugins and install scripts contain extensive duplication, hardcoded paths, and minimal error handling. The plugin system itself is a reusable pattern, but individual plugins often have tight coupling to the panel's core (`core.mw`). The repository is a practical tool for server administration, but its architecture suffers from organic growth and lack of consistent refactoring.
Samarium is a modular, all-in-one business management system (ERP/CMS) built with Laravel 11 and Livewire 3. It provides a comprehensive admin dashboard for small to medium businesses, covering sales invoicing, purchase orders, expense tracking, inventory management, accounting (double-entry ledger, trial balance, income statement), customer/vendor relationship management, and a full content management system (webpages, posts, galleries, navigation menus, themes). It also includes e-commerce capabilities (product catalog, shopping cart, online orders), appointment booking, team management, calendar with Nepali date support, and additional modules like vacancies, testimonials, newsletters, and document/URL link management. The system is configurable via a module toggle in config/app.php and supports both a dashboard interface and a public-facing website. The architecture follows a standard Laravel MVC pattern with Livewire components handling all interactive UI. Each business domain has its own set of Livewire components (e.g., SaleInvoiceEditor, ProductDisplay) that use a shared ModesTrait for state management. A service layer provides pagination and CRUD logic, though many service methods are incomplete. The frontend uses Bootstrap 4, Font Awesome, and Chart.js for reporting. The system is Dockerized for easy deployment and includes seeders for demo data. While the codebase is functional and covers a wide feature set, it exhibits several quality issues: mixed namespaces (some models under App\, others under App\Models\), hardcoded values (VAT 13%, Nepali month arrays), incomplete features (many TODO comments, empty service methods), and code duplication (multiple similar Livewire components for editing fields). The Nepali calendar support is a distinctive feature but requires manual maintenance of hardcoded date ranges. Overall, Samarium is a solid, feature-rich ERP for its target audience but would benefit from refactoring and stricter coding standards.
This is the original Yii framework (version 1.x), a high-performance component-based PHP web framework. The codebase implements a full MVC architecture with ActiveRecord ORM, caching system, internationalization, input validation, logging, and a code generation tool (Gii). It is designed for both web and console applications, with multiple demo applications (blog, hangman, phonebook) showcasing its capabilities. The framework is built around a component/behavior/event system that allows extensibility. However, the code is end-of-life (EOL) as stated in the README, receiving only security and PHP 7/8 compatibility fixes. The codebase shows its age: it uses PHP 5.2-era patterns (no namespaces, var declarations, no type hints), bundles several outdated third-party libraries (HTMLPurifier, Text_Highlighter, Text_Diff), and has a massive collection of auto-generated i18n locale data files. Despite these drawbacks, the core architecture is well-structured and demonstrates solid engineering from its era. It is not recommended for new projects but can serve as a reference for legacy maintenance or for studying the evolution of PHP frameworks.
Vizra ADK is a retired Laravel package (final release v0.0.48) that provides a comprehensive framework for building AI agents with LLM orchestration, tool systems, memory, workflows, evaluations, tracing, and MCP integration. It is not a standalone application but a library designed to be installed into Laravel projects. The architecture follows Laravel package conventions: service providers, facades (Agent, Workflow), Eloquent models, Artisan commands, Livewire components, and database migrations. Key entry points include the Agent facade for running agents, the Workflow facade for orchestrating multi-agent workflows, and a set of CLI generators for scaffolding agents, tools, and evaluations. The system supports multiple LLM providers via Prism PHP, persistent memory (session, user, vector), tool chaining, sub-agent delegation, and an evaluation framework with LLM-as-a-Judge assertions. The codebase is well-structured with strong test coverage (Pest + Mockery), but the package is officially retired with no further development, leading to high technical drift as dependencies age out. Despite retirement, many components (e.g., ToolChain, VersionablePrompts, AgentVectorProxy, HasLogging) are self-contained and demonstrate reusable patterns suitable for extraction into new projects.