PHPackages                             mikemenard/laravel-localization - 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. [Localization & i18n](/categories/localization)
4. /
5. mikemenard/laravel-localization

ActiveLibrary[Localization & i18n](/categories/localization)

mikemenard/laravel-localization
===============================

A modern, flexible Laravel package for URL-based localization with seamless Livewire and third-party package support

v1.0.0(6mo ago)049MITPHPPHP ^8.4

Since Nov 5Pushed 4mo agoCompare

[ Source](https://github.com/mikemenard/laravel-localization)[ Packagist](https://packagist.org/packages/mikemenard/laravel-localization)[ Docs](https://github.com/mikemenard/laravel-localization)[ RSS](/packages/mikemenard-laravel-localization/feed)WikiDiscussions main Synced 1mo ago

READMEChangelogDependencies (3)Versions (2)Used By (0)

Laravel Localization
====================

[](#laravel-localization)

> A modern, flexible Laravel package for URL-based localization with seamless Livewire and third-party package support.

Why This Package?
-----------------

[](#why-this-package)

Most Laravel localization packages force you to wrap all your routes in localized groups, breaking compatibility with Livewire and third-party packages that generate their own URLs. This package takes a different approach.

**The Solution:**

Instead of requiring every route to be in a localized group, this package uses:

1. **A single global middleware** assigned to the `web` group that sets the locale and `URL::defaults()` for every request
2. **Session-based persistence** that remembers the user's locale choice
3. **Optional route-specific middleware** for routes that need locale prefixes

This architecture means:

- ✅ `route('profile')` automatically generates `/fr/profile` when French is active
- ✅ Livewire components work without modification
- ✅ Third-party packages (Filament, Nova, etc.) respect the current locale
- ✅ No need to wrap every single route in a localized group
- ✅ Session persistence works across the entire application

Features
--------

[](#features)

- 🌍 **URL-based localization** with configurable route parameters
- 🔄 **Automatic URL generation** via `URL::defaults()` - no manual locale passing needed
- 💾 **Session persistence** - remembers user locale preference
- 🎯 **Smart locale resolution** - session → browser headers → app default
- 🔗 **Livewire compatible** - works seamlessly with Livewire navigation
- 📦 **Third-party friendly** - packages automatically use the current locale
- 🎨 **Clean route macro** - `Route::localized()` for prefix-based routes
- 🛡️ **Strict enforcement** - optional middleware for canonical URL redirects
- 🔧 **Extensible Locale DTO** - add custom properties via magic methods
- ⚡ **Zero configuration** - works out of the box with sensible defaults

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

[](#requirements)

- PHP 8.4+
- Laravel 10+

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

[](#installation)

Install the package via Composer:

```
composer require mikemenard/laravel-localization
```

The package will automatically register via Laravel's package auto-discovery.

Publish the configuration file (optional):

```
php artisan vendor:publish --tag=localization-config
```

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

[](#quick-start)

### 1. Add the Global Middleware

[](#1-add-the-global-middleware)

Add the `Localize` middleware to your `web` middleware group in `bootstrap/app.php`:

```
use Mikemenard\Localization\Middleware\Localize;

return Application::configure(basePath: dirname(__DIR__))
    ->withMiddleware(function (Middleware $middleware): void {
        $middleware->web(prepend: [
            Localize::class,
        ]);
    })
    // ...
```

**Important:** Use `prepend` instead of `append` to ensure the Localize middleware runs before other middleware (like authentication). This ensures that `URL::defaults()` is set before any route generation occurs, making locale parameters automatically available for auth redirects and other middleware that generate URLs.

### 2. Define Your Locales

[](#2-define-your-locales)

Edit `config/localization.php`:

```
return [
    'supported_locales' => [
        'en' => ['label' => 'English', 'language' => 'en'],
        'fr-ca' => ['label' => 'Français', 'language' => 'fr'],
        'es' => ['label' => 'Español', 'language' => 'es'],
    ],

    'route_parameter' => 'locale',

    'locale_class' => \Mikemenard\Localization\Locale::class,
];
```

### 3. Create Localized Routes

[](#3-create-localized-routes)

Use the `Route::localized()` macro for routes that should have locale prefixes:

```
use Illuminate\Support\Facades\Route;

// Root redirect to localized homepage
Route::get('/', fn() => redirect('/'.Localization::resolveLocale()));

// Localized routes
Route::localized(function () {
    Route::get('/', fn() => view('welcome'));
    Route::get('/about', fn() => view('about'));
    Route::get('/contact', fn() => view('contact'));
});
```

This generates:

- `/en/` → English homepage
- `/fr/` → French homepage
- `/en/about` → English about page
- `/fr/about` → French about page

### 4. Add a Language Switcher (example)

[](#4-add-a-language-switcher-example)

Create a Blade component at `resources/views/components/language-switcher.blade.php`:

```
@use(\Mikemenard\Localization\Facades\Localization)

    @foreach(Localization::getLocales() as $locale)
        @if(!Localization::isCurrentLocale($locale))

                {{ $locale->label }}

            @break
        @endif
    @endforeach

```

Use it in your layout:

```

```

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

[](#configuration)

The configuration file provides three main options:

### Supported Locales

[](#supported-locales)

Define all locales your application supports:

```
'supported_locales' => [
    'en' => [
        'label' => 'English',
        'language' => 'en',
    ],
    'fr-ca' => [
        'label' => 'Français',
        'language' => 'fr',
    ],
    'es' => [
        'label' => 'Español',
        'language' => 'es',
    ],
],
```

Each locale requires:

- **Key**: The locale code (e.g., `'en'`, `'fr-ca'`) - normalized to lowercase with hyphens
- **`label`**: Display name for the language switcher
- **`language`**: Language code for the locale

You can add custom properties that will be accessible via the Locale DTO:

```
'en' => [
    'label' => 'English',
    'language' => 'en',
    'flag' => '🇬🇧',
    'direction' => 'ltr',
    'currency' => 'USD',
],
```

Access custom properties:

```
@foreach(Localization::getLocales() as $locale)
    {{ $locale->flag }} {{ $locale->label }}
@endforeach
```

### Route Parameter

[](#route-parameter)

Customize the route parameter name used in URLs:

```
'route_parameter' => 'locale', // Default

// Or use a different name:
'route_parameter' => 'lang',
```

**Validation:** Must be a single word (alphanumeric and underscores only) - no slashes or special characters.

This affects:

- URL structure: `/{locale}/about` vs `/{lang}/about`
- Route parameters: `route('about', ['locale' => 'fr'])` vs `route('about', ['lang' => 'fr'])`

### Locale Class

[](#locale-class)

Specify a custom Locale DTO class:

```
'locale_class' => \App\Localization\CustomLocale::class,
```

Your custom class must extend `\Mikemenard\Localization\Locale`:

```
namespace App\Localization;

use Mikemenard\Localization\Locale;

class CustomLocale extends Locale
{
    public function displayName(): string
    {
        return strtoupper($this->label);
    }

    public function flagEmoji(): string
    {
        return $this->flag ?? '🏳️';
    }
}
```

How It Works: The Two-Middleware System
---------------------------------------

[](#how-it-works-the-two-middleware-system)

This package uses **two middleware classes** for different purposes:

### 1. Localize Middleware (Global)

[](#1-localize-middleware-global)

**Purpose:** Sets the locale for **every request** and makes URL generation work automatically.

**Added to:** `web` middleware group in `bootstrap/app.php`

**Behavior:**

- Extracts locale from the first URL segment (e.g., `/fr/about` → `'fr'`)
- Falls back to session → browser headers → app default if no locale in URL
- Calls `App::setLocale()` to set the application locale
- Calls `URL::defaults(['locale' => 'fr'])` so all route generation includes the locale
- Saves the locale to session for persistence

**Why this matters:**

- Makes `route('profile')` automatically generate `/fr/profile` when French is active
- Livewire components automatically use the correct locale in their URLs
- Third-party packages respect the current locale without modification
- Session persistence means the locale "sticks" across requests

### 2. EnforceLocale Middleware (Route-Specific)

[](#2-enforcelocale-middleware-route-specific)

**Purpose:** Enforces locale prefixes and handles redirects for routes that **must** have a locale.

**Added to:** Specific route groups via `Route::localized()` macro or manual route groups

**Behavior:**

- Validates the locale in the URL is in the correct format
- Redirects to a valid locale if the format is invalid
- Returns 404 if an unsupported locale is requested
- Redirects to canonical locale format (e.g., `en_US` → `en-us`)
- Ensures strict URL structure for SEO and consistency

**Example:**

```
Route::localized(function () {
    Route::get('/', HomeController::class);
    Route::get('/products', ProductController::class);
});
```

URLs like `/invalid/products` get redirected to `/en/products` (or user's session locale).

Route Macro Usage
-----------------

[](#route-macro-usage)

The `Route::localized()` macro simplifies creating localized route groups.

### Basic Usage

[](#basic-usage)

```
Route::localized(function () {
    Route::get('/', fn() => view('home'));
    Route::get('/about', fn() => view('about'));
});
```

Equivalent to:

```
Route::prefix('{locale}')
    ->middleware(\Mikemenard\Localization\Middleware\EnforceLocale::class)
    ->group(function () {
        Route::get('/', fn() => view('home'));
        Route::get('/about', fn() => view('about'));
    });
```

### Chainable Middleware

[](#chainable-middleware)

You can chain additional middleware **before** calling `group()`:

```
Route::localized()
    ->middleware('auth')
    ->group(function () {
        Route::get('/dashboard', DashboardController::class);
        Route::get('/profile', ProfileController::class);
    });
```

Multiple middleware:

```
Route::localized()
    ->middleware(['auth', 'verified'])
    ->group(function () {
        Route::resource('posts', PostController::class);
    });
```

### Name Prefixing

[](#name-prefixing)

Combine with Laravel's name prefixing:

```
Route::localized()
    ->name('admin.')
    ->prefix('admin')
    ->middleware('auth')
    ->group(function () {
        Route::get('/dashboard', DashboardController::class)->name('dashboard');
        // Route name: admin.dashboard
        // URL: /en/admin/dashboard
    });
```

### Manual Route Groups (Alternative)

[](#manual-route-groups-alternative)

If you prefer not to use the macro, define the group manually:

```
Route::prefix('{locale}')
    ->middleware(\Mikemenard\Localization\Middleware\EnforceLocale::class)
    ->group(function () {
        // Your routes
    });
```

Language Switcher Component
---------------------------

[](#language-switcher-component)

Create a reusable language switcher component at `resources/views/components/language-switcher.blade.php`:

```
@use(\Mikemenard\Localization\Facades\Localization)

    @foreach(Localization::getLocales() as $locale)
        @if(!Localization::isCurrentLocale($locale))

                {{ $locale->label }}

        @else

                {{ $locale->label }}

        @endif
    @endforeach

```

**Explanation:**

- `Localization::getLocales()` returns all configured locales as Locale DTOs
- `Localization::isCurrentLocale($locale)` checks if the locale is currently active
- `Localization::localizeCurrentUrl($locale)` generates the current URL with the locale switched

### Advanced Language Switcher

[](#advanced-language-switcher)

With custom flags and dropdown:

```
@use(\Mikemenard\Localization\Facades\Localization)

        {{ Localization::currentLocale()->flag }}
        {{ Localization::currentLocale()->label }}

        @foreach(Localization::getLocales() as $locale)

                {{ $locale->flag }} {{ $locale->label }}

        @endforeach

```

### Livewire-Compatible Switcher

[](#livewire-compatible-switcher)

If using Livewire with `wire:navigate`:

```
@use(\Mikemenard\Localization\Facades\Localization)

    @foreach(Localization::getLocales() as $locale)
        @if(!Localization::isCurrentLocale($locale))

                {{ $locale->label }}

        @endif
    @endforeach

```

Customizing the Locale DTO
--------------------------

[](#customizing-the-locale-dto)

The `Locale` class uses magic methods to allow custom properties.

### Adding Custom Properties

[](#adding-custom-properties)

In your config:

```
'supported_locales' => [
    'en' => [
        'label' => 'English',
        'language' => 'en',
        'flag' => '🇬🇧',
        'direction' => 'ltr',
        'currency' => 'USD',
        'date_format' => 'Y-m-d',
    ],
    'fr' => [
        'label' => 'Français',
        'language' => 'fr',
        'flag' => '🇫🇷',
        'direction' => 'ltr',
        'currency' => 'EUR',
        'date_format' => 'd/m/Y',
    ],
    'ar' => [
        'label' => 'العربية',
        'language' => 'ar',
        'flag' => '🇸🇦',
        'direction' => 'rtl',
        'currency' => 'SAR',
        'date_format' => 'd/m/Y',
    ],
],
```

Access custom properties via magic `__get()`:

```
@foreach(Localization::getLocales() as $locale)

        {{ $locale->flag }} {{ $locale->label }}

@endforeach

    Currency: {{ Localization::currentLocale()->currency }}
    Date format: {{ Localization::currentLocale()->date_format }}

```

### Extending the Locale Class

[](#extending-the-locale-class)

Create a custom Locale class:

```
namespace App\Localization;

use Mikemenard\Localization\Locale as BaseLocale;

class CustomLocale extends BaseLocale
{
    public function uppercaseLabel(): string
    {
        return strtoupper($this->label);
    }

    public function isRtl(): bool
    {
        return $this->direction === 'rtl';
    }

    public function flagEmoji(): string
    {
        return $this->flag ?? '🏳️';
    }

    public function formattedDate(\DateTime $date): string
    {
        return $date->format($this->date_format);
    }
}
```

Register it in config:

```
'locale_class' => \App\Localization\CustomLocale::class,
```

Use custom methods:

```
@foreach(Localization::getLocales() as $locale)

        {{ $locale->flagEmoji() }} {{ $locale->uppercaseLabel() }}

@endforeach
```

API Reference
-------------

[](#api-reference)

### Facade Methods

[](#facade-methods)

All methods are available via the `Localization` facade:

```
use Mikemenard\Localization\Facades\Localization;
```

#### `supported(): array`

[](#supported-array)

Returns an array of all supported locale codes.

```
Localization::supported(); // ['en', 'fr', 'es']
```

#### `getLocales(): Collection`

[](#getlocales-collection)

Returns a Collection of `Locale` objects.

```
Localization::getLocales()->each(function ($locale) {
    echo $locale->code . ': ' . $locale->label;
});
```

#### `currentLocale(): Locale`

[](#currentlocale-locale)

Returns the `Locale` object for the current application locale.

```
$current = Localization::currentLocale();
echo $current->label; // 'English'
```

#### `setLocale(string|Locale $locale): string`

[](#setlocalestringlocale-locale-string)

Sets the application locale, updates session, and sets URL defaults.

```
Localization::setLocale('fr'); // Returns 'fr'
Localization::setLocale($localeObject); // Also accepts Locale objects
```

**Throws:** `UnsupportedLocaleException` if locale is not supported.

#### `isSupported(string|Locale|null $locale): bool`

[](#issupportedstringlocalenull-locale-bool)

Checks if a locale is supported.

```
Localization::isSupported('fr'); // true
Localization::isSupported('de'); // false
Localization::isSupported(null); // false
```

#### `isCurrentLocale(string|Locale $locale): bool`

[](#iscurrentlocalestringlocale-locale-bool)

Checks if a locale is the current application locale.

```
Localization::isCurrentLocale('en'); // true if current locale is 'en'
```

#### `localizeCurrentUrl(string|Locale $locale): string`

[](#localizecurrenturlstringlocale-locale-string)

Returns the current URL with the locale switched.

```
// Current URL: /en/products?sort=price
Localization::localizeCurrentUrl('fr'); // '/fr/products?sort=price'
```

#### `resolveLocale(): string`

[](#resolvelocale-string)

Resolves the locale from session → browser headers → app default.

```
$locale = Localization::resolveLocale(); // 'fr' (from session or browser)
```

#### `getRouteParameter(): string`

[](#getrouteparameter-string)

Returns the configured route parameter name.

```
Localization::getRouteParameter(); // 'locale'
```

#### `isCanonical(string $locale): bool`

[](#iscanonicalstring-locale-bool)

Checks if a locale is in canonical format (exact match in supported locales).

```
Localization::isCanonical('en'); // true
Localization::isCanonical('en_US'); // false (should be 'en-us')
```

#### `getLocaleFromUrl(): ?string`

[](#getlocalefromurl-string)

Extracts the locale from the current request's route parameter.

```
// URL: /fr/about
Localization::getLocaleFromUrl(); // 'fr'
```

#### `isLocale(string $locale): bool`

[](#islocalestring-locale-bool)

Validates if a string matches the locale format pattern.

```
Localization::isLocale('en'); // true
Localization::isLocale('en-us'); // true
Localization::isLocale('invalid'); // false
```

### Locale DTO Properties

[](#locale-dto-properties)

Every `Locale` object has these properties:

```
$locale->code;      // string - Locale code (e.g., 'en', 'fr-ca')
$locale->label;     // string - Display label (e.g., 'English')
$locale->language;  // string - Language code (e.g., 'en')

// Plus any custom properties from config via __get():
$locale->flag;         // Custom property
$locale->direction;    // Custom property
$locale->currency;     // Custom property
```

Advanced Usage
--------------

[](#advanced-usage)

### Programmatic Locale Switching

[](#programmatic-locale-switching)

In controllers or middleware:

```
use Mikemenard\Localization\Facades\Localization;

class LocaleController
{
    public function switch(string $locale)
    {
        try {
            Localization::setLocale($locale);
            return redirect()->back();
        } catch (\Mikemenard\Localization\Exceptions\UnsupportedLocaleException $e) {
            abort(404, $e->getMessage());
        }
    }
}
```

### URL Generation

[](#url-generation)

Thanks to `URL::defaults()` being set automatically, all route helpers work:

```
// Current locale: 'fr'
route('about'); // '/fr/about'
url('/contact'); // '/fr/contact'
action([ProductController::class, 'index']); // '/fr/products'
```

Override for a specific locale:

```
route('about', ['locale' => 'en']); // '/en/about'
```

### Accessing Session Directly

[](#accessing-session-directly)

The package stores locale in session under key `localization:locale`:

```
session('localization:locale'); // 'fr'
session(['localization:locale' => 'en']); // Manually set
```

### Browser Locale Detection

[](#browser-locale-detection)

The package automatically detects browser locale from `Accept-Language` headers:

```
Accept-Language: fr-FR,fr;q=0.9,en;q=0.8

```

Will resolve to `'fr'` if no session locale exists.

### Locale Fallback Logic

[](#locale-fallback-logic)

When matching locales, the package uses intelligent fallback:

1. **Exact match:** `'fr'` matches `'fr'` in config
2. **Prefix match:** `'fr'` matches `'fr-ca'` in config (if no exact match)
3. **Language code match:** `'fr-ca'` matches `'fr'` in config (if no exact or prefix match)

Example:

```
// Config: ['en', 'fr-ca']
Localization::isSupported('fr-ca'); // true (exact)
Localization::isSupported('fr'); // true (matches 'fr-ca' via prefix)
Localization::isSupported('en-us'); // true (matches 'en' via language code)
```

### Testing

[](#testing)

In tests, you can manually set the locale:

```
use Mikemenard\Localization\Facades\Localization;

test('homepage shows French content', function () {
    Localization::setLocale('fr');

    $response = $this->get(route('home', ['locale' => 'fr']));

    $response->assertSee('Bienvenue');
});
```

Exception Handling
------------------

[](#exception-handling)

The package throws descriptive exceptions for common errors:

### UnsupportedLocaleException

[](#unsupportedlocaleexception)

Thrown when trying to set an unsupported locale:

```
try {
    Localization::setLocale('de'); // Not in config
} catch (\Mikemenard\Localization\Exceptions\UnsupportedLocaleException $e) {
    // "Locale 'de' is not supported. Supported locales: en, fr."
}
```

### InvalidRouteParameterException

[](#invalidrouteparameterexception)

Thrown when route parameter config is invalid:

```
// config/localization.php
'route_parameter' => 'locale/invalid', // Invalid!

// Throws: "The route parameter 'locale/invalid' is invalid.
// It must be a single word without slashes, optionals (?), or special characters."
```

### InvalidLocaleClassException

[](#invalidlocaleclassexception)

Thrown when custom locale class is invalid:

```
// config/localization.php
'locale_class' => \App\Models\User::class, // Doesn't extend Locale!

// Throws: "The locale class 'App\Models\User' must extend \Mikemenard\Localization\Locale."
```

FAQ
---

[](#faq)

### Does this replace Laravel's built-in localization?

[](#does-this-replace-laravels-built-in-localization)

No, it complements it. Laravel's `trans()`, `__()`, and language files still handle translations. This package manages **locale selection, URL structure, and session persistence**.

### Can I use this with Livewire?

[](#can-i-use-this-with-livewire)

Yes! That's one of the main reasons this package exists. The global middleware ensures Livewire respects the current locale without modification.

### What about SEO and duplicate content?

[](#what-about-seo-and-duplicate-content)

Use the `EnforceLocale` middleware on your localized routes to ensure canonical URLs and automatic redirects. This prevents duplicate content issues.

### Can I have non-localized routes?

[](#can-i-have-non-localized-routes)

Absolutely. Only routes inside `Route::localized()` groups require locale prefixes. Other routes work normally:

```
Route::get('/health', fn() => 'OK'); // No locale prefix
Route::get('/api/users', [UserController::class, 'index']); // No locale prefix

Route::localized(function () {
    Route::get('/', fn() => view('home')); // Requires locale prefix
});
```

### How do I handle the root URL `/`?

[](#how-do-i-handle-the-root-url-)

Create a redirect to your default or detected locale:

```
use Mikemenard\Localization\Facades\Localization;

Route::get('/', function () {
    return redirect('/' . Localization::resolveLocale());
});
```

### Can I use subdomain-based locales?

[](#can-i-use-subdomain-based-locales)

Not currently. This package is designed for path-based locales (`/en/about`, `/fr/about`).

### Does this work with Laravel Jetstream/Breeze?

[](#does-this-work-with-laravel-jetstreambreeze)

Yes, but you'll need to wrap their routes in `Route::localized()` groups if you want localized URLs for auth pages.

License
-------

[](#license)

This package is open-source software licensed under the [MIT license](LICENSE.md).

Credits
-------

[](#credits)

Created by [Mike Menard](https://github.com/mikemenard).

Built for Laravel 10+ with PHP 8.4+.

###  Health Score

37

—

LowBetter than 83% of packages

Maintenance73

Regular maintenance activity

Popularity8

Limited adoption so far

Community6

Small or concentrated contributor base

Maturity52

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 100% 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

Unknown

Total

1

Last Release

188d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/1ac7e69759da89d2d5bfafcbc9d6f620783e8464ef4e9910d8c365c833992ccc?d=identicon)[mikemenard](/maintainers/mikemenard)

---

Top Contributors

[![mikemenard](https://avatars.githubusercontent.com/u/12190675?v=4)](https://github.com/mikemenard "mikemenard (3 commits)")

---

Tags

laravellocalizationi18ntranslationmultilinguallivewirelocale

###  Code Quality

TestsPHPUnit

### Embed Badge

![Health badge](/badges/mikemenard-laravel-localization/health.svg)

```
[![Health](https://phpackages.com/badges/mikemenard-laravel-localization/health.svg)](https://phpackages.com/packages/mikemenard-laravel-localization)
```

###  Alternatives

[codezero/laravel-localized-routes

A convenient way to set up, manage and use localized routes in a Laravel app.

543638.1k4](/packages/codezero-laravel-localized-routes)[tractorcow/silverstripe-fluent

Simple localisation for Silverstripe

92421.6k26](/packages/tractorcow-silverstripe-fluent)[opgginc/codezero-laravel-localized-routes

A convenient way to set up, manage and use localized routes in a Laravel app.

2770.1k1](/packages/opgginc-codezero-laravel-localized-routes)[jayesh/laravel-gemini-translator

An interactive command to extract and generate Laravel translations using Gemini AI.

691.7k1](/packages/jayesh-laravel-gemini-translator)[longman/laravel-multilang

Package to integrate multi language (multi locale) functionality in Laravel 5.x

5514.4k1](/packages/longman-laravel-multilang)[awes-io/localization-helper

Package for convenient work with Laravel's localization features

3527.1k4](/packages/awes-io-localization-helper)

PHPackages © 2026

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