# laravel-frontend-presets/tall: a TALL stack preset that publishes its scaffolding into your app

> The TALL preset scaffolds Tailwind CSS, Alpine.js, Laravel and Livewire into a fresh Laravel application, and unlike the default Laravel presets it copies every view, component, controller and test into your own project. Here is what that buys you, what it costs, and when Jetstream or Filament is the better answer.

**laravel-frontend-presets/tall** — A TALL (Tailwind CSS, Alpine.js, Laravel and Livewire) Preset for Laravel

- Repository: https://github.com/laravel-frontend-presets/tall
- Stars: 2,610 · Forks: 209
- Language: Blade
- License: MIT
- Published: 2026-09-28 · Updated: 2026-09-28 · Language: en
- Canonical page: https://hysenlabs.com/projects/laravel-frontend-presets-tall

## What the TALL preset actually does for a fresh Laravel app

The acronym stands for Tailwind CSS, Alpine.js, Laravel and Livewire, and the package is a front-end preset: a one-shot scaffolder that rewrites a new Laravel application into a TALL application. It is aimed at developers who have already decided on that stack and want the wiring done before they write their first feature, rather than at teams evaluating front-end options.

The README lists what you get: views extending a default layout, front-end assets compiled with Vite 3, Tailwind-powered pagination views, and the Tailwind UI and Tailwind Custom Forms extensions available out of the box. The authentication variant adds Livewire components, single action controllers and pre-written tests.

The interesting design decision is not the stack. It is that everything is published into your application. The README states that all routes, components, controllers and tests are published, so you have full control over every aspect of the scaffolding and no reason to dig around in the vendor folder. That is the opposite of a package you depend on and upgrade.

## Published stubs instead of a runtime dependency

Laravel presets work by copying files from the package into the host application. The repository layout reflects this: a src/ directory holds the preset class and its install logic, and a stubs/ directory holds the Blade views, Livewire components, controllers and tests that get written into your app when you run the artisan command.

That means the preset runs once. After `php artisan ui tall` finishes, your application contains ordinary files that belong to you. Livewire remains a real dependency, since the components you just received extend Livewire base classes and need the runtime. The preset package itself does not, which is why the README can say it is safe to remove once installed. It goes further and calls the package fully redundant, because the auth logic lives in your /app directory rather than behind a vendor namespace.

There is a cost hidden in that design. Published code does not receive fixes. If a later release corrects a validation rule in a published controller, nothing tells you. You find out by reading release notes and diffing by hand, or you never find out.

## Installing the preset and rendering your first Tailwind page

The README is explicit that this preset is intended for a fresh Laravel application, and it points to Laravel's own installation instructions for getting a working environment first. Install into an existing application at your own risk, since the preset overwrites views and configuration.

The base install pulls in Livewire and the preset, runs the artisan ui command, then installs and compiles the front-end assets:

```bash
composer require livewire/livewire laravel-frontend-presets/tall
php artisan ui tall
npm install
npm run dev
```

If you want the authentication scaffolding as well, the README says to add the --auth flag to the same command:

```bash
composer require livewire/livewire laravel-frontend-presets/tall
php artisan ui tall --auth
npm install
npm run dev
```

After `npm run dev` completes, the Vite dev server is running and your Blade views are served with compiled Tailwind and Alpine assets. The README ships a screenshot of the login view, so with --auth the first thing you should see is that login screen.

Pagination needs one manual step that the preset cannot do for you. The README says to set the default pagination views in the boot method of a service provider:

```php
use Illuminate\Pagination\Paginator;
use Illuminate\Support\ServiceProvider;

class AppServiceProvider extends ServiceProvider
{
    public function boot()
    {
        Paginator::defaultView('pagination::default');

        Paginator::defaultSimpleView('pagination::simple-default');
    }
}
```

Without those two lines, paginated lists fall back to Laravel's default pagination markup and lose the Tailwind styling the preset provides.

## The auth scaffolding is a starting point, not an account system

The --auth flag gives you Livewire-powered authentication with single action controllers and bundled tests. That is a login, registration and password reset flow you can read and modify. It is not account management.

The README says this directly in a note: if you want an application boilerplate supporting the TALL stack, look at Laravel Jetstream, which it describes as coming with authentication scaffolding, account management, teams support. Profile updates, API tokens, team membership and two-factor authentication are outside what this preset publishes.

There is a second limitation that follows from publishing everything. Because the auth controllers and routes now live in your application, upgrading the preset does not upgrade them. If you install v9.1.0 today and a v9.2.0 ships with a corrected password reset controller, your copy stays as it was. The README's framing that the package is fully redundant is accurate, and it cuts both ways: nothing is hidden from you, and nothing is maintained for you.

## Tailwind purging and the class names you generate at runtime

The README notes that Tailwind uses PurgeCSS to strip unused classes from production CSS builds, and that you can modify or remove this behaviour in the purge section of tailwind.config.js, pointing at Tailwind's documentation on controlling file size.

This matters more in a Livewire application than in a server-rendered one. PurgeCSS scans source files for class strings. A class name assembled at runtime, or one that only appears inside a PHP string in a Livewire component, is a candidate for removal unless the configuration scans that file. The preset configures purging for the files it publishes, but the moment you add components of your own, the scan paths are your responsibility.

The failure mode is unpleasant because it is invisible in development. `npm run dev` does not purge, so everything looks correct locally. The missing classes appear only in the production build. If a button loses its background colour after deploy, check the purge configuration before you check anything else.

## Jetstream and Filament solve adjacent problems differently

The README itself names Laravel Jetstream as the alternative for anyone who wants an application boilerplate rather than a front-end preset. The difference is scope and ownership. Jetstream is a maintained package that provides authentication, profile management, teams and optional API support through its own components, and you upgrade it as a dependency. This preset hands you the files and walks away.

Filament is a different category again. It is an admin panel framework, not a front-end preset, and it answers the question of how to build CRUD screens and dashboards quickly rather than how to lay out a public-facing application. Choosing Filament means adopting its conventions for resources, forms and tables. Choosing this preset means adopting nothing beyond the stack itself.

The practical distinction is who owns the code a year from now. With Jetstream, the vendor does, at least in part. With this preset, you do, entirely. That is the trade the README is describing when it says the package can be removed.

## Maintenance, licence and upgrade cost

The repository is not archived, and the last push was on 2026-06-16. The most recent release listed is v9.1.0 from 2025-03-09, following v9.0.0 on 2025-02-25 and v8.0.0 on 2024-03-28. The pattern in those release dates is roughly annual major versions with patch releases in between, so treat the preset as something you install once per project rather than something you track continuously.

Upgrade cost is low by construction. Because the package publishes files and can then be removed, there is no vendor code to keep in sync. The work of upgrading is deciding whether you want the new stubs at all, and if you do, comparing them against what you have already modified.

The licence is MIT, which permits commercial use, modification and redistribution provided the copyright notice and permission notice are retained. Since the preset copies files into your application, the question of which notice belongs where is worth raising with whoever handles licensing at your organisation. This is a description of the licence terms, not legal advice.

## Conclusion

Adopt this preset if you are starting a fresh Laravel application, you want the TALL stack wired up with Vite 3 and Tailwind, and you intend to own the resulting Blade views and Livewire components yourself. Do not adopt it if you need teams, two-factor authentication, profile management or an API out of the box, since the README points those users at Laravel Jetstream, nor if you want a prebuilt admin panel, which is a different category of tool. Before committing, verify that your Laravel version is supported by the v9 line, check that the published files land where you expect, and confirm whether you want the --auth scaffolding, because removing authentication after the fact means deleting published code by hand rather than uninstalling a package.

## FAQ

### Can I remove laravel-frontend-presets/tall after installing it?

Yes. The README states that unlike the default Laravel presets, this one publishes all the auth logic to your project's /app directory, so the package is fully redundant once installed. Livewire itself must stay, since the published components depend on it.

### Does laravel-frontend-presets/tall include authentication?

Only if you pass the --auth flag to the ui command, as in php artisan ui tall --auth. That variant publishes Livewire components, single action controllers and pre-written tests for authentication.

### What is the TALL stack in Laravel?

TALL is an acronym for Tailwind CSS, Alpine.js, Laravel and Livewire, the four technologies this preset wires together. The README describes the package as a front-end preset that scaffolds an application using that stack.

### How do I get Tailwind-styled pagination with this preset?

The README says to set Paginator::defaultView('pagination::default') and Paginator::defaultSimpleView('pagination::simple-default') in the boot method of a service provider. Without those calls, paginated lists use Laravel's default markup.

### Should I use laravel-frontend-presets/tall or Laravel Jetstream?

The README recommends Jetstream if you are looking for an application boilerplate supporting the TALL stack, noting that it comes with authentication scaffolding, account management and teams support. This preset provides the front-end scaffolding and publishes the files into your app instead.

## Sources

- [Issues](https://github.com/laravel-frontend-presets/tall/issues)
- [laravel-frontend-presets/tall on GitHub](https://github.com/laravel-frontend-presets/tall)
- [License: MIT](https://github.com/laravel-frontend-presets/tall/blob/master/LICENSE)
- [README](https://github.com/laravel-frontend-presets/tall/blob/master/README.md)
- [Releases](https://github.com/laravel-frontend-presets/tall/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/laravel-frontend-presets-tall