Hey there, fellow PHP lovers! If you’re like me, you’ve spent years cranking out killer web apps with Laravel. It’s fast, it’s familiar, and it just feels right. But what if I told you that you could take those exact same skills and build real, native mobile apps for iOS and Android plus desktop apps for Windows, Mac, and Linux—without learning Swift, Kotlin, or Electron from scratch? No more staring at foreign docs or rewriting your whole backend in another language.

That’s exactly what NativePHP lets you do. It’s like someone finally handed Laravel the keys to the native app world. And the best part? It’s all powered by plain old PHP running right on the device. No servers, no browser tabs—just your Laravel code bundled up and feeling right at home on phones and laptops.

In this post, we’re diving deep into how this works, why it’s a total game-changer for PHP devs, and how you can get your first native app up and running in minutes. I’ll keep it real and casual—no jargon overload. By the end, you’ll have a solid roadmap to start building stuff like a notes app, a field service tool, or even a little game. Let’s jump in!

What the Heck is NativePHP, Anyway?

NativePHP isn’t some fancy new framework that forces you to rewrite everything. It’s a smart toolkit that wraps your Laravel (or plain PHP) app in a native shell. Think of it this way: your Laravel code runs with a full PHP runtime baked right into the app. For desktop, it sits inside something like Electron (or Tauri if you prefer lighter options). For mobile, it lives inside Swift for iOS or Kotlin for Android.

The magic happens through “bridges.” These are simple PHP classes (or JS helpers) that let your code talk directly to the phone’s camera, GPS, biometrics, or the desktop’s notifications and file system. Your UI? You can use Blade templates, Livewire for reactive goodness, Inertia with Vue/React, or whatever frontend you’re already comfy with. It all renders in a native web view, but it feels native because the PHP is humming along at full speed—no laggy API calls to a distant server.

And get this: as of early 2026, NativePHP for Mobile (v3, aka “Air”) went fully free and open source under MIT. No more paid tiers for the basics. Desktop has been around a bit longer and is just as solid. Apps end up tiny—mobile ones often under 50MB—and they work offline like a charm. You can even use any Composer package you love, from Eloquent for databases (SQLite works great locally) to your favorite payment libs.

Why does this matter for us PHP folks? Simple: we already know Laravel inside out. Routing, queues, models, policies—you name it. NativePHP lets you reuse 80-90% of that code across web, mobile, and desktop. No more context-switching nightmares.

How NativePHP Handles Desktop Apps

Desktop is where NativePHP started, and it’s buttery smooth. You build your Laravel app like normal, then NativePHP packages it into a standalone .exe, .dmg, or .AppImage that users can double-click and install.

Under the hood:

• PHP 8.3+ runtime gets bundled.
• Your app runs locally at native speeds.
• You get access to stuff like system trays, file dialogs, clipboard, and even hardware acceleration if needed.

It’s perfect for tools like internal company dashboards, invoicing apps, or even creative apps where you want offline power without shipping a full web server.

Mobile: The Real Excitement (iOS and Android, No Sweat)

Mobile was the big “whoa” moment. NativePHP for Mobile embeds PHP right into the app’s binary. Your Laravel code executes on the device itself—full Eloquent queries, controllers, everything. No backend server required (though you can still call APIs if you want).

It bridges straight to native APIs: camera, gallery, push notifications, haptics (that satisfying phone vibration), secure storage (better than localStorage), deep links, location services, and more. And since it’s true native, your app shows up in the App Store or Play Store just like any other.

Apps stay lightweight, perform great, and feel snappy. Plus, you can test on real devices instantly without firing up Xcode or Android Studio every time (more on that in a sec).

Let’s Build Something: Quick Start for Desktop

Ready to try it? Fire up your terminal. Prerequisites are easy: PHP 8.3+, Laravel 11+, Node.js 22+, and you’re good on Windows 10+, macOS 12+, or Linux.

1. Create a fresh Laravel app (or use an existing one):textlaravel new my-desktop-app cd my-desktop-app
2. Install the desktop package:textcomposer require nativephp/electron
3. Run the installer (this sets up configs, publishes files, and grabs any Node deps):textphp artisan native:install
4. Test it in the browser first (smart move to catch bugs early), then launch native:textphp artisan native:serve

Boom—your Laravel app pops up in a real desktop window. Tweak your routes, add Livewire components, whatever. For development, there’s even a composer native:dev script for hot reloading. When you’re ready to ship, NativePHP handles building the final executable. Super straightforward.

Mobile Quick Start: From Zero to App in 5 Minutes

Mobile is even more fun because of “Jump”—a free app you download to your phone for instant previews. No compiling until you want App Store builds.

1. Grab Jump from bifrost.nativephp.com/jump and install it on your iPhone or Android.
2. Create your Laravel app:textlaravel new my-mobile-app cd my-mobile-app
3. Add NativePHP Mobile:textcomposer require nativephp/mobile
4. Start the Jump server:textphp artisan native:jump

A QR code appears. Open Jump on your phone, scan it, and watch your Laravel app load natively on the device. Real PHP, real device—feels like magic.

For full builds (to submit to stores):

text

php artisan native:install
php artisan native:run

This scaffolds the native projects. You’ll need Xcode for iOS or Android Studio for full packaging, but Jump skips that for testing.

A Real Example: Building a Simple Notes App

Let’s make this concrete. Say you’re building a cross-platform notes app. Your Laravel backend stays mostly the same:

• Models for Note (with Eloquent and SQLite).
• A controller to handle CRUD.
• Livewire components for the UI (or Inertia if you prefer Vue).

In a Blade/Livewire view:

HTML

<button wire:click="saveNote">Save & Vibrate</button>

In your Livewire class:

PHP

use Native\Mobile\Facades\Device;  // or whatever the exact facade is

public function saveNote()
{
    // Normal Laravel stuff
    Note::create([...]);
    
    // Native magic
    Device::vibrate();  // Phone buzzes!
    Device::showToast('Note saved!');
}

For JS folks:

vue

<script setup>
import { Device } from '@nativephp/mobile';

const saveNote = async () => {
  await Device.vibrate();
};
</script>

Add camera access? One line: Device::openCamera(). Location? Device::getCurrentLocation(). It’s all PHP-first, with clean facades. Your web version can share the same models and logic—just swap the frontend bits if needed.

Pro tip: Keep your native apps as separate Laravel projects from your main web app. That way