TL;DR
xphp is a PHP superset: you write class Box<T> and new Box<User>(), and a compiler monomorphizes it into plain PHP -- one concrete class per instantiation, native typehints baked in, nothing generic left at runtime.
Disclosure up front: I'm the author and I built this with heavy AI assistance (Claude) in every stage -- design, code, and tests. It's all v0.1. I'm after honest technical feedback more than stars, and "an AI wrote it so it's slop" is fair game too if the code earns it.
The idea
You write .xphp files with class Box<T> and new Box<User>(). The compiler monomorphizes them into plain PHP: one concrete class per instantiation, native typehints baked in, zero generics left at runtime. It compiles to vanilla PHP -- no extension, no runtime. You can drop a single .xphp file into an existing app and compile just that.
Box<int> and Box<User> each become a real class after compilation.
final class T_6da88c34 implements \App\Box { public function __construct(public readonly int $value) {} public function get(): int { return $this->value; } }
The template itself compiles to an empty interface Box {}, and every specialization implements it -- so instanceof Box still works across all Box<...>.
How it parses syntax PHP can't
<T> is a syntax error -- to PHP and to nikic/php-parser, < is the comparison operator.
Forking the grammar is a maintenance black hole, so instead:
- Tokenize with
PhpToken (strings and comments handled correctly). - Walk the tokens, detect
class IDENT <...>, function name<...>, and Name<...> call sites, recording each with its byte range and a parsed type-arg tree. - Replace each
<...> clause with equal-length whitespace -- the result is valid PHP whose byte offsets and line numbers are byte-identical to the original. - Parse that with nikic/php-parser.
- Walk the AST and reattach the generic metadata by matching
(line, name) plus order.
It's being built as an ecosystem, not a monolith
The design choice throughout is to plug into existing tools instead of replacing them, and to have everything reuse the compiler's own core rather than reimplement semantics. That's the only way the surrounding tools stay honest -- and the shape an ecosystem needs, even if it's all day-one right now:
- Editor support: a language server that reuses the compiler's own AST, instantiation registry, and type hierarchy directly -- so definition, references, rename, completion, hover, inlay hints, and diagnostics run on the same semantics the compiler uses, not a second guess. Ships as a PHAR, works with any LSP-capable editor, and a PhpStorm plugin bundles it.
- Framework integration: a Symfony bundle that hooks compilation into
cache:warmup, so the generated PHP falls out of your normal build as a deploy artifact with no extra pipeline step. It can also register a specialization like CachedFinder<User> as an autowired service, so you inject the concrete type straight from the container. (Requires Symfony 8 / PHP 8.4.)
Compiler, editor tooling, framework integration: separate repos, one shared core.
What honestly does not work [yet]
- The
< disambiguation is a heuristic. You can't write bare-identifier comparison chains like FOO < BAR > BAZ in an .xphp file -- it gets misread as a generic and dies with a confusing parse error that points at the stripped source, not your code. Variables, parens, and :: all defuse it, so it's narrow, but it's a real hole. Foo<Bar>[] (array of a generic) is not supported.- Generic methods only on non-generic classes for now.
- The LSP is explicitly partial; the PhpStorm plugin isn't on the Marketplace yet (install from disk).
Prior art I'm not pretending to replace
The long-running generics RFC, the PHP Foundation writeups on why reified generics are hard, Hack/HHVM. This does not attempt runtime reification -- it sidesteps it the way Rust and C++ do, by specializing at build time.
Two questions I actually want answered
- Is a build step plus a generated namespace an acceptable tradeoff in a real project, or an instant dealbreaker for you?
- Where would this earn its place over docblock generics with PHPStan/Psalm, which already give you the static safety without the codegen?
Repos are under the xphp-lang org on GitHub. Roast welcome.
Login
