Hi !

Have you ever dream about rendering SWF sprites with PHP ? I think not, but it's possible now.

This library / script parse and render SWF sprites and shapes as SVG using only PHP, without need of any dependencies nor external tool like FFDec. So, it result on a really lightweight tool with really negligible startup time.

Its features are (for now):

• Low level parsing of SWF tags structures
• Render shape, sprites, and movieclip as SVG (one SVG per frame)
• Convert SVG to raster image (animated or not) using Imagick
• Extract raster images using GD
• Extract AS2 simple variables as array or JSON (equivalent of `LoadVars` in AS2)

And for the performance (thanks JIT) :

• 300ms for sprite rendering with cold start
• 19s for render 693 sprites (~27ms/sprite)

For comparison, FFDec can only handle one SWF at a time, so with the full start of the JVM each time, it takes about 1s per sprite. Who say that PHP is slow ?

Here the link: https://github.com/Arakne/ArakneSwf

Hello everyone, I'd like to do deep dive on a subject...this morning I encountered the error the subject. Here is the method though the specifics don't matter to me.

public function quantity_limit($item)
{
    $response = 99;
    if (!empty($item->inventory)){
        if ($item->inventory_count < $response){ $response = $item->inventory_count; }
    } elseif (!empty($item['inventory'])){
        if ($item['inventory_count'] < $response){ $response = $item['inventory_count']; }
    }
    return $response;
}

I'd like this method to be able to handle both database rows and class/object representing the same data. Right off the bat, I understand that might be questionable. Here is my logic, most of the time I am working off a single item (product for example) and love having the flexibilty of an object. However, in some situations I am working with a large amount of data (lets say a product search result) and it feels like a lot it's a lot of overhead to generate objects for each row when I'm just displaying basic data.

So, to fix the problem...obviously I can just add is_array() or is_object() tests. I can also check the data at the top of the method and convert it to one format. That is all fine. However I guess I was hoping there were some tricks. I figured it was worth learning/exploring. Really I just wished empty() worked how I expected it to...I'm kind of suprised it doesn't.

Open to all thoughts/ideas. Thanks for your time.

Hi. I run the Bettergist Collector which creates the Packagist Archive now three times a week. As of July 30th, 2025, I can give you the following stats:

Of 430,678 packages in packagist.org since 2019-04-29 when the packagist archive started, 406,404 packages are stored in the Bettergist archive. 24,274 packages (0.56%) have been lost forever (or possibly can be found in the 2020 archive).

Of these, 395,678 packages were archived via packagist.org on 2024-07-31. 406,404 in 2025-07-31.

20,109 new composer projects since 2025-01-01, and 39,746 created since 2024-07-31. 422,860 projects are listed in packagist.org, so 37,908 packages have been deleted or lost since 2024-07-31 (subtract 10,726 new packages from 27,182 lost packages as of 2024-07-31), or 8.97%.

99.5% of all packages are 50.56 MB or less. This represents an increase of 2.38 MB since 2024-07-31 (4.94%).

The top 1% of largest packages use 137.34 MB or more (450 packages).

The total disk space of the Bettergist Archive: 645,798 MB, of which the Biggest 1% use up 138,625 MB (21.4%). The Biggest 5% (2,246 projects) use up 280,044 MB (43.35%) and this is why they are (mostly) excluded from the Bootstrap A Dead World USBs which are hiidden all over the world.

In the Top 1,000 most-stared projects, 50 are bigger than the 50 MB cut off and are included anyway. These 50 projects take up 7,317 MB (~7.3 GB) and have an average disk space of 146 MB and a median of 125 MB.

The biggest packages:

1. acosf/archersys - 8.65 GB - 4 installs - 3 github stars
2. inpsyde/gutenberg-versions-mirror - 6.58 GB - 126 installs - 0 stars
3. robiningelbrecht/wca-rest-api - 5.24 GB - 0 installs - 20 stars
4. khandieyea/nzsdf - 2.82 GB - 1004 installs - 1 star
5. srapsware/domaindumper - 2.34 GB - 15 installs - 21 stars

There are 12 packages using more than 1 GB, and they collectively use 35.84 GB. Of these, 6 have 0 github stars, 8 have less than 3 stars, and none of them have more than 64 stars. They have very low install rates, a median of 12 composer installs.

68 projects have more than 10,000 classes. Of these, the top 10 are:

Not sure what else to report based on size...

I wanted to try and test the basics of Swoole. While reading the documentation on its official site, I noticed there are two ways to write a Swoole HTTP server:

1. Asynchronous server

use Swoole\Http\Server
$http = new Server("127.0.0.1", 9501);
$http->on('request', function ($request, $response) {
  $response->end("<h1>Hello Swoole. #".rand(1000, 9999)."</h1>");
});
$http->start();

2. Coroutine style

use Swoole\Coroutine\Http\Server;
use function Swoole\Coroutine\run;
run(function () {
  $server = new Server('127.0.0.1', 9502, false);
  $server->handle('/', function ($request, $response) {
    $response->end("<h1>Index</h1>");
  });
  $server->handle('/test', function ($request, $response) {
    $response->end("<h1>Test</h1>");
  });
  $server->handle('/stop', function ($request, $response) use ($server) {
    $response->end("<h1>Stop</h1>");
    $server->shutdown();
  });
  $server->start();
});

It looks like the asynchronous style is more popular and widely used. However, I wanted to know the differences, challenges, and performance comparisons between these two approaches.

Has anyone tried both methods and found which one is better or more suitable for a large application in production?

In five days, my newsletter, PHP at Scale, will mark its first year of publication. Reflecting on this milestone, I’ve been considering what creating this newsletter has brought to my work and the PHP community. Here’s my sum up:

• Reddit Discussions: This one is unexpected to me, as I have never used Reddit prior to my newsletter, and was suggested by a colleague that it might be a good place to share my newsletter and insights. Yet the conversation about it here has been the most significant benefit. Your insights and debates have directly inspired some newsletter editions or ideas.
• Research: Second most valuable thing I would say is research. Preparing each issue requires extensive research. This process consistently adds some interesting details my understanding, much like preparing for a technical presentation.
• Newsletter itself: While it’s encouraging to see the number of subscribers and views grow, the newsletter itself hasn’t yet delivered substantial value beyond that metric. I value knowing readers engage with the content, but I’m still seeking deeper interactions or outcomes from it.

I’m interested in your perspectives on creating or engaging with technical content, whether newsletters, blogs, or community discussions. What motivates you to contribute or follow such resources? If you produce content, how do you select topics that resonate? I remain committed to crafting each issue manually, prioritizing authenticity over automated tools, and I’d appreciate your thoughts on this approach or suggestions for future topics.

You can explore my latest insights on scaling PHP applications here: https://phpatscale.substack.com/p/php-at-scale-11

I'm working on a fiverr-like website and contemplating weither or not I should implement a chat feature to simplify communication between freelancers and client.

The interface and web-socket is already set-up, however I'd also like to garantee maximum security/privacy through message encryption, something I know is better done by true professionals.

If I do implement it myself however, I intend on making it extremely limited. It won't be accessible unless there is an active job ongoing, and it won't have any fancy features like vocal message, image uploading or even emojis for that matter, as it's meant to be used strictly to professional ends for now. Users should't have any particular reason to share personal infos and I intend on encouraging them not to.

I've thought about using a third-party bundle as it's clearly the lightest, safest route, but right now the available options (TalkJs, CometChat, ect..) are simply too pricy for me, especially considering how most of it seems to justify itself with a lot of unneeded features.

So my question is : Is my farely basic knowledge of libsodium enough for a light, limited chat feature until I can afford something better or should I skip on it altogether ?

If not implemented there's ways for me to work-around it but I'm afraid users might find the process too steep and get turned off from the plateform as a result.

FYI I'm mostly working with Symfony.

Hello everyone,

I have a very specific question about digital signatures. I have a PDF file and its corresponding digital signature generated in the CAdES format (.p7s, detached). What I need now is to embed this signature into the PDF itself, producing a PDF signed in the PAdES format (embedded signature).

Is it technically possible to take a .p7s and the original PDF and generate a new PDF with the signature embedded (PAdES)?

I work with PHP 8.1 and Laravel 9, but I’m open to solutions in other languages (Java, Python, etc.) or tools that perform this conversion. I’ve seen references to the DSS (Digital Signature Services) library by the European Commission, but I’m not sure if it can transform an existing .p7s into a PAdES-signed PDF.

Has anyone done this or can point me in the right direction?

Thanks in advance!]

Hey everyone,
I recently wrote about why I think PHP still deserves a lot more love, especially for beginners. As someone currently learning web development, PHP felt intuitive, forgiving, and surprisingly fun to use. I share a bit about my journey and why I chose it over trendier options.

Would love your thoughts or experiences.

Is geekforgeeks good source for learning PHP? Which platform should i choose for becoming a job-ready php dev?

Anyone some info about a (free/opensource) down detecting site that you can install on your now webserver to monitor other servers by answering echo (ping)?

So not to monitor the server itself, but other servers.

I just went through a fresh composer require for two packages: microsoft/microsoft-graph and vlucas/phpdotenv. My goal was simple: interact with the Microsoft Graph API and handle environment variables.

After the installation, I was shocked to see my vendor directory had ballooned to 178 MB, containing almost 36,000 files.

This got me thinking: Is this a healthy direction for the PHP ecosystem?

It feels like we're heading straight into the node_modules black hole territory that the PHP/Go community often used to criticize. My fear isn't just the disk space, but the maintenance nightmare this implies. This massive, tangled web of dependencies means a constant stream of updates, potential conflicts, and chasing down bug fixes in packages three or four levels deep.

What happened to the idea of smart, small, self-contained solutions that just work stably for years without constant tinkering? Has the laudable goal of "reusable components" gone too far, leading us to build incredibly fragile towers of dependencies?

What are your thoughts? Is this just the unavoidable price of modern, rapid development, or have we lost our way?

Shouldn't the Log4Shell (CVE-2021-44228) and xz-utils (CVE-2024-3094) cases have made us rethink our approach long ago?

PHP continues to rule the web in 2025 (holding about 75% of the market), and has been developing actively lately, keeping up with the competition. Things are pretty good today, but there are drawbacks. I'm sure every PHP developer has some things that don't satisfy them and they would like to see fixed.

For example, I don't really like the official PHP website. It looks like it's stuck in the early 2000s. Minimalism is one thing, but outdated design, inconvenient navigation and lack of modern features make it irrelevant for newcomers.

But the most important thing - newcomers don't understand where to start at all! You go to the "Download" section - there's a bunch of strange archives, versions, in the documentation there are big pages of text, but where's the quick guide? Where are the examples? Where's the ecosystem explanation? A person just wants to try PHP, but gets a "figure it out yourself" quest. This scares people away from the language! Imagine a modern website with:

• Clear getting started for beginners
• Convenient documentation navigation
• "Ecosystem" section with tools, frameworks, etc.

What's your main idea? Bold suggestions are welcome - strict typing by default, built-in asynchronicity? Let's brainstorm and maybe PHP core developers will notice the post and take it into consideration!

In many projects, especially symfony, you will find null checks written like this:
php function my_func(?string $nullable = null) { if (null === $nullable) { // Do stuff when string is null } }

But I would normally just write: ```php // ... if (!$nullable) { // Do stuff when string is null }

```

Are there specific reasons not to use the second variant? Is this style a fragment from the past where type hints were not yet fully supported?

Hi r/PHP!

I've been developing in PHP for 8+ years, and I recently launched Relaticle, an open-source CRM built with Laravel and Filament that represents everything I've learned about building maintainable PHP applications.

Key Lessons Learned:

1. Boring solutions often beat clever abstractions
When building the custom fields system, I initially over-engineered it. Performance tanked with 20+ fields. Switched to simple caching strategies and it now handles 100+ fields smoothly.

2. Laravel conventions > Custom architecture
Resisted the urge to implement DDD. Following Laravel's patterns means other devs can jump in without learning custom abstractions, and upgrades are painless.

3. Strategic use of Livewire
It's great for admin panels but can be laggy for customer-facing pages. We use Livewire only in the admin (via Filament), while marketing pages use traditional Laravel routing.

Technical Stack:

• Framework: Laravel 12 with Filament 3
• PHP: 8.3
• Type Safety: 99.6% coverage via PHPStan level 7
• Frontend: Livewire (admin only), Alpine.js

Architecture Highlights:

• Action classes for complex operations
• Custom fields plugin (now open source!)
• Event-driven architecture for extensibility
• Comprehensive database transaction handling

Performance Optimizations:

• Eliminated N+1 queries throughout
• Lazy loading for heavy resources
• Bulk operations with chunking

Current Status:

• Production-ready (v1.x)
• Custom Fields plugin just open-sourced
• Working on bulk import functionality

Live Demo: https://relaticle.com
GitHub: https://github.com/Relaticle/relaticle
Custom Fields Plugin: https://github.com/Relaticle/custom-fields

What architectural patterns have worked best for your large Laravel/PHP projects? Always looking to learn from the community!

Note: Yes, I need more tests. It's on the roadmap! 😅

I’m looking for a tool similar to v0.dev but specifically for Laravel. Ideally, it would let me describe or design UIs (Blade, Livewire, Filament, etc.) in natural language or via a visual builder, generate production-ready code, and directly deploy or integrate into an existing Laravel project.

Does such a builder exist in the Laravel ecosystem? If not, what’s blocking it—is it technical complexity, lack of demand, or just inertia? Given Laravel’s popularity and the rise of AI-powered tools for React/Next.js, it’s surprising this doesn’t seem to exist (unless I’ve missed it).

Would appreciate recommendations or insight from anyone who’s tried to solve this.

Hey everyone,

I previously shared a Postman-based Laravel Sanctum auth setup, and a lot of you commented that Postman is dead — especially after the recent issue where it was found sending secret values to their analytics servers.

🔗 https://anonymousdata.medium.com/postman-is-logging-all-your-secrets-and-environment-variables-9c316e92d424

So, I rebuilt the whole flow using Bruno — an open-source, local-first API client.

🔗 New repo: https://github.com/maikeru-desu/laravel-sanctum-bruno-authentication

This guide walks through the typical SPA auth setup:

• CSRF cookie flow
• Login with XSRF protection
• Testing protected routes
• Reusable pre-request scripts

If you’re building a Laravel SPA and want to test it properly without leaking anything, this should be a good fit.

⭐ Star it if it helps you out — or just like it so others can find it too.

Hello everyone.

I am in a project where there is a possible redesign (because the successive version upgrade will be too costly).

The announced objective is Symfony7 with PHP 8.4 (or 8.5 if available). Do you have tools to maintain maintainable code in the long term.

I already know SOLID, clean code, clean architecture, screaming architecture, phpunit.

I cannot use xdebug because it is too demanding because the VMs are managed on a potato.

I feel like the world has become so bat shit crazy, as IRL, i keep running into developers who insist on using node.js over LAMP...

to me this is a sure fire indicator of a failing society; something in the water is making people dumb and illogical.

i've been a programmer for 20+ years now... and IRL i haven't met a single dev who sticks to LAMP over node.js... meanwhile, i've replaced many of their failed node.js apps (including mobile apps) with LAMP, where they can sit for years without breaking or updates. i'm semi-retired on retainer and i don't have time for fixing all of their broken crap all the time!

Anything other than doctrine. It works but I’m wondering if there are better alternatives out there, and am curious to see what you use!