Be part of JetBrains PHPverse 2026 on June 9 – a free online event bringing PHP devs worldwide together.

Browse all series

Build Native Apps With PHP

Welcome to my CreatorSeries! I’m Simon, and in this series we’re going to learn about NativePHP and use it to build true native applications for desktop and mobile. We're not talking about web apps accessed through the browser. Your users will be able to install directly on their devices.

This is a big leap forward for the PHP ecosystem, and while it’s a real paradigm shift from the way we normally build with PHP and Laravel, we’ve worked hard to keep it familiar and approachable. So grab a warm drink, get comfortable, and let's start building!

Series trailer thumbnail

Progress

Series Info

Episodes
17
Run Time
2h 30m
Difficulty
Intermediate
Last Updated
Jan 31, 2026
Version
Latest
Play Series

Series Episodes

  1. Mindset, Architecture, and Setup (6)

    1. Introduction To NativePHP

      Let's get our minds ready to use PHP to build native desktop and mobile apps for Mac, Windows, Linux, iOS, and Android. We'll walk through the key fundamentals that make this a different paradigm from typical PHP and Laravel work before we start building.

    2. NativePHP Workflow

      We’ll start by exploring the nativephp.com docs and learning quick shortcuts like Command-K to search. Then we’ll cover how this workflow differs from typical Laravel work, where we run watchers and processes to get changes to show up and sometimes run the app in its native environment to access device features.

    3. Working With Databases

      Now that we're building native PHP apps, it's time to talk databases and why SQLite is usually the right choice when we're shipping software to users. We'll walk through how Laravel and Eloquent work with SQLite in migrations and models, and why you should avoid embedding remote MySQL or Postgres credentials. Instead, put an API layer in front of your database.

    4. Why You Need Separate Applications

      We'll see why you shouldn't force your existing Laravel web app to also serve native PHP mobile and desktop apps. Instead, we'll keep contexts separate and reach for laravel new for each target so we avoid shipping server-side logic to user devices.

    5. Desktop Versus Mobile Applications

      We could try installing native PHP for desktop and native PHP for mobile into the same application, but we shouldn’t—those packages overlap and can cause unexpected errors. Before we get going, we’ll treat desktop and mobile as separate apps and walk through your system setup so everything is configured safely.

    6. System Setup And Prerequisites

      Before we jump into building your first mobile app, we need to get your development environment squared away so you can compile for the platforms your machine supports, such as Windows, Mac, or Linux. Make sure you’re comfortable in the terminal, have Laravel ready, and install platform tools such as Xcode or Android Studio. Follow the native PHP docs, and then we’ll get started.
  2. Developing Mobile Apps (6)

    1. Getting Started With NativePHP Mobile

      We’re going to install native PHP for mobile and build our first application using the PHP and Laravel skills we already have. Along the way, we’ll see how it ties into front-end tools like Inertia, React, Livewire, and Blade so we can ship mobile apps without learning Swift or Kotlin.

    2. Installing NativePHP For Mobile

      Let's create a new Laravel app and add Native PHP for mobile by editing our composer.json and running composer require. Next, we’ll scaffold the native projects with php artisan native:install and boot the app on a simulator with php artisan native:run so we can see Laravel running on a phone.

    3. Exploring Native Device Features

      Now that we're ready to try some native features, we’re going to build a tiny Livewire component that fires a native dialogue alert so we can see how PHP calls into the device. We’ll run the app in a simulator with php artisan native:run ios to test the alert and then note which APIs require a real device to work properly.

    4. Building For Android

      Now that our interface lives in a web view with Laravel on the backend, let’s fire it up on Android using php artisan native:run android and watch the native alerts and UI components behave just like on iOS. Keep in mind Android support is more fragmented across devices and OS versions, so some features might not work everywhere—but we’ll cover tips to make development smoother next.

    5. Development Tips And Hot Reloading

      We’ve been happily building the UI in the browser, but now let’s switch to a simulator so we can exercise native features and iterate without reinstalling every time. Instead of npm run dev, we’ll run php artisan native:run --watch to hot reload onto the simulator, and then attach Safari’s dev tools to the web view so we can inspect and tweak things in real time.

    6. Securing Your Application

      Now that we have some basic flows in place, we’re going to tackle storing sensitive credentials securely on the device using the device key store and the SecureStorage facade. We’ll move away from relying on session state and instead show how to persist tokens with SecureStorage::set and read them back safely across app restarts using native PHP.
  3. How the Sauce is Made (1)

    1. How NativePHP Works Under The Hood

      Now we’re going to pull back the curtain on what’s happening under the hood in native PHP for mobile and see how a compiled PHP engine lives inside a Swift app and exposes native APIs through our extension. We'll follow a request from the web view into a custom scheme handler, watch events like button pressed bridge back to Livewire, and use Xcode to debug the whole flow.
  4. Ship It and What's Next (4)

    1. Publishing To The App Store

      Now that our app is ready, we’re going to walk through submitting it to the App Store and Google Play, focusing on the happy path to get a build into review. Along the way, we’ll run commands like php artisan native:release and php artisan native:build, open Xcode to create an archive, and use Android Studio to generate a signed app bundle.

    2. NativePHP For Desktop

      We’re doing a quick whistle-stop tour of building a native desktop app with Laravel and native-php/desktop: installing the package, booting it with php artisan native:run, and using composer native:dev for live development. Along the way, we’ll tweak the welcome Blade view and call the Doc facade like Doc::bounce() so you can see how Laravel talks to the Electron APIs in real time.

    3. New Features And Updates

      We’re going to dive into the new native PHP workflow and tools that make building real mobile and desktop apps feel fast and friction-free. Along the way, we’ll inspect the slimmed-down core and plugin model, try native UI components, enable hot reloading via v.config, use native jump and the Jump app to run our app on device, and check out the Bioprost build service and Mimi AI for rapidly generating projects.

    4. Wrapping Up

      We've walked through how to run native PHP apps on Android and iOS, tap into native features, and use dev tools like Xcode, Android Studio, and hot reloading while preparing apps for the App Store and Google Play Console. Now it’s on us to pick our favorite UI tools and start building something real and delightful—and when you launch, please come tell us in Discord so we can cheer you on.

Continue Learning

Blaze Deep-Dive thumbnail

Blaze Deep-Dive

With Caleb Porzio

Blade components are slow. Really slow. At scale, they quietly become the biggest bottleneck in your Laravel application. We discovered this while trying to make Flux as fast as possible, and the result is Blaze: a package that fundamentally rethinks how Blade components are compiled and rendered. With multiple levels of optimization, Blaze can shave hundreds of milliseconds off a page load, making Blade rendering up to 25x faster in some cases.In this series, we'll install it, benchmark it, build a toy version from scratch so you truly understand how it works, and then master every directive and edge case so you can squeeze maximum performance out of your own apps.

  • 20 Episodes
Customizing Filament For User-Facing Apps thumbnail

Customizing Filament For User-Facing Apps

With Shruti Balasa

In this series, we'll build a real, user-facing app called Booknest using Laravel and Filament. We'll begin with a fresh install and begin pushing Filament beyond the usual "internal admin only" setup that you typically see. It's capable of so much more.

  • 14 Episodes
Filament 5 in Depth thumbnail

Filament 5 in Depth

With Kevin McKee

Filament's powers have increased exponentially. Now at version 5, it's more powerful and capable than ever. In this series, we'll build a practical Roadmap app from scratch, using Filament for the admin panel and Livewire for the public-facing side.Along the way, we'll cover panel configuration, enum-driven UI, strict authorization with policies, and newer form inputs like ToggleButtons, Sliders, and the TipTap-powered RichEditor. By the end, you'll have a full-featured app and a solid handle on everything new in Filament.

  • 16 Episodes
Everything New in Livewire 4 thumbnail

Everything New in Livewire 4

With Caleb Porzio

Livewire 4 is a major release, and it's packed with features you're going to love. View-based components keep your PHP and Blade together in one file. Islands let you create isolated, independently-updating regions without the overhead of nested components. New directives like wire:sort tackle big things with minimal code. And a powerful JavaScript interceptor system gives you fine-grained control over every request.Whether you're upgrading an existing app or starting fresh, this series will walk you through everything new, from the fundamentals to the advanced stuff. Let's dig in.

  • 25 Episodes
Laravel From Scratch (2026 Edition) thumbnail

Laravel From Scratch (2026 Edition)

With Jeffrey Way

Welcome to the latest iteration of the longest running Laravel introductory video series in the world. Like clockwork, we refresh this series every two years. This latest 2026 iteration covers Laravel 12 and beyond. You'll learn not only the basic fundamentals of Laravel, but also how to leverage more advanced features like authentication, authorization, queues, testing, and more. We'll even review the full deployment process from scratch.

  • 43 Episodes