I built a CLI tool to manage DDEV projects — started as a few lines of bash, ended up as something I'm actually proud of

A while ago I started writing a small bash script to avoid retyping the same DDEV commands over and over. It was maybe 50 lines, just a simple menu to start and stop projects.

Over time it grew. Then I decided to push it properly and turn it into something worth sharing.

The result is ddm (DDevManager) — a bash CLI tool that manages DDEV environments with one-click installations for 25 platforms: WordPress, Drupal, Joomla, TYPO3, Laravel, Symfony, CakePHP, PrestaShop, Moodle, and more.

What it does: - One-command install for 25 CMS/frameworks (fully automated, browser-ready) - Smart dependency checks on startup — Docker, DDEV, and required CLI tools - Docker group and service setup in a single pass - Auto-update system (checks weekly, updates ddm and DDEV) - Project management: start, stop, restart, SSH, wipe DB, delete - Optional Adminer or phpMyAdmin per project - Tools menu: Docker cleaner, delete all, nuclear reset - Works on Arch, Debian/Ubuntu, Fedora/RHEL

Install and run: curl -fsSL https://raw.githubusercontent.com/SalvatoreNoschese/ddm/main/ddm -o ddm && bash ddm No root required. On first run it sets up PATH and everything else automatically.

Honest notes: I'm not a professional developer — this is a personal tool that got out of hand in the best way. I got a lot of help from Claude (AI) during development, especially for bash patterns, edge cases, and code organization. The banner image was generated by Gemini. The code is mine, the ideas are mine, but I'd be lying if I said I did it all alone.

If you use DDEV regularly and are tired of repeating the same setup steps, give it a try.

Repo: https://github.com/SalvatoreNoschese/ddm

Feedback and contributions welcome.

Hey everyone! 👋

I recently came across the 100-Million-Row Challenge post here in the sub. I found it to be a fascinating experiment, but let's be honest: processing 100 million records in pure PHP is always going to be a headache. No matter how much we optimize functions and avoid loading objects into RAM, we end up fighting the physical barriers of the language itself and synchronous blocking.

This got me thinking about something that's been on my mind for months. Whenever people ask me what the "best" programming language is, my answer usually disappoints the purists: "The best language is the one that puts food on the table for you and your family."

For me, that language was PHP. It fed me and my family for many years, even when things got really tough. I owe my career to it. However, over time I realized that neither history nor the architecture of traditional frameworks have been entirely fair to it. As PHP developers, we constantly deal with massive memory consumption, response time bottlenecks, and the endless suffering of object hydration in PDO.

Since I've been working deep in the Rust ecosystem lately, building a data processing engine (pardoX), an idea kept me awake at night: How viable would it be to inject the raw performance of Rust into a PHP framework using FFI?

I got to work, and the result of these past few months is Lyger v0.1

I called it Lyger because it's exactly that: a hybrid. You write your business logic with the elegant, fast syntax we love in PHP, but under the hood, a native HTTP server in Rust intercepts the requests and handles the heavy lifting.

A few things we managed to implement in this version:

• Goodbye PDO (Zero-Copy): Rust handles the direct, asynchronous connection to PostgreSQL, MySQL, and SQLite. Rust runs the query, keeps the data in its memory, and passes only a pointer to PHP. This gave us ~300x faster asynchronous inserts.
• "Always-Alive" Memory: By keeping PHP as a persistent worker in memory, Lyger consumes a stable 2 MB, eradicating the PHP-FPM restart cost that, in frameworks like Laravel, costs you gigabytes at scale.
• Modern DX: An interactive CLI (php rawr install) that cleans up unused code and lets you choose between Vue, React, or Svelte as your frontend from second zero.

I know perfectly well that Lyger cannot enter the official 100 million rows challenge because the rules explicitly disallow the use of FFI, and I respect that—that's the exact spirit of the challenge. But my vision with this project goes in a different direction.

I'm here to share the repository and invite you all to take a look:

GitHub Repo: https://github.com/betoalien/Lyger-PHP-Framework

I want to hear your honest opinions. Test it, break it. But above all, I'd like this thread to be a space without toxicity or framework wars. I'm not here to say that Framework X is trash; I'm here because I love PHP, and I believe that if we support each other, we can build tools that push our language far beyond its historical limits.

What do you think of this hybrid architecture? I'll wait for your PR in Github

Hello,

Tired of paying for test SMS during development? I got frustrated spending money every time I needed to test an SMS integration, so I built SMSCage - a free SMS capture tool for developers.

What it does:

• Gives you a unique endpoint URL to replace your SMS provider
• Captures every SMS your app sends (no actual messages delivered)
• Shows full request details - headers, body, payload
• Groups messages by phone number like an inbox
• Works with Twilio, Vonage, Plivo, or any SMS provider

How it works:

1. Create a channel → get a URL like https://smscage.com/api/trap/abc123
2. Swap your SMS provider URL in your .env
3. Send test SMS → view them instantly in your dashboard

No SDKs, no code changes, just swap the endpoint.

Free tier includes 100 messages/month. Perfect for local dev and staging environments.

Check it out: https://smscage.com

Happy to answer any questions!

Aura.Sql, lazypdo, and Doctrine DBAL have all independently worked around the same gap. I wrote about what a minimal standard PdoInterface could look like, and the two realistic paths forward: a PHP-FIG PSR or a language-level RFC (similar to DateTimeInterface in PHP 5.5).

Would be curious to hear from library maintainers especially: does the absence of a standard interface affect your design decisions?

https://maximegosselin.com/posts/in-search-of-the-missing-pdo-interface/

I have decided to shift away from front-end development and get back into PHP. Back in the day I used XAMPP, but since I have moved to Linux and we're living in the future, I wanted to go for something more modern while still keeping it relatively simple.

My goal was to make a rootless Podman container running FrankenPHP in classic mode. That way I would keep the toolchain off the host machine, preventing conflicts between projects using different versions of PHP and also making it easier to recreate the environment. After a bit of a struggle getting it all working, I have realized that VS Code needs PHP for validation and stuff. I have tried making a wrapper that would forward VSC's requests to PHP inside the container, but that ended up being sloooow.

Before burning any more time, I have decided to check around the Internet for what people were using. I have seen Laravel's Sail, Laragon, Lando, DDev and possibly others. However, from my brief examination it looked like they all basically do the same thing I was trying, they just set up some extra tools. I would like to keep the control of doing things manually, and they wouldn't actually solve the VSC/PHP issue as far as I can tell.

So, what are you guys doing? Are you using a container and eating the delay (or is there a solution for that)? Are you developing old-school directly on the host OS (how are you managing PHP versions)? Or is there something else you would recommend?

EDIT: Whew, thanks for all the responses, everyone.

One thing I forgot to mention in the post is that, even though I'm using VS Code for now, I'm trying not to get locked down in proprietary stuff. Attaching to Docker container (which I have conflated with Dev Containers in some comments, my bad) requires a proprietary Microsoft extension. The only equivalent in other editors seems to be in PHPStorm. However, I have now realized that Intelephense doesn't actually rely on a PHP interpreter, which should allow me to sidestep that issue.

Those ready-made container solutions seem to be really popular, so I think I might give Ddev a closer look.

Sharing this because the implementation might be interesting to other PHP devs even if you don't use WordPress.

I needed to scan rendered HTML pages for common WCAG violations. Most tools do this client-side with JavaScript (axe-core, WAVE, etc). I wanted server-side scanning that runs automatically without anyone having to open a browser.

The core of it is PHP's DOMDocument parsing the final HTML output. I hook into WordPress's output buffer, grab the rendered page, load it into DOMDocument, and run checks against the DOM tree:

• Images without alt attributes (trivial — just querySelector)
• Heading hierarchy violations — walk all h1-h6 elements in order, flag any that skip levels (h2 straight to h5)
• Color contrast — extract computed colors from inline styles and check against WCAG AA ratios (4.5:1 for normal text, 3:1 for large). This is the weakest part because it can't resolve CSS classes, only inline styles and common patterns
• Form inputs without associated labels — check for matching for/id pairs or wrapping label elements
• Generic link text — regex against common lazy patterns ("click here", "read more", "learn more")

The heading hierarchy check was more annoying than expected. You can't just check if h3 exists without h2 because h3 might be inside an aside or nav where it's semantically correct to restart the hierarchy. I ended up only checking the main content area.

The contrast checker is intentionally limited. Real contrast checking needs the full CSS cascade and computed styles, which you can't do server-side without a headless browser. So I catch the obvious cases (inline color/background-color, common utility classes) and skip anything that needs layout computation. Better to catch 60% of contrast issues reliably than to false-positive on everything.

The whole thing is about 800 lines of PHP. No composer dependencies, no external API calls. Results get cached in WordPress transients.

Free on WordPress.org as Cirv Guard: https://wordpress.org/plugins/cirv-guard/

Would be curious if anyone has done similar DOM-based analysis in PHP and found better approaches for the contrast checking problem.

I just released VibeFW 2.0.0. This is an open source PHP foundation designed for the modern development era where flow, intent, and AI assisted velocity (Vibe Coding) are the priority.

GitHub:https://github.com/velkymx/vibefw

Release:https://github.com/velkymx/vibefw/releases/tag/v2.0.0

With version 1, I was experimenting with how fast a 2026 implemented framework could get using PHP 8.4+ features. It was a solid start at 15k requests per second, but with version 2, we destroyed those original benchmarks. By refining the core architecture, we jumped to over 40k requests per second in this release.

The Core Philosophy: Traditional frameworks often rely on deep inheritance and magic configurations that confuse both human developers and LLMs. VibeFW 2.0 is built to be Flat and Fast.

• AI Optimized Context: The core is small enough to fit into a single prompt. No black box behavior means AI agents like Cursor or Copilot can reason about your app with high accuracy.
• Low Cognitive Load: Zero boilerplate routing and a predictable structure designed for rapid iteration.
• Modern Stack: Built for FrankenPHP worker mode, leveraging route preloading and container fast paths to maximize the potential of PHP 8.4 property hooks and promoted properties.

Performance (Local Benchmark): Tested on an Apple M2 Air (4 workers) using FrankenPHP:

• Requests/sec: ~40,058
• Latency: ~5.15ms
• Stability: Stable memory usage after 1.2M+ requests.

VibeFW is for when you want a high performance foundation that stays out of your way and lets you ship at the speed of thought.

Hello everyone,

I just released a new version of Milk Admin, a PHP admin panel I've been working on for a while. It's starting to gain traction and receive feedback, which is really encouraging.

The main idea is quite simple: it's a backend system that's easy to understand even if you don't work with it continuously.

I'm now proud to have introduced a form builder that generates real PHP forms. The great news is that I've managed to integrate the ability to edit the form from the backend and from the PHP code.

Here's the article with the details: https://www.milkadmin.org/article.php?id=09-v095

Here's the GitHub: https://github.com/giuliopanda/milk-admin

My last post regarding this router showcased it in a very simple but barren state.
Since then there have been numerous changes which I now believe makes this quite a nice contender in the realm of PHP router implementations.
Most important is that it has this abstract logo thing which automatically means it's much better than anything else of course.
Maybe the next on the list would be creating a humongous router instead of always focusing on the small things :p

If you find anything obviously wrong with the implementation or something else do tell, I might have missed it.

P.S.
Take the benchmark results with a grain of salt, I would like to refactor this in the future as well as provide more realistic real world scenarios

PSL 5.0 is out. This is the biggest release of the PHP Standard Library yet, with 10 new components.

What's new:

• Crypto - symmetric/asymmetric encryption, signing, AEAD, KDF, HKDF, key exchange, stream ciphers (libsodium)
• Binary - fluent Reader/Writer API for structured binary data in any byte order
• Terminal & Ansi - full TUI framework with buffered rendering, layouts, widgets, keyboard/mouse events
• Process - async process management inspired by Rust's Command API, replaces proc_open
• Networking rewrite - TCP, TLS, UDP, Unix, CIDR, Socks with connection pooling and retry logic
• DateTime - new Period and Interval types
• Performance - optimizations across Vec, Dict, Str, Iter, Type with up to 100% improvement in benchmarks

Requires PHP 8.4+.

Docs: https://psl.carthage.software/5.0.0/

Hey r/php

I've been building Tabularis — an open-source, cross-platform database client — since late January.

v0.9.5 just shipped, wanted to share.

What it is: SQL editor, data grid, schema management, ER diagrams, SSH tunneling, split view, visual query builder, AI assistant (OpenAI/Anthropic/Ollama), MCP server.

Supports MySQL, PostgreSQL and SQLite , hackable with plugins ( DuckDB and mongodb in development )

Runs on Windows, macOS, Linux.

What's new in v0.9.4:

• Multi-database sidebar — attach multiple MySQL/MariaDB databases to a single connection, each as its own sidebar node. Queries are transparent: write them normally, Tabularis resolves the right database based on context.
• Keyboard shortcuts — persistent bindings (keybindings.json), per-platform display hints, customizable from Settings.

Database drivers run as external processes over JSON-RPC 2.0 stdin/stdout — language-agnostic, process-isolated, hot-installable.

Five weeks old, rough edges exist, but the architecture is solidifying.

Happy to answer questions about Tabularis.

Stars and feedback very welcome 🙏

Yesterday I published the full picture the compiler works alongside an enforcement framework to make AI generation deterministic and constrained. Full write up here: https://www.linkedin.com/pulse/pushing-ai-further-what-two-months-back-forth-lucio-saldivar-ij3uc/?trackingId=z7hvqVRXMmqhYCue9V9tSQ%3D%3D

If you've ever maintained multiple PHP packages in separate repositories, you know the pain: change an interface in package A, tag it, bump the constraint in package B, tag that, bump the constraint in the application, push, and pray nothing broke along the way.

For BisouLand, an eXtreme Legacy 2005 LAMP browser game I'm modernising, I hit this exact inflection point. Two apps (the original monolith and Qalin, a Test Control Interface built with Symfony) started sharing domain objects like Account and AuthToken. I could publish them to Packagist and manage separate repos, but after living through that pain on other projects, I went monorepo instead.

The setup is simpler than you'd expect. No monorepo-builder, no split scripts, no version synchronisation tooling. Just Composer path repositories:

"repositories": [

{"type": "path", "url": "../../packages/*"}

]

Composer reads each subdirectory's `composer.json`, resolves the package name, and symlinks it into `vendor/`. Edits are picked up immediately, no composer update needed. Version constraints are just `*@dev` for all in-repo packages.

The result: 2 apps, 10 packages, one repository. PHPStan, PHP CS Fixer, Rector and PHPUnit are all configured once in the QA app, scanning everything. One `make apps-qa` runs the full quality pipeline across the entire codebase.

Symfony's autowiring works across package boundaries too. A bundle in one package can alias a domain interface to a PDO implementation in another package, and Symfony discovers it all through the normal mechanism (which is something I wasn't sure would work back in 2016 when I first tried that!).

The article covers the full setup: repository structure, Composer configuration, the package dependency graph, Docker integration with shared volumes, and the tradeoffs (coupling risk, no granular access control, synchronised upgrades).

Hola r/PHP,

About a year ago I posted here about Workflow 1.0 reaching stability. I've been using it on production since then and today I'm sharing version 3.0.

What's Workflow? A library for organizing multi-step procedures into independent jobs with automatic dependency resolution. Define what you want to happen, the engine figures out the execution order.

What's new in 3.0:

• Supports any callable
• Dependency injection
• Async execution (drops parallel execution)
• Retry policies
• Response property references

Blog post with code examples: https://rodolfoberrios.com/2026/03/02/workflow-3-0/

Repo: https://github.com/chevere/workflow

Would love to hear if anyone gives it a try.
Feedback always welcome.

I’ve tried to provide some additional insights to the RFC regarding closure optimizations.

Built a library that lets you pull from 200,000+ Iconify icons in pure PHP. Download the sets you want via CLI and render them with a helper function.

bash php bin/swarm-icons json:download heroicons tabler

php echo swarm_icon('heroicons:home', ['class' => 'w-6 h-6']);

Supports local SVG directories, the Iconify API, or JSON collections. Twig and Blade integrations, PSR-16 caching, sprite sheet support, and SVG sanitization are all included. Requires PHP 8.2+.

Docs: https://frostybee.github.io/swarm-icons/ GitHub: https://github.com/frostybee/swarm-icons

Still actively working on it, happy to take feedback.

Pricore is a self-hosted private Composer registry for PHP teams. Built with Laravel, Apache 2.0 licensed, and now in public beta.

The problem it solves: managing private packages with VCS repositories in composer.json is slow, Satis requires manual rebuilds, and SaaS options get expensive. Pricore gives you a full Composer v2 registry on your own servers.

What it does:

• Mirrors GitHub/GitLab repos and serves them to Composer
• Webhook-driven updates, no manual rebuilds
• Token-based auth
• Web dashboard for packages, downloads, and activity
• Full Composer v2 metadata-url support

Up and running in about 60 seconds with Docker.

GitHub: https://github.com/pricorephp/pricore

Blog post: https://pricore.dev/blog/introducing-pricore

Feedback and questions welcome.