The difference between copying and innovating is often just velocity.

That’s fair at first glance, but Dataphyre actually includes a built-in diagnostic engine (Dpanel) that: - Validates PHP syntax before runtime - Runs JSON-defined unit tests with dependency checks - Supports perf assertions, expected types, regex, and even custom scripts - Auto-discovers tests inside each module’s unit_tests/ folder - It’s designed to diagnose, trace, and stress-test production modules, not just simulate behavior in CI.

I get that the structure may look unorthodox, but it’s built for resilience and self-healing. Would love for you to take a deeper look, I think you might be surprised.

Totally fair to have that opinion — but the code you’re seeing runs a real-world platform with live users, 3.5M+ SLOC.

I didn’t write this to win style points. I wrote it to survive production firestorms and scale without dependencies.

Happy to take real feedback though — got a specific part you think could be improved?

Yeah, that’s right. It's free if you're not making serious money with it. But if your app's pulling over $10k/year, I ask for a commercial license, it would be rather reasonable.

I’m solo on this, and I’d like to put some (better) food on the table — that’s really the reason behind it.

Doesn't that put the ball a bit far in your court? Once they're already up and running is where you get to dictate any terms to them that would be slightly better than them having to rewrite it with something else.

I get the concern, but I’m not trying to squeeze anyone.

If someone’s making $10k/year using Dataphyre, I’d be genuinely happy with $5/month. I’m just trying to keep this alive and sustainable as a solo dev.

It’s not about control. It’s about being able to put food on the table without VC pressure or paywalls for everything.

https://github.com/jeremie5/dataphyre/blob/main/common/datap... https://github.com/jeremie5/dataphyre/blob/main/common/datap... https://github.com/jeremie5/dataphyre/blob/main/common/datap...

I don't know what you want to say with those screenshots.

I think you get backlash here, because you tried to promote your own work with the argument that the work of other people is bad. Since you attacked potentially a few thousand developers, you should expect negative reactions.

Even if you hadn't attacked the most used PHP framework, it has a sour taste to shit on someone else's work.

Haha, fair — I love the pun.

My issue isn't with PHP as a language. It’s with frameworks that try to do everything for everyone, and end up adding layers of abstraction, indirection, and performance overhead by default — even before you write your first line of app logic.

Symfony, like Laravel, is very capable — but to me, it’s too prescriptive. You either embrace the full stack or fight against the grain. I wanted something where:

- Every module but the core is optional - No need to use the CLI, just drag and drop and it handles it

The templating system, cache, and routing all talk directly

So I wrote Dataphyre — modular, dependency-free, fast as hell. It powers a 3.5M-line ecommerce platform (Shopiro) with a sharded replicated containerized CDN system able of 8k streaming, a fulltext search engine, the "usual" templating and async, all built in.

I'm not sure about your argument. For example, symphony can be used as a micro-framework since a long time (https://symfony.com/blog/new-in-symfony-2-8-symfony-as-a-mic...) and very few dependencies are required.

Relying on such heavy tested is a no brainier for me, especially because it offer well designed abstractions. You seem to see them as dragging you down, I see them as opportunity to have hooks at the right place for free.

Symfony does offer flexibility with its micro-framework mode. But even in that mode, looking at the screenshot in the article you shared, it still adds around 6ms and 2MB just for the controller initialization (probably a tad better with JIT). On the other hand, Dataphyre initializes in ~490KB as of now and serves hello world pages in about ~2.5ms. My issue isn't with abstractions — it's about avoiding unnecessary overhead. Having started off in embedded programming, I’ve always been driven to chase every byte and clock cycle I can. Dataphyre gives you the freedom to choose what's needed, and that’s why it's able to run an entire 3.5M-line platform while staying lean and fast.

Interesting, thanks