webonyx/graphql-php is a comprehensive PHP implementation of the GraphQL specification, serving as a server-side library for parsing, validating, and executing GraphQL queries. It provides a full type system (ObjectType, InterfaceType, UnionType, EnumType, InputObjectType, ScalarType), a recursive-descent parser, an AST visitor infrastructure, a query validator with over 30 validation rules, and a reference executor that mirrors the GraphQL.js implementation. The library also includes a PSR-7-compatible server layer (StandardServer) for handling HTTP requests, along with optional promise adapters for async execution via ReactPHP or Amp. The architecture is library-oriented: clients build schemas programmatically or from SDL via BuildSchema, then execute queries through GraphQL::executeQuery() or the StandardServer. The type system uses lazy initialization (closures/callables) to handle circular references, and a type loader enables deferred schema composition. Notable design patterns include a rich AST visitor with enter/leave operations (including skip, stop, remove, edit), a synchronous promise adapter that enables DataLoader-like batching in synchronous PHP, and a modular validation rule system where each rule is a standalone visitor. The codebase demonstrates high craftsmanship with heavy use of static analysis (PHPStan), extensive unit tests ported from graphql-js, and performance benchmarks. While it is a port of the JavaScript reference implementation, it introduces PHP-idiomatic features such as attribute-based annotations (#[Description], #[Deprecated]) and per-schema scalar overrides.
WordPress Playground is a browser-based WordPress runtime that runs entirely client-side via WebAssembly. It compiles the PHP interpreter (versions 5.2 through 8.5) into WASM using Emscripten, enabling WordPress to execute in the browser without a server. The monorepo is organized into several key packages: php-wasm (PHP-to-WASM compilation toolchain, runtime bindings for Node.js and web, extensions, and Xdebug bridge), playground (blueprint engine, CLI, remote access tunneling, MCP server for AI agents, and a full-featured website application for managing WordPress instances), and docs (Docusaurus-based documentation site). The architecture is a dependency-injected, modular monorepo using Nx for builds and Lerna for publishing. The blueprint system allows declarative configuration of WordPress environments (plugins, themes, content, settings) and supports V1 and V2 schema. The project also includes a sync engine for incremental state persistence, OPFS-based storage, and a CORS proxy for network requests. It is actively maintained with comprehensive CI/CD pipelines and extensive test coverage across Node.js and browser runtimes.
Brick\Money is a high-quality, immutable PHP library for representing monetary values, performing arithmetic, currency conversion, allocation, and locale-aware formatting. It provides exact arithmetic via brick/math, supports multiple contexts (default, cash rounding, custom scale, auto-scale), and includes a rich set of exchange rate providers (configurable, PDO-backed, cached, chained, base-currency derived). The library features a strategy pattern for allocation (five algorithms including Hamilton's method) and cross-currency comparison. It is thoroughly tested, type-safe, and follows modern PHP practices (PHP 8.2+, readonly classes, enums, sealed interfaces). The codebase demonstrates strong software craftsmanship with clean abstractions, immutable value objects, and well-isolated components. It is actively maintained with regular releases and comprehensive documentation.
ZipStream-PHP is a PHP library for dynamically streaming ZIP archives directly to the client or any output stream without writing to disk on the server. It provides a clean API via the `ZipStream` class, which accepts files as strings, paths, streams, PSR-7 streams, or callbacks. The library supports DEFLATE and STORE compression, ZIP64 extensions for large archives, zero-header mode for streaming efficiency, and simulation modes to calculate output size without generating the archive. The architecture is monolithic but well-modularized: the main ZipStream orchestrates file entries, each handled by an internal `File` class, and binary data packing is abstracted through `PackField`. External dependencies are minimal (ext-mbstring, ext-zlib, optional PSR-7 packages), making it lightweight and easy to integrate. The codebase demonstrates strong engineering with comprehensive unit tests, static analysis (Psalm level 1), coding style enforcement, and CI/CD pipelines covering multiple PHP versions and OS platforms. Notable design choices include the use of PHP stream wrappers for custom output (CallbackStreamWrapper) and a simulation mode that enables accurate content-length headers without reading entire streams. Exception classes are well-defined, and the entire public API is fully documented with attributes and inline PHPDoc. The project is actively maintained with frequent commits, up-to-date dependency management, and a clear versioning and support policy.
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.
Mautic is an open-source marketing automation platform built on Symfony (PHP). It provides a comprehensive suite for managing contacts (leads), creating and executing marketing campaigns, sending emails, building forms and landing pages, tracking user interactions, and integrating with third-party CRMs and services. The architecture is a modular monolith with bundles and plugins, a REST API, and a CLI console. Key data flows include contact tracking via tracking pixels and form submissions, campaign execution with scheduled events, email sending with bounce/feedback processing, and integration sync with external systems. External dependencies include MySQL/MariaDB, optional Redis/Memcached caching, a mailer transport, and various third-party APIs for IP geolocation, data enrichment, and social media. The codebase is actively maintained with extensive test coverage, modern PHP practices, and a plugin ecosystem.
PsySH is a production-grade interactive PHP shell, REPL, and runtime debugger. It accepts PHP input from a terminal, validates and rewrites it through a pipeline of PHP-Parser AST passes, evaluates it inside an isolated execution context, and renders results using a custom VarDumper presenter, formatters, and support for paging, themes, clipboard copy, and OSC 8 hyperlinks. It is distributed both as a Composer library and a self-updating PHAR binary, with primary entry points in src/functions.php (sh(), debug(), info(), bin()) and the bin/psysh launcher. The architecture is modular and interface-driven: a central Shell/Configuration core coordinates commands built on Symfony Console, multiple readline backends (GNU, libedit, userland, and a new experimental interactive readline), a completion engine with typed sources and refiners, legacy tab-completion matchers, execution-loop listeners, manual/documentation loaders, and updater strategies for both the PHP manual and PsySH itself. The main data flow is: terminal input -> readline -> code cleaning/validation -> eval -> output; completion and history are layered on top via AST analysis, fuzzy matching, suggestions, and JSONL-backed history persistence. The codebase is unusually thorough for a developer tool: nearly every subsystem has unit and integration tests, CI spans PHP 7.4 through 8.6 plus 32-bit and downstream consumer tests, and static analysis baselines manage compatibility across php-parser 4-5 and Symfony 3.4-7.x. The main weaknesses are the vendored Hoa terminal library, a wide compatibility surface requiring deprecation baselines and version shims, and the complexity of the experimental interactive readline, which creates maintenance risk. Overall this is a high-craft, actively maintained project with several genuinely reusable components.
Imagine is a PHP library for image manipulation providing a unified API over GD, Imagick, and Gmagick extensions. It offers a rich set of features including resizing, cropping, rotating, effects, drawing, filters, color management, metadata reading, and layered image support. The library is well-architected with clean interfaces, abstract base classes, and a factory pattern that allows swapping drivers. It includes extensive test coverage with reusable test infrastructure. While primarily a library, it is a mature, actively maintained solution for PHP image processing.
nette/http is a standalone PHP library providing HTTP abstraction for request/response handling, URL manipulation, session management, and file uploads. It is part of the Nette Framework ecosystem but is usable independently. The library offers immutable `Request` and `UrlImmutable` objects for safe processing, alongside mutable `Response` and `Session` for stateful operations. It includes security-focused features such as input sanitization, CSRF protection via `Sec-Fetch-*` headers (with fallback), SSRF protection via `UrlValidator` and `IPAddress`, and a proxy trust model for client IP resolution behind reverse proxies. The codebase is well-structured, with clear separation of concerns, comprehensive test coverage (Nette Tester), and strict static analysis (PHPStan level 8). It requires PHP 8.3-8.5 and depends on `nette/utils`. The repository is actively maintained with recent commits, CI on multiple OSes, and an issue tracker.
This repository provides a comprehensive shell script (`install-php-extensions`) that automates the installation of PHP extensions in official Docker PHP images (both Alpine and Debian variants). The script handles dependency resolution, version pinning, source-based compilation, and cleanup of build artifacts. It supports over 160 extensions, including those bundled with PHP source, PECL packages, and proprietary agents (New Relic, Blackfire, Datadog). The repo also includes a structured compatibility database (`data/supported-extensions`, `data/dependencies.json`) that tracks extension-to-PHP-version mappings, library version pins, and detection mechanisms. CI workflows automatically test extension installation across a large matrix of PHP versions and distros, and a daily update checker monitors new releases and runs tests, notifying maintainers via Telegram if issues arise. The project is a developer utility, not a service or library, and is distributed as a Docker image and standalone script.
This repository is a Laravel package that provides a server-side processing engine for jQuery DataTables. It handles AJAX requests from DataTables, performing searching, sorting, pagination, and column formatting on data sourced from Eloquent ORM, Query Builder, or in-memory collections. The architecture uses a factory pattern (DataTables class) to select the appropriate engine (EloquentDataTable, QueryDataTable, CollectionDataTable, PaginatorDataTable, ApiResourceDataTable) based on the source type. Each engine extends the abstract DataTableAbstract class, which defines the common workflow: count total records, apply global and column filters, order, paginate, fetch results, process rows (add/edit columns, format), and render a JSON response. The package integrates deeply with Laravel's service container and configuration system, and includes support for eager-loaded relations, complex query counting, and optional full-text search via Laravel Scout. The codebase is well-structured, extensively tested, and follows modern PHP practices.
Neuron AI is a PHP framework for building AI-powered applications with support for multiple large language model providers (OpenAI, Anthropic, Gemini, Mistral, Ollama, AWS Bedrock, etc.), tool integration, structured output, retrieval-augmented generation (RAG), and complex workflow orchestration. It provides a composable agent class that can operate in chat, stream, and structured output modes, a workflow engine with interrupt/resume and persistence, a built-in evaluation framework with LLM-based judges and assertions, and a Model Context Protocol (MCP) client for connecting to external tool servers. The architecture is modular: agents are built on top of workflows, tools are defined via PHP classes with JSON schema generation, and providers are abstracted behind a common interface with traits for shared logic.
VichUploaderBundle is a mature Symfony bundle that automates file upload management for Doctrine entities. It listens to Doctrine lifecycle events to inject uploaded files into entities on load, upload them on persist, clean up replaced files on update, and remove files when entities are deleted. The bundle supports ORM, MongoDB ODM, and PHPCR ODM through adapter classes, and provides pluggable storage backends for local filesystem, Flysystem, and Gaufrette (legacy). Configured via attributes, YAML, XML, or a shared PHP mapping configuration, it exposes services for naming, directory organization, metadata reading, and property mapping resolution, plus console commands for debugging mappings and cleaning orphaned files. The architecture is a classic extensible library: a bundle facade registers compiler passes, a dependency injection extension wires services from configuration, and interfaces such as StorageInterface, NamerInterface, DirectoryNamerInterface, and MetadataReaderInterface define seams for customization. Core orchestration lives in UploadHandler and DownloadHandler, while PropertyMappingFactory resolves entity fields to storage and naming strategies. The bundle also ships Twig helpers for rendering asset URLs and form types (VichFileType, VichImageType) with delete/download options, a profiler data collector, a FileRequired validator, and translations in 20+ locales. The codebase is well-tested with unit, integration, and functional tests, and shows deliberate design in areas like immutable namer configuration, a chain directory namer, event cancellation, and clever file-extension guessing. It is actively maintained, follows modern PHP (^8.3) and Symfony (^6.4/^7.4/^8.0), and has clear deprecation paths for legacy features. A few areas such as Gaufrette storage and the older ConfigurableInterface are in maintenance mode, but the core remains current and trustworthy.
This is the Symfony Security Core component, a pure PHP library providing a generic, extensible authorization and authentication framework. It is infrastructure code, not an application – it defines interfaces and implementations for token storage, access decision making (with pluggable voters and strategies), role hierarchies, user providers and checkers, signature hashing for secure links, and validation constraints. The architecture relies heavily on design patterns: Strategy (access decision strategies), Chain of Responsibility (user providers/checkers), Decorator (traceable managers, usage tracking token storage), and Template Method (abstract Voter class). It is well-typed with PHP 8.4 features and includes extensive unit tests. The repository also bundles 50+ locale translations for security-related exception messages. It is a mature, actively maintained component that forms the security foundation for Symfony applications.
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+.
This repository is a pure, generic microformats2 parser for PHP that makes HTML as easy to consume as a JSON API. It provides both functional and object-oriented interfaces for parsing microformats2 structured data from HTML documents. The parser handles all standard microformats2 property types (p-, u-, dt-, e-), implements implied property parsing, resolves relative URLs according to HTML and URI specifications, and includes backward compatibility for classic microformats markup. It features a robust test suite and follows PSR-0 autoloading standards.
Sylius is a mature open-source e-commerce framework built on Symfony, organized as a monorepo of decoupled PHP bundles and domain components. In production it powers multi-channel, multi-currency, multi-locale storefronts with product catalogs, carts and checkout, order management, payments via Payum, taxes, shipping, promotions and coupons, inventory, customer accounts, and an admin panel. It exposes a JSON:API via API Platform for headless commerce, a Twig/Stimulus storefront, an admin interface, and CLI commands for installation, user management, and maintenance. The domain logic lives primarily in the Sylius Component and Bundle layers, with UI and API layers acting as adapters over shared services.
Medoo is a lightweight PHP database framework that provides a fluent, array-based API for building SQL queries and mapping results. It supports multiple database engines (MySQL, PostgreSQL, SQLite, MSSQL, Oracle, Sybase) via the PDO extension. The library is contained in a single source file (src/Medoo.php) and offers CRUD operations, joins, aggregates, raw SQL, transactions, and column type mapping. It is designed to be simple and intuitive, fitting naturally into various PHP frameworks. The codebase includes a comprehensive test suite that validates SQL generation across different database dialects, and the project is actively maintained with modern PHP version support.
ProxyManager is a PHP library for generating proxy classes at runtime. It provides implementations for several proxy patterns: lazy loading (ghost and value holder), access interceptors (with value holder or scope localizer), null objects, and remote objects. The library uses Laminas Code for code generation and reflection to dynamically create proxy classes that wrap or substitute real objects. It is designed as a standalone Composer package with a configuration-driven architecture: a central Configuration object manages autoloading, generator strategies (evaluating or file-writing), class name inflectors, and signature verification. Factories (e.g., LazyLoadingValueHolderFactory, NullObjectFactory) serve as the primary entry points for users, each producing proxies for a given class or interface. The generated proxies include methods for initialization control, interceptor callbacks, and property access simulation. The library is extensively tested with unit tests, functional tests, and mutation testing, and includes benchmarks for performance. External dependencies are limited to Laminas Code and Composer's installed versions API.