PECL is down?

Cached pages seem fine but release pages like
https://pecl.php.net/rest/r/amqp/stable.txt timeout

https://redd.it/1v1nr55
@r_php

modyra/modyra: A framework-agnostic, type-safe form engine
https://github.com/modyra/modyra

https://redd.it/1v1t2iv
@r_php

How is Forge?

I've been looking into alternatives for the server management panel I currently use (Ploi), and I am wondering how people that have been using Forge (or used to use it) are finding it nowadays? And if you moved to Forge from Ploi/RunCloud/etc. how does it compare? And if you were using Forge but moved away, why, and to where?

For reference, I have 5 servers, and 28 applications deployed on those combined. I will not be using the Laravel VPS'.


Specifically, how is the Forge experience outside of Laravel deployments and the usage of "Laravel VPS"? While most of my applications are using Laravel, a growing amount are using Next.js or SvelteKit.

https://redd.it/1v1yvpj
@r_php

I built a tool to manage Composer dependencies on WordPress sites without SSH access
https://www.loopress.dev/

https://redd.it/1v1ym3j
@r_php

NO SLEEP - TILL BOSTON
https://redd.it/1v22mh8
@r_php

A pure PHP web server. No nginx, no Apache, no php-fpm.

What if PHP by itself was enough to run a web server?
What if it was actually \*much faster\* than NGINX + PHP-FPM?
And it was \*much safer\* than FrankenPHP or Swoole?

Well, that's exactly that this is. MIT-licensed. Enjoy!

[**https://github.com/Qbix/webserver**](https://github.com/Qbix/webserver)

**Who this is for:**

* PHP Developers who want to host things
* Normies who don't want to install and configure apache/nginx/varnish/go/ssl certificates/mysql/etc.
* People who just get the standalone binary and can host on their computer, without the internet even.

Static file throughput is 55–73% of nginx (C will always beat PHP on raw I/O).

But on actual PHP workloads, the bootstrap savings make this 2–5x faster.

This was taken from the much larger all-in-one PHP platform:

[**https://github.com/Qbix/Platform**](https://github.com/Qbix/Platform)

https://redd.it/1v1odre
@r_php

🚀 Introducing URL Image Uploader for FilamentPHP

If you're tired of forcing users to download remote images locally just to re-upload them into your admin panels, I built a custom form component that solves this exact friction: the **URL Image Uploader** package for FilamentPHP.

# ✨ Key Features

Direct Remote Imports: Instantly fetch and attach images directly from any public web link.
Built-in Preview: Gives users an immediate preview before saving to ensure the target URL is correct.
Laravel Storage Integration: Seamlessly saves files straight to your configured storage disk and path.
Image Validation: Validates the link to ensure it targets a readable image format.
Native Look & Feel: Fully compatible with Filament's UI, including dark mode and multilingual setups.

# 📦 Quick Setup & Usage

1. Install via Composer:

composer require amjadiqbal/filament-url-image-uploader


2. Add to your Form Schema:

use Amjadiqbal\FilamentUrlImageUploader\UrlImageUploader;

UrlImageUploader::make('image')
->directory('images');


3. Model Attribute Setup:

use Illuminate\Database\Eloquent\Casts\Attribute;

protected function image(): Attribute
{
return Attribute::make(
get: fn ($value) => $value,
set: fn ($value) => is_array($value) ? $value['image'] : $value,
);
}


🔗 Repositories & Links:

Filament Directory: URL Image Uploader Plugin Page

https://redd.it/1v1px6i
@r_php

I extracted file-based routing into a standalone PHP package (works in Laravel and Symfony too)

A few weeks ago I posted a small framework here and got a lot of honest feedback. The clearest point, from several people, was that the file-based routing was the interesting part and would be more useful as a standalone library than baked into a whole framework. So I built that.

file-router is a zero-dependency package that maps your directory structure to routes, Next.js style: users/[id].php → /users/{id}, [...slug] for catch-all, route groups, compiled route cache. PHP 8.1+.

The part I think is actually useful: it's framework-agnostic. It runs standalone, but there are thin adapters so it plugs into Laravel (registers as native routes, inherits middleware/container) or Symfony (as a custom route loader, uses Symfony's own matcher and cache). So you can get file-based routing without adopting a new framework.

It's tested across PHP 8.1–8.5, and the migrations in the example template are verified on SQLite, MySQL and Postgres (not assumed; actually run end to end).

Repo: github.com/lizzyman04/file-router

Genuinely looking for feedback again, especially on the adapter approach. Does registering into the host framework's own router feel right to you, or would you expect it to work differently?

https://redd.it/1v2m919
@r_php

Quarterly Progress Report - Q2 2026
https://thephp.foundation/blog/2026/07/21/quarterly-report-q2-2026/

https://redd.it/1v2n7hw
@r_php

Pure PHP web+socket server, serves 10x more concurrent PHP than NginX+FPM

# Qbix Server

Yesterday, I posted on Reddit about a web server I launched that's written in pure userland PHP, managed its own preforked workers, and removed the need for NGINX and PHP-FPM.

It was already able to run 10x more concurrent workers (e.g. 1600 workers on an 8GB server).

The biggest bottleneck in PHP hosting is \*memory\*. Each php-fpm worker loads your entire framework independently: 30–60MB per worker. On an 8GB server, that's \~160 workers max. That's your ceiling for concurrent PHP requests.

Well, Qbix Server forks workers \*after\* preloading your classes. Thanks to copy-on-write from the operating system, all that shared code (framework, config, autoloader) uses memory only once. Each worker adds maybe 3-6MB for its per-request data.

This means you get to run 10x more workers, and each worker actually loads much \*faster\* because you don't have to bootstrap your entire framework, config, etc. on every request.

[**https://github.com/Qbix/webserver**](https://github.com/Qbix/webserver)

# But wait... it got faster.

Yesterday, some people were complaining that a userland-PHP server was "only" 70% as fast as NGINX for serving static files. Well, it's 24 hours later, and I'm back, baby! After caching more, it turns out that it's now 25-35% FASTER than NGINX even for static files (as long as you keepalive connections).

Don't believe me? Run the benchmarks. It comes with a test suite now.

# But wait... it now supports sockets

Yes, it is wire-compatible with [socket.io](https://socket.io), and bundles it out of the box (no need for npm). Now you can just drop PHP files into folders, in order to:

1. Handle HTTP Requests. (Cleanup after request is handled.)

2. Handle Web Sockets. (Long-lived, cleanup after disconnect.)

3. Handle Rooms. (Long-lived, cleanup after last websocket leaves.)

In my opinion, the coolest thing is that this retains all the things that made PHP great:

1. Shared-nothing. No way to have memory or secrets leak between requests.

2. Normie-friendly. Just drop files into folders and things just work! No need for hot-reload even. Not even for websockets and rooms -- the old handler will work for the old connections, while the new one is loaded for the new ones.

3. Sequential processing, sure it means you occasionally miss out on fanning out concurrent I/O races, but it's much easier to understand the code.

Give it a try! It's MIT licensed. Enjoy 😄



**Who this is for:**

* PHP Developers who want to host things
* Normies who don't want to install and configure apache/nginx/varnish/go/ssl certificates/mysql/etc.
* People who just get the standalone binary and can host on their computer, without the internet even.

This was taken from the much larger all-in-one PHP platform:

[**https://github.com/Qbix/Platform**](https://github.com/Qbix/Platform)

https://redd.it/1v2xe3w
@r_php

There's no pyenv/nvm equivalent for PHP that works out of the box, so I built one

I wanted something like pyenv or nvm but for PHP. Couldn't find one that actually works the way those do — resolve deps, build from source, switch versions cleanly. The existing options either wrap pre-built binaries or half-ass the dependency resolution.

So I built phpv: https://github.com/supanadit/phpv

`phpv install 8.4` checks your system, builds whatever deps are missing from source, compiles PHP with the right flags. 25 default extensions, out of the box. Supports PHP 4.x through 8.x, version switching, per-project pinning via .php-version, PECL extensions, PHAR tools, portable bundles you can export and import across machines. Linux amd64/arm64 + macOS Intel/Apple Silicon.

Install:

curl -fsSL https://raw.githubusercontent.com/supanadit/phpv/main/install.sh | bash

Then:

eval "$(phpv init bash)"

phpv install 8

Honest con: it compiles from source, so first install is slow. There's no pre-built PHP binary cache yet — working on portable musl-static bundles so you can skip compiling entirely, but that's not done. What's there now works, it just takes a few minutes on first run.

It works. I've been using it on Ubuntu and macOS daily. But I know there are distros and edge cases I haven't hit — Alpine, Arch, weird setups. If you're on any of those, try it and file an issue if it breaks. I want to know.

Repo: https://github.com/supanadit/phpv

Issues: https://github.com/supanadit/phpv/issues

Break it and tell me.

https://redd.it/1v3cmd4
@r_php

New dev building a Laravel + Postgres Attendance & Payroll system — need advice on deployment with strict company control

Hey everyone,

I recently joined a new company as a developer, and I’m building our internal **Attendance and Payroll system** using **Laravel and PostgreSQL**.

Development is going well, but I’m relatively new to deploying Laravel apps in production. I need some guidance on choosing the right hosting and database setup based on my company's requirements:

**App Scope & Needs:**

* **Core Features:** Employee attendance tracking, HR management, and monthly payroll calculation/generation (PDFs, background processing).
* **Database:** Currently using **PostgreSQL** in local development and plan to stick with it.
* **Company Requirement:** Management wants **full control** over the system, server, and employee data (so no fully managed black-box cloud PaaS where we don't control the underlying infrastructure/server location).

**Questions I have for the community:**

1. **Hosting:** Given the need for complete control over the infrastructure, should I spin up a self-hosted VPS (e.g., DigitalOcean, Hetzner, AWS EC2) using **Laravel Forge** or **Coolify**, or setup a bare-metal LEMP stack manually?
2. **Database Setup:** Is running Postgres on the same VPS fine for a small-to-medium internal company tool, or should I decouple it onto its own dedicated instance/managed DB from day one?
3. **Queue & Scheduler:** Since payroll will generate PDFs and queue emails, what’s the best low-maintenance way to handle Laravel queue workers (Supervisor/Redis) and the scheduler in a production environment with complete server access?
4. **Data Protection:** What are the non-negotiables for securing sensitive financial and employee payroll data on a self-hosted server?

Would love to hear how you'd structure this setup! Any tips, common pitfalls, or architectural recommendations are greatly appreciated. Thanks!

https://redd.it/1v3dq25
@r_php

Removed by Reddit

Removed by Reddit on account of violating the [content policy. ]

https://redd.it/1v397go
@r_php

SymfonyCon Warsaw 2026: 10 easy steps towards a more inclusive workplace
https://symfony.com/blog/symfonycon-warsaw-2026-10-easy-steps-towards-a-more-inclusive-workplace?utm_medium=feed&utm_source=Symfony%20Blog%20Feed

https://redd.it/1v3k3tu
@r_php

A more Laravel-native approach to route localization

About ten months ago I shared [an alternative approach to Laravel route localization](https://www.reddit.com/r/laravel/comments/1n5rhrf/) here. I originally built this for myself and wasn't really expecting a design discussion, but the feedback pushed me somewhere better than where I'd started.

[https://github.com/goodcat-dev/laravel-l10n](https://github.com/goodcat-dev/laravel-l10n)

**TL;DR**

* Route translations live in standard Laravel lang files (`lang/{locale}/routes.php`)
* Localized routes register at boot, so `php artisan route:cache` just works, no custom commands
* URL generation stays on the normal `route()` / `action()` helpers
* Three prefix strategies, plus translated domains
* `L10n::is()`, `hreflang` \+ switcher components, and Ziggy/Wayfinder helpers with SSR

**Route translations now live in standard lang files**

The original post used inline translations. [Someone opened an issue](https://github.com/goodcat-dev/laravel-l10n/issues/1) asking for lang-file support, and I was actually against it at first. But it ended up being a clear improvement: it solved the mess of juggling inline translations across route groups, which had quietly become a nightmare.

Route::get('/example', Controller::class)
->name('example')
->lang(['es', 'it']);

// lang/es/routes.php

return [
'example' => 'ejemplo',
];

**It stays out of the way of the framework**

This is the part I care about most. The localized routes are registered during boot, so Laravel's own route cache works with no custom commands:

php artisan route:cache

And URL generation goes through the normal helpers, there's no separate localized URL API to learn:

// current locale: es
route('example'); // /es/ejemplo
route('example', ['lang' => 'it']); // /it/example
route('example', ['lang' => 'en']); // /example

**Frontend URL generation (Ziggy & Wayfinder)**

Localized routes usually break down once you generate URLs on the frontend. This is the one area I haven't seen other localization packages tackle, so the package ships JavaScript and TypeScript helpers that keep Ziggy's `route()` and Wayfinder calls locale-aware.

**Matching routes across locales**

A comment on the original post pointed out that `routeIs()` gets awkward once localized routes carry different internal names. That's now handled:

L10n::is('example');
L10n::is('admin.*');

It matches the canonical route regardless of the current localized variant.

**Routing strategies**

The package supports three:

* `prefix_except_default`: `/example`, `/es/ejemplo`
* `prefix`: `/en/example`, `/es/ejemplo`
* `no_prefix`: `/example`, `/ejemplo`

The `prefix` variant, which forces a prefix on the default locale too, came out of [another issue](https://github.com/goodcat-dev/laravel-l10n/issues/2).

**Translated domains**

Domains are translated through the same lang files:

return [
'example.com' => 'es.example.com',
'example' => 'ejemplo',
];

This produces `es.example.com/ejemplo`, without adding a redundant locale prefix to the path.

The package is still relatively young and intentionally opinionated. It requires PHP 8.2+ and Laravel 12.44 or 13.

One known trade-off worth calling out up front: `lang` is reserved as the locale-selection parameter, so routes with their own `{lang}` parameter aren't supported by the URL helpers.

Repository: [https://github.com/goodcat-dev/laravel-l10n](https://github.com/goodcat-dev/laravel-l10n)

composer require goodcat/laravel-l10n

That's the update. Any feedback is hugely appreciated, especially from anyone using translated domains, Ziggy, Wayfinder or SSR. Thanks!

https://redd.it/1v3nisj
@r_php

Files touch() storage implementation for Symfony Lock component
https://github.com/oliezekat/symfony-lock-filetouch

https://redd.it/1v3pmhl
@r_php

This Week In PHP Internals | July 22, 2026
https://youtu.be/tCUKb5rPuJ4

https://redd.it/1v444zx
@r_php

Caching an Eloquent collection can give you N+1 queries on cache hits

Took me far too long to spot this the first time, because a cache hit is supposed to mean an empty query log.

$posts = Cache::remember('posts:index', now()->addMinutes(15), fn () =>
Post::latest()->take(20)->get()
);

foreach ($posts as $post) {
echo $post->author->name; // one query. per post. on every hit.
}

The cached payload is the models, not the relations. So every hit deserialises 20 models with no author loaded and lazy-loads it in the loop. In one sense it's worse than not caching at all: you've hidden the expensive query, kept the N+1, and made it harder to find. Debugbar now shows twenty small identical queries instead of the one big one you were hunting for.

The fix is boring. Eager load inside the closure so the relations are part of what you store:

$posts = Cache::remember('posts:index', now()->addMinutes(15), fn () =>
Post::with('author', 'tags')->latest()->take(20)->get()
);

The habit I'd actually push though is not caching models at all. Cache the shape you render, a lean array or DTO. Cheaper to serialise, cheaper to deserialise, and it physically cannot lazy-load anything. Rehydrating a graph of Eloquent models out of Redis on every request eats a real chunk of the win you were chasing.

Has anyone found a decent way to enforce this? I've considered turning on preventLazyLoading() beyond local but it gets noisy fast.

(This came out of a longer caching write-up I did on my blog with tags, atomic locks and invalidation strategy: https://richdynamix.com/articles/laravel-caching-strategies-complete-guide)

https://redd.it/1v49hoc
@r_php

Symfony 8 ignores #[Groups] serializer attribute
https://ddz.dev/blog/symfony-8-groups-attribute-silently-ignored/

https://redd.it/1v4k4ql
@r_php

Built a security-first Artisan/shell runner for Laravel Nova 4 & 5, looking for feedback

Hey folks,

I’ve been using Nova for a while and always wanted a sane way to run a few curated Artisan commands from the panel — without ending up with a free-text bash box that can cat .env if someone gets clever.

Most of the older Nova “command runner” tools either:

assume bash/custom commands are fine by default, or
break on Nova 5 (__ is not defined / localization helper changes), or
don’t really gate who can run what in production

So I built Nova Command Center as a clean-room alternative:

bash + free-form commands off by default
commands run as argv via Symfony Process (no shell string interpolation)
tool canSee \+ global gate + per-command abilities (catalogue hides what you can’t run)
run history with variables/flags + rerun
Nova 4 and 5 on one path
small doctor CLI + a11y polish in the latest release

Repo: [https://github.com/farsidev/nova-command-center](https://github.com/farsidev/nova-command-center)
Install: `composer require farsi/nova-command-center`

Not trying to dunk on other packages — they scratched a real itch. I just wanted safer defaults.

If you run Nova in production (or got burned by a runner during a Nova 5 upgrade), I’d love honest feedback:

what’s missing for you to trust this in prod?
any footguns in the README/install flow?
would you use DB-defined commands, config-only, or both?

Happy to answer questions. Roast the security model if something looks off, that’s useful.



https://redd.it/1v4o1tz
@r_php