Invention · method
The biggest thing I have built, and the one you cannot download — because it is not, in the end, a thing. LuCipher is a philosophy of system design first, and a family of implementations second. What it really is, is how I do it.
Everything below this line is downstream of one idea. Laravel is treated as the All Mind: a single mind that corresponds to itself, and is made of multiple Laravels inside the same project. Not a framework running an app — a framework running itself, at more than one scale at once, where the shape you find at the top is the shape you find at the bottom.
That is the law of correspondence — as above, so below — applied until it stops being a metaphor and starts being a build. The seven laws it belongs to are written down separately, on their own page, deliberately kept free of any framework so they outlive this one.
The mechanism is literal. One document root, one PHP process: a request arrives, and the application it lands in boots a sibling Laravel's autoloader and bootstrap file in place and runs it — Laravel inside Laravel, no iframe, no CORS, no internal HTTP hop. Two questions are answered before any of your code runs: which application am I, resolved from the filesystem, and whose install is this, resolved from the domain that reached us.
A fleet of separate applications then behaves as one product, and the engine underneath stays one codebase serving them all. That sentence is the law restated in plain English: the same structure at the fleet scale and at the single-app scale, agreeing, or the seam shows.
And it is not a demonstration. Every application I have built for myself, and the infrastructure of my own companies, runs on LuCipher. I live in it daily; that is the only claim about it I would call proof.
What it collapses
The philosophy is the point; this is what it buys, which is easier to see.
Most companies that offer web tools offer a pile of logins: one product for SEO, another for analytics, a third for the storefront, a fourth for project management — each with its own account, its own session, its own idea of who you are. LuCipher exists to collapse that pile.
One account works everywhere. Sign in once and every tool in the fleet already knows who you are and which company you belong to. The applications stay independent underneath — their own code, their own schema — and the doors open both ways: a signed-in user moves from one to the next and is simply still signed in. No second login, no hand-off screen. Software that was never designed to meet behaves as one product.
It is white-label to the bone. The platform decides who it is from the domain that reaches it: point a domain at it and the whole thing comes up wearing that reseller's name — their branding, their clients, their own slice of the data — while the engine underneath stays one codebase serving them all. Rows are scoped per install, with a shared tier that every install can see, by design rather than by accident.
An existing Laravel application can be grafted into the structure whole. It keeps its own code and does its own job; everything around the job becomes shared — user base, authentication, session, data access. A CMS dropped in already knows every user. A CRM dropped in is already behind the same login, looking at the same accounts.
The implementation
The philosophy is framework-agnostic on purpose. What follows is one implementation of it — the current Laravel one — and it is not the point.
lucipher/unitethe glue
Boots a fleet of Laravel applications into one system. Which brand you are under, which company you belong to and which data you are on is decided before the first page renders — and one session signs you in across every application in the fleet.
lucipher/modelsthe engine room
A model-driven CRUD engine. Describe a model and it serves the web, REST and API routes for it — list, show, create, edit — from the model's own metadata, through one route shape, without a controller per table. That one shape covering every resource is correspondence you can visit in a browser.
lucipher/razorthe face
The shared view layer: layouts, navigation and interface components every application renders through, so a dozen of them look and behave like one product instead of twelve.
I would rewrite all three tomorrow if a better shape turned up. The Laravel build is an old one and could already have been done better — the philosophy is the part I will never abandon. Anything that names a framework, a package or a class is implementation; the laws never mention one.
Laravel Universal (CRM in PHP/HTML, etc duh!) Repository
That is where the name came from, when it was only a Laravel thing. Say it out loud and you will hear the other joke. Neither one is the definition — the definition is seven laws that never mention Laravel at all.
The philosophy
The principles of the Kybalion applied to system design. Correspondence is the master law and its practice has a working name — fractal design: the function is the architecture in miniature, the commit history is the roadmap in miniature. When the small and the large disagree, one level is lying, and it will fail at the seam.
They are held by inference and relatively — mutable laws, not doctrine. Confidence about the code; humility about the laws, in that order. The whole set, each with the way you will actually watch it fail, is on its own page.
Access
LuCipher is proprietary — the platform and the philosophy both. It is not on a marketplace, there is no public price list, and none of it is open source. It runs companies, so it moves the way infrastructure moves: by arrangement, for enterprises, with me involved. The laws are published so they can be read and argued with, which is not the same as being given away.