README

LaraVibe-Vue

A modern Laravel + Inertia.js + Vue 3 starter kit — skip the boilerplate, build your app.

Introduction

LaraVibe-Vue is an open-source starter kit that combines the backend power of Laravel 13 with a fully typed Vue 3 frontend via Inertia.js v3 — giving you a modern SPA feel without sacrificing the simplicity of classic server-side routing and controllers.

Out of the box you get authentication, account management, an administration area, SSR support, type-safe route helpers, and a curated set of developer tooling — all wired together and ready to go.

Tech Stack

Every package in this stack was chosen deliberately. Nothing is here for show — each one earns its place by solving a real problem well.

Core

The backbone. These three working together is what makes LaraVibe-Vue feel different from a traditional Laravel app or a standalone SPA.

Package	Version	Why it's here
Laravel	13	The application framework — routing, ORM, auth, jobs, mail, and everything in between
Inertia.js	3	The bridge — write server-side controllers, get a full SPA on the frontend, no API required
Vue 3	3	Reactive UI with the Composition API — clean, typed, and a joy to work in

Frontend

Package	Version	Why it's here
Tailwind CSS	4	Utility-first styling — design directly in your markup, no context switching
Reka UI	2	Headless, accessible UI primitives — the foundation for the bundled shadcn-vue components
VueUse	12	Hundreds of battle-tested Vue composables so you don't write them from scratch
TypeScript	5	End-to-end type safety across your entire frontend codebase
Vite	8	Instant HMR, fast builds, and the plugin that powers Wayfinder auto-generation
Lucide Vue	latest	Clean, consistent icon library with tree-shaking out of the box
vue-sonner	2	The Vue renderer behind the built-in toast notification system

Developer Experience & Tooling

Package	Version	Why it's here
Laravel Wayfinder	0.x	Auto-generates TypeScript route functions from your PHP controllers — no hardcoded URLs, ever
Pest	4	The most expressive PHP testing framework available today
Larastan	3	PHPStan tuned for Laravel — catches type errors and N+1 risks before they ship
Laravel Pint	1	Opinionated PHP formatter — your code style is decided, consistently, forever
Rector	2	Automated PHP refactoring and upgrade rules — future-proofs your codebase
ESLint	9	Flat-config linting for TypeScript and Vue with auto-fix
Prettier	3	Frontend formatting — `.vue`, `.ts`, and everything else, consistent every time
Laravel Pail	1	Real-time log tailing right in your terminal — no more `tail -f storage/logs/laravel.log`
Laravel Sail	1	Docker environment for teams that prefer containers over local installs

Features

LaraVibe-Vue isn't just a scaffold — it's a carefully assembled foundation that solves the boring problems so you can focus on what makes your product unique.

For Your Users

🔐 Authentication — Complete, Out of the Box

Full auth flows, ready on day one. No extra packages, no wiring up forms manually.

Registration & login with email/password
Password reset via email — the full flow, already working
Email verification — prompt users to verify before accessing protected areas
Confirmable password (sudo mode) — re-prompt for the password before sensitive operations like deleting an account or changing security settings

👤 Account Management — The Pages Users Expect

Users expect to manage their own profile. LaraVibe-Vue ships those pages pre-built so you don't have to.

Profile — update name and email address, with email re-verification on change
Security — change password with current-password confirmation
Appearance — light, dark, and system theme switcher that persists across sessions

🛡️ Administration Area — Protected and Ready to Extend

A dedicated /administration section, guarded by middleware, with a dashboard page waiting for your content. Add your admin features without worrying about route structure or access control from scratch.

For Developers

🤖 AI-Ready from Day One

LaraVibe-Vue is ship with Laravel Boost integration, providing AI agents with complete codebase context — schema inspection, database queries, real-time error logs, and semantic documentation search. Pre-configured for GitHub Copilot and OpenAI agents, it ships with agent scaffolding that understands your entire stack instantly.

The structured conventions, documented architecture, and included AGENTS.md file mean AI agents can read, understand, and contribute confidently alongside your team. When you need to regenerate or customize agent configuration, the Laravel Boost command rebuilds your setup with full context — no manual wiring required.

🛠️ Developer Tooling — Full Power, Zero Configuration

Most starter kits leave you to wire up your own code quality tools. LaraVibe-Vue ships with a complete, pre-configured professional toolchain — the same setup senior engineers spend days assembling on real projects, ready to go from your very first commit.

Tool	What it does
Pest 4	Expressive, readable PHP tests — the best testing experience in the Laravel ecosystem
Larastan (PHPStan lv9)	Catches bugs before they reach production — static analysis tuned for Laravel
Laravel Pint	Zero-config PHP code formatter — your code always looks clean, always
Rector	Automated PHP refactoring and upgrades — keeps your codebase modern without manual effort
ESLint 9	Lints your TypeScript and Vue files with a flat config that just works
Prettier 3	Frontend formatting on save — consistent style across every `.vue` and `.ts` file

Everything is wired into composer scripts so the whole team uses the same workflow. One command before you push — composer review — and you know your code is clean, typed, formatted, and tested. No arguments, no setup, no excuses.

New team member? They get the full toolchain the moment they clone the repo. Senior dev? Nothing to configure. It's already right.

⚡ Type-Safe Routing with Laravel Wayfinder

Tired of hardcoded URLs breaking silently? Wayfinder auto-generates fully-typed TypeScript functions for every controller action and named route — straight from your PHP code into your Vue components. It runs automatically during composer dev and npm run build, so your frontend and backend are always in sync.

<!-- No more magic strings. Just types. -->
<Link :href="AccountController.edit().url()">My Account</Link>

🖥️ SSR Out of the Box

Server-side rendering is configured and ready. Powered by @inertiajs/vite in cluster mode, your app serves fast initial HTML to every visitor — great for SEO and perceived performance — without any extra setup on your part.

🎨 shadcn-vue UI Components

Pre-configured via components.json with Reka UI as the headless base. Beautiful, accessible, unstyled-by-default components you can drop in and style with Tailwind. Add new components with a single command:

npx shadcn-vue@latest add button

🍞 Toast Notifications — Architected, Not Hacked In

The toast system is a first-class citizen, not an afterthought. It has its own service layer, typed DTOs, and a Vue renderer that handles every case. Trigger toasts from anywhere on the backend with a single helper:

toastSuccess('Profile updated.');
toastError('Something went wrong.');

See app/Toast/README.md for the full architecture and usage guide.

🔑 Auth Composable — No Prop Drilling

Access the authenticated user anywhere in Vue without passing props down the tree. The useAuth composable gives you everything you need:

const { user, isAuthenticated, can, requireUser } = useAuth()

user — the current user or null for guests
requireUser() — non-null user on protected pages, no optional-chaining noise
can('publishPost') — UI gating backed by real server-side ability checks
isAuthenticated — boolean flag for conditional rendering

See resources/composables/README.md for the full guide.

🧱 Structured Architecture You'll Actually Enjoy

Every part of the app has a clear home and a convention to follow — documented with READMEs so your whole team stays consistent:

Layer	Purpose	Docs
Actions	Single-responsibility business operations	README
DTOs	Typed data transfer objects (`PageMeta`, `BreadCrumb`)	README
Enums	Backed enums with shared behavior	README
HTTP Resources	Eloquent serialization for API & Inertia	README
Support	Framework utilities and helpers	README
Toast	Self-contained notification system	README

Project Structure

app/
├── Actions/            # Single-responsibility action classes
├── DTOs/               # Typed data transfer objects (PageMeta, BreadCrumb)
├── Enums/              # Backed enums + shared enum concerns
├── Http/
│   ├── Controllers/    # Auth & Account controllers
│   ├── Middleware/     # Custom middleware
│   ├── Requests/       # Form request validation
│   └── Resources/      # Eloquent API resources and shared concerns
├── Models/             # Eloquent models
├── Support/            # Framework support utilities
├── Toast/              # Self-contained toast notification system
└── Traits/             # Reusable compatibility traits

resources/
├── components/         # Shared Vue components & shadcn-vue UI
├── composables/        # Vue composables (useAuth, useAppearance, …)
├── layouts/            # Page layouts (Account, Auth, Guest, Administration)
├── views/              # Inertia pages (auth/, account/, administration/)
├── wayfinder/          # Auto-generated Wayfinder route/action files
└── app.ts              # Frontend entry point

Requirements

PHP 8.4+
Composer
Node.js 20+ & npm
SQLite / MySQL / PostgreSQL

Installation

1. Create the project

If you have the Laravel CLI installer installed, this is the fastest way to get started:

laravel new my-app --using=softpulze/laravibe-vue
cd my-app

Prefer Composer? This works equally well:

composer create-project softpulze/laravibe-vue my-app
cd my-app

Or clone the repository directly:

git clone https://github.com/softpulze/laravibe-vue.git my-app
cd my-app
cp .env.example .env
composer install
php artisan key:generate

2. Configure your environment

Edit .env and set your database connection (SQLite is the default):

DB_CONNECTION=sqlite
# DB_CONNECTION=mysql
# DB_HOST=127.0.0.1
# DB_DATABASE=laravibe
# DB_USERNAME=root
# DB_PASSWORD=

Set your application URL and mail settings as needed.

3. Run migrations

php artisan migrate

4. Install frontend dependencies

npm install

5. Start the development server

composer dev

This starts Vite, queue listener, and Pail log watcher concurrently.

If you are using Laravel Herd, open your local Herd URL (for example: https://my-app.test). If you are not using Herd, run php artisan serve in another terminal.

Available Scripts

Everything you need for your daily workflow is a single command away. No need to remember a chain of tools, flags, or file paths — just use the script that matches what you're doing right now.

Starting development

composer dev

This is the only command you'll need to kick off your day. It starts the Vite dev server, a queue listener, and Pail log watcher — all at once, in a single terminal. Open your browser and start building.

If you're on Laravel Herd, your site is already available at https://my-app.test — no extra server command needed.

Running tests

composer test          # Run the full test suite
composer test:coverage # Run with coverage report

Or go straight to Pest:

composer pest          # Pest with compact output
composer pest:coverage # Pest with coverage

Keeping code clean

You shouldn't have to think about formatting or style — these scripts handle it for you:

composer format        # Format PHP (Pint) + frontend (Prettier) in one go
composer format:check  # Check formatting without writing any changes
composer lint          # Auto-fix PHP (Rector) + JS/TS (ESLint) issues
composer lint:check    # Check for lint issues without fixing

Need to target one tool specifically?

composer pint          # Format PHP code with Laravel Pint
composer pint:check    # Check PHP formatting only
composer phpstan       # Run Larastan static analysis
composer rector        # Apply Rector refactoring
composer rector:check  # Preview Rector changes without applying
composer eslint        # Run ESLint with auto-fix
composer eslint:check  # Run ESLint without fixing

Pre-commit / CI review

Before pushing or opening a PR, run the full quality check in one command:

composer review

This runs lint checks, format checks, tests, and static analysis — everything that matters, in one pass. If it passes locally, it'll pass in CI.

Building for production

composer build         # Build frontend assets
composer build:ssr     # Build frontend + SSR bundle (recommended for production)

Or use npm directly if you prefer:

npm run build
npm run build:ssr

Keeping dependencies fresh

composer deps:update        # Update both Composer and npm packages together
composer update:composer    # Update Composer packages only
composer update:npm         # Update npm packages only

Miscellaneous

composer logs:delete # Wipe log files from storage/logs

Using Laravel Wayfinder

Wayfinder is integrated with Vite and auto-generates typed TypeScript helpers for all your controllers and named routes whenever you run composer dev or npm run build — no manual step required.

Import and use them in your Vue components:

import { AccountController } from '@/actions/Account/AccountController'
import { route } from '@/routes/web'

<!-- In a template -->
<Link :href="AccountController.edit().url()">Account</Link>

For the full API and advanced usage, refer to the official Wayfinder documentation.

Testing & Code Quality

Run the full test suite:

composer test

Filter to a specific test:

php artisan test --compact --filter=AccountController

Run the full quality review before pushing:

composer review

See Available Scripts for the complete list of individual tool commands.

Docker (Laravel Sail)

If you prefer Docker, Laravel Sail is included:

./vendor/bin/sail up -d
./vendor/bin/sail artisan migrate
./vendor/bin/sail npm run dev

Deployment

LaraVibe-Vue can be deployed to any environment that supports PHP 8.4. For the fastest path to production, use Laravel Cloud.

Before deploying, build your frontend assets and run:

composer build:ssr        # build frontend + SSR bundle
php artisan config:cache
php artisan route:cache
php artisan view:cache

Contributing

Contributions are welcome. If you find a bug, have a feature idea, or want to improve the documentation — please open an issue or pull request on GitHub.

Fork the repository
Create a feature branch: git checkout -b feature/my-feature
Make your changes and run composer review to ensure everything passes
Push and open a pull request with a clear description of what changed and why

License

LaraVibe-Vue is open-sourced software licensed under the MIT license.

softpulze / laravibe-vue

Maintainers

Package info

Statistics

Security