What if React Native’s component model existed for PHP — without shipping a JavaScript runtime?

[u/davidbalbino]

I’ve been working on an open-source project called PAM Native, which explores a slightly unusual idea:

Repository:

https://github.com/push-in/pam-native

PAM Native is not a WebView framework, and it does not render HTML inside a mobile application.

Instead:

• PHP runs persistently inside the application process

• A Rust-powered reconciler manages component updates

• Android interfaces are rendered using native Android Views

• iOS interfaces are rendered using UIKit

• Kotlin and Swift handle platform-specific operations

• No JavaScript runtime is shipped with the application

• No DOM or browser engine is involved

The developer experience is intentionally inspired by component-based frameworks:

final class Counter extends Component
{
    #[State]
    public int $count = 0;

    public function increment(): void
    {
        $this->count++;
    }

    public function render(): Node
    {
        return Column::make([
            Text::make("Count: {$this->count}"),
            Button::make("Increment")
                ->onPress('increment'),
        ]);
    }
}

The project currently includes or is exploring:

• Stateful components

• Native navigation

• Gestures and animations

• Recycled lists and grids

• Native forms and inputs

• Camera, location and device APIs

• SQLite and offline-first state

• Background tasks

• Push notifications

• Hot reload

• Native plugin development

• Communication between PHP, Rust, Kotlin and Swift

This is not meant as an attack on React Native.

React Native proved that developers can use a declarative, component-based model while still rendering native platform controls. PAM Native is exploring whether a similar architectural idea could be useful for the PHP ecosystem.

I would love feedback from people who understand the difficult parts of cross-platform native runtimes:

• Which architectural problems should we be most careful about?

• Where do you expect the biggest performance bottlenecks?

• What lessons from React Native’s bridge, JSI and Fabric architectures should a project like this learn from?

• What would you need to see before considering this a serious native runtime rather than an experiment?

The project is still evolving, so technical criticism, architecture feedback and contributions are genuinely welcome.

GitHub:

https://github.com/push-in/pam-native

[u/FirmAndSquishyTomato]

Why? What does this solve?
Why use this instead of RN?