PHPackages                             dancycodes/hyper - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Templating & Views](/categories/templating)
4. /
5. dancycodes/hyper

ActiveLibrary[Templating & Views](/categories/templating)

dancycodes/hyper
================

Laravel-native reactive frontends using Datastar. Build dynamic UIs with Blade templates.

v0.1.6(7mo ago)9130[2 PRs](https://github.com/dancycodes/hyper/pulls)MITPHPPHP ^8.2CI passing

Since Oct 19Pushed 6mo agoCompare

[ Source](https://github.com/dancycodes/hyper)[ Packagist](https://packagist.org/packages/dancycodes/hyper)[ Docs](https://laravel-hyper.com)[ RSS](/packages/dancycodes-hyper/feed)WikiDiscussions main Synced today

READMEChangelog (6)Dependencies (8)Versions (12)Used By (0)

Laravel Hyper
=============

[](#laravel-hyper)

[![Latest Version on Packagist](https://camo.githubusercontent.com/992694ecd0df0e535fde9c412f133678f0978c59a225e723677c87dae48eb3d9/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f762f64616e6379636f6465732f68797065722e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/dancycodes/hyper)[![Total Downloads](https://camo.githubusercontent.com/e016efc845c5abae52b245435937fa16b3781fc9bd6d7de06840f8fe26bb5277/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f64742f64616e6379636f6465732f68797065722e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/dancycodes/hyper)[![Tests](https://camo.githubusercontent.com/d5e96893370708014d3420cdacb0bbf527665cac733400eaa0b504f9fe1af6e0/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f616374696f6e732f776f726b666c6f772f7374617475732f64616e6379636f6465732f68797065722f74657374732e796d6c3f6272616e63683d6d61696e266c6162656c3d7465737473267374796c653d666c61742d737175617265)](https://github.com/dancycodes/hyper/actions/workflows/tests.yml)[![Code Style](https://camo.githubusercontent.com/0b75db1bc3cf419de3675190697aca03ca69fc77230323eec994277a78a9a654/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f616374696f6e732f776f726b666c6f772f7374617475732f64616e6379636f6465732f68797065722f636f64652d7374796c652e796d6c3f6272616e63683d6d61696e266c6162656c3d636f64652532307374796c65267374796c653d666c61742d737175617265)](https://github.com/dancycodes/hyper/actions/workflows/code-style.yml)[![License](https://camo.githubusercontent.com/aa77fd770f797a87559524164892f5794ee6b4ed9d0f050773e1a3cb7daf6089/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f6c2f64616e6379636f6465732f68797065722e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/dancycodes/hyper)[![PHP Version](https://camo.githubusercontent.com/0c2d65b16e912ed16c81904117c020f7c0784180d1d378de7fd895a98366ff4f/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f7068702d762f64616e6379636f6465732f68797065722e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/dancycodes/hyper)

What is Laravel Hyper?
----------------------

[](#what-is-laravel-hyper)

Laravel Hyper integrates [Datastar](https://data-star.dev)—a reactive hypermedia framework—with Laravel's development patterns, enabling you to build reactive user interfaces using server-side rendering and Blade templates.

Datastar provides the reactive signals system and frontend reactivity engine. Laravel provides the backend framework and development patterns. Hyper bridges these two technologies with Laravel-specific helpers, Blade directives, CSRF protection, validation integration, and file upload handling.

**📚 [Full Documentation at laravel-hyper.com](https://laravel-hyper.com)**

```

 0])>
    +

    -

```

```
// Laravel controller with Hyper's helpers
public function increment()
{
    $count = signals('count', 0);
    return hyper()->signals(['count' => $count + 1]);
}
```

The Problem Hyper Solves
------------------------

[](#the-problem-hyper-solves)

Modern web applications benefit from reactive interfaces where UI updates feel instant—users expect immediate feedback when clicking buttons, typing in search fields, or submitting forms. Achieving this responsiveness traditionally required either building separate JavaScript frontends or accepting slower full-page reloads.

Hyper offers server-driven reactivity: your Laravel application maintains control of business logic, validation, and data access while the interface updates reactively. This approach works well when your application logic belongs on the server and you want reactive UI without managing complex client-side state.

Core Technologies
-----------------

[](#core-technologies)

### Datastar (Reactive Framework)

[](#datastar-reactive-framework)

[Datastar](https://data-star.dev) is an independent hypermedia framework that powers the reactive behavior in Hyper applications. It provides:

- **Reactive Signals**: Variables that automatically update UI when they change
- **Data Attributes**: HTML attributes like `data-bind`, `data-text`, `data-show` for reactive behavior
- **HTTP Actions**: Trigger server requests with `@get`, `@post` and other verbs
- **Server-Sent Events**: Receive updates from the server via SSE
- **DOM Morphing**: Efficiently update HTML without full page reloads

All reactivity in Hyper applications comes from Datastar. When you use `data-bind`, `data-text`, or any reactive attribute, that's Datastar handling the reactivity.

### Laravel (Backend Framework)

[](#laravel-backend-framework)

Laravel provides the server-side foundation—routing, controllers, Blade templates, validation, Eloquent, and all the patterns Laravel developers know.

### Hyper (Integration Layer)

[](#hyper-integration-layer)

Hyper connects Datastar and Laravel with:

**Server-Side Helpers:**

- `hyper()` - Fluent response builder for reactive responses
- `signals()` - Read signals sent from the frontend (similar to `request()`)

**Blade Directives:**

- `@hyper` - Include Datastar JavaScript and CSRF token
- `@signals` - Initialize signals from PHP data
- `@fragment` / `@endfragment` - Define reusable view sections

**Laravel Integration:**

- `@postx`, `@putx`, `@patchx`, `@deletex` - HTTP actions with automatic CSRF tokens
- `data-error` - Display Laravel validation errors
- `data-navigate` - Client-side navigation with Laravel routes
- Validation integration via `signals()->validate()`
- Base64 file upload handling with `signals()->store()`

**Custom Attributes:**

- `data-for` - Optimized loops for rendering collections
- `data-if` - Conditional rendering based on signals

Requirements
------------

[](#requirements)

- PHP 8.2 or higher
- Laravel 11.0 or higher

Installation
------------

[](#installation)

Install Laravel Hyper via Composer:

```
composer require dancycodes/hyper
```

Laravel's package auto-discovery will register the service provider automatically.

Publish the JavaScript assets to your `public` directory:

```
php artisan vendor:publish --tag=hyper-assets
```

This copies Datastar and Hyper's JavaScript files to `public/vendor/hyper/js/`.

Add the `@hyper` directive to your layout's `` section:

```

    My Application
    @hyper

    @yield('content')

```

The `@hyper` directive includes the CSRF meta tag and loads the JavaScript module.

Quick Start
-----------

[](#quick-start)

### Reactive State with Signals

[](#reactive-state-with-signals)

Signals are reactive variables. When a signal's value changes, any UI element displaying that signal updates automatically. This concept comes from Datastar.

```
 '', 'email' => ''])>

    Hello, !

```

The `@signals` directive (Hyper) creates signals from PHP data. The `data-bind` and `data-text` attributes (Datastar) make the interface reactive.

### Server Communication

[](#server-communication)

Use CSRF-protected HTTP actions to communicate with your Laravel controllers:

```

    Save Contact

```

The `@postx` action (Hyper) automatically includes Laravel's CSRF token. The `data-error` attribute (Hyper) displays validation errors.

```
public function store()
{
    $validated = signals()->validate([
        'name' => 'required|string|max:255',
        'email' => 'required|email'
    ]);

    Contact::create($validated);

    return hyper()->signals([
        'name' => '',
        'email' => '',
    ]);
}
```

The `signals()` helper (Hyper) reads signals from the request. The `hyper()` helper (Hyper) builds the response.

> **📚 Learn more at [laravel-hyper.com](https://laravel-hyper.com)**

### Updating HTML Content

[](#updating-html-content)

Render Blade views to update specific sections of your page:

```

    @foreach($users as $user)

            {{ $user->name }}

                Delete

    @endforeach

```

```
public function destroy(User $user)
{
    $user->delete();

    $users = User::all();

    return hyper()->view('users.list', compact('users'));
}
```

Datastar receives the rendered HTML and updates the matching element by ID.

> **📚 Learn more at [laravel-hyper.com](https://laravel-hyper.com)**

Working with Signals
--------------------

[](#working-with-signals)

### Signal Types

[](#signal-types)

Signals come in three types, each serving different purposes:

**Regular Signals** (sent to server with every request):

```
 0, 'email' => ''])>

```

**Local Signals** (stay in browser, never sent to server):

```
 0, '_showMenu' => false])>

    Toggle Menu
    Navigation content...

```

Local signals are useful for UI state that doesn't need server processing—dropdowns, accordions, modal visibility, etc.

**Locked Signals** (protected from client tampering):

```
 auth()->id(), 'role_' => auth()->user()->role])>

```

Locked signals are stored encrypted in the session and validated on every request. If a locked signal is tampered with, Hyper throws a `HyperSignalTamperedException`. This feature is provided by Hyper for secure state management.

> **📚 Learn more at [laravel-hyper.com](https://laravel-hyper.com)**

### Creating Signals

[](#creating-signals)

The `@signals` directive offers several syntaxes:

**Array syntax:**

```
 0, 'message' => 'Hello'])>

```

**Variable syntax:**

```
@php
    $username = 'John';
    $_editing = false;
    $userId_ = auth()->id();
@endphp

```

**Spread syntax:**

```
 []])>

```

**Automatic type conversion:**

The `@signals` directive automatically converts Laravel types:

```

```

### Reading Signals

[](#reading-signals)

**In the frontend** (Datastar):

```
 100, 'quantity' => 2])>

    Items in cart

```

The `$` prefix accesses signal values in Datastar expressions.

**In the backend** (Hyper):

```
public function updateCart()
{
    // Get specific signal with default value
    $quantity = signals('quantity', 1);

    // Check if signal exists
    if (signals()->has('coupon')) {
        $discount = signals('coupon');
    }

    // Get all signals
    $allSignals = signals()->all();

    // Get only specific signals
    $data = signals()->only(['name', 'email']);
}
```

### Updating Signals

[](#updating-signals)

**From the frontend** (Datastar):

```
 0])>
    Increment
    Decrement
    Reset

```

**From the backend** (Hyper):

```
// Update single signal
return hyper()->signals(['count' => 5]);

// Update multiple signals
return hyper()->signals([
    'count' => 5,
    'message' => 'Updated!',
    'errors' => []
]);

// Chain with other operations
return hyper()
    ->signals(['count' => 5])
    ->view('status', $data)
    ->js('console.log("Done")');
```

Validation
----------

[](#validation)

Laravel's validation system integrates seamlessly with signals through Hyper's `signals()->validate()` method:

```
public function store()
{
    $validated = signals()->validate([
        'title' => 'required|string|max:100',
        'content' => 'required|string',
        'email' => 'required|email|unique:users'
    ]);

    Post::create($validated);

    return hyper()->signals(['message' => 'Post created']);
}
```

When validation fails, Hyper automatically:

1. Creates an `errors` signal with Laravel's error messages
2. Sends it to the frontend
3. The `data-error` attribute displays field-specific errors

```

        Title

        Content

    Create Post

```

### Custom Validation Messages

[](#custom-validation-messages)

All Laravel validation features work with signals:

```
signals()->validate(
    [
        'email' => 'required|email|unique:users',
        'password' => 'required|min:8'
    ],
    [
        'email.unique' => 'This email is already registered.',
        'password.min' => 'Password must be at least :min characters.'
    ],
    [
        'email' => 'email address',
        'password' => 'password'
    ]
);
```

> **📚 Learn more at [laravel-hyper.com](https://laravel-hyper.com)**

File Uploads
------------

[](#file-uploads)

File inputs bound with `data-bind` automatically encode files as base64 (Datastar behavior). Hyper provides validation rules and storage helpers for handling these base64-encoded files.

```

    Upload Avatar

```

### Base64 Validation Rules

[](#base64-validation-rules)

Hyper provides specialized validation rules for base64-encoded files:

```
public function uploadAvatar()
{
    signals()->validate([
        'avatar' => 'required|b64image|b64max:2048|b64dimensions:min_width=200,min_height=200'
    ]);

    $path = signals()->store('avatar', 'avatars', 'public');

    auth()->user()->update(['avatar' => $path]);

    return hyper()->signals(['avatar' => $path]);
}
```

**Available validation rules:**

- `b64file` - Validates any base64-encoded file
- `b64image` - Validates base64-encoded image files
- `b64max:size` - Maximum file size in kilobytes
- `b64min:size` - Minimum file size in kilobytes
- `b64mimes:ext1,ext2` - Allowed file extensions
- `b64dimensions:constraints` - Image dimension validation

**Dimension constraints:**

```
'avatar' => 'b64dimensions:min_width=100,max_width=1000,ratio=16/9'
```

Supports: `min_width`, `max_width`, `min_height`, `max_height`, `width`, `height`, `ratio`

### Storing Files

[](#storing-files)

```
// Store with auto-generated filename
$path = signals()->store('avatar', 'avatars', 'public');

// Store and get public URL
$url = signals()->storeAsUrl('avatar', 'avatars', 'public');

// Store multiple files
$paths = signals()->storeMultiple([
    'avatar' => 'avatars',
    'banner' => 'banners'
], 'public');
```

> **📚 Learn more at [laravel-hyper.com](https://laravel-hyper.com)**

Fragment Rendering
------------------

[](#fragment-rendering)

Fragments let you define reusable sections within Blade views and render them independently.

```

@fragment('todo-list')

      @forelse($todos as $todo)

               {{ $todo->title }}

                  Delete

      @empty
         No todos found.
      @endforelse

@endfragment

@fragment('todo-count')

        {{ $todos->count() }} todos remaining

@endfragment
```

From your controller, render specific fragments:

```
public function destroy(Todo $todo)
{
    $todo->delete();
    $todos = Todo::all();

    return hyper()
        ->fragment('todos.index', 'todo-list', compact('todos'))
        ->fragment('todos.index', 'todo-count', compact('todos'));
}
```

### Fragment Targeting

[](#fragment-targeting)

By default, fragments target elements by ID. You can specify custom selectors:

```
return hyper()->fragment('todos.index', 'todo-list', compact('todos'), [
    'selector' => '#todo-list',
    'mode' => 'outer'  // Replace the element selected with all content
]);
```

**Merge modes** (Datastar):

- `outer` - Replace entire element (default)
- `inner` - Replace inner HTML only
- `prepend` - Add content at the beginning
- `append` - Add content at the end
- `before` - Insert before element
- `after` - Insert after element

Navigation
----------

[](#navigation)

Hyper provides client-side navigation features that work with Laravel routes.

### Link Navigation

[](#link-navigation)

```

Dashboard

Electronics

Products

Reset Page
```

The `data-navigate` attribute (Hyper) enables client-side navigation without full page reloads.

### Server-Side Navigation

[](#server-side-navigation)

```
// Navigate to a URL
return hyper()->navigate('/dashboard');

// Navigate with merged query parameters
return hyper()->navigateMerge('/products', ['category' => 'electronics']);

// Navigate keeping only specific parameters
return hyper()->navigateOnly('/products', ['search', 'sort']);

// Navigate excluding specific parameters
return hyper()->navigateExcept('/products', ['page']);

// Navigate with debounce
return hyper()->navigate('/search', ['debounce' => 300]);
```

### Full Page Redirects

[](#full-page-redirects)

For full page reloads (not AJAX):

```
// Standard Laravel redirect
return redirect('/dashboard');

// With flash data
return redirect('/dashboard')->with('success', 'User created');
```

> **📚 Learn more at [laravel-hyper.com](https://laravel-hyper.com)**

Advanced Features
-----------------

[](#advanced-features)

### Streaming

[](#streaming)

Send continuous updates to the client using Server-Sent Events:

```
public function liveMetrics()
{
    return hyper()->stream(function($hyper) {
        while (true) {
            $metrics = $this->getLatestMetrics();

            $hyper->signals(['metrics' => $metrics])
                  ->fragment('dashboard', 'metrics-card', $metrics)
                  ->send();

            sleep(5);
        }
    });
}
```

### Route Discovery

[](#route-discovery)

Automatically generate routes from controller methods using PHP attributes:

**Enable in config/hyper.php:**

```
return [
    'route_discovery' => [
        'enabled' => true,
        'discover_controllers_in_directory' => [
            app_path('Http/Controllers'),
        ],
    ],
];
```

**Use attributes in controllers:**

```
use Dancycodes\Hyper\Routing\Attributes\Route;

#[Route(middleware: 'web')]
class PostController extends Controller
{
    public function index()
    {
        // Auto-registered as GET /post
    }

    #[Route(method: 'post')]
    public function store()
    {
        // Auto-registered as POST /post/store
    }

    #[Route(method: 'delete', uri: '/posts/{post}')]
    public function destroy(Post $post)
    {
        // Custom URI with route model binding
    }
}
```

### Conditional Logic

[](#conditional-logic)

Use conditional methods to build responses dynamically:

```
return hyper()
    ->signals(['count' => $count])
    ->when($count > 10, function($hyper) {
        return $hyper->js('showWarning()');
    })
    ->unless($errors->isEmpty(), function($hyper) use ($errors) {
        return $hyper->signals(['errors' => $errors]);
    });
```

### JavaScript Execution

[](#javascript-execution)

Execute JavaScript code from the server:

```
// Execute once
return hyper()->js('console.log("Task complete")');

// Execute with auto-removal
return hyper()->js('showNotification()', ['autoRemove' => true]);

// Dispatch custom DOM events
return hyper()->dispatch('task:complete', ['taskId' => 123]);
```

Datastar Attributes Reference
-----------------------------

[](#datastar-attributes-reference)

Hyper applications use Datastar's reactive attributes. Here are the most commonly used:

### State Management

[](#state-management)

- `data-signals="{...}"` - Create reactive signals
- `data-computed:name="expression"` - Create computed signal
- `data-effect="expression"` - Run code when signals change

### Display & Binding

[](#display--binding)

- `data-text="$signal"` - Display signal value as text
- `data-bind="signal"` - Two-way bind input to signal
- `data-show="condition"` - Show/hide element
- `data-class:name="condition"` - Toggle CSS class
- `data-attr:name="value"` - Set attribute value

### Events

[](#events)

- `data-on:click="expression"` - Handle click events
- `data-on:input="expression"` - Handle input events
- `data-on:submit="expression"` - Handle form submit
- `data-on:[event]="expression"` - Handle any DOM event

Event modifiers:

- `data-on:click__prevent` - Prevent default
- `data-on:submit__prevent__stop` - Prevent default and stop propagation
- `data-on:input__debounce.300ms` - Debounce input

### HTTP Actions

[](#http-actions)

- `@get('/url')` - GET request
- `@post('/url')` - POST request
- `@put('/url')` - PUT request
- `@patch('/url')` - PATCH request
- `@delete('/url')` - DELETE request

**Hyper's CSRF-protected actions:**

- `@postx('/url')` - POST with CSRF token
- `@putx('/url')` - PUT with CSRF token
- `@patchx('/url')` - PATCH with CSRF token
- `@deletex('/url')` - DELETE with CSRF token

### References

[](#references)

- `data-ref="myRef"` - Create reference to element
- `data-intersect="expression"` - Run when element enters viewport

For complete Datastar documentation, visit [data-star.dev](https://data-star.dev).

> **📚 For Hyper-specific attributes and Laravel integration, visit [laravel-hyper.com](https://laravel-hyper.com)**

Testing
-------

[](#testing)

Run the test suite:

```
composer test
```

Hyper includes tests covering:

- Signals and state management
- Validation integration
- File upload handling
- Fragment rendering
- Navigation
- Security (locked signals, CSRF)
- Response building

What Can You Build?
-------------------

[](#what-can-you-build)

Hyper works well for server-driven applications with reactive UI requirements:

- **CRUD Interfaces**: Admin panels, data tables, content management
- **Forms**: Multi-step wizards, dynamic forms with live validation
- **Live Features**: Real-time dashboards, notifications, chat interfaces
- **Interactive UIs**: Search, filtering, sorting, pagination
- **File Management**: Upload interfaces with previews and progress

Hyper maintains Laravel's server-side architecture while providing reactive user experiences.

Contributing
------------

[](#contributing)

Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.

### Development Setup

[](#development-setup)

1. Clone the repository
2. Install dependencies: `composer install`
3. Run tests: `composer test`
4. Ensure all tests pass before submitting pull requests

Security
--------

[](#security)

Security vulnerabilities should be reported privately. Please review [SECURITY.md](SECURITY.md) for responsible disclosure procedures.

Credits
-------

[](#credits)

**Laravel Hyper** is made possible by:

- **[Laravel](https://laravel.com)** - The PHP framework for web artisans
- **[Datastar](https://data-star.dev)** - The reactive hypermedia framework
- **DancyCodes** - Hyper's integration layer and Laravel-specific features
- The Laravel and Datastar communities

License
-------

[](#license)

Laravel Hyper is open-source software licensed under the [MIT license](LICENSE).

Support
-------

[](#support)

- **Documentation**: [laravel-hyper.com](https://laravel-hyper.com)
- **Issues**: [GitHub Issues](https://github.com/dancycodes/hyper/issues)
- **Discussions**: [GitHub Discussions](https://github.com/dancycodes/hyper/discussions)
- **Email**:

---

Made with ❤️ for the Laravel community

###  Health Score

37

—

LowBetter than 81% of packages

Maintenance65

Regular maintenance activity

Popularity18

Limited adoption so far

Community9

Small or concentrated contributor base

Maturity45

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 84.3% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~5 days

Total

7

Last Release

224d ago

### Community

Maintainers

![](https://avatars.githubusercontent.com/u/139002105?v=4)[dancycodes](/maintainers/dancycodes)[@dancycodes](https://github.com/dancycodes)

---

Top Contributors

[![dancycodes](https://avatars.githubusercontent.com/u/139002105?v=4)](https://github.com/dancycodes "dancycodes (43 commits)")[![github-actions[bot]](https://avatars.githubusercontent.com/in/15368?v=4)](https://github.com/github-actions[bot] "github-actions[bot] (6 commits)")[![dependabot[bot]](https://avatars.githubusercontent.com/in/29110?v=4)](https://github.com/dependabot[bot] "dependabot[bot] (2 commits)")

---

Tags

laravelvalidationreal-timebladehypermediasignalsreactiveSPAfragmentsDatastarhtmx-alternativelivewire-alternative

###  Code Quality

TestsPHPUnit

Static AnalysisPHPStan

Code StyleLaravel Pint

### Embed Badge

![Health badge](/badges/dancycodes-hyper/health.svg)

```
[![Health](https://phpackages.com/badges/dancycodes-hyper/health.svg)](https://phpackages.com/packages/dancycodes-hyper)
```

###  Alternatives

[blade-ui-kit/blade-icons

A package to easily make use of icons in your Laravel Blade views.

2.5k42.5M404](/packages/blade-ui-kit-blade-icons)[tightenco/jigsaw

Simple static sites with Laravel's Blade.

2.3k453.6k30](/packages/tightenco-jigsaw)[moonshine/moonshine

Laravel administration panel

1.3k253.1k81](/packages/moonshine-moonshine)[hasinhayder/tyro-dashboard

Tyro Dashboard - Beautiful admin dashboard for managing Tyro roles, privileges, users, and settings

5443.8k](/packages/hasinhayder-tyro-dashboard)[technikermathe/blade-lucide-icons

A package to easily make use of Lucide icons in your Laravel Blade views.

18421.4k11](/packages/technikermathe-blade-lucide-icons)[hasinhayder/tyro-login

Tyro Login - Beautiful, customizable authentication views for Laravel 12 & 13

2464.9k6](/packages/hasinhayder-tyro-login)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)