Grease

🍱

A menu, not a monolith

Independent, opt-in tiers across Laravel's hot paths — model, events, Blade, config, validation, query grammar, container, request, router. Take the ones whose hot paths you run; skip the rest. The model trait is the zero-config on-ramp, not the whole package.

🪞

Byte-identical output

Same bytes as vanilla — or it's a failing test. Asserted across every tier in the parity suite: every cast, edge value, dirty-check, resolved SQL string, served response. That promise is the whole product.

🧱

Compute once, reuse

Every tier removes the same waste — work that's a pure function of stable inputs, recomputed per row, per attribute, per component, per render, per request, per query. Grease computes each fact once and reuses it.

🚀

Across the whole request lifecycle

Container resolution → request input → route-middleware resolve → config reads → query compilation → hydration & casting → Blade render → serialization. A faster path at each stage, all stacking on one real request.

⚡

The model trait is the easiest win

hydrate −54% · toArray −53% · set+dirty −62% · read −27% · enum cast −44% · date serialization −87%. `use HasGrease;` and done — no config, no provider. Marginal in isolation; compounded on a real request, they aren't.

🧊

Eager caches make once-per-request work ~free

`grease:config-cache`, `grease:route-cache`, `grease:view-cache` — drop-in twins of Laravel's `*:cache` that precompute resolution into opcache-interned files. Config reads, middleware, and view lookups become hash hits, server-wide.

🧩

Zero cost to what doesn't opt in

Nothing is auto-discovered beyond the trait you add. Every tier is a deliberate opt-in; code that doesn't take one runs pure vanilla. PHP 8.2+, Laravel 12 / 13.

Start with one trait

php

use Grease\Concerns\HasGrease;

class User extends Model
{
    use HasGrease; 
}

An endpoint that lists 100 users and serializes them to JSON drops from 3.58 ms to 0.46 ms — real SQL included, not a micro-benchmark. That's :memory: SQLite, where Eloquent is most of the request; against a networked database the same ~3.1 ms come off a larger total, so the percentage is smaller while the time removed holds (how to read these honestly).

That's the model and event tiers together. The model trait alone is the easiest win and a fine place to stop — but Grease is a menu, and the rest of it lives across the request, not just in Eloquent:

Model — use HasGrease; (or extend Grease\GreasedModel): hydration, casting, serialization, dirty-checking. Per-row × per-attribute. Zero config.

Providers you register — a faster event dispatcher, Blade compiler, config repository, validator, and query grammar: each one line in bootstrap/providers.php.

App-entry swaps — a greased container, request, and router: a one-line edit where each is constructed, before any provider runs.

Deploy caches — grease:config-cache, grease:route-cache, grease:view-cache: drop-in twins of Laravel's own *:cache that take once-per-request resolution to ~free.

The same idea runs under all of them. Laravel re-derives the same stable facts over and over — the casts array and a fresh ReflectionClass per hydrated row, the merged input map on every $request->input(), a config key's dot-walk on every config(), a route's middleware resolve-and-sort and a view's name→path stat-walk on every request, an identifier's quoting on every query. None of it changes for the life of the process. Grease computes each fact once and reuses it — byte-for-byte the same result, a fraction of the work.

Each of these was proposed to Laravel core and declined on reasonable grounds — every one "marginal in isolation." Individually, maybe. Layered on a real request — booted, routed, hydrated, rendered, serialized — they move the number you actually pay for. Grease is where that declined work lives — see the history.

Byte-identical to vanilla, or it's a failing test.

Get greased →

GreaseGet greased.