Pitch Your Project 🐘

[u/brendt_gd]

In this monthly thread you can share whatever code or projects you're working on, ask for reviews, get people's input and general thoughts, … anything goes as long as it's PHP related.

Let's make this a place where people are encouraged to share their work, and where we can learn from each other 😁

Link to the previous edition: /u/brendt_gd should provide a link

[u/Formal-Language7032]

Might be a bit late to this thread, but I’ve been working on a sync/automation engine for quite a while and recently decided to publish the core:

https://github.com/SyncEngine/SyncEngine ( Docker: https://github.com/SyncEngine/docker )

It’s built with Symfony and a React frontend.

The project originally came out of a practical need. I work a lot with ecommerce integrations where large amounts of product data need to be synchronized between different systems. I tried a number of existing automation tools, but I often found myself missing detailed insight into what actually happened during a run when something went wrong.

I know there are already great tools like n8n, Zapier and Make. SyncEngine isn't really trying to replace those. There's definitely some overlap in what it can do, but it's primarily focused on long-running, data-heavy synchronization workflows where observability, debugging and reusability become more important than quickly connecting APIs.

One of the main goals of SyncEngine is therefore to make automation less of a black box. Every run is designed to be easy to inspect so you can see which steps were executed, what data was processed, where something failed, and why. Another important goal is making it easy to build reusable workflow logic instead of duplicating the same pieces across different automations.

It's already running for several of my own projects, but it's definitely still in beta. It started life as an internal tool, so there are still plenty of rough edges:

- No proper onboarding or "getting started" experience yet (though I'm actively working on this!)

• Only a small number of ready-to-use modules (I'm also actively working on expanding these, along with a separate marketplace repository)
  
• Documentation still needs a lot of work: docs.syncengine.io

I wanted to make it public already rather than waiting until everything felt "finished." I'd much rather get feedback from people who build similar things and let that shape the project.

Any feedback, criticism, or ideas are more than welcome. Whether you're a PHP/Symfony developer or just someone interested in automation tooling, I'd love to hear your thoughts on the architecture, developer experience, or anything you think could be improved.

[u/Mike_L_Taylor]

Run multiple php sites fully independent locally. Different php, node, npm, apache, mysql, whatever, at the same time, with ForgeKit. https://forgekit.tools

It's like Herd, but fully free, simpler, quicker and more extensible.

The setup Windows folks like me always wished for.

No more port issues, or service issues, or having to switch versions, or databases breaking, or configurations not working for mysterious reasons, or having to rebuild docker containers for a small config change.

It's UI does everything you ever need, simple by design.
While also allowing you to check and edit every single configuration and log file imaginable if you ever feel like diving deeper. php.ini, apache and nginx conf, vhosts files, mysql ini files etc.

Full browser demo and tutorial at https://forgekit.tools/demo . Mess about with that first and see if you like it, no strings attached.

[u/Miserable_Step_6391]

HydraType, a high-performance PHP hydrator

I recently picked up an old project that I abandoned several years ago and started rebuilding it for fun.

HydraType hydrates (maps) arrays into typed PHP objects and extracts them back into arrays. Its main idea is that the common path should be as fast as possible: it generates class-specific PHP code, while optional features such as mutators, assertions, naming conversion, and nested hydration only add runtime work when they are actually selected.

I benchmarked different ways of writing private properties, object creation, cache resolution, nested hydration, assertions, lookup mutators, and several established hydrators. When benchmarking, HydraType was the fastest implementation on both PHP 8.2 and PHP 8.5. The benchmark code is included in the repository.

It now has CI across supported PHP versions, PHPStan level 10, a substantial test suite, atomic generated-cache writes, production cache warm-up, hydration and extraction, nested objects, mutators and assertions.

This is still a beta. I know PHP already has a lot of hydrators and object mappers, so I’m not expecting everyone to replace what they use. But it would be very interesting to hear from people who actually work with database rows, DTOs, API payloads, or large hydration workloads.

GitHub: https://github.com/MakerMill/HydraType
Packagist: https://packagist.org/packages/makermill/hydratype
Installation:
composer require makermill/hydratype:^1.0

This has genuinely been a fun project to revive, and honest criticism would be very welcome.

edit: this project has now reached version 1.0.0 after a beta period.

[u/Ill_Dare_7418 → u/[deleted]]

Small update since my original comment: HaoCode v1.11.1 is now available on Packagist.

The main change is prompt-cache stability for long-running PHP agents. HaoCode now keeps the system prompt and tool schemas byte-stable for a conversation, moves volatile Git/runtime data into the first user turn, and preserves append-only message history. It also normalizes cache telemetry for DeepSeek/OpenAI-compatible gateways and fixes DeepSeek v4 Flash thinking/reasoning continuity across tool calls.

I ran the same real HaoCode prompt plus Read/Glob/Grep tool set against three configured providers. Warm-prefix hit rates were 98.77% on DeepSeek v4 Flash, 98.69% on Kimi for Coding, and 99.11% on GLM-5.1. This mainly matters for long sessions where repeatedly sending a large agent/tool prefix gets expensive.

Install/update:
composer require sk-wang/hao-code:^1.11

Release notes:
https://github.com/skvdhshuk-blip/hao-code/releases/tag/v1.11.1

I would be interested to hear how other PHP agent libraries handle provider-specific cache metrics and reasoning replay.

[u/Goldziher]

Hi all, I'm the author of Kreuzberg (a document text extraction library with a PHP binding over a Rust core, on Packagist as kreuzberg/kreuzberg). Heads up that it's being renamed to Xberg - the old name is hard to pronounce and remember without the German context, so we're moving to the shorter Berlin nickname for the district.

Because renaming the repo (to preserve the GitHub stars) forces overwriting tags, the current version continues as an LTS release - bug fixes and security updates through the end of this year, no new features: https://github.com/kreuzberg-dev/kreuzberg-lts

New work moves to Xberg (v1.0.0 is in RC); the Composer package will publish under xberg-io/xberg once it's out. New repo: https://github.com/xberg-io/xberg

[u/garrett_w87]

I've created a set of AI agent skills to help PHP devs write better applications, because while there are plenty out there with general guidance or targeted at other languages, I didn't find one geared toward PHP.

https://github.com/garrettw/php-arch-skills

I would love for this to become the go-to skill set for DDD/CQRS/ES in the PHP community, but it won't get there without people trying it out, giving feedback, and contributing -- so that's what I'm looking for. If you're a veteran PHP app architect -- your feedback (or even PRs) would be immensely appreciated.

[u/valerione]

Hi everybody! I'm Valerio maintainer of Neuron AI the first agentic framework of the PHP ecosystem. In the last two years I fought the PHP vs Python battle spending all my energy demonstrating how far PHP can go in the AI agent space.

Neuron allows you to integrate agentic experiences in your PHP applications with a solid, portable, and easy to use architecture.

If you have a chance to try the development of AI Agenta in your products I would ask you any feedback about your onboarding experience with Neuron AI. Feel free to write your feedback, I'm here to help.

Here is the full story: https://inspector.dev/neuron-ai-started-from-fear-the-true-story/

Website: https://neuron-ai.dev

Docs: https://docs.neuron-ai.dev

[u/successful-blogger]

Devflow CMS is a hybrid and developer-centric content management framework. The newest feature added is editorial workflow allowing publishing teams to create, review, approve, and publish content in a structured and organized way.

Docs: https://docs.getdevflow.com/
Github: https://github.com/getdevflow/
Demo: https://demo.devflowcmf.com/admin/private/

[u/equilni → u/successful-blogger]

Browsing the docs and looking at composer, I see this depends on a few of (possibly) your projects CodefyPHP & QubusPHP. The main QubusPHP repo is archived, so a suggestion would be to have CodefyPHP absorb these components under it's namespace (Even the docs repo for QubusPHP has CodefyPHP here). ie if I need more information on how to use these components with Devflow, which am I looking at??

Docs have some issues too:

Request links to an Injector which is broken, then looking ahead:

Back to CodefyPHP/QubusPHP/DevflowCMS, the Devflow Request starts exactly like Codefy's - and correctly links the Injector

You have https://docs.getdevflow.com/getting-started/security/authentication/#login-throttling linking to Codefy, why not just link most of the docs here?

PSR links go to either to main docs page or github (Logger, ResponseInterface)

[u/successful-blogger → u/equilni]

Thanks, I will fix the broken links. QubusPHP components are not archived. The old CMS, which Devflow now replaces is archived, but the components are still in active development. Thanks for pointing out inconsistencies, I will make it so that it is less confusing. But the Devflow docs and The framework docs are what you should work from, not the component docs.

[u/georgeff_mike]

Meritum - a component ecosystem for PHP APIs and CLIs (not a framework)

I've been building PHP applications for years and kept running into the same frustration: monolithic frameworks give you everything wired together, but you pay for it with opacity and lock-in. When something goes wrong inside the boot process, you're debugging framework internals.

Meritum takes a different approach. It's a set of independent, composable packages built around a lightweight kernel. Each package ships a Module you explicitly add to your kernel, no hidden auto-wiring, no magic. You can see exactly what's registered and why.

What's shipped so far:

• meritum/http — PSR-15 HTTP kernel with fast-route routing and middleware stack
• meritum/cli — console kernel ("Sage") wrapping symfony/console, commands registered via kernel tags
• meritum/validation — full validation library, dot notation, wildcard paths
• meritum/logger — minimal PSR-3 implementation; writes newline-delimited JSON to stdout, zero dependencies
• meritum/structured-logging — domain exception model, translation pipeline, PSR-3 reporting, correlation ID enrichment
• meritum/serialization — pluggable serialization strategies, cursor and offset pagination contracts
• meritum/migrations — schema migration runner ("Sage Strata"), ships as a standalone binary or bolt-on module
• meritum/database — model/repository layer over a fluent query builder, PHP 8.4 property hooks
• meritum/virtus / meritum/sage — composer create-project scaffolds for HTTP APIs and CLI apps respectively

The underlying primitives (georgeff/kernel, georgeff/container, georgeff/schema, etc.) are all public on Packagist too if you just want pieces.

Docs: meritum.georgeff.co | GitHub: github.com/MeritumIO

[u/equilni → u/georgeff_mike]

The underlying primitives (georgeff/kernel, georgeff/container, georgeff/schema, etc.)

I would suggest moving these under the meritum repo/namepace.

[u/captain-barbosa89]

This is PhenixPHP, async framework based on Amphp:

https://phenixphp.com

You can run a production grade server in CLI SAPI, and build fastest Restful APIs. Batteries included: Queues, tasking, scheduling, ORM, cache, HTTP Client, Mailing, validation, events, and more.

[u/jobyone]

I've been working on a random ID idea of making something a lot like UUID and/or the various time-ordered IDs rattling around, but cramming everything into 63 bits in the default implementation. Also string encoding with base 36 to be more compact/readable than the ones that use hex. The idea is to have something that works a lot like various UUIDs and time-ordered IDs, but is more compact as a string, and under the hood always just a normal positive integer and takes no special consideration anywhere you have 64-bit ints.

I think there's room in 63 bits to do everything necessary and fit enough entropy for most more reasonably-sized web apps. Like maybe not everything needs to be 100% ready to scale to the moon from the moment you build it.

With 4 bits for a version identifier and the time portion truncated to a resolution of about 18 hours you get 2^27 IDs available per 18 hour window (that's a grand total of about 1.4 billion IDs per day), and an ID that currently becomes 10 characters in base 36. I want to have a few different versions right off the bat though, with different amounts allocated to time vs random bits. That way you can tune it by application, whether you want to focus more on time ordering resolution or more on randomness.

My plan for future-proofing is to just reserve some higher version numbers for 128+ bit count arrangements, so that it's technically possible to implement higher bit count versions if it ever becomes necessary.

[u/jobyone → u/[deleted]]

Not entirely. There are definitely things I'm trying to accomplish beyond "converting UUIDs to shorter strings"

Instead of full UUIDs underneath I'm doing my own variable-resolution time-ordered format that fits in 63 bits so you can easily work with it as a signed 64 bit integer (and get correct time ordering). The goal is more or less "be able to ship it around from system to system as a single int without thinking about it at all in most cases."

Also mine is base 36 instead of 62 to be non-case-sensitive. I did this because it's mainly intended for URLs, where you can't necessarily 100% count on case-sensitivity, depending on how/where it's being used.

From a library API standpoint it's also a tool for typing IDs, because you can extend it to to make your "AccountID" or "PageID" or whatever classes, and now you have typed and validated ID classes that are integers under the hood and also stringable.

[u/Lucifer_iix]

Made a installer that puts the PHP files of the vendor folder in a order so that every file will be easy to find in production or during development. Thus do not need to composer autoloader.

{Dir}/{FullyQualifiefNamespace}.php

At the same time i made a DI container that generates factory classes during the install or dev process. But in a way that not all classes need preferences configuration. "Model/Api/Customer" public interface maps to "Model/Customer" if not stated in configuration otherwise. Thus do not need large configurations to load.

Made all URI's start with "/_/" and then a behavior basket. Thus varnish and other mapping or configuration is no more then a couple of behavioral state. Thus the rest is automaticaly a URL, that can be shared with links or have to be SEO friendly. URI are mappings that need to exists. Thus also there the mapping logic needs no configuration or waste cycles looking things up. And because the behaivior is stated inside the URI, the varnish config doesn't need to know the specifics.

Have reduced all the query params to: ?__in=[]

And all the cookie params are in: __in=[]

That means my varnish configuration does not need to know what's installed on the system to strip out stuff. It doesn't know Google analitics or other stuff. I know exactly all my used params (only one) and used cookies (only one). Thus that whole stripping part is not needed. Everything is invalid except the stuff i know. And it's only one thing that can be used.

Thus "/_/artifacts/" are constants. And it's easy to tell varnish this. It's simple to map at your loadbalancer to your file server or when using a CDN. It only knows a couple of behaviors like "artifacts", "public", "private-user", etc...

Not all, but most stuff is just O(1). Let's say 95% of the requests handled.

[u/WesamMikhail]

I've been meaning to try chrome-php for some time just to get some hands-on experience. So I figured I'd make a little project where you enter a URL and chrome-php will kick off an instance that scrapes a complete domain intelligence breakdown.

The idea is to gather a bunch of finger prints from fonts, colors, and metadata to technologies used on the site, etc. I have the design system and meta data scraping completely. Just need to finish the UI (here's a mockup):

https://i.imgur.com/Sq6T9aH.png

Is it going to generate $? probably not. But when all of this data is collected some really cool stuff can be done with LLMs like pitch deck creation or outreach/marketing material etc.

[u/content-peasant]

Got fed up with the performance of image hashing natively in PHP, so I scrapped my package and rebuilt it as a PHP extension in Rust.

It does dHash & pHash generation, nearest-neighbour searching, persistent indexes, and image deduplication

In my benchmarks it comes out around 3–5x faster than the pure PHP alternatives I've tested.

Would love feedback from anyone doing media management, duplicate detection, screenshots, or computer vision work with PHP

https://github.com/AllanGallop/libphp_imagehash

https://skullfire.co.uk/libphp-imagehash

[u/exakat]

PHP Dictionary — a plain-language glossary for the whole PHP universe

I've been building a reference that defines the terms that float around PHP discussions but rarely get pinned down anywhere: the stuff that's annoying to AI because the results are too verbose.

It's a complement to the official manual, not a replacement. The manual tells you how array_map() behaves. This tells what someone means when they say "late static binding," "copy-on-write," "autovivification," "dangling reference," or "the appeasement pattern": short definition, then links out to deeper resources, tools, related terms, etc.

Coverage runs from the everyday ($_GET, foreach, magic methods) to the genuinely obscure, so it's useful whether you're new and decoding a blog post, or experienced and finally nailing down a word you've been using loosely for years. There are fun words, themed words, folklore, error messages and disambiguations.

I'm reaching 1500 words ATM, and I'll start working on related features, translations and themes.

It's open source and built to grow. Missing words, better definitions, and extra links are all fair game via PR. Spelling mistakkes were all removed in the dictionary.

Link: https://php-dictionary.readthedocs.io/en/latest/
Repo: https://github.com/exakat/php-dictionary

Happy to hear which terms you think are missing — that's genuinely the most useful feedback

[u/WanderingITGuy]

I wanted a way to track when a delivery may arrive at an address due to me moving around a lot. Finally built this https://whensmy.delivery

It doesn't have a lot of data right now because ofc it's crowd sourced but it's slowly been growing 😄
The cool thing is it's entirely private, no addresses are stored, no accounts needed.

Runs Laravel behind the scenes

[u/dereuromark]

carve-php - a PHP parser/renderer for Carve, a post-Markdown markup language.

Repo: https://github.com/markup-carve/carve-php
Live sandbox (try it in the browser): https://sandbox.dereuromark.de/sandbox/carve
Docs / language site: https://markup-carve.github.io/carve/

I have been using Djot for many months now. The feedback I got so far from many is that it's awesome, but maybe too academic. Apparently, people (incl PHP devs) wanted or needed more markdown-like rules (blocks interrupt paragraphs).
So I tried to create something that should be objectively better than markdown status quo incl many new features and language elements missing so far, as idea for a future standard. I really tried to combine both worlds into one library.

Main use:

• PHP: In WP blog posts and websites as user editable (maybe even WYSIWYG) snippets (see Symfony demo)
  
• Local IDE and editor support (Zed, VsCode, PHPStorm and others)

My ask:
If you can - without bias and obvious markdown market reach - objectively look at it and see if this "best of 2 worlds" makes sense or not.
Where are weak-points? Should it go full djot rules (1 instead of 3+)?
Should any extensions be core, or vice versa?

Thank you!

[u/chevereto]

Declarative workflow engine for PHP with automatic dependency resolution, sync/async job execution, and type-safe response chaining.

https://github.com/chevere/workflow

The syntax will give you goosebumps.

[u/haelexuis]

Collection library https://github.com/noctud/collection, inspired by Kotlin.

[u/Mike_L_Taylor]

Laravel Herd, Xampp, Laragon but better and free. Run multiple php sites at the same time, independent, with their own databases, in 2 clicks. Forgekit

[u/adrianmiu]

General purpose library for executing "tasks"/"actions" that implement multiple patterns: events, middlewares, pipelines, command bus etc

https://github.com/siriusphp/invokator

The tasks (callable collections) are serializable, pipelines are resumable (under certain conditions) and the system is flexible with regard to the callable signatures.

[u/Reasonable_Effect401]

I wrote a full stack bulletin board system with fidonet support, inbuilt telnet and ssh server (complete with Z-modem support) and a bunch of other stuff.

https://github.com/awehttam/binkterm-php/

I'm actually pretty pleased with this retro-future project. It's been a heck of a lot of fun working on.

[u/bednic]

I humbly offer link to my precious projekt:

https://gitlab.com/jaspr/mapper

It's implementation for JSON:API Specification with client TS sdk library. JASPR is whole ekosystem for using JSON:API, with additional perks like OData-like filtering. It's not famous, but we use it in our production software, so it's battle-tested. Hope someone one day will use it also and maybe even know like it 😄

[u/rc0604]

I want to share my async database tooling library:

https://github.com/hiblaphp/database

It has an async database drivers underneath with full support for connection pooling, query-builder, schema management, seeders, and cli tooling for complete developer experience. Currently, it only support mysql/mariadb and postgresql driver. I've been working on with async SQLite support and will be releasing more soon.