PHPackages                             iazaran/smart-cache - 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. [Caching](/categories/caching)
4. /
5. iazaran/smart-cache

ActiveLibrary[Caching](/categories/caching)

iazaran/smart-cache
===================

Smart Cache is a caching optimization package designed to enhance the way your Laravel application handles data caching. It intelligently manages large data sets by compressing, chunking, or applying other optimization strategies to keep your application performant and efficient.

1.13.0(2w ago)21111.6k—6.2%8MITPHPPHP ^8.1CI failing

Since Apr 22Pushed 1mo ago3 watchersCompare

[ Source](https://github.com/iazaran/smart-cache)[ Packagist](https://packagist.org/packages/iazaran/smart-cache)[ Docs](https://github.com/iazaran/smart-cache)[ RSS](/packages/iazaran-smart-cache/feed)WikiDiscussions main Synced 2d ago

READMEChangelog (10)Dependencies (40)Versions (39)Used By (0)

Laravel SmartCache
==================

[](#laravel-smartcache)

[![Latest Version](https://camo.githubusercontent.com/6769f71bf7fd2e43c7dfc36209590610720a4cfd86c00f02e647b416572fb05a/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f762f69617a6172616e2f736d6172742d63616368652e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/iazaran/smart-cache)[![Total Downloads](https://camo.githubusercontent.com/9bcba3653766080fcea103e1045be62f38f0e912412c6eeedad666d7d53a139a/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f64742f69617a6172616e2f736d6172742d63616368652e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/iazaran/smart-cache)[![GitHub Stars](https://camo.githubusercontent.com/01358752c7feb7cd94605b2b6cfcc67138edada56b6ea1f871bf7024ceab73fa/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f64796e616d69632f6a736f6e3f75726c3d68747470732533412532462532466170692e6769746875622e636f6d2532467265706f7325324669617a6172616e253246736d6172742d63616368652671756572793d2532342e7374617267617a6572735f636f756e74266c6162656c3d7374617273267374796c653d666c61742d737175617265)](https://github.com/iazaran/smart-cache)[![License](https://camo.githubusercontent.com/f847a9822c4d17db5b9f70077f3abf42538249b17ba12cdc05db0df6e9eb94a2/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f6c2f69617a6172616e2f736d6172742d63616368652e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/iazaran/smart-cache)[![PHP Version](https://camo.githubusercontent.com/428ef520c8529b35c22f9249a49ff88590e3a489b5ed0413d1698d23d0a140a1/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f7068702d762f69617a6172616e2f736d6172742d63616368652e7376673f7374796c653d666c61742d737175617265)](https://packagist.org/packages/iazaran/smart-cache)[![Tests](https://camo.githubusercontent.com/4f40d36f8c539063b1b9f5d89002448c29cf721846232e0dd918c517d391d9c0/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f616374696f6e732f776f726b666c6f772f7374617475732f69617a6172616e2f736d6172742d63616368652f74657374732e796d6c3f6272616e63683d6d61696e266c6162656c3d7465737473267374796c653d666c61742d737175617265)](https://github.com/iazaran/smart-cache/actions/workflows/tests.yml)[![Coverage](https://camo.githubusercontent.com/1fa44e7aa4cbc3cf180feb470699c183e2ef0340740af63c7ca4783dc5d5f02c/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f616374696f6e732f776f726b666c6f772f7374617475732f69617a6172616e2f736d6172742d63616368652f636f64652d616e616c797369732e796d6c3f6272616e63683d6d61696e266c6162656c3d636f766572616765267374796c653d666c61742d737175617265)](https://github.com/iazaran/smart-cache/actions/workflows/code-analysis.yml)

**Drop-in replacement for Laravel's `Cache` facade** that automatically compresses, chunks, and optimizes cached data — with write deduplication, self-healing recovery, and cost-aware eviction built in.

Implements `Illuminate\Contracts\Cache\Repository` and PSR-16 `SimpleCache`. Your existing code works unchanged.

**PHP 8.1+ · Laravel 8–13 · Redis, File, Database, Memcached, Array**

---

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

[](#installation)

**Prerequisites:** PHP extensions `ext-zlib` (for data compression) and `ext-json` (for optimal object serialization) are strongly recommended to enable all performance optimization strategies.

```
composer require iazaran/smart-cache
```

That's it. No further configuration is required — works immediately with your existing cache driver.

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

[](#quick-start)

```
use SmartCache\Facades\SmartCache;

// Same API you already know
SmartCache::put('users', $users, 3600);
$users = SmartCache::get('users');

// Remember pattern — with automatic compression & cost tracking
$users = SmartCache::remember('users', 3600, fn() => User::all());

// Helper function
smart_cache(['products' => $products], 3600);
$products = smart_cache('products');
```

Large data is automatically compressed and chunked behind the scenes. No code changes needed.

Why SmartCache?
---------------

[](#why-smartcache)

ProblemWithout SmartCacheWith SmartCacheLarge payloads (100 KB+)Stored as-is, slow readsAuto-compressed & chunkedRedundant writesEvery `put()` hits the storeSkipped when unchanged (write deduplication)Corrupted entriesException crashes the requestAuto-evicted and regenerated, including broken chunk setsEviction decisionsLRU / randomCost-aware scoring — keeps high-value keysCache stampedeThundering herd on expiryXFetch, jitter, and rate limitingConditional cachingManual `if` around `put()``rememberIf()` — one-linerStale data servingNot availableSWR, stale, refresh-ahead, async queue refreshObservabilityDIY loggingBuilt-in dashboard, metrics, and health checks### How Automatic Optimization Works

[](#how-automatic-optimization-works)

SmartCache selects the best strategy based on your data — zero configuration:

Data ProfileStrategy AppliedEffectArrays with 5 000+ itemsChunkingLower memory, faster accessSerialized data > 50 KBCompressionSignificant size reduction (gzip)API responses > 100 KBChunking + CompressionBest of bothData < 50 KBNoneZero overheadAll thresholds are [configurable](#configuration).

### Production Safety for Large Data

[](#production-safety-for-large-data)

SmartCache is built for the painful cases that appear after an application grows: large Eloquent result sets, API payloads, reports, dashboards, and Redis/Memcached entries that get too big to manage safely.

- **Data shape is preserved.** Chunked payloads keep associative keys and sparse numeric keys intact, so ID-keyed arrays do not come back reindexed.
- **Partial chunk loss is recoverable.** If a chunk is missing or corrupted, SmartCache treats the entry as a cache miss, evicts the broken metadata, and lets `remember()` regenerate a clean value.
- **Null remains a valid cached value.** Stored `null` is distinguished from a miss, preserving Laravel cache semantics while still enabling self-healing.
- **Raw repository access is still available.** Use `SmartCache::repository()` when a package or one-off operation needs the underlying Laravel cache store directly.

Features
--------

[](#features)

Every feature below is **opt-in** and backward-compatible.

### Multiple Cache Drivers

[](#multiple-cache-drivers)

```
// Each store preserves all SmartCache optimizations
SmartCache::store('redis')->put('key', $value, 3600);
SmartCache::store('memcached')->remember('users', 3600, fn() => User::all());

// Bypass SmartCache when needed
SmartCache::repository('redis')->put('key', $value, 3600);
```

### SWR Patterns (Stale-While-Revalidate)

[](#swr-patterns-stale-while-revalidate)

```
// Serve stale data while refreshing in background
$data = SmartCache::swr('github_repos', fn() => Http::get('...')->json(), 300, 900);

// Extended stale serving (1 h fresh, 24 h stale)
$config = SmartCache::stale('site_config', fn() => Config::fromDatabase(), 3600, 86400);

// Proactive refresh before expiry
$analytics = SmartCache::refreshAhead('daily_analytics', fn() => Analytics::generateReport(), 1800, 300);

// Queue-based background refresh — returns stale immediately, refresh runs on a worker
$data = SmartCache::asyncSwr('dashboard_stats', fn() => Stats::generate(), 300, 900, 'cache-refresh');
```

> **How "background" works.** `swr()`, `stale()` and `refreshAhead()` run the refresh callback **synchronously** in the same PHP process after returning the stale value to the caller. This keeps the request hot path fast (the caller does not wait for the new value), but the worker still pays the cost of the regeneration. Use `asyncSwr()` with a Laravel queue worker if you need the refresh to run in a separate process. **`asyncSwr()` does not accept `Closure` callbacks** — pass either a serializable invokable class or a `"Class@method"` string. Closures throw `InvalidArgumentException` since v1.12.0 so the failure is loud at dispatch time instead of inside the queue serializer.
>
> **Single-flight refresh (opt-in, v1.12.0+).** Set `smart-cache.swr.single_flight = true` to wrap the synchronous refresh in an opportunistic non-blocking lock keyed on `_sc_swr_refresh:{key}`. When the cache store implements `LockProvider` (redis, memcached, database, dynamodb, file) only one worker regenerates a stale entry; concurrent workers keep serving stale and return immediately. Default `false` preserves the historical "every worker refreshes" behaviour.

### Stampede Protection

[](#stampede-protection)

```
// XFetch algorithm — probabilistic early refresh
$data = SmartCache::rememberWithStampedeProtection('key', 3600, fn() => expensiveQuery());

// Rate-limited regeneration
SmartCache::throttle('api_call', 10, 60, fn() => expensiveApiCall());

// TTL jitter — prevents thundering herd on expiry
SmartCache::withJitter(0.1)->put('popular_data', $data, 3600);
// Actual TTL: 3240–3960 s (±10 %)
```

### Write Deduplication (Cache DNA)

[](#write-deduplication-cache-dna)

Hashes every value before writing. Identical content → write skipped entirely.

```
SmartCache::put('app_config', Config::all(), 3600);
SmartCache::put('app_config', Config::all(), 3600); // no I/O — data unchanged
```

### Self-Healing Cache

[](#self-healing-cache)

Corrupted entries are auto-evicted and regenerated on next read — zero downtime. This includes missing chunks from large chunked payloads.

```
$report = SmartCache::remember('report', 3600, fn() => Analytics::generate());
```

### Conditional Caching

[](#conditional-caching)

```
$data = SmartCache::rememberIf('external_api', 3600,
    fn() => Http::get('https://api.example.com/data')->json(),
    fn($value) => !empty($value) && isset($value['status'])
);
```

### Cost-Aware Eviction

[](#cost-aware-eviction)

GreedyDual-Size–inspired scoring: `score = (cost × ln(1 + access_count) × decay) / size`

```
SmartCache::remember('analytics', 3600, fn() => AnalyticsService::generateReport());
SmartCache::getCacheValueReport();       // all entries ranked by value
SmartCache::suggestEvictions(5);         // lowest-value entries to remove
```

### Circuit Breaker & Fallback

[](#circuit-breaker--fallback)

```
$data = SmartCache::withFallback(
    fn() => SmartCache::get('key'),
    fn() => $this->fallbackSource()
);
```

### In-Request Memoization

[](#in-request-memoization)

```
$memo = SmartCache::memo();
$users = $memo->remember('users', 3600, fn() => User::all());
$users = $memo->get('users'); // instant — served from memory
```

### Atomic Locks

[](#atomic-locks)

```
SmartCache::lock('expensive_operation', 10)->get(function () {
    return regenerateExpensiveData();
});
```

### Namespacing

[](#namespacing)

```
SmartCache::namespace('api_v2')->put('users', $users, 3600);
SmartCache::flushNamespace('api_v2');
```

### Cache Invalidation

[](#cache-invalidation)

```
// Pattern-based
SmartCache::flushPatterns(['user_*', 'api_v2_*', '/product_\d+/']);

// Dependency tracking
SmartCache::dependsOn('user_posts', 'user_profile');
SmartCache::invalidate('user_profile'); // also clears user_posts

// Tag-based
SmartCache::tags(['users'])->put('user_1', $user, 3600);
SmartCache::flushTags(['users']);
```

### Model Auto-Invalidation

[](#model-auto-invalidation)

```
use SmartCache\Traits\CacheInvalidation;

class User extends Model
{
    use CacheInvalidation;

    protected function cacheInvalidation(): array
    {
        return [
            'keys' => ['user_{id}_profile', 'user_{id}_posts'],
            'tags' => ['users', 'user_{id}', 'team_{team_id}'],
            'patterns' => ['users_list_*'],
            'dependencies' => ['team_{team_id}_summary'],
        ];
    }
}

// Event-blind writes can flush explicitly:
User::where('status', 'inactive')->update(['archived' => true]);
User::flushCacheTags(['users']);
```

Model invalidation is deferred until the current database transaction commits by default (`smart-cache.model_invalidation.after_commit = true`). This prevents another request from re-caching pre-commit data between an Eloquent event and the final commit. Set the flag to `false` if you need the historical immediate behavior.

Eloquent events do not fire for `saveQuietly()`, query-builder `update()` / `delete()`, `upsert()`, mass `insert()`, or raw SQL. For those paths, call `flushCacheTags()` or `SmartCache::flushTags()` explicitly.

### Choosing Cache Tags

[](#choosing-cache-tags)

Tags should describe the data used to build a response, not the controller that built it. Start with the tables or models read by the endpoint: list endpoints usually use coarse tags such as `products`, while item endpoints can add instance tags such as `product_123`. Over-tagging causes extra refreshes; under-tagging leaves stale data behind. For hard-to-map endpoints, enable Laravel's query log in a test and compare the tables read during response generation with the tags declared for that cache entry.

### Encryption at Rest

[](#encryption-at-rest)

```
// config/smart-cache.php → strategies.encryption
'encryption' => [
    'enabled' => true,
    'keys' => ['user_token_abc123'],          // exact cache-key match
    'patterns' => ['/^user_token_/', '/^payment_/'],  // regex match
],
```

### Adaptive Compression

[](#adaptive-compression)

```
config(['smart-cache.strategies.compression.mode' => 'adaptive']);
// Hot data → fast compression (level 3–4), cold data → high compression (level 7–9)
```

### Lazy Loading

[](#lazy-loading)

```
config(['smart-cache.strategies.chunking.lazy_loading' => true]);
$dataset = SmartCache::get('100k_records'); // LazyChunkedCollection
foreach ($dataset as $record) { /* max 3 chunks in memory */ }
```

### Batch Operations

[](#batch-operations)

```
$values = SmartCache::many(['key1', 'key2', 'key3']);
SmartCache::putMany(['key1' => $a, 'key2' => $b], 3600);
SmartCache::deleteMultiple(['key1', 'key2', 'key3']);
```

### Cache Events

[](#cache-events)

```
config(['smart-cache.events.enabled' => true]);
Event::listen(CacheHit::class, fn($e) => Log::info("Hit: {$e->key}"));
Event::listen(CacheMissed::class, fn($e) => Log::warning("Miss: {$e->key}"));
Event::listen(TagFlushed::class, fn($e) => Log::notice("Flushed {$e->tag}", [
    'keys' => $e->keyCount,
    'source' => $e->source, // manual, model, or model_helper
]));
```

### Monitoring & Dashboard

[](#monitoring--dashboard)

```
SmartCache::getPerformanceMetrics(); // hit_ratio, compression_savings, timing
SmartCache::analyzePerformance();    // health score + recommendations
```

```
// Enable web dashboard
'dashboard' => ['enabled' => true, 'prefix' => 'smart-cache', 'middleware' => ['web', 'auth']],
// GET /smart-cache/dashboard | /smart-cache/statistics | /smart-cache/health
```

```
php artisan smart-cache:status
php artisan smart-cache:audit --driver=redis
php artisan smart-cache:bench --driver=redis --iterations=5
php artisan smart-cache:clear
php artisan smart-cache:warm --warmer=products --warmer=categories
php artisan smart-cache:cleanup-chunks
```

### Cache Audit & Benchmarks

[](#cache-audit--benchmarks)

Use the audit command before production changes or after a cache incident:

```
php artisan smart-cache:audit
php artisan smart-cache:audit --format=json
php artisan smart-cache:audit --driver=redis --limit=50
```

It reports managed keys, missing tracked keys, broken chunked entries, orphan chunks, large unoptimized values, and cost-aware eviction suggestions without mutating the cache.

Use the benchmark command to measure your own driver and payload behavior:

```
php artisan smart-cache:bench
php artisan smart-cache:bench --profile=api-json --driver=redis --iterations=10
php artisan smart-cache:bench --format=json --output=storage/smart-cache-bench.json
```

A generated Redis report is included at [`docs/benchmark-report-redis.json`](docs/benchmark-report-redis.json). On the included PHP 8.4 / Laravel 13 / Redis run, the `api-json` profile compressed from 323,811 bytes to 7,829 bytes (97.58% smaller). Each profile includes a `goal`, `success_metric`, `goal_passed`, and `result_summary` field so compression is judged by byte reduction, chunking is judged by driver-safe splitting and key preservation, and small payloads are judged by avoiding unnecessary optimization.

Best Practices & Troubleshooting
------------------------------------

[](#best-practices--troubleshooting)

- **Binary Data:** If caching already compressed objects like images, video, or encrypted data, disable `compression` for those specific cache keys as they waste CPU cycles without yielding size reductions.
- **Memory Limits with Chunking:** Large multi-megabyte datasets automatically trigger the 'chunking' strategy. For arrays over 100,000 items, verify `memory_limit` in `php.ini` or enable `lazy_loading` via config to avoid server crashes.
- **Provider Not Found:** Laravel aggressively caches service providers and aliases. Always run `php artisan optimize:clear` after upgrading or installing this package if encountering *"Class 'SmartCache' not found"*.
- **IDE Autocomplete:** Modern IDEs (PhpStorm, VSCode) completely resolve `SmartCache::` magical methods automatically via our included Facade PHPDocs without needing `ide-helper` generated files.

Configuration
-------------

[](#configuration)

Publish the config file (optional — sensible defaults are applied automatically):

```
php artisan vendor:publish --tag=smart-cache-config
```

```
// config/smart-cache.php (excerpt)
return [
    'thresholds' => [
        'compression' => 1024 * 50,  // 50 KB
        'chunking'    => 1024 * 100, // 100 KB
    ],
    'strategies' => [
        'compression' => ['enabled' => true, 'mode' => 'fixed', 'level' => 6],
        'chunking'    => ['enabled' => true, 'chunk_size' => 1000],
        'encryption'  => ['enabled' => false, 'keys' => []],
    ],
    'monitoring'      => ['enabled' => true, 'metrics_ttl' => 3600],
    'circuit_breaker' => [
        'enabled'           => false,
        'failure_threshold' => 5,
        'recovery_timeout'  => 30,
        'shared'            => false, // v1.12.0: share breaker state across workers via the cache
        'shared_ttl'        => 300,   // v1.12.0: TTL for the shared state key
    ],
    'rate_limiter'    => ['enabled' => true, 'window' => 60, 'max_attempts' => 10],
    'jitter'          => ['enabled' => false, 'percentage' => 0.1],
    'deduplication'   => ['enabled' => true],   // Write deduplication (Cache DNA)
    'self_healing'    => ['enabled' => true],   // Auto-evict corrupted entries
    'swr'             => ['single_flight' => false], // v1.12.0: opt-in single-flight refresh
    'managed_keys'    => ['max_tracked' => 0],       // v1.12.0: 0 = unlimited (default)
    'metadata_lock'   => ['enabled' => true, 'ttl' => 5, 'wait' => 1],
    'model_invalidation' => ['after_commit' => true],
    'dashboard'       => ['enabled' => false, 'prefix' => 'smart-cache', 'middleware' => ['web']],
    'warmers'         => [],                    // Cache warmer classes for smart-cache:warm
];
```

Laravel Octane / Long-Running Workers
-------------------------------------

[](#laravel-octane--long-running-workers)

SmartCache is registered as a singleton, which means per-request state (active tags, namespaces, in-memory metric buffers) would normally leak between requests on **Laravel Octane**, **Swoole**, **FrankenPHP** or **RoadRunner**. Since **v1.12.0** the service provider's `terminating()` hook calls `SmartCache::reset()` and `OrphanChunkCleanupService::flush()` at the end of every request, so there is **nothing extra to configure**. If you embed SmartCache in your own long-running runtime, call `app(\SmartCache\Contracts\SmartCache::class)->reset()` between iterations.

Migration from Laravel Cache
----------------------------

[](#migration-from-laravel-cache)

Change one import — everything else stays the same:

```
- use Illuminate\Support\Facades\Cache;
+ use SmartCache\Facades\SmartCache;

SmartCache::put('users', $users, 3600);
$users = SmartCache::get('users');
```

Documentation
-------------

[](#documentation)

[Full documentation →](https://iazaran.github.io/smart-cache/) — Installation, API reference, SWR patterns, and more.

Testing
-------

[](#testing)

```
composer test            # 485 tests, 1,972 assertions
composer test-coverage   # with code coverage
```

See [TESTING.md](TESTING.md) for details.

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

[](#contributing)

Please see [CONTRIBUTING.md](CONTRIBUTING.md).

License
-------

[](#license)

MIT — see [LICENSE](LICENSE).

Links
-----

[](#links)

- [Packagist](https://packagist.org/packages/iazaran/smart-cache)
- [GitHub Issues](https://github.com/iazaran/smart-cache/issues)
- [Documentation](https://iazaran.github.io/smart-cache/)

###  Health Score

56

—

FairBetter than 97% of packages

Maintenance94

Actively maintained with recent releases

Popularity44

Moderate usage in the ecosystem

Community14

Small or concentrated contributor base

Maturity58

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 99.5% 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 ~13 days

Total

33

Last Release

17d ago

### Community

Maintainers

![](https://avatars.githubusercontent.com/u/10566709?v=4)[Ismael Azaran](/maintainers/iazaran)[@iazaran](https://github.com/iazaran)

---

Top Contributors

[![iazaran](https://avatars.githubusercontent.com/u/10566709?v=4)](https://github.com/iazaran "iazaran (202 commits)")[![sc85](https://avatars.githubusercontent.com/u/4824890?v=4)](https://github.com/sc85 "sc85 (1 commits)")

---

Tags

cachecache-managementcachingcomposer-packagedata-compressionlaravellaravel-packagelaravel-packagesoptimizationperformancephpredislaravel-packagepsr-16redis-cachefile cacheswrstale-while-revalidatedata-compressionlaravel performancecache managementlaravel cache driverlaravel optimizationsmart-cachesmart cache laravellaravel cachingcache optimizationcache chunkingcache serializationcache strategiesphp cachingcache stampede preventioncost-aware evictionself-healing cachewrite deduplicationlaravel cache replacement

###  Code Quality

TestsPHPUnit

### Embed Badge

![Health badge](/badges/iazaran-smart-cache/health.svg)

```
[![Health](https://phpackages.com/badges/iazaran-smart-cache/health.svg)](https://phpackages.com/packages/iazaran-smart-cache)
```

###  Alternatives

[propaganistas/laravel-disposable-email

Disposable email validator

6023.0M7](/packages/propaganistas-laravel-disposable-email)[laravel/ai

The official AI SDK for Laravel.

1.0k3.2M194](/packages/laravel-ai)[laravel/pulse

Laravel Pulse is a real-time application performance monitoring tool and dashboard for your Laravel application.

1.7k15.1M132](/packages/laravel-pulse)[mike-bronner/laravel-model-caching

Automatic caching for Eloquent models.

2.4k91.0k1](/packages/mike-bronner-laravel-model-caching)[tallstackui/tallstackui

TallStackUI is a powerful suite of Blade components that elevate your workflow of Livewire applications.

725173.0k14](/packages/tallstackui-tallstackui)[roots/acorn

Framework for Roots WordPress projects built with Laravel components.

9762.4M131](/packages/roots-acorn)

PHPackages © 2026

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