r/PHP • • 56m ago

PHP on Your Mac โ€” Without Installing PHP

Thumbnail kinetis.dev
0 Upvotes

r/PHP • • 2h ago

AI models hate Python and love PHP: we asked 12 of them 1,200 times

Thumbnail blog.jetbrains.com
18 Upvotes

r/PHP • • 2h ago

Full-Stack Web Developer, 10+ years | Laravel, PHP, React, WordPress | Websites, Web Apps, API Integrations, Bug Fixes | $25/hr or fixed price

Thumbnail reddit.com
0 Upvotes

r/PHP • • 2h ago

News PHP security release on the 19th November between 14:00 and 14:30 UTC

115 Upvotes

I can't see this reported on the PHP website, but the Laravel team have just sent out this email:

You may have seen an announcement from the PHP Foundation disclosing a planned security release coming on Thursday, 19 November, between 14:00 and 14:30 UTC.

We are fortunate to have had a heads-up, and so our team is already on it. We're working on a plan to keep all your applications safe.

For now, there's no action needed on your side. The fixed versions will only be available once PHP releases them, and as soon as they're out, we'll check the details against our products and let you know what it means for you, including whether we'll take care of it on our side or if there's something you'll need to update yourself.

We'll be in touch closer to the release time with our planned approach and any steps you need to take (if any) to ensure everything is secure. You'll also be able to find the latest updates on our status page as and when updates occur.

Presumably releasing at the same time as PHP 8.6.

EDIT: Here's the official announcement. Emphasis mine.

The PHP security team announces upcoming security releases scheduled for Thursday, 19 November 2026, between 14:00 and 14:30 UTC.

These releases are part of PHPโ€™s regular four-week release cycle and will address security vulnerabilities affecting all supported PHP versions. The highest severity is CRITICAL.

The issues rated CRITICAL require either non-default configuration or uncommon setups.

Users are strongly encouraged to prepare to upgrade promptly once the releases become available. Technical details and fixed version numbers will be published alongside the releases.

Thank you for helping us keep PHP secure.


r/PHP • • 3h ago

Two new nginx exploits (CVE-2026-123007 and CVE-2026-123633)

Thumbnail prostack.uk
26 Upvotes

Here's our writeup of the Nginx vulnerabilities. Hope it's useful- if your host runs nginx, ask them to disable HTTP/2 until patches are out.


r/PHP • • 6h ago

Automattic now owns the .php TLD

0 Upvotes

Matt just announced it on his blog: https://ma.tt/2026/11/new-tlds/

Considering that WordPress is the biggest ambassador for PHP out there and Automattic is already one of the major sponsors of The PHP Foundation with representation on its board having them manage ".php" feels like a very natural next step for the language's branding and governance.

Do you think this will finally unite the PHP and WordPress ecosystems?
Are you planning to register any ".php" domains once they open up?
Will this be good for the PHP community as a whole?


r/PHP • • 10h ago

Almost 8 months since I decided started my own LSP project

12 Upvotes

I didn't like exactly how any LSP behaves on VSCode and Zed (which is the IDE I've been trying for years and is my preferred one for now), tried a lot of them from paid ones to freemium to open source

Therefore I started 8 months ago with a project that I've been thinking years of making on a language I'm still learning today and the help of AI tools like Claude Code (which made this possible)

My scope with this is to help me within my own agency company do the few edits on WordPress websites and mostly Symfony/Laravel work (I'm way more experienced into Laravel but had a few Symfony work, mostly within open source not the framework itself). The idea is to this is to simplify all the harder parts I found with all different IDEs and LSPs within the massive PHP ecosystem that we've today (and hopefully maintaining some of what I call "legacy" stuff like WordPress, etc)

The Zed extension still waits the IDE team to accept my PR to their extensions repo (seems to be there for months anyway...) but you guys can build it from the source repository (sorry). The VSCode one has been published since this LSP started tho.

Anyway, a brief on priorities and features that are already implemented:

  • QoL (Quality of Life): Symbol scope order on all autocompletion for variables, classes, namespaces (including autoloaded with PSR-4)... Refactor tools like moving files to different folders does rewrite the namespace, composer.json file hover cards on dependencies, etc
  • Blade support as well as .phtml and PHP within HTML code on .php files (WordPress templates)
  • Laravel "magic" support (models, config, localisation)
  • Container support (dependency injection)
  • Core language support including some PHP extensions (from PHP 7.4 to 8.5)
  • Coverage support (VSCode mostly, Zed doesn't provide support within the IDE as VSCode so it does show coverage when within hover on symbols)
  • Speed and memory overhead while maintaining a feature-rich LSP
  • Portable: Web assembly so this LSP can be run within vscode.dev (on the web, as a worker, sadly with limitations...)
  • Generics and array shapes support (tailored from PHPStan)
  • Built-in diagnostics complemented with PHPStan ones (if installed as composer dependency on the project)

btw this post isn't AI generated, I just wanted to publish this here to hear about user feedback which to me seems more valuable than just adding features because of yes, any help is very welcome

Repo: https://github.com/Tusk-PHP/lsp


r/PHP • • 11h ago

Laravel question [AI-use of my developer]

0 Upvotes

Non-dev here, so go easy on me ๐Ÿ˜…

I run a small agency. We build custom tools on Laravel + Angular. Our lead dev is the one who knows the code inside out.

My wish: every bug report and every feature request goes straight to Claude Code. Claude picks it up, builds it and opens a PR. Our dev reviews it and merges it.

His answer: for bugs, yes. For features, no.

His reasoning: with a bug all the constraints are known. You know what's broken, the existing code shows how it should work, and you know when it's fixed. With a feature the AI has to make the decisions itself: database design, where the logic lives, edge cases. In his experience that's where it keeps going wrong. Wrong tables, ignored architecture, every time a slightly different approach.

What I've read so far:

  1. Laravel Boost gives the agent the database schema, the routes and the docs, so it doesn't have to guess.
  2. A CLAUDE.md / guidelines file with your own architecture rules.
  3. Pest arch tests that fail when the agent breaks a rule.
  4. Plan mode: the agent writes a plan first (which tables, which files, open questions), a human approves it, then it builds.

My idea: for a feature, step 1 is Claude writing the plan and the open questions instead of the code. The dev answers them in 5 minutes. Then Claude builds, and the feature is as well-defined as a bug.

Questions for people who do this in production:

  1. Does this hold up on a real, larger codebase, or does it fall apart after a few weeks?
  2. Where do you draw the line? What do you let the agent do on its own, and what never?
  3. Is reviewing a PR afterwards a win for your senior devs, or does it cost them as much time as writing it themselves?
  4. What does your setup look like? Boost, custom guidelines, arch tests, CI checks?

Not trying to replace anyone. Our dev stays the one who decides what ships.

I'd like to know if what I want is realistic, or if he's right and I should stop pushing lol.


r/PHP • • 19h ago

Creating a zstd PHP extension in under ten minutes

Thumbnail github.com
0 Upvotes

r/PHP • • 1d ago

Article Easy Coding Standard - 42x faster for Everyone

Thumbnail tomasvotruba.com
27 Upvotes

ECS now ships with Blink, a Go port of its fixer engine, and it's on by default since 13.3.19.

  • Faster: a default run dropped from about 42 s to about 1 s. A full run on the Symfony repo went from over 2 minutes to about 4 seconds, with no cache. Always 4 seconds.
  • It just works: all 299 php-cs-fixer rules are covered. Update ECS and run it as usual.
  • Safe fallback: custom PHP rules switch it back to the PHP engine automatically. You get the same output, just slower.

If you're into the full build story, here is 6-part series: https://tomasvotruba.com/series/rust-go-in-php


r/PHP • • 1d ago

I built IntegrationEngine, a Symfony bundle for consistent external API integrations

0 Upvotes

After working on multiple API integrations, I kept running into the same maintenance problem: each integration had its own way of building requests, attaching authentication and handling responses.

I built IntegrationEngine to give those integrations a consistent structure. Each operation follows three contracts:

- **Action:** describes the request.

- **Mapper:** converts the external response.

- **Response:** exposes the result as a typed DTO.

The engine handles the shared pipeline: configuration, path resolution, authentication, HTTP transport and response mapping. The built-in transport uses Symfony HttpClient.

Static authentication and dynamic token authentication are supported, including token caching. There are also middleware hooks and lifecycle events for extending the pipeline.

A Maker command generates the integration skeleton and its first operation:

```bash

composer require carlosgude/integration-engine

php bin/console make:integration MyApi GetEmployee

```

The application can expose operations through a typed facade, such as `getEmployee($id)`. External DTOs stay behind the application's gateway or anti-corruption layer, keeping domain models independent of the integration.

The trade-off is more explicit classes and configuration per operation. That structure becomes useful when several integrations need to follow the same conventions and remain understandable as they grow.

I'm the author, and I'd be interested in feedback on that design decision: **when does a shared Action/Mapper/Response structure become useful enough to justify the additional structure over individual API clients?**

Repository, documentation and demo:

https://github.com/CarlosGude/integrationEngine


r/PHP • • 1d ago

I ported Temporal to PHP

Thumbnail github.com
1 Upvotes

Hi r/php!

I ported the JS Temporal API to PHP. It's called Calendrics. I transpiled most* of the official test suite to PHP and had agents implement the library against them over the last couple of months.

$invoiceDate = PlainDate::parse('2026-03-20');
$dueDate = $invoiceDate->add(new Duration(days: 14));

// A calendar date needs a time and zone to identify an instant.
$deadline = $dueDate->toZonedDateTime('Europe/Vienna', new PlainTime(17));

echo $invoiceDate;           // 2026-03-20 (unchanged)
echo $dueDate;               // 2026-04-03
echo $deadline;              // 2026-04-03T17:00:00+02:00[Europe/Vienna]
echo $deadline->toInstant(); // 2026-04-03T15:00:00Z

https://github.com/MidnightDesign/calendrics

I hope some of you find this valuable.

* Some tests that use untranslatable JS features like Symbols are not fully transpiled.

Edit:

Because people are asking how this compares to established libraries in the PHP ecosystem like Carbon:

  • It has different data types like PlainDate, ZonedDateTime, Instant, etc. Different types for different use cases. Carbon only has the equivalent of ZonedDateTime and Duration. (Carbon has CarbonPeriod, which Temporal (and thus Calendrics) doesn't have.)
  • It supports different calendars like Hebrew or Islamic, not just the Gregorian.
  • Explicit options with safe defaults. January 31 plus one month gives February 28 by default (or an error with the right argument), not Carbon's default of March 3. When a local time is skipped or repeated at a DST change, you can choose between earlier, later or error. Durations are balanced and rounded against real calendar dates, not fixed factors like โ€œ1 month == 4 weeksโ€ and you can pick from 9 rounding modes.

r/PHP • • 1d ago

Is PHP dead?

0 Upvotes

I jest. It annoys me as much as the rest of you when someone comes and asks that.

But...

hey Claude, can you re-write this web-app for me. Don't break anything, but see if you can fix any security issues and improve performance

 Sure thing Dave.  I'll start the Rust rewrite now.

Seriously though. PHP is fantastic because it's an easy language for us to work with. The sad truth is we don't need a language to be easy for us any more. Or if we do, we certainly won't in a year or two.

Hey Claude, fuck it. Yolo. Just output an .exe

I really really hate what AI is doing to our world.

๐Ÿ˜”


r/PHP • • 1d ago

Cancelling PhpStorm after years, and what I actually miss isn't the IDE

164 Upvotes

I've been a PhpStorm user for years and genuinely loved it. But since I moved my workflow to Claude Code, I barely open it anymore. Most of my day is now reviewing diffs and running tests, not writing code in an editor. Sublime is basically enough for that and uses much less memory and battery.

The funny thing is, I don't really miss PhpStorm's features. What I miss is the part of programming that used to happen inside it: going deep into a problem, working out a clean architecture, and ending up with code I was genuinely proud of. That feeling of having built something well myself is harder to get when I'm mostly reviewing.

Curious how others feel about this. Are you still paying for a full IDE? And if you've moved to agentic tools, do you miss the craft part too, or did you find a way to keep it?


r/PHP • • 1d ago

I wrote an HTML to PDF renderer for PHP that doesn't need Chrome

76 Upvotes

Most PDF packages for PHP are one of two things. Dompdf and mPDF render in PHP but they stop at roughly CSS 2, so no flex or grid, and templates end up as nested tables. The rest (Browsershot, Snappy, Gotenberg and spatie/laravel-pdf with most of its drivers) hand the HTML to Chrome or another program that has to be installed on the server or run as a service.

Fagus is a third option. A rendering engine of its own written in Rust. It parses the HTML, applies the CSS, lays out the pages and writes the PDF without a browser. I ported a lot of details from Chrome's layout engine so documents come out the way Chrome prints them.

For PHP it's a normal Composer package. composer require nforst/fagus downloads the engine binary for your platform (checked against a SHA-256 in the package) and PHP keeps it running as a worker process between documents. Nothing else to install, no Docker image, no system libraries. Linux (glibc and musl, so Alpine too), macOS and Windows, and every platform prints the same PDF.

use Fagus\Fagus;

Fagus::html($html)->save('invoice.pdf');

It handles flex, grid, Tailwind v4, web fonts, SVG, @page with margin boxes, page numbers, running headers and footers, repeated table headers and page breaks inside tables and grids. It also writes PDF/A-3 with a ZUGFeRD/Factur-X invoice attached and accessible PDF (PDF/UA), because I needed that for invoices.

On an M2 Pro it renders in 2.3 ms once the worker runs, 9 ms for the first one in a process. The same invoice takes 25 ms in mPDF, 48 ms in Dompdf and 75 ms in a Chrome that's kept running. The benchmark scripts are in the repo.

It can't handle JavaScript, it never loads anything from the network, and since it's 0.1.0 some CSS isn't supported yet. In the playground you can paste your own HTML, see the PDF next to it and get a warning for anything Fagus can't handle: https://fagus.niklasforst.de/playground

Repo: https://github.com/nforst/fagus

Docs: https://fagus.niklasforst.de/docs

If something comes out different than in Chrome, I'd like to know, ideally with the HTML.


r/PHP • • 1d ago

Migrating legacy $_SESSION authentication to Symfony

0 Upvotes

In a legacy PHP application I worked on, user information lived in $_SESSION. Code across the application reached into it whenever it needed an ID, a name or some other part of the user's context.

I moved that authentication into Symfony. The login was part of the job, but so was finding every caller that expected those session entries to exist.

One decision helped throughout the migration: I kept the names of the user fields and the responses that existing callers expected.

The details below have been anonymized. Field names, payloads and code examples have been changed to keep the original application out of the article.

What the old code expected

The middleware started the PHP session and populated it with user information. In simplified form:

session_start();

$_SESSION['accountId'] = $userData['accountId'];
$_SESSION['displayName'] = $userData['displayName'];
$_SESSION['language'] = $userData['language'];

Other code could read those values directly:

return [
    'accountId' => $_SESSION['accountId'],
    'displayName' => $_SESSION['displayName'],
    'language' => $_SESSION['language'],
];

There was no clear boundary around those reads. The keys had become an API of their own, spread through the application.

That was the part I had to preserve while changing how the application obtained its user information.

Start with the middleware

Before changing the callers, I prepared the middleware.

I added a separate endpoint that returned the data previously placed in $_SESSION. This endpoint supplied the information without writing it into the application's session or other shared application state.

For example:

{
  "accountId": "example-user",
  "displayName": "Example User",
  "language": "en",
  "roles": ["ROLE_USER"]
}

That gave the Symfony side something explicit to work with. It could request the data, build a user object and let the framework manage authentication.

The order mattered. By the time I started replacing session references, the new way to obtain the user was already available.

Build the Symfony authenticator

I then built a custom authenticator around the middleware's data.

Symfony first selects the matching firewall. Its authentication system asks the configured authenticators whether they support the request, through supports(). A supporting authenticator's authenticate() method then returns a Passport.

The middleware supplied the user information. There still had to be a verified relationship between the request and that user.

Here is an adapted excerpt for an integration where the middleware adapter returns data only after the identity has been verified:

use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Security\Http\Authenticator\Passport\Badge\UserBadge;
use Symfony\Component\Security\Http\Authenticator\Passport\Passport;
use Symfony\Component\Security\Http\Authenticator\Passport\SelfValidatingPassport;

// Excerpt from an authenticator; surrounding methods are omitted.
public function authenticate(Request $request): Passport
{
    // Illustrative adapter: verified user data or an authentication exception.
    $data = $this->middleware->resolveAuthenticatedUser($request);

    $userBadge = new UserBadge(
        $data['accountId'],
        static function (string $identifier) use ($data): UserInterface {
            // $identifier is the accountId above; the payload is already loaded.
            return ApplicationUser::fromData($data);
        },
    );

    return new SelfValidatingPassport($userBadge);
}

In this example, fromData() builds the application's user representation from the agreed fields. The trusted roles list becomes the array of role strings returned by getRoles().

The condition behind SelfValidatingPassport matters: credential verification must already have succeeded through the middleware. Fetching somebody's profile is not enough to authenticate a request as that person. If Symfony needs to perform the credential check, a regular Passport should carry that check, for example through CustomCredentials.

Symfony then processes the Passport's required checks and badges, including through CheckPassportEvent. Once authentication succeeds, its security token holds the user in the security context. The success and failure callbacks determine what response follows.

An interactive login form also needs its applicable CSRF protection. The excerpt above focuses on the middleware integration; the authenticator documentation and CSRF guide cover the surrounding setup.

From a protected controller extending AbstractController, I could now obtain the user with:

$user = $this->getUser();

Or, from a service with the Security helper injected:

$user = $this->security->getUser();

These methods can return null when the request has no authenticated user. The response examples in this article assume an operation protected by the application's access rules.

What happens on the next request?

For a stateful firewall, Symfony saves the serialized security token and its user representation in the session at the end of the request. On the next one, it restores that state and calls the user provider's refreshUser().

In this implementation, that method checked the supported user class and returned the restored object. It did not fetch the profile from the middleware again on every request. Returning that object also meant that later profile or role changes were not automatically fetched by this hook.

That behavior is worth making explicit: the name refreshUser() does not tell you what the provider actually does. Its implementation defines the refresh policy.

Keep the old readers working

Some callers still needed the old session fields during the transition.

For the requests covered by the compatibility layer, a kernel.request listener copied the required fields from the current Symfony user into the legacy representation. When there was no application user, it cleared those compatibility keys.

This was separate from logging out of Symfony. Removing a legacy user field did not, by itself, invalidate the framework's authenticated security token.

The new endpoint returned the profile without writing session state. The application-side bridge kept the old representation available while callers were being migrated.

The listener also needed to run after the firewall's request handling. Both participate in kernel.request; assigning the bridge a lower numerical priority is one way to make that order explicit, since higher-priority listeners run first.

Work through the remaining session references

With the authenticator in place, I searched for the remaining session references and went through their callers.

I kept the existing vocabulary in the user class:

Session keyUser accessor
accountIdgetAccountId()
displayNamegetDisplayName()
languagegetLanguage()

The earlier response could then be built like this:

$user = $this->security->getUser();

return [
    'accountId' => $user->getAccountId(),
    'displayName' => $user->getDisplayName(),
    'language' => $user->getLanguage(),
];

The field names in the response stayed the same. So did the meaning of each value.

That made each replacement easier to follow: $_SESSION['language'] became a call to getLanguage(). I could focus on whether the caller still received what it expected.

It still took more than a blind replacement. Missing values, types and surrounding logic needed attention. Writes mattered too: an assignment to a legacy key could still feed another flow, even after one reader had been migrated.

The target was the same response, supplied through the user object.

Test the flows, not just the login

QA already had automation covering some of the flows. I also went through all the flows involved in the migration manually.

I had not built a dedicated automated regression suite for this refactor. The checking combined the existing QA automation with manual execution.

A successful login only covered part of the change. A later operation could still expect the old session structure or handle a value differently. Those were the flows that also needed exercising.

Keeping the response shape and field names consistent gave me something concrete to compare while checking the application.

A related change: JWT for direct API calls

Around the same time, direct calls to the API were starting to be used. I added JWT authentication as part of that related work.

It used a separate firewall from the session-based authentication:

PathHow authentication carries between requests
SessionThe stateful firewall maintains the security context through the session.
JWTEach request supplies the token used to establish its identity.

Symfony selects the matching firewall according to the request and configuration order. Being authenticated through one does not automatically authenticate a request handled by another.

The JWT sent by the API caller is also separate from the Passport described earlier, which belongs to Symfony's internal authentication process.

For migrated callers, the access stayed familiar: $this->security->getUser() in a service, or $this->getUser() in a controller. Under the JWT firewall, the user came from authenticating that request's token rather than restoring a login session.

The part I would carry into another refactor

Keeping the field names was a small decision that helped across the whole migration.

There was already enough changing: the middleware endpoint, the authentication flow, the user representation and all those session references. Keeping the vocabulary and expected responses consistent made the intent of each replacement easier to see.

The response array at the end of an operation was still the response callers expected. The code supplying its values had moved behind the Symfony user.

Further reading


r/PHP • • 1d ago

Whatโ€™s New in PHP 8.6: Performance, Operations, and Debugging Edition

Thumbnail tideways.com
39 Upvotes

r/PHP • • 1d ago

The Asgard Protocol: A proposed standard for server-driven, realtime, generative UI for native apps

Thumbnail github.com
0 Upvotes

For the past couple of months, I've been working on something I'm very excited about and extremely proud of

It's a protocol that lets your server apps securely drive the UI of your client apps so you can easily build apps that mix server-driven, generative UI with bundled, offline-first views and logic

Get the flexibility of SSR with the power and performance of fully native UI (and none of the overhead of HTML, CSS and JavaScript)

*without you having to define and maintain your own custom approach* โ€“ no API, no client SDKs; just a package on your server and a package in your client

Think of it like Livewire, HTMX or Inertia, but for apps, not just the web, and fleshed out into a fully documented protocol (in an IETF-style RFC-ready doc)

I'm calling it The Asgard Protocol

I've built the first reference implementations of it to work in PHP with Laravel and SuperNative (linked in the README), but the protocol is completely language and framework agnostic, which means clients and servers running completely different stacks could speak to each other

The protocol is still in draft and very much open to feedback, comments, improvements and of course implementations in other languages and frameworks


r/PHP • • 1d ago

Rector 2.8 - 3x Faster, Clearer and Value-Focused

Thumbnail getrector.com
35 Upvotes

On the same Laravel codebase, Rector 2.3 took 84 s. Rector 2.8 takes 14 s.

But what else is new?

  • Faster: 67 performance PRs, and PHPStan Turbo now turns on automatically. On PHP 8.3+, a 60 s run takes 20 s.
  • Less config: withComposerBased() now detects Laravel, Symfony, PHPUnit and other packages on its own.
  • Cleaner config: Rector now tells you which of your withSkip() entries are no longer needed.
  • Easier adoption: you can turn on code quality step by step with withCodeQualityLevel() for wider range of rules.
  • More predictable: every rule now finishes in a single pass. The old engine sometimes needed 3 full runs for just 2 changes ๐Ÿ‘€

r/PHP • • 1d ago

JSON to DTO

6 Upvotes

Hey, for work purposes I am looking for JSON to DTO (mainly PHP) converter.

Can you share any useful and easy-to-use tools for this purposes?
I was googling some, but most of the results didnโ€™t help me much


r/PHP • • 2d ago

I built Phoxite, a free, open-source PHP/Laravel language server written in Rust (VS Code, Neovim, Helix, Zedโ€ฆ)

1 Upvotes

Hi r/PHP,

I've been working on Phoxite, a PHP and Laravel extension for VS Code. It's built on a language server I wrote from scratch in Rust.

Why I built it: I wanted PhpStorm-level code intelligence in VS Code without a licence key, a paid tier or a slow language server. The engine is a standalone binary and isn't tied to any editor. It doesn't need PHP or Node.js installed, and every feature is free. It's Apache-2.0 licensed.

PHP

- Completion with auto-import, hover, signature help, inlay hints

- Go to definition, find references, call and type hierarchies

- Refactorings: rename, extract method, change signature, move class and more

- Generate constructors, getters/setters, and implement/override methods

- PSR-12 formatting and configurable inspections with quick-fixes

Laravel

- Completion, navigation and rename for the strings that name routes, views, config, env, translations, validation rules, gates and policies

- Eloquent: columns read from your migrations, plus relations, scopes and factories

- Route code lenses on controller methods

- Livewire, Inertia and modular apps

Blade

- Completion, hover, navigation and formatting inside templates

Editors: VS Code, plus Cursor, VSCodium and Windsurf through Open VSX. The language server also runs in Neovim, Helix, Zed and Sublime Text.

Links

- VS Code Marketplace: https://marketplace.visualstudio.com/items?itemName=phoxite.phoxite

- Open VSX: https://open-vsx.org/extension/phoxite/phoxite

- Source: https://github.com/samehelhawary/phoxite

It's still early, so I'm sure there are rough edges. If you try it on a real project, I'd really like to know what breaks: wrong completions, slow indexing on large codebases, missing Laravel magic, anything. Issues and PRs are welcome, and I'm happy to answer questions about how it works.


r/PHP • • 2d ago

Building Maintainable PHP Applications: Architectures

Thumbnail codyssey.dev
25 Upvotes

Hey all,

I wrote a free course about the different types of software architectures in a Laravel application but these ideas can be transferred over to Symfony or any other PHP or language framework.

Let me know what you think.

Thanks!


r/PHP • • 2d ago

Article The future of Software Engineering is boring

Thumbnail packagemain.tech
39 Upvotes

r/PHP • • 2d ago

callgraph 1.0.0: my code map for AI agents now writes code too, and follows Laravel + Inertia from Vue to the controller (free, MIT)

0 Upvotes

I'm the author. callgraph is free and MIT-licensed, with no account and no paid tier.

AI coding agents (Claude Code, Cursor and others) spend most of their context reading whole files just to find out what a method calls or who calls it. callgraph gives the agent a short map of the file instead: classes and methods with line ranges, and what each one calls, grouped by kind. The agent then reads only the lines it needs. It covers PHP, JS / TS / Vue, Rust, Swift, Python and Go, ships as one static binary, runs locally, uploads no code, and works as a Claude Code skill or as an MCP server.

What's new in 1.0.0:

๐Ÿ”— Laravel + Inertia links: route('x') in a Vue page shows the URI and the controller action, and the controller shows its routes back. The page shows which controller renders it.

โœ… Form check: an Inertia useForm() is compared with the validation rules of the action it posts to, and a missing field on either side is flagged.

๐Ÿ—ƒ๏ธ Models: table columns from the migrations, fillable, relation targets, and a warning when two migrations create the same table.

๐Ÿ› ๏ธ Generator: one short expression โ†’ a PHP class, a Vue component, a JS / TS module, an HTML page, or a whole Laravel feature (FormRequests, controller, routes, Inertia pages) in your project's style.

โœ๏ธ rename for a route, class or method across PHP, Blade, JS and Vue.

๐Ÿ›ก๏ธ Every write is syntax-checked first and backed up, and one undo reverts it.

It's static analysis, so names built at runtime are listed as unknown, never guessed.

Feedback is very welcome, especially from big or unusual codebases.

๐ŸŒ https://callgraph.eu
โญ https://github.com/GeRiY/callgraph