PHP-first interfaces for Laravel and Inertia.

Build the interface from PHP. Keep the frontend cohesive.

Inlay turns Laravel contracts into polished administration screens with the same behavior in React and Vue.

Read the documentation See it in action

Laravel 12+Inertia v3React + Vue

Inlay panelLive contract

ADMIN PANELUsers

Active users2,481+12.4%

Pending review18Today

NameRoleStatus

AM Alex MorganAdmin Active

JR Jamie RiveraEditor Active

SK Sam KimViewer Invited

PHP schema

TextInput::make('email')
    ->email()
    ->required();

from schema to screen

Choose a surface. Keep the contract.

Start with one PHP vocabulary, then switch between the screens your application needs.

Form schema

Validated inputs, ready for a real screen.

Describe fields once, then carry rules, messages, and accessibility into React or Vue.

Explore forms

Form.phpinlay.forms.v1

TextInput::make('email')
    ->email()
    ->required();

Table schema

Search and sort without duplicating query logic.

Keep filters, pagination, and row actions in the contract your server already understands.

Explore tables

Table.phpinlay.tables.v1

TextColumn::make('name')
    ->searchable()
    ->sortable();

Infolist schema

Readable record details from the same data shape.

Present a polished summary view without creating another set of model mappings.

Explore infolists

Infolist.phpinlay.infolists.v1

TextEntry::make('email')
    ->label('Email');

Action schema

Intentional operations with policy built in.

Turn a domain operation into a clear, confirmable action with feedback for the user.

Explore actions

Actions.phpinlay.actions.v1

Action::make('approve')
    ->requiresConfirmation();

01: Server-owned rules
02: Versioned Inertia props
03: React and Vue renderers
04: Packages that compose

// under the hood

One contract. Every surface in sync.

Keep authorization, validation, querying, and persistence in Laravel. Inlay carries the intent across Inertia, so your frontend stays focused on rendering a great experience.

A resource stays readable

final class UserResource extends Resource
{
    public static function form(Form $form): Form
    {
        return $form->schema([
            TextInput::make('name')->required(),
            Select::make('role')->options($roles),
        ]);
    }
}

01 Describe: Define the screen in PHP, close to your model and policy.
02 Transport: Serialize a stable, typed contract through Inertia v3.
03 Render: Let React or Vue provide the accessible browser controls.

// built to grow with you

Everything you need to ship a panel.

Start with a Form or Table. Add Resources, themes, actions, widgets, and plugins when the application earns them.

01PHP-first contracts: Define forms, tables, Resources, and panels in the language your Laravel application already owns.
02One shared payload: Inertia carries a versioned contract to React or Vue, keeping behavior and presentation aligned.
03Ready for real CRUD: Search, filters, validation, actions, widgets, policies, and account settings grow with your application.
04Open extension points: Themes, plugins, fields, columns, renderers, and community packages fit the same public seams.

// get started

From a clean Laravel app to your first screen.

Install the foundation, scaffold a panel, then let your resource classes describe the work your team does every day.

FrontendReact is the defaultPrefer Vue? Use --renderer=vue.See renderer options

Read the getting started guide Browse the package map

The first three commands ready to run

01
Install the foundation
Add the panel runtime and renderer contracts.
```
composer require inlayphp/inlay:"^0.3"
```
02
Scaffold your panel
Generate the provider, auth pages, and User Resource.
```
php artisan inlay:install --panels
```
03
Describe the first resource
Shape its Forms, Tables, validation, and actions in PHP.
```
php artisan make:inlay-resource Post --generate
```

React renderer includedVue preset available

// start where you are

A guide for the whole journey.

From a clean Laravel application to a production-ready admin panel, follow the path from schemas and validation to actions, themes, and plugins.

// make the next screen yours

Start with a clean Laravel application.

Install Inlay, register a panel, and let PHP describe the interface your users need.

Get started View the source

Build the interface from PHP. Keep the frontend cohesive.

Choose a surface. Keep the contract.

Validated inputs, ready for a real screen.

Search and sort without duplicating query logic.

Readable record details from the same data shape.

Intentional operations with policy built in.

One contract. Every surface in sync.

Everything you need to ship a panel.

From a clean Laravel app to your first screen.

Install the foundation

Scaffold your panel

Describe the first resource

A guide for the whole journey.

The mental model

Forms

Tables

Resources

Infolists

Validation

Actions

Themes

Plugins

Start with a clean Laravel application.

Search the docs