diff --git a/.github/instructions/babylon-native-debugging.instructions.md b/.github/instructions/babylon-native-debugging.instructions.md
index 9baf72432..734480898 100644
--- a/.github/instructions/babylon-native-debugging.instructions.md
+++ b/.github/instructions/babylon-native-debugging.instructions.md
@@ -24,7 +24,7 @@ For pure RenderDoc CLI usage (any app, not BN-specific), see
 |---|---|
 | `Apps/Playground/Shared/CommandLine.{h,cpp}` | Argument parser. Single source of truth for supported flags. |
 | `Apps/Playground/Shared/Diagnostics.{h,cpp}` | Crash handler, `DumpFailure`, finish-line, exit-code tracking. |
-| `Apps/Playground/Shared/AppContext.cpp` | Wires `UnhandledExceptionHandler` + `console.error` into `DumpFailure`; injects `_playgroundOptions` into JS. |
+| `Apps/Playground/Win32/App.cpp` (and the other per-host `App.*`) | Wires the `RuntimeOptions::log` callback into `DumpFailure` (`JS CONSOLE ERROR` for `LogLevel::Error`, `UNCAUGHT JS ERROR` for `LogLevel::Fatal`) and injects `_playgroundOptions` into JS via `Runtime::RunOnJsThread`. |
 | `Apps/Playground/Scripts/validation_native.js` | Test runner. Reads `_playgroundOptions`, picks tests, calls `TestUtils.captureNextFrame()`. Reference-image load failures arrive via `BABYLON.Tools.LoadFile`'s `onLoadFileError` and are tagged with `MISSING_REFERENCE_IMAGE:`. |
 | `Apps/Playground/Scripts/config.json` | Test catalog. Each entry has `title`, `playgroundId`/`scriptToRun`, `referenceImage`, optional `excludeFromAutomaticTesting`/`reason`/`onlyVisual`/`renderCount`/`capture`/`threshold`/`errorRatio`. |
 | `Plugins/TestUtils/Source/TestUtils.cpp` | Native side of `TestUtils.captureNextFrame()` -- calls `m_deviceContext.RequestCaptureNextFrame()`. |
@@ -80,13 +80,15 @@ When you see `[Error] Error: Cannot load X` in stdout, **scroll up** --
 short error line. The short line is kept so legacy log scrapers still match.
 
 ### 3. JS stack on every `console.error`
-`AppContext.cpp`'s `Console::Initialize` callback calls
+The Embedding layer's `Console::Initialize` callback calls
 `Babylon::Polyfills::Console::CaptureCurrentJsStack(env)` on every
-`LogLevel::Error` message and appends the captured stack to the
-`DumpFailure` banner body. The capture is best-effort -- if the JS engine
-can't produce a stack (no JS context active, etc.) the helper returns an
-empty string and the banner just shows the message.
-Do not add per-callsite stack capture -- it's automatic.
+`LogLevel::Error` message and appends the captured stack to the message
+body that the host's `RuntimeOptions::log` callback receives (which the
+Playground hosts then route into the `DumpFailure` banner). The capture is
+best-effort — if the JS engine can't produce a stack (no JS context active,
+unsupported engine, etc.) the helper returns an empty string and the host
+just gets the bare message.
+Do not add per-callsite stack capture — it's automatic.
 
 ### 4. Colored finish line
 `Playground: Finished in <time>. (exit <code>)` is printed once at every exit
diff --git a/Apps/Playground/Android/BabylonNative/CMakeLists.txt b/Apps/Playground/Android/BabylonNative/CMakeLists.txt
index d5fdc0c50..0824b7ad3 100644
--- a/Apps/Playground/Android/BabylonNative/CMakeLists.txt
+++ b/Apps/Playground/Android/BabylonNative/CMakeLists.txt
@@ -8,45 +8,30 @@ project(BabylonNative)
 get_filename_component(PLAYGROUND_DIR "${CMAKE_CURRENT_LIST_DIR}/../.." ABSOLUTE)
 get_filename_component(REPO_ROOT_DIR "${PLAYGROUND_DIR}/../.." ABSOLUTE)
 
+# Build the cross-platform Embedding facade *and* the Android JNI
+# interop layer (`libBabylonNativeEmbedding.so`). The Playground
+# Android app loads that library directly via `BabylonNative.java`
+# (in the `com.babylonjs.embedding` package).
+set(BABYLON_NATIVE_EMBEDDING ON CACHE BOOL "" FORCE)
+set(BABYLON_NATIVE_EMBEDDING_ANDROID ON CACHE BOOL "" FORCE)
+
 add_subdirectory(${REPO_ROOT_DIR} "${CMAKE_CURRENT_BINARY_DIR}/BabylonNative")
 
-add_library(BabylonNativeJNI SHARED
-    src/main/cpp/BabylonNativeJNI.cpp
-    ${PLAYGROUND_DIR}/Shared/AppContext.cpp
-    ${PLAYGROUND_DIR}/Shared/Diagnostics.cpp)
+# Append a Playground-specific JNI helper to the generic
+# BabylonNativeEmbedding target so the bootstrap script list can stay
+# in Apps/Playground/Shared/PlaygroundScripts.{h,cpp} (shared with the
+# Win32 / iOS / macOS hosts) instead of being duplicated on the Java
+# side. Compiling these into the same .so keeps the Embedding layer
+# as a single in-process instance — handles produced by one entry point
+# can be safely consumed by another.
+target_sources(BabylonNativeEmbedding
+    PRIVATE src/main/cpp/PlaygroundJNI.cpp
+            ${PLAYGROUND_DIR}/Shared/Diagnostics.cpp
+            ${PLAYGROUND_DIR}/Shared/PlaygroundScripts.cpp)
 
-target_include_directories(BabylonNativeJNI
+target_include_directories(BabylonNativeEmbedding
     PRIVATE ${PLAYGROUND_DIR})
 
-target_link_libraries(BabylonNativeJNI
-    PRIVATE GLESv3
-    PRIVATE android
+target_link_libraries(BabylonNativeEmbedding
     PRIVATE bx
-    PRIVATE EGL
-    PRIVATE log
-    PRIVATE -lz
-    PRIVATE AbortController
-    PRIVATE AndroidExtensions
-    PRIVATE AppRuntime
-    PRIVATE Blob
-    PRIVATE Canvas
-    PRIVATE Console
-    PRIVATE Fetch
-    PRIVATE File
-    PRIVATE GraphicsDevice
-    PRIVATE NativeCamera
-    PRIVATE NativeCapture
-    PRIVATE NativeEncoding
-    PRIVATE NativeEngine
-    PRIVATE NativeInput
-    PRIVATE NativeOptimizations
-    PRIVATE NativeTracing
-    PRIVATE NativeXr
-    PRIVATE Performance
-    PRIVATE ScriptLoader
-    PRIVATE ShaderCache
-    PRIVATE TestUtils
-    PRIVATE TextDecoder
-    PRIVATE TextEncoder
-    PRIVATE Window
-    PRIVATE XMLHttpRequest)
+    PRIVATE Foundation)     # for <Babylon/PerfTrace.h> in PlaygroundScripts.cpp
diff --git a/Apps/Playground/Android/BabylonNative/consumer-rules.pro b/Apps/Playground/Android/BabylonNative/consumer-rules.pro
index e69de29bb..c487ee80c 100644
--- a/Apps/Playground/Android/BabylonNative/consumer-rules.pro
+++ b/Apps/Playground/Android/BabylonNative/consumer-rules.pro
@@ -0,0 +1,2 @@
+-keep class com.babylonjs.embedding.BabylonNative { *; }
+-keep class com.babylonjs.embedding.BabylonNative$RuntimeOptions { *; }
diff --git a/Apps/Playground/Android/BabylonNative/src/main/cpp/BabylonNativeJNI.cpp b/Apps/Playground/Android/BabylonNative/src/main/cpp/BabylonNativeJNI.cpp
deleted file mode 100644
index 15a1e9b0f..000000000
--- a/Apps/Playground/Android/BabylonNative/src/main/cpp/BabylonNativeJNI.cpp
+++ /dev/null
@@ -1,194 +0,0 @@
-#include <jni.h>
-#include <android/native_window.h> // requires ndk r5 or newer
-#include <android/native_window_jni.h> // requires ndk r5 or newer
-#include <android/log.h>
-
-#include <optional>
-#include <string>
-#include <vector>
-
-#include <Shared/AppContext.h>
-#include <AndroidExtensions/Globals.h>
-#include <Babylon/Plugins/NativeXr.h>
-
-namespace
-{
-    std::optional<AppContext> appContext{};
-    std::optional<Babylon::Plugins::NativeXr> nativeXr{};
-    bool isXrActive{};
-}
-
-extern "C"
-{
-    JNIEXPORT void JNICALL
-    Java_com_library_babylonnative_Wrapper_initEngine(JNIEnv* env, jclass clazz)
-    {
-    }
-
-    JNIEXPORT void JNICALL
-    Java_com_library_babylonnative_Wrapper_finishEngine(JNIEnv* env, jclass clazz)
-    {
-        isXrActive = false;
-
-        nativeXr.reset();
-        appContext.reset();
-    }
-
-    JNIEXPORT void JNICALL
-    Java_com_library_babylonnative_Wrapper_surfaceCreated(JNIEnv* env, jclass clazz, jobject surface, jobject jniContext)
-    {
-        if (!appContext)
-        {
-            JavaVM* javaVM{};
-            if (env->GetJavaVM(&javaVM) != JNI_OK)
-            {
-                throw std::runtime_error("Failed to get Java VM");
-            }
-
-            android::global::Initialize(javaVM, jniContext);
-
-            ANativeWindow* window = ANativeWindow_fromSurface(env, surface);
-            int32_t width  = ANativeWindow_getWidth(window);
-            int32_t height = ANativeWindow_getHeight(window);
-
-            appContext.emplace(
-                window,
-                static_cast<size_t>(width),
-                static_cast<size_t>(height),
-                [](const char* message) {
-                    __android_log_write(ANDROID_LOG_INFO, "BabylonNative", message);
-                },
-                [](Napi::Env env) {
-                    nativeXr.emplace(Babylon::Plugins::NativeXr::Initialize(env));
-                    nativeXr->SetSessionStateChangedCallback([](bool isXrActive){ ::isXrActive = isXrActive; });
-                });
-        }
-    }
-
-    JNIEXPORT void JNICALL
-    Java_com_library_babylonnative_Wrapper_surfaceChanged(JNIEnv* env, jclass clazz, jint width, jint height, jobject surface)
-    {
-        if (appContext)
-        {
-            ANativeWindow* window = ANativeWindow_fromSurface(env, surface);
-            appContext->Runtime().Dispatch([window, width = static_cast<size_t>(width), height = static_cast<size_t>(height)](auto) {
-                appContext->Device().UpdateWindow(window);
-                appContext->Device().UpdateSize(width, height);
-            });
-        }
-    }
-
-    JNIEXPORT void JNICALL
-    Java_com_library_babylonnative_Wrapper_setCurrentActivity(JNIEnv* env, jclass clazz, jobject currentActivity)
-    {
-        android::global::SetCurrentActivity(currentActivity);
-    }
-
-    JNIEXPORT void JNICALL
-    Java_com_library_babylonnative_Wrapper_activityOnPause(JNIEnv* env, jclass clazz)
-    {
-        android::global::Pause();
-        if (appContext)
-        {
-            appContext->Runtime().Suspend();
-        }
-    }
-
-    JNIEXPORT void JNICALL
-    Java_com_library_babylonnative_Wrapper_activityOnResume(JNIEnv* env, jclass clazz)
-    {
-        if (appContext)
-        {
-            appContext->Runtime().Resume();
-        }
-        android::global::Resume();
-    }
-
-    JNIEXPORT void JNICALL
-    Java_com_library_babylonnative_Wrapper_activityOnRequestPermissionsResult(JNIEnv* env, jclass clazz, jint requestCode, jobjectArray permissions, jintArray grantResults)
-    {
-        std::vector<std::string> nativePermissions{};
-        for (int i = 0; i < env->GetArrayLength(permissions); i++)
-        {
-            jstring permission = (jstring)env->GetObjectArrayElement(permissions, i);
-            const char* utfString{env->GetStringUTFChars(permission, nullptr)};
-            nativePermissions.push_back(utfString);
-            env->ReleaseStringUTFChars(permission, utfString);
-        }
-
-        auto grantResultElements{env->GetIntArrayElements(grantResults, nullptr)};
-        auto grantResultElementCount = env->GetArrayLength(grantResults);
-        std::vector<int32_t> nativeGrantResults{grantResultElements, grantResultElements + grantResultElementCount};
-        env->ReleaseIntArrayElements(grantResults, grantResultElements, 0);
-
-        android::global::RequestPermissionsResult(requestCode, nativePermissions, nativeGrantResults);
-    }
-
-    JNIEXPORT void JNICALL
-    Java_com_library_babylonnative_Wrapper_loadScript(JNIEnv* env, jclass clazz, jstring path)
-    {
-        if (appContext)
-        {
-            appContext->ScriptLoader().LoadScript(env->GetStringUTFChars(path, nullptr));
-        }
-    }
-
-    JNIEXPORT void JNICALL
-    Java_com_library_babylonnative_Wrapper_eval(JNIEnv* env, jclass clazz, jstring source, jstring sourceURL)
-    {
-        if (appContext)
-        {
-            std::string url = env->GetStringUTFChars(sourceURL, nullptr);
-            std::string src = env->GetStringUTFChars(source, nullptr);
-            appContext->ScriptLoader().Eval(std::move(src), std::move(url));
-        }
-    }
-
-    JNIEXPORT void JNICALL
-    Java_com_library_babylonnative_Wrapper_setTouchInfo(JNIEnv* env, jclass clazz, jint pointerId, jfloat x, jfloat y, jboolean buttonAction, jint buttonValue)
-    {
-        if (appContext && appContext->Input())
-        {
-            if (buttonAction)
-            {
-                if (buttonValue == 1)
-                    appContext->Input()->TouchDown(pointerId, x, y);
-                else
-                    appContext->Input()->TouchUp(pointerId, x, y);
-            }
-            else {
-                appContext->Input()->TouchMove(pointerId, x, y);
-            }
-        }
-    }
-
-    JNIEXPORT void JNICALL
-    Java_com_library_babylonnative_Wrapper_renderFrame(JNIEnv* env, jclass clazz)
-    {
-        if (appContext)
-        {
-            appContext->Device().FinishRenderingCurrentFrame();
-            appContext->Device().StartRenderingCurrentFrame();
-        }
-    }
-
-    JNIEXPORT void JNICALL
-    Java_com_library_babylonnative_Wrapper_xrSurfaceChanged(JNIEnv* env, jclass clazz, jobject surface)
-    {
-        if (nativeXr)
-        {
-            ANativeWindow* window{};
-            if (surface)
-            {
-                window = ANativeWindow_fromSurface(env, surface);
-            }
-            nativeXr->UpdateWindow(window);
-        }
-    }
-
-    JNIEXPORT jboolean JNICALL
-    Java_com_library_babylonnative_Wrapper_isXRActive(JNIEnv* env, jclass clazz)
-    {
-        return isXrActive;
-    }
-}
diff --git a/Apps/Playground/Android/BabylonNative/src/main/cpp/PlaygroundJNI.cpp b/Apps/Playground/Android/BabylonNative/src/main/cpp/PlaygroundJNI.cpp
new file mode 100644
index 000000000..0bc3f5c37
--- /dev/null
+++ b/Apps/Playground/Android/BabylonNative/src/main/cpp/PlaygroundJNI.cpp
@@ -0,0 +1,39 @@
+// Playground-specific JNI helper. Built into the same .so as the generic
+// Embedding/Android JNI (added via target_sources in the Playground
+// CMakeLists), so there's a single copy of Babylon::Embedding across
+// the process — avoids cross-library handle-passing UB.
+//
+// Sole purpose: surface Apps/Playground/Shared/PlaygroundScripts.{h,cpp}
+// to Java so the bootstrap script list stays in one place, shared with
+// the other Playground hosts.
+
+#include <Babylon/Embedding/Runtime.h>
+#include <Babylon/Embedding/Android/RuntimeHandle.h>
+
+#include <Shared/PlaygroundScripts.h>
+
+#include <jni.h>
+
+extern "C"
+{
+
+JNIEXPORT void JNICALL
+Java_com_android_babylonnative_playground_PlaygroundActivity_loadBootstrapScripts(
+    JNIEnv*, jclass, jlong runtimeHandle)
+{
+    auto* runtime = Babylon::Embedding::Android::RuntimeFromHandle(runtimeHandle);
+    if (runtime == nullptr)
+    {
+        return;
+    }
+
+    // Idempotent process-wide setup (PerfTrace level, etc.).
+    Playground::Initialize();
+
+    // Queue bootstrap scripts; they run after the first View attach
+    // completes engine init on the JS thread.
+    Playground::LoadBootstrapScripts(*runtime);
+}
+
+} // extern "C"
+
diff --git a/Apps/Playground/Android/BabylonNative/src/main/java/com/babylonjs/embedding/BabylonNative.java b/Apps/Playground/Android/BabylonNative/src/main/java/com/babylonjs/embedding/BabylonNative.java
new file mode 100644
index 000000000..6f0605e39
--- /dev/null
+++ b/Apps/Playground/Android/BabylonNative/src/main/java/com/babylonjs/embedding/BabylonNative.java
@@ -0,0 +1,152 @@
+package com.babylonjs.embedding;
+
+import android.app.Activity;
+import android.content.Context;
+import android.view.Surface;
+
+/**
+ * JVM binding for the C++ Babylon::Embedding layer. Native methods
+ * mirror byte-for-byte the {@code extern "C" JNIEXPORT} entry points in
+ * {@code Embedding/Android/src/main/cpp/BabylonNativeEmbedding.cpp}.
+ *
+ * <p>Thin facade — owns no state, exposes the C++ API as static methods.
+ * Hosts typically wrap it in their own {@code View} subclass (see
+ * {@link com.library.babylonnative.BabylonView}).
+ *
+ * <p>Lifecycle:
+ * <ol>
+ *   <li>{@link #setContext(Context)} once at app startup.</li>
+ *   <li>Create a Runtime via {@link #runtimeCreate()} or
+ *       {@link #runtimeCreate(RuntimeOptions)} and keep the handle.</li>
+ *   <li>Optional: queue scripts via {@link #runtimeLoadScript(long, String)};
+ *       they run after the first {@link #viewAttach(long, Surface)}.</li>
+ *   <li>Attach a View and drive {@link #viewRenderFrame(long)} from your draw loop.</li>
+ *   <li>Tear down with {@link #viewDetach(long)} then {@link #runtimeDestroy(long)}.</li>
+ * </ol>
+ */
+public final class BabylonNative {
+    /**
+     * Construction options. Defaults match the C++
+     * {@code Babylon::Embedding::RuntimeOptions}. Fields are public for
+     * simple object-initializer patterns.
+     */
+    public static final class RuntimeOptions {
+        /** Optional MSAA samples (0, 2, 4, 8, 16). */
+        public Integer msaaSamples = null;
+
+        /** Enable the JavaScript debugger (engine-dependent). */
+        public boolean enableDebugger = false;
+
+        /** Enable Babylon::DebugTrace output through the logcat sink. */
+        public boolean enableDebugTrace = false;
+
+        /** Block engine startup until a debugger attaches (engine-dependent). */
+        public boolean waitForDebugger = false;
+
+        /** Optional persistent on-disk shader cache path. */
+        public String shaderCachePath = null;
+    }
+
+    static {
+        System.loadLibrary("BabylonNativeEmbedding");
+    }
+
+    private BabylonNative() {}
+
+    // -------------------------------------------------------------------
+    // Process-wide platform lifecycle
+    // -------------------------------------------------------------------
+
+    /**
+     * Register the application Context. Call once at app startup
+     * (typically from {@code Application.onCreate}) before constructing
+     * any Runtime. Repeated calls replace the existing Context global ref.
+     */
+    public static native void setContext(Context context);
+
+    public static native void setCurrentActivity(Activity activity);
+
+    public static native void pause();
+
+    public static native void resume();
+
+    public static native void requestPermissionsResult(
+            int requestCode, String[] permissions, int[] grantResults);
+
+    // -------------------------------------------------------------------
+    // Runtime
+    // -------------------------------------------------------------------
+
+    /** Returns an opaque handle; release with {@link #runtimeDestroy(long)}. */
+    public static native long runtimeCreate();
+
+    /**
+     * Returns an opaque handle; release with {@link #runtimeDestroy(long)}.
+     * Pass {@code null} for the same defaults as {@link #runtimeCreate()}.
+     *
+     * <p>If {@link RuntimeOptions#shaderCachePath} is non-null, the cache
+     * is loaded on first {@link #viewAttach(long, Surface)} and saved on
+     * suspend / destroy. Throws {@link IllegalStateException} when
+     * shaderCachePath is set but {@code BABYLON_NATIVE_PLUGIN_SHADERCACHE}
+     * is disabled in the native build.
+     */
+    public static native long runtimeCreate(RuntimeOptions options);
+
+    public static native void runtimeDestroy(long handle);
+
+    public static native void runtimeLoadScript(long handle, String url);
+
+    public static native void runtimeEval(long handle, String source, String sourceUrl);
+
+    // No per-Runtime Suspend/Resume here: each Runtime auto-subscribes to
+    // pause/resume in runtimeCreate. Hosts call those once per Activity
+    // state change and every Runtime reacts. Use the C++ API for
+    // finer-grained control.
+
+    /**
+     * Set the Surface that XR renders into (typically a transparent
+     * SurfaceView overlay). Pass {@code null} to clear. Throws
+     * {@link IllegalStateException} when {@code BABYLON_NATIVE_PLUGIN_NATIVEXR}
+     * is disabled in the native build.
+     */
+    public static native void runtimeSetXrSurface(long handle, Surface surface);
+
+    /**
+     * Whether an XR session is active. Returns {@code false} (never
+     * throws) when {@code BABYLON_NATIVE_PLUGIN_NATIVEXR} is disabled.
+     */
+    public static native boolean runtimeIsXrActive(long handle);
+
+    // -------------------------------------------------------------------
+    // View
+    // -------------------------------------------------------------------
+
+    /** Returns an opaque handle; release with {@link #viewDetach(long)}. */
+    public static native long viewAttach(long runtimeHandle, Surface surface);
+
+    public static native void viewDetach(long handle);
+
+    public static native void viewRenderFrame(long handle);
+
+    /**
+     * Push the surface's new pixel-buffer dimensions. {@code width} and
+     * {@code height} are in physical pixels — pass the values from
+     * {@code SurfaceHolder.Callback.surfaceChanged} unchanged. The native
+     * View divides by DPR internally.
+     */
+    public static native void viewResize(long handle, int width, int height);
+
+    /**
+     * Pointer events. Pass {@code MotionEvent.getX/getY} through
+     * unchanged (physical pixels); native View converts internally
+     * before forwarding to Babylon.js's clientX/clientY pipeline.
+     *
+     * <p>Throws {@link IllegalStateException} when
+     * {@code BABYLON_NATIVE_PLUGIN_NATIVEINPUT} is disabled.
+     */
+    public static native void viewPointerDown(long handle, int pointerId, float x, float y);
+
+    public static native void viewPointerMove(long handle, int pointerId, float x, float y);
+
+    public static native void viewPointerUp(long handle, int pointerId, float x, float y);
+}
diff --git a/Apps/Playground/Android/BabylonNative/src/main/java/com/library/babylonnative/BabylonView.java b/Apps/Playground/Android/BabylonNative/src/main/java/com/library/babylonnative/BabylonView.java
index 517f376dc..000ba726e 100644
--- a/Apps/Playground/Android/BabylonNative/src/main/java/com/library/babylonnative/BabylonView.java
+++ b/Apps/Playground/Android/BabylonNative/src/main/java/com/library/babylonnative/BabylonView.java
@@ -1,41 +1,54 @@
 package com.library.babylonnative;
 
-import android.app.Activity;
 import android.content.Context;
 import android.graphics.Canvas;
-import android.util.Log;
 import android.view.MotionEvent;
 import android.view.SurfaceHolder;
 import android.view.SurfaceView;
 import android.view.View;
 import android.widget.FrameLayout;
 
+import com.babylonjs.embedding.BabylonNative;
+
+/**
+ * Playground View built on {@link BabylonNative}. Borrows a Runtime handle
+ * from the host (which owns the Runtime's lifetime); this class owns only
+ * the View handle, mirroring the Surface lifecycle: attach in
+ * {@code surfaceCreated}, resize in {@code surfaceChanged}, detach in
+ * {@code surfaceDestroyed}.
+ *
+ * <p>All sizes and coordinates passed to native are physical pixels —
+ * the Device queries DPR internally.
+ *
+ * <p>The host Activity owns process-wide {@code setContext} /
+ * {@code setCurrentActivity} / {@code pause} / {@code resume} /
+ * {@code requestPermissionsResult} (see {@code PlaygroundActivity}). The
+ * Runtime auto-subscribes to pause/resume on creation, so there is no
+ * per-view pause/resume.
+ */
 public class BabylonView extends FrameLayout implements SurfaceHolder.Callback2, View.OnTouchListener {
-    private static final FrameLayout.LayoutParams childViewLayoutParams = new FrameLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
-    private static final String TAG = "BabylonView";
-    private boolean mViewReady = false;
-    private final ViewDelegate mViewDelegate;
-    private Activity mCurrentActivity;
+    private static final FrameLayout.LayoutParams childViewLayoutParams =
+            new FrameLayout.LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT);
+
     private final SurfaceView primarySurfaceView;
     private final SurfaceView xrSurfaceView;
-    private final float pixelDensityScale = getResources().getDisplayMetrics().density;
-    public BabylonView(Context context, ViewDelegate viewDelegate) {
-        this(context, viewDelegate, (Activity)viewDelegate);
-    }
 
-    public BabylonView(Context context, ViewDelegate viewDelegate, Activity currentActivity) {
+    /** Runtime handle borrowed from the host. Not owned by this view. */
+    private final long mRuntimeHandle;
+
+    /** Native View handle (0 if not attached). Owned by this view. */
+    private long mViewHandle = 0;
+
+    public BabylonView(Context context, long runtimeHandle) {
         super(context);
+        mRuntimeHandle = runtimeHandle;
 
         this.primarySurfaceView = new SurfaceView(context);
         this.primarySurfaceView.setLayoutParams(BabylonView.childViewLayoutParams);
         this.primarySurfaceView.getHolder().addCallback(this);
         this.addView(this.primarySurfaceView);
 
-        this.mCurrentActivity = currentActivity;
-        SurfaceHolder holder = this.primarySurfaceView.getHolder();
-        holder.addCallback(this);
         setOnTouchListener(this);
-        this.mViewDelegate = viewDelegate;
 
         this.xrSurfaceView = new SurfaceView(context);
         this.xrSurfaceView.setLayoutParams(childViewLayoutParams);
@@ -47,49 +60,18 @@ public void surfaceCreated(SurfaceHolder holder) {
 
             @Override
             public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
-                Wrapper.xrSurfaceChanged(holder.getSurface());
+                BabylonNative.runtimeSetXrSurface(mRuntimeHandle, holder.getSurface());
             }
 
             @Override
             public void surfaceDestroyed(SurfaceHolder holder) {
-                Wrapper.xrSurfaceChanged(null);
+                BabylonNative.runtimeSetXrSurface(mRuntimeHandle, null);
             }
         });
         this.xrSurfaceView.setVisibility(View.INVISIBLE);
         this.addView(this.xrSurfaceView);
 
         setWillNotDraw(false);
-
-        Wrapper.initEngine();
-    }
-
-    public void setCurrentActivity(Activity currentActivity)
-    {
-        if (currentActivity != this.mCurrentActivity) {
-            this.mCurrentActivity = currentActivity;
-            Wrapper.setCurrentActivity(this.mCurrentActivity);
-        }
-    }
-
-    public void loadScript(String path) {
-        Wrapper.loadScript(path);
-    }
-
-    public void eval(String source, String sourceURL) {
-        Wrapper.eval(source, sourceURL);
-    }
-
-    public void onPause() {
-        setVisibility(View.GONE);
-        Wrapper.activityOnPause();
-    }
-
-    public void onResume() {
-        Wrapper.activityOnResume();
-    }
-
-    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] results) {
-        Wrapper.activityOnRequestPermissionsResult(requestCode, permissions, results);
     }
 
     /**
@@ -97,12 +79,7 @@ public void onRequestPermissionsResult(int requestCode, String[] permissions, in
      * not normally called or subclassed by clients of BabylonView.
      */
     public void surfaceCreated(SurfaceHolder holder) {
-        Wrapper.surfaceCreated(holder.getSurface(), this.getContext());
-        Wrapper.setCurrentActivity(this.mCurrentActivity);
-        if (!this.mViewReady) {
-            this.mViewDelegate.onViewReady();
-            this.mViewReady = true;
-        }
+        mViewHandle = BabylonNative.viewAttach(mRuntimeHandle, holder.getSurface());
     }
 
     /**
@@ -110,6 +87,10 @@ public void surfaceCreated(SurfaceHolder holder) {
      * not normally called or subclassed by clients of BabylonView.
      */
     public void surfaceDestroyed(SurfaceHolder holder) {
+        if (mViewHandle != 0) {
+            BabylonNative.viewDetach(mViewHandle);
+            mViewHandle = 0;
+        }
     }
 
     /**
@@ -117,40 +98,37 @@ public void surfaceDestroyed(SurfaceHolder holder) {
      * not normally called or subclassed by clients of BabylonView.
      */
     public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
-        Wrapper.surfaceChanged((int)(w / this.pixelDensityScale), (int)(h / this.pixelDensityScale), holder.getSurface());
-    }
-
-    public interface ViewDelegate {
-        void onViewReady();
+        if (mViewHandle != 0) {
+            BabylonNative.viewResize(mViewHandle, w, h);
+        }
     }
 
     @Override
     public boolean onTouch(View v, MotionEvent event) {
+        if (mViewHandle == 0) {
+            return false;
+        }
+
         int pointerId = event.getPointerId(event.getActionIndex());
-        float mX = event.getX(event.getActionIndex()) / this.pixelDensityScale;
-        float mY = event.getY(event.getActionIndex()) / this.pixelDensityScale;
+        float x = event.getX(event.getActionIndex());
+        float y = event.getY(event.getActionIndex());
 
         switch (event.getActionMasked()) {
             case MotionEvent.ACTION_DOWN:
             case MotionEvent.ACTION_POINTER_DOWN:
-                Wrapper.setTouchInfo(pointerId, mX, mY, true, 1);
+                BabylonNative.viewPointerDown(mViewHandle, pointerId, x, y);
                 break;
             case MotionEvent.ACTION_MOVE:
-                Wrapper.setTouchInfo(pointerId, mX, mY, false, 0);
+                BabylonNative.viewPointerMove(mViewHandle, pointerId, x, y);
                 break;
             case MotionEvent.ACTION_UP:
             case MotionEvent.ACTION_POINTER_UP:
-                Wrapper.setTouchInfo(pointerId, mX, mY, true, 0);
+                BabylonNative.viewPointerUp(mViewHandle, pointerId, x, y);
                 break;
         }
         return true;
     }
 
-    @Override
-    protected void finalize() throws Throwable {
-        Wrapper.finishEngine();
-    }
-
     /**
      * This method is part of the SurfaceHolder.Callback2 interface, and is
      * not normally called or subclassed by clients of BabylonView.
@@ -163,13 +141,15 @@ public void surfaceRedrawNeeded(SurfaceHolder holder) {
 
     @Override
     protected void onDraw(Canvas canvas) {
-        if (Wrapper.isXRActive()) {
+        if (BabylonNative.runtimeIsXrActive(mRuntimeHandle)) {
             this.xrSurfaceView.setVisibility(View.VISIBLE);
         } else {
             this.xrSurfaceView.setVisibility(View.INVISIBLE);
         }
 
-        Wrapper.renderFrame();
+        if (mViewHandle != 0) {
+            BabylonNative.viewRenderFrame(mViewHandle);
+        }
         invalidate();
     }
 }
diff --git a/Apps/Playground/Android/BabylonNative/src/main/java/com/library/babylonnative/Wrapper.java b/Apps/Playground/Android/BabylonNative/src/main/java/com/library/babylonnative/Wrapper.java
deleted file mode 100644
index 8ab648690..000000000
--- a/Apps/Playground/Android/BabylonNative/src/main/java/com/library/babylonnative/Wrapper.java
+++ /dev/null
@@ -1,40 +0,0 @@
-package com.library.babylonnative;
-
-import android.app.Activity;
-import android.content.Context;
-import android.view.Surface;
-
-public class Wrapper {
-    // JNI interface
-    static {
-        System.loadLibrary("BabylonNativeJNI");
-    }
-
-    public static native void initEngine();
-
-    public static native void finishEngine();
-
-    public static native void surfaceCreated(Surface surface, Context context);
-
-    public static native void surfaceChanged(int width, int height, Surface surface);
-
-    public static native void setCurrentActivity(Activity currentActivity);
-
-    public static native void activityOnPause();
-
-    public static native void activityOnResume();
-
-    public static native void activityOnRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults);
-
-    public static native void setTouchInfo(int pointerId, float dx, float dy, boolean button, int buttonValue);
-
-    public static native void loadScript(String path);
-
-    public static native void eval(String source, String sourceURL);
-
-    public static native void renderFrame();
-
-    public static native void xrSurfaceChanged(Surface surface);
-
-    public static native boolean isXRActive();
-}
\ No newline at end of file
diff --git a/Apps/Playground/Android/app/src/main/java/com/android/babylonnative/playground/PlaygroundActivity.java b/Apps/Playground/Android/app/src/main/java/com/android/babylonnative/playground/PlaygroundActivity.java
index 3064c14b7..ca725d6ca 100644
--- a/Apps/Playground/Android/app/src/main/java/com/android/babylonnative/playground/PlaygroundActivity.java
+++ b/Apps/Playground/Android/app/src/main/java/com/android/babylonnative/playground/PlaygroundActivity.java
@@ -1,41 +1,82 @@
 package com.android.babylonnative.playground;
 
-import android.Manifest;
 import android.app.Activity;
-import android.content.pm.PackageManager;
 import android.os.Bundle;
-import android.support.v4.app.ActivityCompat;
-import android.support.v4.content.ContextCompat;
 import android.view.View;
 
+import com.babylonjs.embedding.BabylonNative;
 import com.library.babylonnative.BabylonView;
 
-public class PlaygroundActivity extends Activity implements BabylonView.ViewDelegate {
-    BabylonView mView;
+public class PlaygroundActivity extends Activity {
+    /**
+     * Bridges to {@code Apps/Playground/Shared/PlaygroundScripts.cpp},
+     * which holds the bootstrap script list shared with the other
+     * Playground hosts. Implemented in PlaygroundJNI.cpp.
+     */
+    private static native void loadBootstrapScripts(long runtimeHandle);
+
+    private long mRuntimeHandle = 0;
+    private BabylonView mView;
 
-    // Activity life
     @Override
     protected void onCreate(Bundle icicle) {
         super.onCreate(icicle);
-        mView = new BabylonView(getApplication(), this);
+
+        // Register Context/Activity with AndroidExtensions::Globals (used
+        // by NativeCamera, NativeXr). Process-wide, not per-view. The JNI
+        // layer guards against double-initialization.
+        BabylonNative.setContext(getApplication());
+        BabylonNative.setCurrentActivity(this);
+
+        // Activity owns the Runtime lifetime; the View only borrows it.
+        BabylonNative.RuntimeOptions runtimeOptions = new BabylonNative.RuntimeOptions();
+        runtimeOptions.enableDebugger = true;
+        runtimeOptions.enableDebugTrace = true;
+        mRuntimeHandle = BabylonNative.runtimeCreate(runtimeOptions);
+
+        // Queue the bootstrap scripts + experience script. They run after
+        // the first View attach completes engine init on the JS thread, in
+        // submission order.
+        loadBootstrapScripts(mRuntimeHandle);
+        BabylonNative.runtimeLoadScript(mRuntimeHandle, "app:///Scripts/experience.js");
+
+        mView = new BabylonView(getApplication(), mRuntimeHandle);
         setContentView(mView);
     }
 
     @Override
     protected void onPause() {
-        mView.onPause();
+        // Hide the view to stop its draw loop; onWindowFocusChanged
+        // restores visibility on return.
+        mView.setVisibility(View.GONE);
+
+        // Process-wide: every Runtime auto-suspends (each subscribed in
+        // runtimeCreate); cross-cutting subsystems (NativeCamera,
+        // NativeXr) also hook this via AndroidExtensions::Globals.
+        BabylonNative.pause();
         super.onPause();
     }
 
     @Override
     protected void onResume() {
         super.onResume();
-        mView.onResume();
+        BabylonNative.resume();
+    }
+
+    @Override
+    protected void onDestroy() {
+        // Surface lifecycle (view detach) has already fired; just
+        // release the Runtime.
+        if (mRuntimeHandle != 0) {
+            BabylonNative.runtimeDestroy(mRuntimeHandle);
+            mRuntimeHandle = 0;
+        }
+        super.onDestroy();
     }
 
     @Override
     public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] results) {
-        mView.onRequestPermissionsResult(requestCode, permissions, results);
+        BabylonNative.requestPermissionsResult(requestCode, permissions, results);
     }
 
     @Override
@@ -45,9 +86,4 @@ public void onWindowFocusChanged(boolean hasFocus) {
             mView.setVisibility(View.VISIBLE);
         }
     }
-
-    @Override
-    public void onViewReady() {
-        mView.loadScript("app:///Scripts/experience.js");
-    }
 }
diff --git a/Apps/Playground/AppleShared/PlaygroundBootstrap.h b/Apps/Playground/AppleShared/PlaygroundBootstrap.h
new file mode 100644
index 000000000..b432b89ea
--- /dev/null
+++ b/Apps/Playground/AppleShared/PlaygroundBootstrap.h
@@ -0,0 +1,25 @@
+// PlaygroundBootstrap.h — Obj-C helper exposed to Swift via the
+// bridging header on iOS, and used directly from Obj-C++ on macOS.
+// Single class method that hands a freshly-created `BNRuntime` to
+// `Apps/Playground/Shared/PlaygroundScripts.cpp`, which loads the
+// Babylon.js bootstrap script list shared with the other Playground
+// hosts (Win32, Android, …).
+
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+@class BNRuntime;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface PlaygroundBootstrap : NSObject
+
+/// Performs process-wide Playground setup (PerfTrace level, …) and
+/// queues the Babylon.js bootstrap scripts onto `runtime`. Idempotent;
+/// safe to call multiple times.
++ (void)loadScripts:(BNRuntime*)runtime;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/Apps/Playground/AppleShared/PlaygroundBootstrap.mm b/Apps/Playground/AppleShared/PlaygroundBootstrap.mm
new file mode 100644
index 000000000..f8620e83a
--- /dev/null
+++ b/Apps/Playground/AppleShared/PlaygroundBootstrap.mm
@@ -0,0 +1,29 @@
+// PlaygroundBootstrap.mm — calls into Apps/Playground/Shared/PlaygroundScripts.cpp
+// so the bootstrap script list stays in one place.
+
+#import "PlaygroundBootstrap.h"
+
+#import <Babylon/Embedding/Apple/BNRuntime.h>
+
+#include <Babylon/Embedding/Runtime.h>
+#include <Shared/PlaygroundScripts.h>
+
+// Re-declare the internal class extension that exposes the C++ Runtime*
+// from BNRuntime (implementation lives in Embedding/Apple/Source/BNRuntime.mm).
+@interface BNRuntime ()
+- (Babylon::Embedding::Runtime*)nativeRuntime;
+@end
+
+@implementation PlaygroundBootstrap
+
++ (void)loadScripts:(BNRuntime*)runtime
+{
+    if (runtime == nil)
+    {
+        return;
+    }
+    Playground::Initialize();
+    Playground::LoadBootstrapScripts(*[runtime nativeRuntime]);
+}
+
+@end
diff --git a/Apps/Playground/CMakeLists.txt b/Apps/Playground/CMakeLists.txt
index 355fb3dc4..e24dd7be0 100644
--- a/Apps/Playground/CMakeLists.txt
+++ b/Apps/Playground/CMakeLists.txt
@@ -20,12 +20,12 @@ set(SCRIPTS
     "Scripts/config.json")
 
 set(SOURCES
-    "Shared/AppContext.cpp"
-    "Shared/AppContext.h"
     "Shared/CommandLine.cpp"
     "Shared/CommandLine.h"
     "Shared/Diagnostics.cpp"
-    "Shared/Diagnostics.h")
+    "Shared/Diagnostics.h"
+    "Shared/PlaygroundScripts.cpp"
+    "Shared/PlaygroundScripts.h")
 
 if(APPLE)
     find_library(JAVASCRIPTCORE_LIBRARY JavaScriptCore)
@@ -36,12 +36,15 @@ if(APPLE)
             "${CMAKE_CURRENT_LIST_DIR}/iOS/Base.lproj/Main.storyboard"
             "${CMAKE_CURRENT_LIST_DIR}/iOS/Base.lproj/LaunchScreen.storyboard")
         set(RESOURCE_FILES ${STORYBOARD} ${SCRIPTS})
-        set(ADDITIONAL_LIBRARIES PRIVATE z NativeXr)
+        # NativeXr is consumed transitively through `BabylonNativeEmbedding`
+        # (the Apple interop static lib); no need to link it directly.
+        set(ADDITIONAL_LIBRARIES PRIVATE z BabylonNativeEmbedding)
         set(SOURCES ${SOURCES}
             "iOS/AppDelegate.swift"
             "iOS/ViewController.swift"
-            "iOS/LibNativeBridge.h"
-            "iOS/LibNativeBridge.mm"
+            "iOS/Playground-Bridging-Header.h"
+            "AppleShared/PlaygroundBootstrap.h"
+            "AppleShared/PlaygroundBootstrap.mm"
             "AppleShared/GestureRecognizer.swift")
         set_source_files_properties(${SCRIPTS} ${BABYLON_SCRIPTS} ${DEPENDENCIES} PROPERTIES MACOSX_PACKAGE_LOCATION "Scripts")
         set_source_files_properties(${REFERENCE_IMAGES} PROPERTIES MACOSX_PACKAGE_LOCATION "ReferenceImages")
@@ -49,10 +52,14 @@ if(APPLE)
         set(PLIST_FILE
             "${CMAKE_CURRENT_LIST_DIR}/visionOS/Info.plist")
         set(RESOURCE_FILES ${SCRIPTS})
+        # NativeXr is consumed transitively through `BabylonNativeEmbedding`
+        # (the Apple interop static lib); no need to link it directly.
+        set(ADDITIONAL_LIBRARIES PRIVATE z BabylonNativeEmbedding)
         set(SOURCES ${SOURCES}
             "visionOS/App.swift"
-            "visionOS/LibNativeBridge.mm"
-            "visionOS/LibNativeBridge.h"
+            "visionOS/Playground-Bridging-Header.h"
+            "AppleShared/PlaygroundBootstrap.h"
+            "AppleShared/PlaygroundBootstrap.mm"
             "AppleShared/GestureRecognizer.swift")
         set_source_files_properties(${SCRIPTS} ${BABYLON_SCRIPTS} ${DEPENDENCIES} PROPERTIES MACOSX_PACKAGE_LOCATION "Scripts")
         set_source_files_properties(${REFERENCE_IMAGES} PROPERTIES MACOSX_PACKAGE_LOCATION "ReferenceImages")
@@ -60,12 +67,15 @@ if(APPLE)
         set(PLIST_FILE "${CMAKE_CURRENT_LIST_DIR}/macOS/Info.plist")
         set(STORYBOARD "${CMAKE_CURRENT_LIST_DIR}/macOS/Base.lproj/Main.storyboard")
         set(RESOURCE_FILES ${STORYBOARD})
+        set(ADDITIONAL_LIBRARIES PRIVATE BabylonNativeEmbedding)
         set(SOURCES ${SOURCES}
             "macOS/main.mm"
-            "macOS/AppDelegate.m"
             "macOS/AppDelegate.h"
+            "macOS/AppDelegate.mm"
+            "macOS/ViewController.h"
             "macOS/ViewController.mm"
-            "macOS/ViewController.h")
+            "AppleShared/PlaygroundBootstrap.h"
+            "AppleShared/PlaygroundBootstrap.mm")
         set_source_files_properties(${SCRIPTS} ${BABYLON_SCRIPTS} ${DEPENDENCIES} PROPERTIES MACOSX_PACKAGE_LOCATION "Resources/Scripts")
         set_source_files_properties(${REFERENCE_IMAGES} PROPERTIES MACOSX_PACKAGE_LOCATION "Resources/ReferenceImages")
     endif()
@@ -134,32 +144,18 @@ endif()
 
 target_include_directories(Playground PRIVATE ".")
 
+# The Embedding layer links and initializes the full canonical set of
+# polyfills/plugins (Blob, Canvas, Console, File, GraphicsDevice, the
+# Native* plugins, ScriptLoader, ShaderCache, the polyfills, etc.) and
+# forwards them transitively, so the Playground only needs to list the
+# libraries it consumes directly:
+#   - Embedding : the Runtime + View API the host is built on.
+#   - bx        : <bx/*.h> used by Shared/Diagnostics.cpp.
+#   - TestUtils : <Babylon/Plugins/TestUtils.h> used by Win32/X11 --test mode.
 target_link_libraries(Playground
-    PRIVATE AbortController
-    PRIVATE AppRuntime
-    PRIVATE Blob
+    PRIVATE Embedding
     PRIVATE bx
-    PRIVATE Canvas
-    PRIVATE Console
-    PRIVATE ExternalTexture
-    PRIVATE File
-    PRIVATE GraphicsDevice
-    PRIVATE NativeCamera
-    PRIVATE NativeCapture
-    PRIVATE NativeEncoding
-    PRIVATE NativeEngine
-    PRIVATE NativeInput
-    PRIVATE NativeOptimizations
-    PRIVATE NativeTracing
-    PRIVATE Performance
-    PRIVATE ScriptLoader
-    PRIVATE ShaderCache
     PRIVATE TestUtils
-    PRIVATE TextDecoder
-    PRIVATE TextEncoder
-    PRIVATE Window
-    PRIVATE XMLHttpRequest
-    PRIVATE Fetch
     ${ADDITIONAL_LIBRARIES}
     ${BABYLON_NATIVE_PLAYGROUND_EXTENSION_LIBRARIES})
 
@@ -195,7 +191,7 @@ if(APPLE)
             XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER "com.BabylonNative.Playground.iOS"
 
             XCODE_ATTRIBUTE_SWIFT_VERSION "4.0"
-            XCODE_ATTRIBUTE_SWIFT_OBJC_BRIDGING_HEADER "${CMAKE_CURRENT_LIST_DIR}/iOS/LibNativeBridge.h"
+            XCODE_ATTRIBUTE_SWIFT_OBJC_BRIDGING_HEADER "${CMAKE_CURRENT_LIST_DIR}/iOS/Playground-Bridging-Header.h"
             XCODE_ATTRIBUTE_LD_RUNPATH_SEARCH_PATHS "@executable_path/Frameworks"
             XCODE_ATTRIBUTE_FRAMEWORK_SEARCH_PATHS "$(inherited) $(SDKROOT)$(SYSTEM_LIBRARY_DIR)/Frameworks"
             XCODE_ATTRIBUTE_ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES YES
@@ -218,7 +214,7 @@ if(APPLE)
             XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER "com.BabylonNative.Playground.visionOS"
 
             XCODE_ATTRIBUTE_SWIFT_VERSION "5.0"
-            XCODE_ATTRIBUTE_SWIFT_OBJC_BRIDGING_HEADER "${CMAKE_CURRENT_LIST_DIR}/visionOS/LibNativeBridge.h"
+            XCODE_ATTRIBUTE_SWIFT_OBJC_BRIDGING_HEADER "${CMAKE_CURRENT_LIST_DIR}/visionOS/Playground-Bridging-Header.h"
             XCODE_ATTRIBUTE_LD_RUNPATH_SEARCH_PATHS "@executable_path/Frameworks"
             XCODE_ATTRIBUTE_FRAMEWORK_SEARCH_PATHS "$(inherited) $(SDKROOT)$(SYSTEM_LIBRARY_DIR)/Frameworks"
             XCODE_ATTRIBUTE_ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES YES
diff --git a/Apps/Playground/Shared/AppContext.cpp b/Apps/Playground/Shared/AppContext.cpp
deleted file mode 100644
index c0a1c4961..000000000
--- a/Apps/Playground/Shared/AppContext.cpp
+++ /dev/null
@@ -1,248 +0,0 @@
-#include "AppContext.h"
-#include "Diagnostics.h"
-
-#include <Babylon/AppRuntime.h>
-#include <Babylon/DebugTrace.h>
-#include <Babylon/Graphics/Device.h>
-#include <Babylon/PerfTrace.h>
-#include <Babylon/ScriptLoader.h>
-
-#include <Babylon/Plugins/NativeCamera.h>
-#include <Babylon/Plugins/NativeCapture.h>
-#include <Babylon/Plugins/NativeEncoding.h>
-#include <Babylon/Plugins/NativeEngine.h>
-#include <Babylon/Plugins/NativeInput.h>
-#include <Babylon/Plugins/NativeOptimizations.h>
-#include <Babylon/Plugins/NativeTracing.h>
-#include <Babylon/Plugins/ShaderCache.h>
-#include <Babylon/Plugins/TestUtils.h>
-
-#include <Babylon/Polyfills/AbortController.h>
-#include <Babylon/Polyfills/Blob.h>
-#include <Babylon/Polyfills/Canvas.h>
-#include <Babylon/Polyfills/Console.h>
-#include <Babylon/Polyfills/Fetch.h>
-#include <Babylon/Polyfills/File.h>
-#include <Babylon/Polyfills/Performance.h>
-#include <Babylon/Polyfills/TextDecoder.h>
-#include <Babylon/Polyfills/TextEncoder.h>
-#include <Babylon/Polyfills/Window.h>
-#include <Babylon/Polyfills/XMLHttpRequest.h>
-
-#include <iostream>
-#include <sstream>
-
-namespace
-{
-    const char* GetLogLevelString(Babylon::Polyfills::Console::LogLevel logLevel)
-    {
-        switch (logLevel)
-        {
-            case Babylon::Polyfills::Console::LogLevel::Log:
-                return "Log";
-            case Babylon::Polyfills::Console::LogLevel::Warn:
-                return "Warn";
-            case Babylon::Polyfills::Console::LogLevel::Error:
-                return "Error";
-            default:
-                return "";
-        }
-    }
-}
-
-AppContext::AppContext(
-    Babylon::Graphics::WindowT window,
-    size_t width,
-    size_t height,
-    DebugLogCallback debugLog,
-    AdditionalInitCallback additionalInit,
-    PlaygroundOptions playgroundOptions)
-{
-    Babylon::DebugTrace::EnableDebugTrace(playgroundOptions.DebugTrace.value_or(true));
-    Babylon::DebugTrace::SetTraceOutput(debugLog);
-
-    Babylon::PerfTrace::Level perfLevel{Babylon::PerfTrace::Level::Mark};
-    if (playgroundOptions.PerfTrace.has_value())
-    {
-        const auto& v = *playgroundOptions.PerfTrace;
-        if (v == "None" || v == "none")
-        {
-            perfLevel = Babylon::PerfTrace::Level::None;
-        }
-        else if (v == "Log" || v == "log" || v == "Detail" || v == "detail")
-        {
-            perfLevel = Babylon::PerfTrace::Level::Log;
-        }
-    }
-    Babylon::PerfTrace::SetLevel(perfLevel);
-
-    Babylon::Graphics::Configuration graphicsConfig{};
-    graphicsConfig.Window = window;
-    graphicsConfig.Width = width;
-    graphicsConfig.Height = height;
-    graphicsConfig.MSAASamples = 4;
-
-    m_device.emplace(graphicsConfig);
-
-    // Mirror bgfx trace output (BgfxCallback::traceVargs) to debugLog so it
-    // reaches stdout in headless mode, not just OutputDebugString.
-    m_device->SetDiagnosticOutput(debugLog);
-
-    Babylon::Plugins::ShaderCache::Enable();
-
-    m_device->StartRenderingCurrentFrame();
-
-    Babylon::AppRuntime::Options options{};
-
-    options.EnableDebugger = true;
-
-    options.UnhandledExceptionHandler = [debugLog](const Napi::Error& error) {
-        // Bx-style banner with native + JS callstack, then keep the legacy
-        // "[Uncaught Error] ..." one-liner for log scrapers.
-        const std::string js = Napi::GetErrorString(error);
-
-        Diagnostics::DumpFailure(
-            "UNCAUGHT JS ERROR",
-            nullptr,
-            0,
-            0,
-            "%s",
-            js.c_str());
-
-        std::ostringstream ss{};
-        ss << "[Uncaught Error] " << js;
-        debugLog(ss.str().data());
-
-        Diagnostics::SetExitCode(1);
-        Diagnostics::PrintFinishLine();
-        std::quick_exit(1);
-    };
-
-    m_runtime.emplace(options);
-
-    m_runtime->Dispatch([this, window, debugLog, additionalInit = std::move(additionalInit), playgroundOptions = std::move(playgroundOptions)](Napi::Env env) {
-        m_device->AddToJavaScript(env);
-
-        {
-            auto js = Napi::Object::New(env);
-            js.Set("listTests",          Napi::Boolean::New(env, playgroundOptions.ListTests));
-            js.Set("headless",           Napi::Boolean::New(env, playgroundOptions.Headless));
-            js.Set("breakOnFail",        Napi::Boolean::New(env, playgroundOptions.BreakOnFail));
-            js.Set("generateReferences", Napi::Boolean::New(env, playgroundOptions.GenerateReferences));
-            js.Set("runOnce",            Napi::Boolean::New(env, playgroundOptions.RunOnce));
-            js.Set("includeExcluded",    Napi::Boolean::New(env, playgroundOptions.IncludeExcluded));
-            if (playgroundOptions.SaveResults.has_value())
-            {
-                js.Set("saveResults", Napi::Boolean::New(env, *playgroundOptions.SaveResults));
-            }
-            if (playgroundOptions.CaptureFrame.has_value())
-            {
-                js.Set("captureFrame", Napi::Number::New(env, *playgroundOptions.CaptureFrame));
-            }
-
-            auto filters = Napi::Array::New(env, playgroundOptions.TestFilters.size());
-            for (uint32_t i = 0; i < playgroundOptions.TestFilters.size(); ++i)
-            {
-                filters[i] = Napi::String::New(env, playgroundOptions.TestFilters[i]);
-            }
-            js.Set("testFilters", filters);
-
-            auto indices = Napi::Array::New(env, playgroundOptions.TestIndices.size());
-            for (uint32_t i = 0; i < playgroundOptions.TestIndices.size(); ++i)
-            {
-                indices[i] = Napi::Number::New(env, playgroundOptions.TestIndices[i]);
-            }
-            js.Set("testIndices", indices);
-
-            env.Global().Set("_playgroundOptions", js);
-        }
-
-        Babylon::Polyfills::Blob::Initialize(env);
-        Babylon::Polyfills::File::Initialize(env);
-
-        Babylon::Polyfills::Console::Initialize(env, [env, debugLog](const char* message, Babylon::Polyfills::Console::LogLevel logLevel) {
-            std::ostringstream ss{};
-            ss << "[" << GetLogLevelString(logLevel) << "] " << message;
-            debugLog(ss.str().data());
-
-            // Promote console.error to a banner with JS + native callstack.
-            // Babylon.js routes recoverable errors here.
-            if (logLevel == Babylon::Polyfills::Console::LogLevel::Error)
-            {
-                auto jsStack = Babylon::Polyfills::Console::CaptureCurrentJsStack(env);
-                Diagnostics::DumpFailure(
-                    "JS CONSOLE ERROR",
-                    nullptr,
-                    0,
-                    0,
-                    "%s%s%s",
-                    message != nullptr ? message : "(null)",
-                    jsStack.empty() ? "" : "\nJS callstack:\n",
-                    jsStack.c_str());
-            }
-        });
-
-        Babylon::Polyfills::Performance::Initialize(env);
-
-        Babylon::Polyfills::Window::Initialize(env);
-
-        Babylon::Polyfills::AbortController::Initialize(env);
-
-        Babylon::Polyfills::TextDecoder::Initialize(env);
-
-        Babylon::Polyfills::TextEncoder::Initialize(env);
-
-        Babylon::Polyfills::XMLHttpRequest::Initialize(env);
-        Babylon::Polyfills::Fetch::Initialize(env);
-        m_canvas.emplace(Babylon::Polyfills::Canvas::Initialize(env));
-
-        Babylon::Plugins::NativeTracing::Initialize(env);
-
-        Babylon::Plugins::NativeEncoding::Initialize(env);
-
-        Babylon::Plugins::NativeEngine::Initialize(env);
-
-        Babylon::Plugins::NativeOptimizations::Initialize(env);
-
-        Babylon::Plugins::NativeCapture::Initialize(env);
-
-        Babylon::Plugins::NativeCamera::Initialize(env);
-
-        m_input = &Babylon::Plugins::NativeInput::CreateForJavaScript(env);
-
-        Babylon::Plugins::TestUtils::Initialize(env, window);
-
-        if (additionalInit)
-        {
-            additionalInit(env);
-        }
-    });
-
-    m_scriptLoader.emplace(*m_runtime);
-    m_scriptLoader->LoadScript("app:///Scripts/ammo.js");
-    // Commenting out recast.js for now because v8jsi is incompatible with asm.js.
-    // m_scriptLoader->LoadScript("app:///Scripts/recast.js");
-    m_scriptLoader->LoadScript("app:///Scripts/babylon.max.js");
-    m_scriptLoader->LoadScript("app:///Scripts/babylonjs.addons.js");
-    m_scriptLoader->LoadScript("app:///Scripts/babylonjs.loaders.js");
-    m_scriptLoader->LoadScript("app:///Scripts/babylonjs.materials.js");
-    m_scriptLoader->LoadScript("app:///Scripts/babylon.gui.js");
-    m_scriptLoader->LoadScript("app:///Scripts/meshwriter.min.js");
-    m_scriptLoader->LoadScript("app:///Scripts/babylonjs.serializers.js");
-}
-
-AppContext::~AppContext()
-{
-    if (m_device)
-    {
-        m_device->FinishRenderingCurrentFrame();
-    }
-
-    Babylon::Plugins::ShaderCache::Disable();
-
-    m_scriptLoader.reset();
-    m_canvas.reset();
-    m_input = {};
-    m_runtime.reset();
-    m_device.reset();
-}
diff --git a/Apps/Playground/Shared/AppContext.h b/Apps/Playground/Shared/AppContext.h
deleted file mode 100644
index e4d1292da..000000000
--- a/Apps/Playground/Shared/AppContext.h
+++ /dev/null
@@ -1,53 +0,0 @@
-#pragma once
-
-#include "CommandLine.h"
-
-#include <Babylon/AppRuntime.h>
-#include <Babylon/Graphics/Device.h>
-#include <Babylon/Polyfills/Canvas.h>
-#include <Babylon/Polyfills/Console.h>
-#include <Babylon/Plugins/NativeInput.h>
-#include <Babylon/ScriptLoader.h>
-
-#include <functional>
-#include <optional>
-#include <vector>
-#include <string>
-
-class AppContext
-{
-public:
-    using AdditionalInitCallback = std::function<void(Napi::Env)>;
-    using DebugLogCallback = std::function<void(const char*)>;
-
-    AppContext(
-        Babylon::Graphics::WindowT window,
-        size_t width,
-        size_t height,
-        DebugLogCallback debugLog,
-        AdditionalInitCallback additionalInit = {},
-        PlaygroundOptions playgroundOptions = {});
-
-    ~AppContext();
-
-    // Copy semantics
-    AppContext(const AppContext&) = delete;
-    AppContext& operator=(const AppContext&) noexcept = delete;
-
-    // Move semantics
-    AppContext(AppContext&&) = delete;
-    AppContext& operator=(AppContext&&) noexcept = delete;
-
-    Babylon::Graphics::Device& Device() { return *m_device; }
-    Babylon::AppRuntime& Runtime() { return *m_runtime; }
-    Babylon::Polyfills::Canvas& Canvas() { return *m_canvas; }
-    Babylon::Plugins::NativeInput* Input() { return m_input; }
-    Babylon::ScriptLoader& ScriptLoader() { return *m_scriptLoader; }
-
-private:
-    std::optional<Babylon::Graphics::Device> m_device;
-    std::optional<Babylon::AppRuntime> m_runtime;
-    std::optional<Babylon::Polyfills::Canvas> m_canvas;
-    Babylon::Plugins::NativeInput* m_input{};
-    std::optional<Babylon::ScriptLoader> m_scriptLoader;
-};
diff --git a/Apps/Playground/Shared/PlaygroundScripts.cpp b/Apps/Playground/Shared/PlaygroundScripts.cpp
new file mode 100644
index 000000000..6536bf5ec
--- /dev/null
+++ b/Apps/Playground/Shared/PlaygroundScripts.cpp
@@ -0,0 +1,95 @@
+#include "PlaygroundScripts.h"
+
+#include "Diagnostics.h"
+
+#include <Babylon/Embedding/Runtime.h>
+#include <Babylon/PerfTrace.h>
+
+#include <cstdlib>
+#include <string>
+#include <utility>
+
+namespace Playground
+{
+    void Initialize(const PlaygroundOptions& options)
+    {
+        // Process-wide perf-tracing configuration.
+        Babylon::PerfTrace::Level perfLevel{Babylon::PerfTrace::Level::Mark};
+        if (options.PerfTrace.has_value())
+        {
+            const auto& value = *options.PerfTrace;
+            if (value == "None" || value == "none")
+            {
+                perfLevel = Babylon::PerfTrace::Level::None;
+            }
+            else if (value == "Log" || value == "log" || value == "Detail" || value == "detail")
+            {
+                perfLevel = Babylon::PerfTrace::Level::Log;
+            }
+        }
+        Babylon::PerfTrace::SetLevel(perfLevel);
+    }
+
+    void LoadBootstrapScripts(Babylon::Embedding::Runtime& runtime)
+    {
+        runtime.LoadScript("app:///Scripts/ammo.js");
+        // Commenting out recast.js for now because v8jsi is incompatible with asm.js.
+        // runtime.LoadScript("app:///Scripts/recast.js");
+        runtime.LoadScript("app:///Scripts/babylon.max.js");
+        // Load addons right after babylon.max.js so addons init sees a fully
+        // constructed BABYLON global.
+        runtime.LoadScript("app:///Scripts/babylonjs.addons.js");
+        runtime.LoadScript("app:///Scripts/babylonjs.loaders.js");
+        runtime.LoadScript("app:///Scripts/babylonjs.materials.js");
+        runtime.LoadScript("app:///Scripts/babylon.gui.js");
+        runtime.LoadScript("app:///Scripts/meshwriter.min.js");
+        runtime.LoadScript("app:///Scripts/babylonjs.serializers.js");
+    }
+
+    std::function<void(Babylon::Embedding::LogLevel, std::string_view)>
+    MakeLogCallback(std::function<void(std::string_view)> platformSink)
+    {
+        return [sink = std::move(platformSink)](Babylon::Embedding::LogLevel level, std::string_view message) {
+            std::string text{message};
+            while (!text.empty() && (text.back() == '\n' || text.back() == '\r'))
+            {
+                text.pop_back();
+            }
+
+            if (sink)
+            {
+                sink(text);
+            }
+
+            // Babylon.js routes recoverable errors through console.error;
+            // surface them as a grep-able banner with a native callstack.
+            if (level == Babylon::Embedding::LogLevel::Error)
+            {
+                Diagnostics::DumpFailure(
+                    "JS CONSOLE ERROR",
+                    nullptr,
+                    0,
+                    0,
+                    "%s",
+                    text.c_str());
+            }
+
+            // Uncaught JS exceptions: banner + finish-line + non-zero exit.
+            // The Embedding UnhandledExceptionHandler has already formatted
+            // the message as "[Uncaught Error] <message + JS stack>".
+            if (level == Babylon::Embedding::LogLevel::Fatal)
+            {
+                Diagnostics::DumpFailure(
+                    "UNCAUGHT JS ERROR",
+                    nullptr,
+                    0,
+                    0,
+                    "%s",
+                    text.c_str());
+                Diagnostics::SetExitCode(1);
+                Diagnostics::PrintFinishLine();
+                std::quick_exit(1);
+            }
+        };
+    }
+}
diff --git a/Apps/Playground/Shared/PlaygroundScripts.h b/Apps/Playground/Shared/PlaygroundScripts.h
new file mode 100644
index 000000000..bbe91fad0
--- /dev/null
+++ b/Apps/Playground/Shared/PlaygroundScripts.h
@@ -0,0 +1,52 @@
+#pragma once
+
+#include "CommandLine.h"
+
+#include <Babylon/Embedding/LogLevel.h>
+
+#include <functional>
+#include <string_view>
+
+namespace Babylon::Embedding
+{
+    class Runtime;
+}
+
+namespace Playground
+{
+    // Apply process-wide settings shared by every Playground host:
+    // currently PerfTrace. Call before queuing scripts and attaching
+    // the first view.
+    void Initialize(const PlaygroundOptions& options = {});
+
+    // Queue the standard Babylon.js bootstrap scripts (core, loaders,
+    // materials, GUI, serializers, etc.) onto `runtime` in dependency order.
+    //
+    // The `Babylon::Embedding` layer doesn't bundle script loading;
+    // each host picks between this multi-UMD route and a pre-bundled
+    // `bundle.js` route. Centralizing the list keeps every Playground
+    // host in sync as the bundle list evolves.
+    //
+    // LoadScript calls made before the first View attach are queued and
+    // dispatched after engine init, so this is safe to call immediately
+    // after constructing the Runtime.
+    void LoadBootstrapScripts(Babylon::Embedding::Runtime& runtime);
+
+    // Build a `RuntimeOptions::log` callback that:
+    //   1) Trims trailing newlines from `message` and forwards it to
+    //      `platformSink` so the host can route to OutputDebugStringA,
+    //      NSLog, __android_log_print, stdout, etc. `platformSink` is
+    //      called for every level (including Verbose / Log / Warn).
+    //   2) On `LogLevel::Error`: emits a `JS CONSOLE ERROR` banner via
+    //      `Diagnostics::DumpFailure` (banner header + native callstack +
+    //      build info). The JS callstack is already appended by the
+    //      Embedding layer, so it lands inside the banner body.
+    //   3) On `LogLevel::Fatal`: emits an `UNCAUGHT JS ERROR` banner,
+    //      sets exit code 1, prints the finish line, and `std::quick_exit`s.
+    //
+    // Centralizing this matches the behavior every Playground host had
+    // pre-Embedding via `AppContext` (which routed `console.error` and
+    // the unhandled exception handler through `DumpFailure`).
+    std::function<void(Babylon::Embedding::LogLevel, std::string_view)>
+    MakeLogCallback(std::function<void(std::string_view)> platformSink);
+}
diff --git a/Apps/Playground/UWP/App.cpp b/Apps/Playground/UWP/App.cpp
index 8f9b81cf0..4a3dcc626 100644
--- a/Apps/Playground/UWP/App.cpp
+++ b/Apps/Playground/UWP/App.cpp
@@ -1,7 +1,16 @@
+// App.cpp : Defines the entry point for the application.
+//
+// Built on Babylon::Embedding: the cross-platform Runtime + View API
+// handles plugin/polyfill setup, GPU device construction, frame rendering,
+// and input forwarding.
+
 #include "App.h"
 
-#include <sstream>
+#include <Shared/PlaygroundScripts.h>
+
 #include <iostream>
+#include <string>
+#include <string_view>
 
 using namespace winrt::Windows::ApplicationModel;
 using namespace winrt::Windows::ApplicationModel::Core;
@@ -12,6 +21,9 @@ using namespace winrt::Windows::System;
 using namespace winrt::Windows::Foundation;
 using namespace winrt::Windows::Graphics::Display;
 
+using Babylon::Embedding::CoordinateUnits;
+using BNView = Babylon::Embedding::View;
+
 // The main function is only used to initialize our IFrameworkView class.
 int __stdcall wWinMain(HINSTANCE, HINSTANCE, PWSTR, int)
 {
@@ -20,29 +32,33 @@ int __stdcall wWinMain(HINSTANCE, HINSTANCE, PWSTR, int)
     return 0;
 }
 
-// Helper function to handle mouse button routing
-void ProcessMouseButtons(Babylon::Plugins::NativeInput* input, PointerUpdateKind updateKind, int x, int y)
+namespace
 {
-    switch (updateKind)
+    void ProcessMouseButtons(BNView& view, PointerUpdateKind updateKind, float x, float y)
     {
-        case PointerUpdateKind::LeftButtonPressed:
-            input->MouseDown(Babylon::Plugins::NativeInput::LEFT_MOUSE_BUTTON_ID, x, y);
-            break;
-        case PointerUpdateKind::MiddleButtonPressed:
-            input->MouseDown(Babylon::Plugins::NativeInput::MIDDLE_MOUSE_BUTTON_ID, x, y);
-            break;
-        case PointerUpdateKind::RightButtonPressed:
-            input->MouseDown(Babylon::Plugins::NativeInput::RIGHT_MOUSE_BUTTON_ID, x, y);
-            break;
-        case PointerUpdateKind::LeftButtonReleased:
-            input->MouseUp(Babylon::Plugins::NativeInput::LEFT_MOUSE_BUTTON_ID, x, y);
-            break;
-        case PointerUpdateKind::MiddleButtonReleased:
-            input->MouseUp(Babylon::Plugins::NativeInput::MIDDLE_MOUSE_BUTTON_ID, x, y);
-            break;
-        case PointerUpdateKind::RightButtonReleased:
-            input->MouseUp(Babylon::Plugins::NativeInput::RIGHT_MOUSE_BUTTON_ID, x, y);
-            break;
+        switch (updateKind)
+        {
+            case PointerUpdateKind::LeftButtonPressed:
+                view.OnMouseDown(BNView::LeftMouseButton(), x, y, CoordinateUnits::Logical);
+                break;
+            case PointerUpdateKind::MiddleButtonPressed:
+                view.OnMouseDown(BNView::MiddleMouseButton(), x, y, CoordinateUnits::Logical);
+                break;
+            case PointerUpdateKind::RightButtonPressed:
+                view.OnMouseDown(BNView::RightMouseButton(), x, y, CoordinateUnits::Logical);
+                break;
+            case PointerUpdateKind::LeftButtonReleased:
+                view.OnMouseUp(BNView::LeftMouseButton(), x, y, CoordinateUnits::Logical);
+                break;
+            case PointerUpdateKind::MiddleButtonReleased:
+                view.OnMouseUp(BNView::MiddleMouseButton(), x, y, CoordinateUnits::Logical);
+                break;
+            case PointerUpdateKind::RightButtonReleased:
+                view.OnMouseUp(BNView::RightMouseButton(), x, y, CoordinateUnits::Logical);
+                break;
+            default:
+                break;
+        }
     }
 }
 
@@ -107,10 +123,9 @@ void App::Run()
 {
     while (!m_windowClosed)
     {
-        if (m_appContext)
+        if (m_view)
         {
-            m_appContext->Device().FinishRenderingCurrentFrame();
-            m_appContext->Device().StartRenderingCurrentFrame();
+            m_view->RenderFrame();
         }
 
         CoreWindow::GetForCurrentThread().Dispatcher().ProcessEvents(CoreProcessEventsOption::ProcessAllIfPresent);
@@ -122,7 +137,10 @@ void App::Run()
 // class is torn down while the app is in the foreground.
 void App::Uninitialize()
 {
-    m_appContext.reset();
+    // View first (unbinds surface, closes in-flight frame), then Runtime
+    // (joins JS thread).
+    m_view.reset();
+    m_runtime.reset();
 }
 
 // Application lifecycle event handlers.
@@ -152,11 +170,10 @@ void App::OnSuspending(IInspectable const& /*sender*/, SuspendingEventArgs const
     // the app will be forced to exit.
     auto deferral = args.SuspendingOperation().GetDeferral();
 
-    if (m_appContext)
+    if (m_runtime)
     {
-        m_appContext->Device().FinishRenderingCurrentFrame();
-
-        m_appContext->Runtime().Suspend();
+        // Closes any in-flight frame on the attached View internally.
+        m_runtime->Suspend();
     }
 
     deferral.Complete();
@@ -164,14 +181,10 @@ void App::OnSuspending(IInspectable const& /*sender*/, SuspendingEventArgs const
 
 void App::OnResuming(IInspectable const& /*sender*/, IInspectable const& /*args*/)
 {
-    if (m_appContext)
+    if (m_runtime)
     {
-        // Restore any data or state that was unloaded on suspend. By default, data
-        // and state are persisted when resuming from suspend. Note that this event
-        // does not occur if the app was previously terminated.
-        m_appContext->Runtime().Resume();
-
-        m_appContext->Device().StartRenderingCurrentFrame();
+        // Re-opens the frame on the attached View internally.
+        m_runtime->Resume();
     }
 }
 
@@ -179,11 +192,11 @@ void App::OnResuming(IInspectable const& /*sender*/, IInspectable const& /*args*
 
 void App::OnWindowSizeChanged(CoreWindow const& /*sender*/, WindowSizeChangedEventArgs const& args)
 {
-    if (m_appContext)
+    if (m_view)
     {
-        size_t width = static_cast<size_t>(args.Size().Width * m_displayScale);
-        size_t height = static_cast<size_t>(args.Size().Height * m_displayScale);
-        m_appContext->Device().UpdateSize(width, height);
+        m_view->Resize(static_cast<uint32_t>(args.Size().Width),
+                       static_cast<uint32_t>(args.Size().Height),
+                       CoordinateUnits::Logical);
     }
 }
 
@@ -200,81 +213,78 @@ void App::OnWindowClosed(CoreWindow const& /*sender*/, CoreWindowEventArgs const
 
 void App::OnPointerMoved(CoreWindow const&, PointerEventArgs const& args)
 {
-    if (m_appContext && m_appContext->Input())
+    if (!m_view) return;
+
+    const auto position = args.CurrentPoint().RawPosition();
+    const auto deviceType = args.CurrentPoint().PointerDevice().PointerDeviceType();
+    const auto deviceSlot = args.CurrentPoint().PointerId();
+    const auto updateKind = args.CurrentPoint().Properties().PointerUpdateKind();
+    const auto x = position.X;
+    const auto y = position.Y;
+
+    if (deviceType == winrt::Windows::Devices::Input::PointerDeviceType::Mouse)
     {
-        const auto position = args.CurrentPoint().RawPosition();
-        const auto deviceType = args.CurrentPoint().PointerDevice().PointerDeviceType();
-        const auto deviceSlot = args.CurrentPoint().PointerId();
-        const auto updateKind = args.CurrentPoint().Properties().PointerUpdateKind();
-        const auto x = static_cast<int>(position.X * m_displayScale);
-        const auto y = static_cast<int>(position.Y * m_displayScale);
-
-        if (deviceType == winrt::Windows::Devices::Input::PointerDeviceType::Mouse)
-        {
-            m_appContext->Input()->MouseMove(x, y);
+        m_view->OnMouseMove(x, y, CoordinateUnits::Logical);
 
-            if (args.CurrentPoint().IsInContact())
-            {
-                ProcessMouseButtons(m_appContext->Input(), updateKind, x, y);
-            }
-        }
-        else
+        if (args.CurrentPoint().IsInContact())
         {
-            m_appContext->Input()->TouchMove(deviceSlot, x, y);
+            ProcessMouseButtons(*m_view, updateKind, x, y);
         }
     }
+    else
+    {
+        m_view->OnPointerMove(static_cast<int32_t>(deviceSlot), x, y, CoordinateUnits::Logical);
+    }
 }
 
 void App::OnPointerPressed(CoreWindow const&, PointerEventArgs const& args)
 {
-    if (m_appContext && m_appContext->Input())
+    if (!m_view) return;
+
+    const auto position = args.CurrentPoint().RawPosition();
+    const auto deviceType = args.CurrentPoint().PointerDevice().PointerDeviceType();
+    const auto deviceSlot = args.CurrentPoint().PointerId();
+    const auto updateKind = args.CurrentPoint().Properties().PointerUpdateKind();
+    const auto x = position.X;
+    const auto y = position.Y;
+
+    if (deviceType == winrt::Windows::Devices::Input::PointerDeviceType::Mouse)
     {
-        const auto position = args.CurrentPoint().RawPosition();
-        const auto deviceType = args.CurrentPoint().PointerDevice().PointerDeviceType();
-        const auto deviceSlot = args.CurrentPoint().PointerId();
-        const auto updateKind = args.CurrentPoint().Properties().PointerUpdateKind();
-        const auto x = static_cast<int>(position.X * m_displayScale);
-        const auto y = static_cast<int>(position.Y * m_displayScale);
-
-        if (deviceType == winrt::Windows::Devices::Input::PointerDeviceType::Mouse)
-        {
-            ProcessMouseButtons(m_appContext->Input(), updateKind, x, y);
-        }
-        else
-        {
-            m_appContext->Input()->TouchDown(deviceSlot, x, y);
-        }
+        ProcessMouseButtons(*m_view, updateKind, x, y);
+    }
+    else
+    {
+        m_view->OnPointerDown(static_cast<int32_t>(deviceSlot), x, y, CoordinateUnits::Logical);
     }
 }
 
 void App::OnPointerReleased(CoreWindow const&, PointerEventArgs const& args)
 {
-    if (m_appContext && m_appContext->Input())
+    if (!m_view) return;
+
+    const auto position = args.CurrentPoint().RawPosition();
+    const auto deviceType = args.CurrentPoint().PointerDevice().PointerDeviceType();
+    const auto deviceSlot = args.CurrentPoint().PointerId();
+    const auto updateKind = args.CurrentPoint().Properties().PointerUpdateKind();
+    const auto x = position.X;
+    const auto y = position.Y;
+
+    if (deviceType == winrt::Windows::Devices::Input::PointerDeviceType::Mouse)
     {
-        const auto position = args.CurrentPoint().RawPosition();
-        const auto deviceType = args.CurrentPoint().PointerDevice().PointerDeviceType();
-        const auto deviceSlot = args.CurrentPoint().PointerId();
-        const auto updateKind = args.CurrentPoint().Properties().PointerUpdateKind();
-        const auto x = static_cast<int>(position.X * m_displayScale);
-        const auto y = static_cast<int>(position.Y * m_displayScale);
-
-        if (deviceType == winrt::Windows::Devices::Input::PointerDeviceType::Mouse)
-        {
-            ProcessMouseButtons(m_appContext->Input(), updateKind, x, y);
-        }
-        else
-        {
-            m_appContext->Input()->TouchUp(deviceSlot, x, y);
-        }
+        ProcessMouseButtons(*m_view, updateKind, x, y);
+    }
+    else
+    {
+        m_view->OnPointerUp(static_cast<int32_t>(deviceSlot), x, y, CoordinateUnits::Logical);
     }
 }
 
 void App::OnPointerWheelChanged(CoreWindow const&, PointerEventArgs const& args)
 {
-    if (m_appContext && m_appContext->Input())
+    if (m_view)
     {
         const auto delta = args.CurrentPoint().Properties().MouseWheelDelta();
-        m_appContext->Input()->MouseWheel(Babylon::Plugins::NativeInput::MOUSEWHEEL_Y_ID, -delta);
+        m_view->OnMouseWheel(BNView::MouseWheelY(), -delta);
     }
 }
 
@@ -290,9 +300,9 @@ void App::OnKeyPressed(CoreWindow const& window, KeyEventArgs const& args)
 
 void App::OnDpiChanged(DisplayInformation const& /*sender*/, IInspectable const& /*args*/)
 {
-    DisplayInformation displayInformation = DisplayInformation::GetForCurrentView();
-    m_displayScale = static_cast<float>(displayInformation.RawPixelsPerViewPixel());
-    // resize event happens after. No need to force resize here.
+    // DPR is queried by the View through Babylon::Graphics::GetDevicePixelRatio
+    // on each Resize, so we don't cache it here. SizeChanged fires after a DPI
+    // change, which re-drives Resize.
 }
 
 void App::OnOrientationChanged(DisplayInformation const& /*sender*/, IInspectable const& /*args*/)
@@ -311,26 +321,24 @@ void App::RestartRuntime(Rect bounds)
 {
     Uninitialize();
 
-    DisplayInformation displayInformation = DisplayInformation::GetForCurrentView();
-    m_displayScale = static_cast<float>(displayInformation.RawPixelsPerViewPixel());
-    size_t width = static_cast<size_t>(bounds.Width * m_displayScale);
-    size_t height = static_cast<size_t>(bounds.Height * m_displayScale);
-    IInspectable window{CoreWindow::GetForCurrentThread()};
+    Babylon::Embedding::RuntimeOptions runtimeOptions{};
+    runtimeOptions.enableDebugger = true;
+    runtimeOptions.log = Playground::MakeLogCallback([](std::string_view text) {
+        std::string line{text};
+        line.push_back('\n');
+        OutputDebugStringA(line.c_str());
+        std::cout << line;
+    });
 
-    m_appContext.emplace(
-        window,
-        width,
-        height,
-        [](const char* message) {
-            std::ostringstream ss{};
-            ss << message << std::endl;
-            OutputDebugStringA(ss.str().data());
-            std::cout << ss.str();
-        });
+    m_runtime.emplace(std::move(runtimeOptions));
+
+    PlaygroundOptions playgroundOptions{};
+    Playground::Initialize(playgroundOptions);
+    Playground::LoadBootstrapScripts(*m_runtime);
 
     if (m_files == nullptr)
     {
-        m_appContext->ScriptLoader().LoadScript("app:///Scripts/experience.js");
+        m_runtime->LoadScript("app:///Scripts/experience.js");
     }
     else
     {
@@ -340,9 +348,21 @@ void App::RestartRuntime(Rect bounds)
 
             // There is no built-in way to convert a local file path to a url in UWP, but
             // Foundation::Uri works with a url constructed using "file:///" with a local path.
-            m_appContext->ScriptLoader().LoadScript("file:///" + winrt::to_string(file.Path()));
+            m_runtime->LoadScript("file:///" + winrt::to_string(file.Path()));
         }
 
-        m_appContext->ScriptLoader().LoadScript("app:///Scripts/playground_runner.js");
+        m_runtime->LoadScript("app:///Scripts/playground_runner.js");
     }
+
+    // First View attach triggers Device construction, plugin init, and
+    // flushes the queued scripts. The CoreWindow is passed as IInspectable
+    // (matching Babylon::Graphics::WindowT on WinRT).
+    IInspectable window{CoreWindow::GetForCurrentThread()};
+    m_view.emplace(*m_runtime, window);
+
+    // Drive the first Resize with the initial window bounds (logical pixels);
+    // the View handles physical conversion via GetDevicePixelRatio.
+    m_view->Resize(static_cast<uint32_t>(bounds.Width),
+                   static_cast<uint32_t>(bounds.Height),
+                   CoordinateUnits::Logical);
 }
diff --git a/Apps/Playground/UWP/App.h b/Apps/Playground/UWP/App.h
index bcff16385..a1098d78f 100644
--- a/Apps/Playground/UWP/App.h
+++ b/Apps/Playground/UWP/App.h
@@ -1,6 +1,8 @@
 #pragma once
 
-#include <Shared/AppContext.h>
+#include <Babylon/Embedding/Runtime.h>
+#include <Babylon/Embedding/View.h>
+
 #include <optional>
 
 #include <winrt/Windows.ApplicationModel.h>
@@ -50,12 +52,17 @@ struct App : winrt::implements<App, winrt::Windows::ApplicationModel::Core::IFra
 
     void RestartRuntime(winrt::Windows::Foundation::Rect bounds);
 
-    std::optional<AppContext> m_appContext{};
+    // Process-scoped: created on app start, recreated on 'R' refresh,
+    // destroyed in Uninitialize.
+    std::optional<Babylon::Embedding::Runtime> m_runtime{};
+
+    // Window-scoped: created during RestartRuntime, destroyed in Uninitialize
+    // (and before a fresh Runtime is constructed).
+    std::optional<Babylon::Embedding::View> m_view{};
 
     winrt::Windows::Foundation::Collections::IVectorView<winrt::Windows::Storage::IStorageItem> m_files{nullptr};
     bool m_windowClosed;
     bool m_windowVisible;
-    float m_displayScale{1.f};
 };
 
 struct Direct3DApplicationSource : winrt::implements<Direct3DApplicationSource, winrt::Windows::ApplicationModel::Core::IFrameworkViewSource>
diff --git a/Apps/Playground/Win32/App.cpp b/Apps/Playground/Win32/App.cpp
index 0fba87e0b..1a3640d27 100644
--- a/Apps/Playground/Win32/App.cpp
+++ b/Apps/Playground/Win32/App.cpp
@@ -1,19 +1,33 @@
 // App.cpp : Defines the entry point for the application.
 //
+// Built on Babylon::Embedding: the cross-platform Runtime + View API
+// handles plugin/polyfill setup, GPU device construction, frame rendering,
+// and input forwarding.
 
 #include "App.h"
-#include <Shared/AppContext.h>
+
+#include <Babylon/Embedding/Runtime.h>
+#include <Babylon/Embedding/View.h>
+#include <Babylon/Plugins/TestUtils.h>
+
 #include <Shared/CommandLine.h>
 #include <Shared/Diagnostics.h>
-#include <Babylon/Plugins/TestUtils.h>
+#include <Shared/PlaygroundScripts.h>
+
 #include <Windows.h>
 #include <Windowsx.h>
 #include <Shlwapi.h>
+
+#include <napi/napi.h>
+
+#include <cstdio>
+#include <cstdlib>
 #include <filesystem>
 #include <iostream>
+#include <memory>
 #include <optional>
-#include <sstream>
-
+#include <string>
+#include <vector>
 
 #define MAX_LOADSTRING 100
 
@@ -21,9 +35,16 @@
 HINSTANCE hInst;                     // current instance
 WCHAR szTitle[MAX_LOADSTRING];       // The title bar text
 WCHAR szWindowClass[MAX_LOADSTRING]; // the main window class name
-std::optional<AppContext> appContext{};
+
+// Process-scoped: created on app start, recreated on 'R' refresh,
+// destroyed on app exit.
+std::optional<Babylon::Embedding::Runtime> g_runtime;
+
+// Window-scoped: created on InitInstance after CreateWindowW returns,
+// destroyed on WM_DESTROY (or torn down + recreated by RefreshBabylon).
+std::optional<Babylon::Embedding::View> g_view;
+
 bool minimized{false};
-int buttonRefCount{0};
 PlaygroundOptions options{};
 
 // Forward declarations of functions included in this code module:
@@ -69,66 +90,104 @@ namespace
         return arguments;
     }
 
-    void Uninitialize()
+    Babylon::Embedding::RuntimeOptions MakeRuntimeOptions()
     {
-        appContext.reset();
+        Babylon::Embedding::RuntimeOptions runtimeOptions{};
+        runtimeOptions.enableDebugger = true;
+        runtimeOptions.enableDebugTrace = options.DebugTrace.value_or(true);
+        runtimeOptions.log = Playground::MakeLogCallback([](std::string_view text) {
+            std::string line{text};
+            line.push_back('\n');
+            OutputDebugStringA(line.c_str());
+            std::fputs(line.c_str(), stdout);
+        });
+        return runtimeOptions;
     }
 
-    void RefreshBabylon(HWND hWnd)
+    void QueuePlaygroundOptions()
     {
-        Uninitialize();
+        g_runtime->RunOnJsThread([playgroundOptions = options](Napi::Env env) {
+            auto js = Napi::Object::New(env);
+            js.Set("listTests",          Napi::Boolean::New(env, playgroundOptions.ListTests));
+            js.Set("headless",           Napi::Boolean::New(env, playgroundOptions.Headless));
+            js.Set("breakOnFail",        Napi::Boolean::New(env, playgroundOptions.BreakOnFail));
+            js.Set("generateReferences", Napi::Boolean::New(env, playgroundOptions.GenerateReferences));
+            js.Set("runOnce",            Napi::Boolean::New(env, playgroundOptions.RunOnce));
+            js.Set("includeExcluded",    Napi::Boolean::New(env, playgroundOptions.IncludeExcluded));
+            if (playgroundOptions.SaveResults.has_value())
+            {
+                js.Set("saveResults", Napi::Boolean::New(env, *playgroundOptions.SaveResults));
+            }
+            if (playgroundOptions.CaptureFrame.has_value())
+            {
+                js.Set("captureFrame", Napi::Number::New(env, *playgroundOptions.CaptureFrame));
+            }
 
-        RECT rect;
-        if (!GetClientRect(hWnd, &rect))
-        {
-            throw std::exception{"Unable to get client rect"};
-        }
+            auto filters = Napi::Array::New(env, playgroundOptions.TestFilters.size());
+            for (uint32_t idx = 0; idx < playgroundOptions.TestFilters.size(); ++idx)
+            {
+                filters[idx] = Napi::String::New(env, playgroundOptions.TestFilters[idx]);
+            }
+            js.Set("testFilters", filters);
 
-        auto width = static_cast<size_t>(rect.right - rect.left);
-        auto height = static_cast<size_t>(rect.bottom - rect.top);
-
-        appContext.emplace(
-            hWnd,
-            width,
-            height,
-            [](const char* message) {
-                // Normalize trailing newline (bgfx traceVargs adds one;
-                // others don't) so we don't produce blank lines.
-                std::string text{message};
-                while (!text.empty() && (text.back() == '\n' || text.back() == '\r'))
-                {
-                    text.pop_back();
-                }
-                text.push_back('\n');
-                OutputDebugStringA(text.c_str());
-                // Use C stdio (unbuffered, set in wWinMain) so each line
-                // reaches the pipe even when the process exits via
-                // std::quick_exit / TestUtils.exit() without unwinding.
-                std::fputs(text.c_str(), stdout);
-            },
-            AppContext::AdditionalInitCallback{},
-            options);
+            auto indices = Napi::Array::New(env, playgroundOptions.TestIndices.size());
+            for (uint32_t idx = 0; idx < playgroundOptions.TestIndices.size(); ++idx)
+            {
+                indices[idx] = Napi::Number::New(env, playgroundOptions.TestIndices[idx]);
+            }
+            js.Set("testIndices", indices);
+
+            env.Global().Set("_playgroundOptions", js);
+        });
+    }
+
+    void LoadScripts()
+    {
+        Playground::LoadBootstrapScripts(*g_runtime);
 
         if (options.Scripts.empty())
         {
-            appContext->ScriptLoader().LoadScript("app:///Scripts/experience.js");
+            g_runtime->LoadScript("app:///Scripts/experience.js");
         }
         else
         {
             for (const auto& arg : options.Scripts)
             {
-                appContext->ScriptLoader().LoadScript(GetUrlFromPath(arg));
+                g_runtime->LoadScript(GetUrlFromPath(arg));
             }
-
-            appContext->ScriptLoader().LoadScript("app:///Scripts/playground_runner.js");
+            g_runtime->LoadScript("app:///Scripts/playground_runner.js");
         }
     }
 
-    void UpdateWindowSize(size_t width, size_t height)
+    void Uninitialize()
+    {
+        // View first (unbinds surface, closes in-flight frame), then
+        // Runtime (joins JS thread).
+        g_view.reset();
+        g_runtime.reset();
+    }
+
+    void RefreshBabylon(HWND hWnd)
     {
-        if (appContext)
+        Uninitialize();
+
+        g_runtime.emplace(MakeRuntimeOptions());
+        Playground::Initialize(options);
+        QueuePlaygroundOptions();
+        LoadScripts();
+
+        // First View attach triggers Device construction, plugin init, and
+        // flushes the queued scripts.
+        g_view.emplace(*g_runtime, hWnd);
+
+        // Drive the first Resize with the initial window bounds (physical pixels);
+        // the View handles physical conversion via GetDevicePixelRatio.
+        RECT rect{};
+        if (GetClientRect(hWnd, &rect))
         {
-            appContext->Device().UpdateSize(width, height);
+            g_view->Resize(static_cast<uint32_t>(rect.right - rect.left),
+                           static_cast<uint32_t>(rect.bottom - rect.top),
+                           Babylon::Embedding::CoordinateUnits::Physical);
         }
     }
 }
@@ -173,7 +232,7 @@ int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
 
     if (options.ParseError)
     {
-        std::fprintf(stderr, "Error: %s\n\n", options.ErrorMessage.c_str());
+        std::cerr << "Error: " << options.ErrorMessage << "\n\n";
         CommandLine::PrintUsage(argv.empty() ? nullptr : argv[0]);
         Diagnostics::SetExitCode(2);
         return 2;
@@ -202,7 +261,10 @@ int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
 
     MSG msg{};
 
-    // Main message loop:
+    // Main message loop. When minimized, block on GetMessage to avoid
+    // spinning the CPU. Otherwise, peek + render one frame per loop
+    // iteration; View::RenderFrame is a no-op while suspended so we
+    // don't need to special-case that here.
     while (msg.message != WM_QUIT)
     {
         BOOL result;
@@ -213,12 +275,10 @@ int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
         }
         else
         {
-            if (appContext)
+            if (g_view)
             {
-                appContext->Device().FinishRenderingCurrentFrame();
-                appContext->Device().StartRenderingCurrentFrame();
+                g_view->RenderFrame();
             }
-
             result = PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE) && msg.message != WM_QUIT;
         }
 
@@ -236,11 +296,6 @@ int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
     return (int)msg.wParam;
 }
 
-//
-//  FUNCTION: MyRegisterClass()
-//
-//  PURPOSE: Registers the window class.
-//
 ATOM MyRegisterClass(HINSTANCE hInstance)
 {
     WNDCLASSEXW wcex;
@@ -262,19 +317,9 @@ ATOM MyRegisterClass(HINSTANCE hInstance)
     return RegisterClassExW(&wcex);
 }
 
-//
-//   FUNCTION: InitInstance(HINSTANCE, int)
-//
-//   PURPOSE: Saves instance handle and creates main window
-//
-//   COMMENTS:
-//
-//        In this function, we save the instance handle in a global variable and
-//        create and display the main program window.
-//
 BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
 {
-    hInst = hInstance; // Store instance handle in our global variable
+    hInst = hInstance;
 
     HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
         CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);
@@ -284,65 +329,59 @@ BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
         return FALSE;
     }
 
+    RefreshBabylon(hWnd);
+
     ShowWindow(hWnd, nCmdShow);
     UpdateWindow(hWnd);
     EnableMouseInPointer(true);
 
-    RefreshBabylon(hWnd);
-
     return TRUE;
 }
 
 void ProcessMouseButtons(tagPOINTER_BUTTON_CHANGE_TYPE changeType, int x, int y)
 {
+    using View = Babylon::Embedding::View;
+    using CoordinateUnits = Babylon::Embedding::CoordinateUnits;
+    if (!g_view) return;
+
     switch (changeType)
     {
         case POINTER_CHANGE_FIRSTBUTTON_DOWN:
-            appContext->Input()->MouseDown(Babylon::Plugins::NativeInput::LEFT_MOUSE_BUTTON_ID, x, y);
+            g_view->OnMouseDown(View::LeftMouseButton(), static_cast<float>(x), static_cast<float>(y), CoordinateUnits::Physical);
             break;
         case POINTER_CHANGE_FIRSTBUTTON_UP:
-            appContext->Input()->MouseUp(Babylon::Plugins::NativeInput::LEFT_MOUSE_BUTTON_ID, x, y);
+            g_view->OnMouseUp(View::LeftMouseButton(), static_cast<float>(x), static_cast<float>(y), CoordinateUnits::Physical);
             break;
         case POINTER_CHANGE_SECONDBUTTON_DOWN:
-            appContext->Input()->MouseDown(Babylon::Plugins::NativeInput::RIGHT_MOUSE_BUTTON_ID, x, y);
+            g_view->OnMouseDown(View::RightMouseButton(), static_cast<float>(x), static_cast<float>(y), CoordinateUnits::Physical);
             break;
         case POINTER_CHANGE_SECONDBUTTON_UP:
-            appContext->Input()->MouseUp(Babylon::Plugins::NativeInput::RIGHT_MOUSE_BUTTON_ID, x, y);
+            g_view->OnMouseUp(View::RightMouseButton(), static_cast<float>(x), static_cast<float>(y), CoordinateUnits::Physical);
             break;
         case POINTER_CHANGE_THIRDBUTTON_DOWN:
-            appContext->Input()->MouseDown(Babylon::Plugins::NativeInput::MIDDLE_MOUSE_BUTTON_ID, x, y);
+            g_view->OnMouseDown(View::MiddleMouseButton(), static_cast<float>(x), static_cast<float>(y), CoordinateUnits::Physical);
             break;
         case POINTER_CHANGE_THIRDBUTTON_UP:
-            appContext->Input()->MouseUp(Babylon::Plugins::NativeInput::MIDDLE_MOUSE_BUTTON_ID, x, y);
+            g_view->OnMouseUp(View::MiddleMouseButton(), static_cast<float>(x), static_cast<float>(y), CoordinateUnits::Physical);
             break;
     }
 }
 
-//
-//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
-//
-//  PURPOSE: Processes messages for the main window.
-//
-//  WM_COMMAND  - process the application menu
-//  WM_PAINT    - Paint the main window
-//  WM_DESTROY  - post a quit message and return
-//
-//
 LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 {
+    using View = Babylon::Embedding::View;
+    using CoordinateUnits = Babylon::Embedding::CoordinateUnits;
+
     switch (message)
     {
         case WM_SYSCOMMAND:
         {
             if ((wParam & 0xFFF0) == SC_MINIMIZE)
             {
-                if (appContext)
+                if (g_runtime)
                 {
-                    appContext->Device().FinishRenderingCurrentFrame();
-
-                    appContext->Runtime().Suspend();
+                    g_runtime->Suspend();
                 }
-
                 minimized = true;
             }
             else if ((wParam & 0xFFF0) == SC_RESTORE)
@@ -350,12 +389,9 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
                 if (minimized)
                 {
                     minimized = false;
-
-                    if (appContext)
+                    if (g_runtime)
                     {
-                        appContext->Runtime().Resume();
-
-                        appContext->Device().StartRenderingCurrentFrame();
+                        g_runtime->Resume();
                     }
                 }
             }
@@ -365,7 +401,6 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
         case WM_COMMAND:
         {
             int wmId = LOWORD(wParam);
-            // Parse the menu selections:
             switch (wmId)
             {
                 case IDM_ABOUT:
@@ -381,9 +416,12 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
         }
         case WM_SIZE:
         {
-            auto width = static_cast<size_t>(LOWORD(lParam));
-            auto height = static_cast<size_t>(HIWORD(lParam));
-            UpdateWindowSize(width, height);
+            if (g_view)
+            {
+                g_view->Resize(static_cast<uint32_t>(LOWORD(lParam)),
+                                static_cast<uint32_t>(HIWORD(lParam)),
+                                CoordinateUnits::Physical);
+            }
             break;
         }
         case WM_DESTROY:
@@ -402,15 +440,15 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
         }
         case WM_POINTERWHEEL:
         {
-            if (appContext && appContext->Input())
+            if (g_view)
             {
-                appContext->Input()->MouseWheel(Babylon::Plugins::NativeInput::MOUSEWHEEL_Y_ID, -GET_WHEEL_DELTA_WPARAM(wParam));
+                g_view->OnMouseWheel(View::MouseWheelY(), -GET_WHEEL_DELTA_WPARAM(wParam));
             }
             break;
         }
         case WM_POINTERDOWN:
         {
-            if (appContext && appContext->Input())
+            if (g_view)
             {
                 POINTER_INFO info;
                 auto pointerId = GET_POINTERID_WPARAM(wParam);
@@ -427,7 +465,10 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
                     }
                     else
                     {
-                        appContext->Input()->TouchDown(pointerId, x, y);
+                        g_view->OnPointerDown(static_cast<int32_t>(pointerId),
+                                                static_cast<float>(x),
+                                                static_cast<float>(y),
+                                                CoordinateUnits::Physical);
                     }
                 }
             }
@@ -435,7 +476,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
         }
         case WM_POINTERUPDATE:
         {
-            if (appContext && appContext->Input())
+            if (g_view)
             {
                 auto pointerId = GET_POINTERID_WPARAM(wParam);
                 POINTER_INFO info;
@@ -449,11 +490,14 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
                     if (info.pointerType == PT_MOUSE)
                     {
                         ProcessMouseButtons(info.ButtonChangeType, x, y);
-                        appContext->Input()->MouseMove(x, y);
+                        g_view->OnMouseMove(static_cast<float>(x), static_cast<float>(y), CoordinateUnits::Physical);
                     }
                     else
                     {
-                        appContext->Input()->TouchMove(pointerId, x, y);
+                        g_view->OnPointerMove(static_cast<int32_t>(pointerId),
+                                                static_cast<float>(x),
+                                                static_cast<float>(y),
+                                                CoordinateUnits::Physical);
                     }
                 }
             }
@@ -461,7 +505,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
         }
         case WM_POINTERUP:
         {
-            if (appContext && appContext->Input())
+            if (g_view)
             {
                 auto pointerId = GET_POINTERID_WPARAM(wParam);
                 POINTER_INFO info;
@@ -478,7 +522,10 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
                     }
                     else
                     {
-                        appContext->Input()->TouchUp(pointerId, x, y);
+                        g_view->OnPointerUp(static_cast<int32_t>(pointerId),
+                                              static_cast<float>(x),
+                                              static_cast<float>(y),
+                                              CoordinateUnits::Physical);
                     }
                 }
             }
diff --git a/Apps/Playground/X11/App.cpp b/Apps/Playground/X11/App.cpp
index 8eb4358ff..7ef5c79e2 100644
--- a/Apps/Playground/X11/App.cpp
+++ b/Apps/Playground/X11/App.cpp
@@ -5,58 +5,70 @@
 #include <X11/Xutil.h>
 #include <unistd.h> // syscall
 #undef None
-#include <filesystem>
+#include <cstring>
 #include <iostream>
 #include <optional>
 
-#include <Shared/AppContext.h>
-#include <Shared/Diagnostics.h>
+#include <Babylon/Embedding/Runtime.h>
+#include <Babylon/Embedding/View.h>
 #include <Babylon/Plugins/TestUtils.h>
+#include <Shared/Diagnostics.h>
+#include <Shared/PlaygroundScripts.h>
 
 static const char* s_applicationName  = "BabylonNative Playground";
 static const char* s_applicationClass = "Playground";
 
 namespace
 {
-    std::optional<AppContext> g_appContext{};
+    std::optional<Babylon::Embedding::Runtime> g_runtime;
+    std::optional<Babylon::Embedding::View> g_view;
 
     void Uninitialize()
     {
-        g_appContext.reset();
+        // View first (unbinds surface, closes in-flight frame), then
+        // Runtime (joins JS thread).
+        g_view.reset();
+        g_runtime.reset();
     }
 
-    void InitBabylon(Window window, int width, int height, int argc, const char* const* argv)
+    void InitBabylon(Window window, int argc, const char* const* argv)
     {
         Uninitialize();
 
-        g_appContext.emplace(
-            window,
-            static_cast<size_t>(width),
-            static_cast<size_t>(height),
-            [](const char* message) {
-                std::cout << message << std::endl;
-            });
+        Babylon::Embedding::RuntimeOptions runtimeOptions{};
+        runtimeOptions.log = Playground::MakeLogCallback([](std::string_view text) {
+            std::cout << text << std::endl;
+        });
+
+        g_runtime.emplace(std::move(runtimeOptions));
+        Playground::Initialize();
+        Playground::LoadBootstrapScripts(*g_runtime);
 
         if (argc == 1)
         {
-            g_appContext->ScriptLoader().LoadScript("app:///Scripts/experience.js");
+            g_runtime->LoadScript("app:///Scripts/experience.js");
         }
         else
         {
             for (int i = 1; i < argc; ++i)
             {
-                g_appContext->ScriptLoader().LoadScript(argv[i]);
+                g_runtime->LoadScript(argv[i]);
             }
 
-            g_appContext->ScriptLoader().LoadScript("app:///Scripts/playground_runner.js");
+            g_runtime->LoadScript("app:///Scripts/playground_runner.js");
         }
+
+        // First View attach triggers Device construction, plugin init, and
+        // flushes the queued scripts.
+        g_view.emplace(*g_runtime, window);
     }
 
-    void UpdateWindowSize(float width, float height)
+    void UpdateWindowSize(uint32_t width, uint32_t height)
     {
-        if (g_appContext)
+        if (g_view)
         {
-            g_appContext->Device().UpdateSize(width, height);
+            // X11 reports surface dimensions in physical pixels.
+            g_view->Resize(width, height, Babylon::Embedding::CoordinateUnits::Physical);
         }
     }
 }
@@ -131,16 +143,15 @@ int main(int _argc, const char* const* _argv)
             , NULL
             );
 
-    InitBabylon(window, width, height, _argc, _argv);
+    InitBabylon(window, _argc, _argv);
     UpdateWindowSize(width, height);
 
     bool exit{};
     while (!exit)
     {
-        if (!XPending(display) && g_appContext)
+        if (!XPending(display) && g_view)
         {
-            g_appContext->Device().FinishRenderingCurrentFrame();
-            g_appContext->Device().StartRenderingCurrentFrame();
+            g_view->RenderFrame();
         }
         else
         {
@@ -169,22 +180,22 @@ int main(int _argc, const char* const* _argv)
                         const XMotionEvent& xmotion = event.xmotion;
                         const XButtonEvent& xbutton = event.xbutton;
 
-                        if (g_appContext && g_appContext->Input()) {
+                        if (g_view) {
                             switch (xbutton.button) {
                                 case Button1:
-                                    g_appContext->Input()->MouseDown(Babylon::Plugins::NativeInput::LEFT_MOUSE_BUTTON_ID, xmotion.x, xmotion.y);
+                                    g_view->OnMouseDown(Babylon::Embedding::View::LeftMouseButton(), xmotion.x, xmotion.y, Babylon::Embedding::CoordinateUnits::Physical);
                                     break;
                                 case Button2:
-                                    g_appContext->Input()->MouseDown(Babylon::Plugins::NativeInput::MIDDLE_MOUSE_BUTTON_ID, xmotion.x, xmotion.y);
+                                    g_view->OnMouseDown(Babylon::Embedding::View::MiddleMouseButton(), xmotion.x, xmotion.y, Babylon::Embedding::CoordinateUnits::Physical);
                                     break;
                                 case Button3:
-                                    g_appContext->Input()->MouseDown(Babylon::Plugins::NativeInput::RIGHT_MOUSE_BUTTON_ID, xmotion.x, xmotion.y);
+                                    g_view->OnMouseDown(Babylon::Embedding::View::RightMouseButton(), xmotion.x, xmotion.y, Babylon::Embedding::CoordinateUnits::Physical);
                                     break;
                                 case Button4:
-                                    g_appContext->Input()->MouseWheel(Babylon::Plugins::NativeInput::MOUSEWHEEL_Y_ID, -120);
+                                    g_view->OnMouseWheel(Babylon::Embedding::View::MouseWheelY(), -120);
                                     break;
                                 case Button5:
-                                    g_appContext->Input()->MouseWheel(Babylon::Plugins::NativeInput::MOUSEWHEEL_Y_ID, 120);
+                                    g_view->OnMouseWheel(Babylon::Embedding::View::MouseWheelY(), 120);
                                     break;
                             }
                         }
@@ -195,18 +206,18 @@ int main(int _argc, const char* const* _argv)
                         const XMotionEvent& xmotion = event.xmotion;
                         const XButtonEvent& xbutton = event.xbutton;
 
-                        if (g_appContext && g_appContext->Input())
+                        if (g_view)
                         {
                             switch (xbutton.button)
                             {
                                 case Button1:
-                                    g_appContext->Input()->MouseUp(Babylon::Plugins::NativeInput::LEFT_MOUSE_BUTTON_ID, xmotion.x, xmotion.y);
+                                    g_view->OnMouseUp(Babylon::Embedding::View::LeftMouseButton(), xmotion.x, xmotion.y, Babylon::Embedding::CoordinateUnits::Physical);
                                     break;
                                 case Button2:
-                                    g_appContext->Input()->MouseUp(Babylon::Plugins::NativeInput::MIDDLE_MOUSE_BUTTON_ID, xmotion.x, xmotion.y);
+                                    g_view->OnMouseUp(Babylon::Embedding::View::MiddleMouseButton(), xmotion.x, xmotion.y, Babylon::Embedding::CoordinateUnits::Physical);
                                     break;
                                 case Button3:
-                                    g_appContext->Input()->MouseUp(Babylon::Plugins::NativeInput::RIGHT_MOUSE_BUTTON_ID, xmotion.x, xmotion.y);
+                                    g_view->OnMouseUp(Babylon::Embedding::View::RightMouseButton(), xmotion.x, xmotion.y, Babylon::Embedding::CoordinateUnits::Physical);
                                     break;
                             }
                         }
@@ -215,8 +226,8 @@ int main(int _argc, const char* const* _argv)
                 case MotionNotify:
                     {
                         const XMotionEvent& xmotion = event.xmotion;
-                        if (g_appContext && g_appContext->Input()) {
-                            g_appContext->Input()->MouseMove(xmotion.x, xmotion.y);
+                        if (g_view) {
+                            g_view->OnMouseMove(xmotion.x, xmotion.y, Babylon::Embedding::CoordinateUnits::Physical);
                         }
                     }
                     break;
diff --git a/Apps/Playground/iOS/AppDelegate.swift b/Apps/Playground/iOS/AppDelegate.swift
index ea4b901a2..3c1e7165e 100644
--- a/Apps/Playground/iOS/AppDelegate.swift
+++ b/Apps/Playground/iOS/AppDelegate.swift
@@ -4,36 +4,42 @@ import UIKit
 class AppDelegate: UIResponder, UIApplicationDelegate {
 
     var window: UIWindow?
-    var _bridge: LibNativeBridge?
+
+    /// Owned by the app: created in `application(_:didFinishLaunchingWithOptions:)`,
+    /// torn down in `applicationWillTerminate`. The `ViewController` borrows
+    /// this handle to construct its `BNView`.
+    var runtime: BNRuntime?
 
     func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
-        // Override point for customization after application launch.
-        _bridge = LibNativeBridge()
+        let runtimeOptions = BNRuntimeOptions()
+        runtimeOptions.enableDebugger = true
+        runtimeOptions.enableDebugTrace = true
+        guard let runtime = BNRuntime(options: runtimeOptions) else {
+            fatalError("Failed to construct BNRuntime")
+        }
+
+        // Queue the Babylon.js bootstrap scripts (shared with the other
+        // Playground hosts via Apps/Playground/Shared/PlaygroundScripts.cpp),
+        // then the playground experience script. They will run after the
+        // first BNView attach completes engine initialization on the JS
+        // thread, in submission order.
+        PlaygroundBootstrap.loadScripts(runtime)
+        runtime.loadScript("app:///Scripts/experience.js")
+
+        self.runtime = runtime
         return true
     }
 
     func applicationWillResignActive(_ application: UIApplication) {
-        // Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
-        // Use this method to pause ongoing tasks, disable timers, and invalidate graphics rendering callbacks. Games should use this method to pause the game.
-    }
-
-    func applicationDidEnterBackground(_ application: UIApplication) {
-        // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
-        // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.
-    }
-
-    func applicationWillEnterForeground(_ application: UIApplication) {
-        // Called as part of the transition from the background to the active state; here you can undo many of the changes made on entering the background.
+        runtime?.suspend()
     }
 
     func applicationDidBecomeActive(_ application: UIApplication) {
-        // Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
+        runtime?.resume()
     }
 
     func applicationWillTerminate(_ application: UIApplication) {
-        // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
+        runtime = nil
     }
-
-
 }
 
diff --git a/Apps/Playground/iOS/LibNativeBridge.h b/Apps/Playground/iOS/LibNativeBridge.h
deleted file mode 100644
index b3faf54ff..000000000
--- a/Apps/Playground/iOS/LibNativeBridge.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#pragma once
-
-#include <Foundation/Foundation.h>
-#include <MetalKit/MetalKit.h>
-
-
-@interface LibNativeBridge : NSObject
-
-- (instancetype)init;
-- (void)dealloc;
-
-- (void)init:(MTKView*)inView screenScale:(float)inScreenScale width:(int)inWidth height:(int)inHeight xrView:(void*)xrView;
-- (void)resize:(int)inWidth height:(int)inHeight;
-- (void)render;
-- (void)setTouchDown:(int)pointerId x:(int)inX y:(int)inY;
-- (void)setTouchMove:(int)pointerId x:(int)inX y:(int)inY;
-- (void)setTouchUp:(int)pointerId x:(int)inX y:(int)inY;
-- (bool)isXRActive;
-
-@end
-
diff --git a/Apps/Playground/iOS/LibNativeBridge.mm b/Apps/Playground/iOS/LibNativeBridge.mm
deleted file mode 100644
index 337dd6797..000000000
--- a/Apps/Playground/iOS/LibNativeBridge.mm
+++ /dev/null
@@ -1,95 +0,0 @@
-#include "LibNativeBridge.h"
-
-#import <Shared/AppContext.h>
-#import <Babylon/Plugins/NativeXr.h>
-#import <optional>
-
-std::optional<AppContext> appContext{};
-std::optional<Babylon::Plugins::NativeXr> nativeXr{};
-bool isXrActive{};
-float screenScale{1.0f};
-
-@implementation LibNativeBridge
-
-- (instancetype)init
-{
-    self = [super init];
-    return self;
-}
-
-- (void)dealloc
-{
-    isXrActive = false;
-
-    nativeXr.reset();
-    appContext.reset();
-}
-
-- (void)init:(MTKView*)view screenScale:(float)inScreenScale width:(int)inWidth height:(int)inHeight xrView:(void*)xrView
-{
-    screenScale = inScreenScale;
-
-    appContext.emplace(
-        (__bridge CA::MetalLayer*)view.layer,
-        static_cast<size_t>(inWidth),
-        static_cast<size_t>(inHeight),
-        [](const char* message) {
-            NSLog(@"%s", message);
-        },
-        [xrView](Napi::Env env) {
-            nativeXr.emplace(Babylon::Plugins::NativeXr::Initialize(env));
-            nativeXr->UpdateWindow(xrView);
-            nativeXr->SetSessionStateChangedCallback([](bool isXrActive){ ::isXrActive = isXrActive; });
-        });
-
-    appContext->ScriptLoader().LoadScript("app:///Scripts/experience.js");
-}
-
-- (void)resize:(int)inWidth height:(int)inHeight
-{
-    if (appContext)
-    {
-        appContext->Device().FinishRenderingCurrentFrame();
-
-        appContext->Device().UpdateSize(static_cast<size_t>(inWidth), static_cast<size_t>(inHeight));
-
-        appContext->Device().StartRenderingCurrentFrame();
-    }
-}
-
-- (void)render
-{
-    if (appContext)
-    {
-        appContext->Device().FinishRenderingCurrentFrame();
-        appContext->Device().StartRenderingCurrentFrame();
-    }
-}
-
-- (void)setTouchDown:(int)pointerId x:(int)inX y:(int)inY
-{
-    if (appContext && appContext->Input()) {
-        appContext->Input()->TouchDown(pointerId, inX * screenScale, inY * screenScale);
-    }
-}
-
-- (void)setTouchMove:(int)pointerId x:(int)inX y:(int)inY
-{
-    if (appContext && appContext->Input()) {
-        appContext->Input()->TouchMove(pointerId, inX * screenScale, inY * screenScale);
-    }
-}
-
-- (void)setTouchUp:(int)pointerId x:(int)inX y:(int)inY
-{
-    if (appContext && appContext->Input()) {
-        appContext->Input()->TouchUp(pointerId, inX * screenScale, inY * screenScale);
-    }
-}
-
-- (bool)isXRActive
-{
-    return ::isXrActive;
-}
-
-@end
diff --git a/Apps/Playground/iOS/Playground-Bridging-Header.h b/Apps/Playground/iOS/Playground-Bridging-Header.h
new file mode 100644
index 000000000..6e8a19bec
--- /dev/null
+++ b/Apps/Playground/iOS/Playground-Bridging-Header.h
@@ -0,0 +1,11 @@
+// Swift-Obj-C bridging header for the iOS Playground app.
+//
+// Exposes both the Babylon::Embedding Apple interop layer
+// (`BNRuntime`, `BNView`) and the Playground-specific helper
+// (`PlaygroundBootstrap`) to the Swift sources.
+
+#pragma once
+
+#import <Babylon/Embedding/Apple/BabylonNativeEmbedding.h>
+
+#import "AppleShared/PlaygroundBootstrap.h"
diff --git a/Apps/Playground/iOS/ViewController.swift b/Apps/Playground/iOS/ViewController.swift
index 3b73cbf21..6cc540a47 100644
--- a/Apps/Playground/iOS/ViewController.swift
+++ b/Apps/Playground/iOS/ViewController.swift
@@ -5,64 +5,64 @@ class ViewController: UIViewController {
 
     var mtkView: MTKView!
     var xrView: MTKView!
-
-    override func viewDidLoad() {
-        super.viewDidLoad()
-    }
+    var bnView: BNView?
 
     override func viewDidAppear(_ animated: Bool) {
         super.viewDidAppear(animated)
         guard
             let appDelegate = UIApplication.shared.delegate as? AppDelegate,
-            let bridge = appDelegate._bridge
+            let runtime = appDelegate.runtime
         else { return }
-        
+
         setupViews()
-        
-        let device = MTLCreateSystemDefaultDevice()
-        mtkView.device = device
-        
-        mtkView.colorPixelFormat = .bgra8Unorm_srgb
-        mtkView.depthStencilPixelFormat = .depth32Float
-        
-        // Simple gesture recognizer, just provides platform to handle input events
-        let gesture = UIBabylonGestureRecognizer(
+
+        // Hand the runtime a reference to the XR overlay so NativeXr
+        // can render its content into a separate transparent layer
+        // when an XR session is active. The runtime keeps the
+        // overlay's visibility in sync with the XR session state on
+        // its own — the host doesn't need to toggle anything.
+        runtime.setXrView(xrView)
+
+        // Attach BNView to the main MTKView. Because mtkView's delegate
+        // is still nil at this point, BNView auto-installs a managed
+        // `BNViewDelegate` that drives the per-frame render callback.
+        // Resize is driven separately from `viewDidLayoutSubviews` below.
+        // First attach on this runtime triggers GPU device construction +
+        // plugin initialization on the JS thread + queued-script flush.
+        bnView = BNView(runtime: runtime, view: mtkView)
+
+        // Simple gesture recognizer: forwards touches to BNView.
+        let recognizer = UIBabylonGestureRecognizer(
             target: self,
-            onTouchDown: bridge.setTouchDown,
-            onTouchMove: bridge.setTouchMove,
-            onTouchUp: bridge.setTouchUp
+            onTouchDown: { [weak self] (id, x, y) in self?.bnView?.pointerDown(id: Int(id), x: CGFloat(x), y: CGFloat(y)) },
+            onTouchMove: { [weak self] (id, x, y) in self?.bnView?.pointerMove(id: Int(id), x: CGFloat(x), y: CGFloat(y)) },
+            onTouchUp:   { [weak self] (id, x, y) in self?.bnView?.pointerUp  (id: Int(id), x: CGFloat(x), y: CGFloat(y)) }
         )
-        mtkView.addGestureRecognizer(gesture)
-        
-        // Force a layout pass so mtkView (and its backing CAMetalLayer) is laid
-        // out and gets a valid drawable size before bgfx is initialized and
-        // before the first draw(in:) callback. mtkView is added via Auto Layout
-        // and is otherwise still 0x0 at this point, which would make bgfx render
-        // into a 0x0 layer and trigger the Metal validation error
-        // "No output textures defined for the render pass".
-        view.layoutIfNeeded()
+        mtkView.addGestureRecognizer(recognizer)
+    }
 
-        let scale  = view.contentScaleFactor
-        let width  = view.bounds.size.width
-        let height = view.bounds.size.height
-        
-        bridge.init(
-            mtkView,
-            screenScale:Float(UIScreen.main.scale),
-            width:Int32(width * scale),
-            height:Int32(height * scale),
-            xrView:Unmanaged.passUnretained(xrView).toOpaque()
-        )
+    override func viewDidLayoutSubviews() {
+        super.viewDidLayoutSubviews()
+
+        // Babylon Native owns the drawable size (BNView sets
+        // autoResizeDrawable = NO), so MTKView no longer reports size
+        // changes via its delegate. Drive resize explicitly from layout,
+        // passing logical points; BNView applies the device-pixel-ratio
+        // internally.
+        guard let mtkView = mtkView, let bnView = bnView else { return }
+        let size = mtkView.bounds.size
+        if size.width > 0 && size.height > 0 {
+            bnView.resize(width: UInt(size.width), height: UInt(size.height))
+        }
     }
-  
+
     func setupViews() {
         mtkView = MTKView()
-        mtkView.delegate = self
         mtkView.translatesAutoresizingMaskIntoConstraints = false
         view.addSubview(mtkView)
         view.addConstraints(NSLayoutConstraint.constraints(withVisualFormat: "|[mtkView]|", options: [], metrics: nil, views: ["mtkView" : mtkView]))
         view.addConstraints(NSLayoutConstraint.constraints(withVisualFormat: "V:|[mtkView]|", options: [], metrics: nil, views: ["mtkView" : mtkView]))
-        
+
         xrView = MTKView()
         xrView.translatesAutoresizingMaskIntoConstraints = false
         xrView.isUserInteractionEnabled = false
@@ -72,23 +72,3 @@ class ViewController: UIViewController {
         view.addConstraints(NSLayoutConstraint.constraints(withVisualFormat: "V:|[xrView]|", options: [], metrics: nil, views: ["xrView" : xrView]))
     }
 }
-
-// MARK: MTKViewDelegate
-extension ViewController: MTKViewDelegate {
-    func draw(in view: MTKView) {
-        // Skip rendering until the layer has a valid drawable size, otherwise
-        // bgfx cannot acquire a drawable and Metal validation reports a render
-        // pass with no output textures.
-        guard view.drawableSize.width > 0, view.drawableSize.height > 0 else { return }
-        guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else { return }
-        xrView.isHidden = !(appDelegate._bridge?.isXRActive() ?? false)
-        appDelegate._bridge?.render()
-    }
-    
-    func mtkView(_ view: MTKView, drawableSizeWillChange size: CGSize) {
-        guard size.width > 0, size.height > 0 else { return }
-        guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else { return }
-        appDelegate._bridge?.resize(Int32(size.width), height: Int32(size.height))
-    }
-}
-
diff --git a/Apps/Playground/macOS/AppDelegate.m b/Apps/Playground/macOS/AppDelegate.mm
similarity index 100%
rename from Apps/Playground/macOS/AppDelegate.m
rename to Apps/Playground/macOS/AppDelegate.mm
diff --git a/Apps/Playground/macOS/ViewController.mm b/Apps/Playground/macOS/ViewController.mm
index a7eb1e6f2..0fd9d45d0 100644
--- a/Apps/Playground/macOS/ViewController.mm
+++ b/Apps/Playground/macOS/ViewController.mm
@@ -1,45 +1,21 @@
 #import "ViewController.h"
 
-#include <Shared/AppContext.h>
-#include <optional>
+#import <Babylon/Embedding/Apple/BabylonNativeEmbedding.h>
+#import "AppleShared/PlaygroundBootstrap.h"
 
 #import <MetalKit/MTKView.h>
 
-std::optional<AppContext> appContext{};
-
-@interface EngineView : MTKView <MTKViewDelegate>
-
-@end
-
-@implementation EngineView
-
-- (void)mtkView:(MTKView *)__unused view drawableSizeWillChange:(CGSize) size
-{
-    if (appContext) {
-        appContext->Device().FinishRenderingCurrentFrame();
-
-        appContext->Device().UpdateSize(static_cast<size_t>(size.width), static_cast<size_t>(size.height));
-
-        appContext->Device().StartRenderingCurrentFrame();
-    }
-}
-
-- (void)drawInMTKView:(MTKView *)__unused view
+@implementation ViewController
 {
-    if (appContext) {
-        appContext->Device().FinishRenderingCurrentFrame();
-        appContext->Device().StartRenderingCurrentFrame();
-    }
+    BNRuntime* _runtime;
+    BNView* _bnView;
+    MTKView* _mtkView;
 }
 
-@end
-
-@implementation ViewController
-
 - (void)viewDidLoad {
     [super viewDidLoad];
 
-    // Required for mouseMoved events.
+    // Required for mouseMoved events to be delivered to the view.
     NSTrackingArea* trackingArea = [
         [NSTrackingArea alloc]
         initWithRect:NSZeroRect
@@ -51,41 +27,46 @@ - (void)viewDidLoad {
 }
 
 - (void)uninitialize {
-    appContext.reset();
+    // Tear down View first (closes in-flight frame, unbinds the surface),
+    // then Runtime (joins the JS thread).
+    _bnView = nil;
+    _runtime = nil;
+    [_mtkView removeFromSuperview];
+    _mtkView = nil;
 }
 
 - (void)refreshBabylon {
     [self uninitialize];
 
-    EngineView* engineView = [[EngineView alloc] initWithFrame:[self view].frame device:nil];
-    engineView.autoresizingMask = NSViewWidthSizable | NSViewHeightSizable;
-    [[self view] addSubview:engineView];
-    engineView.delegate = engineView;
-    size_t width = static_cast<size_t>(engineView.drawableSize.width);
-    size_t height = static_cast<size_t>(engineView.drawableSize.height);
-
-    appContext.emplace(
-        (__bridge CA::MetalLayer*)engineView.layer,
-        width,
-        height,
-        [](const char* message)
-        {
-            NSLog(@"%s", message);
-        });
+    BNRuntimeOptions* options = [[BNRuntimeOptions alloc] init];
+    options.enableDebugger = YES;
+    options.enableDebugTrace = YES;
+    _runtime = [[BNRuntime alloc] initWithOptions:options];
+
+    [PlaygroundBootstrap loadScripts:_runtime];
 
-    NSArray *arguments = [[NSProcessInfo processInfo] arguments];
+    NSArray* arguments = [[NSProcessInfo processInfo] arguments];
     if (arguments.count == 1)
     {
-        appContext->ScriptLoader().LoadScript("app:///Scripts/experience.js");
+        [_runtime loadScript:@"app:///Scripts/experience.js"];
     }
     else
     {
-        for (NSUInteger i = 1; i < arguments.count; i++) {
-            appContext->ScriptLoader().LoadScript([arguments[i] UTF8String]);
+        for (NSUInteger i = 1; i < arguments.count; i++)
+        {
+            [_runtime loadScript:arguments[i]];
         }
-
-        appContext->ScriptLoader().LoadScript("app:///Scripts/playground_runner.js");
+        [_runtime loadScript:@"app:///Scripts/playground_runner.js"];
     }
+
+    _mtkView = [[MTKView alloc] initWithFrame:[self view].frame device:nil];
+    _mtkView.autoresizingMask = NSViewWidthSizable | NSViewHeightSizable;
+    [[self view] addSubview:_mtkView];
+
+    // BNView attaches the runtime to the MTKView and installs a default
+    // MTKViewDelegate that drives per-frame render. Resize is driven
+    // separately from -viewDidLayout below.
+    _bnView = [[BNView alloc] initWithRuntime:_runtime view:_mtkView];
 }
 
 - (void)viewDidAppear {
@@ -100,119 +81,91 @@ - (void)viewDidDisappear {
     [self uninitialize];
 }
 
-- (CGFloat)getScreenHeight {
-    return [self view].frame.size.height;
-}
+- (void)viewDidLayout {
+    [super viewDidLayout];
 
-- (void)mouseMoved:(NSEvent *) theEvent {
-    if (appContext && appContext->Input())
+    // Babylon Native owns the drawable size (BNView sets
+    // autoResizeDrawable = NO), so MTKView no longer reports size changes
+    // via its delegate. Drive resize explicitly from layout, passing
+    // logical points; BNView applies the device-pixel-ratio internally.
+    if (_bnView != nil)
     {
-        NSPoint eventLocation = [theEvent locationInWindow];
-        auto invertedY = [self getScreenHeight] - eventLocation.y;
-        CGFloat screenScale = [[NSScreen mainScreen] backingScaleFactor];
-        appContext->Input()->MouseMove(eventLocation.x * screenScale, invertedY * screenScale);
+        const CGSize size = _mtkView.bounds.size;
+        if (size.width > 0 && size.height > 0)
+        {
+            [_bnView resizeWithWidth:static_cast<NSUInteger>(size.width)
+                              height:static_cast<NSUInteger>(size.height)];
+        }
     }
 }
 
-- (void)mouseDown:(NSEvent *) theEvent {
-    if (appContext && appContext->Input())
-    {
-        NSPoint eventLocation = [theEvent locationInWindow];
-        auto invertedY = [self getScreenHeight] - eventLocation.y;
-        CGFloat screenScale = [[NSScreen mainScreen] backingScaleFactor];
-        appContext->Input()->MouseDown(Babylon::Plugins::NativeInput::LEFT_MOUSE_BUTTON_ID, eventLocation.x * screenScale, invertedY * screenScale);
-    }
+#pragma mark - Input forwarding
+
+// AppKit reports event locations in window coordinates with a bottom-left
+// origin; Babylon (CSS) expects top-left. Convert here and pass logical
+// pixels through unchanged — BNView handles device-pixel-ratio scaling.
+- (NSPoint)logicalPointFromEvent:(NSEvent*)event {
+    NSPoint location = [event locationInWindow];
+    CGFloat height = [self view].frame.size.height;
+    return NSMakePoint(location.x, height - location.y);
 }
 
-- (void)mouseDragged:(NSEvent *)theEvent {
-    if (appContext && appContext->Input())
-    {
-        NSPoint eventLocation = [theEvent locationInWindow];
-        auto invertedY = [self getScreenHeight] - eventLocation.y;
-        CGFloat screenScale = [[NSScreen mainScreen] backingScaleFactor];
-        appContext->Input()->MouseMove(eventLocation.x * screenScale, invertedY * screenScale);
-    }
+- (void)mouseMoved:(NSEvent*)theEvent {
+    NSPoint p = [self logicalPointFromEvent:theEvent];
+    [_bnView mouseMoveAtX:p.x y:p.y];
 }
 
-- (void)mouseUp:(NSEvent *) theEvent {
-    if (appContext && appContext->Input())
-    {
-        NSPoint eventLocation = [theEvent locationInWindow];
-        auto invertedY = [self getScreenHeight] - eventLocation.y;
-        CGFloat screenScale = [[NSScreen mainScreen] backingScaleFactor];
-        appContext->Input()->MouseUp(Babylon::Plugins::NativeInput::LEFT_MOUSE_BUTTON_ID, eventLocation.x * screenScale, invertedY * screenScale);
-    }
+- (void)mouseDown:(NSEvent*)theEvent {
+    NSPoint p = [self logicalPointFromEvent:theEvent];
+    [_bnView mouseDown:BNViewMouseButtonLeft atX:p.x y:p.y];
 }
 
-- (void)otherMouseDown:(NSEvent *) theEvent {
-    if (appContext && appContext->Input())
-    {
-        NSPoint eventLocation = [theEvent locationInWindow];
-        auto invertedY = [self getScreenHeight] - eventLocation.y;
-        CGFloat screenScale = [[NSScreen mainScreen] backingScaleFactor];
-        appContext->Input()->MouseDown(Babylon::Plugins::NativeInput::MIDDLE_MOUSE_BUTTON_ID, eventLocation.x * screenScale, invertedY * screenScale);
-    }
+- (void)mouseDragged:(NSEvent*)theEvent {
+    NSPoint p = [self logicalPointFromEvent:theEvent];
+    [_bnView mouseMoveAtX:p.x y:p.y];
 }
 
-- (void)otherMouseDragged:(NSEvent *)theEvent {
-    if (appContext && appContext->Input())
-    {
-        NSPoint eventLocation = [theEvent locationInWindow];
-        auto invertedY = [self getScreenHeight] - eventLocation.y;
-        CGFloat screenScale = [[NSScreen mainScreen] backingScaleFactor];
-        appContext->Input()->MouseMove(eventLocation.x * screenScale, invertedY * screenScale);
-    }
+- (void)mouseUp:(NSEvent*)theEvent {
+    NSPoint p = [self logicalPointFromEvent:theEvent];
+    [_bnView mouseUp:BNViewMouseButtonLeft atX:p.x y:p.y];
 }
 
-- (void)otherMouseUp:(NSEvent *) theEvent {
-    if (appContext && appContext->Input())
-    {
-        NSPoint eventLocation = [theEvent locationInWindow];
-        auto invertedY = [self getScreenHeight] - eventLocation.y;
-        CGFloat screenScale = [[NSScreen mainScreen] backingScaleFactor];
-        appContext->Input()->MouseUp(Babylon::Plugins::NativeInput::MIDDLE_MOUSE_BUTTON_ID, eventLocation.x * screenScale, invertedY * screenScale);
-    }
+- (void)otherMouseDown:(NSEvent*)theEvent {
+    NSPoint p = [self logicalPointFromEvent:theEvent];
+    [_bnView mouseDown:BNViewMouseButtonMiddle atX:p.x y:p.y];
 }
 
-- (void)rightMouseDown:(NSEvent *) theEvent {
-    if (appContext && appContext->Input())
-    {
-        NSPoint eventLocation = [theEvent locationInWindow];
-        auto invertedY = [self getScreenHeight] - eventLocation.y;
-        CGFloat screenScale = [[NSScreen mainScreen] backingScaleFactor];
-        appContext->Input()->MouseDown(Babylon::Plugins::NativeInput::RIGHT_MOUSE_BUTTON_ID, eventLocation.x * screenScale, invertedY * screenScale);
-    }
+- (void)otherMouseDragged:(NSEvent*)theEvent {
+    NSPoint p = [self logicalPointFromEvent:theEvent];
+    [_bnView mouseMoveAtX:p.x y:p.y];
 }
 
-- (void)rightMouseDragged:(NSEvent *)theEvent {
-    if (appContext && appContext->Input())
-    {
-        NSPoint eventLocation = [theEvent locationInWindow];
-        auto invertedY = [self getScreenHeight] - eventLocation.y;
-        CGFloat screenScale = [[NSScreen mainScreen] backingScaleFactor];
-        appContext->Input()->MouseMove(eventLocation.x * screenScale, invertedY * screenScale);
-    }
+- (void)otherMouseUp:(NSEvent*)theEvent {
+    NSPoint p = [self logicalPointFromEvent:theEvent];
+    [_bnView mouseUp:BNViewMouseButtonMiddle atX:p.x y:p.y];
 }
 
-- (void)rightMouseUp:(NSEvent *) theEvent {
-    if (appContext && appContext->Input())
-    {
-        NSPoint eventLocation = [theEvent locationInWindow];
-        auto invertedY = [self getScreenHeight] - eventLocation.y;
-        CGFloat screenScale = [[NSScreen mainScreen] backingScaleFactor];
-        appContext->Input()->MouseUp(Babylon::Plugins::NativeInput::RIGHT_MOUSE_BUTTON_ID, eventLocation.x * screenScale, invertedY * screenScale);
-    }
+- (void)rightMouseDown:(NSEvent*)theEvent {
+    NSPoint p = [self logicalPointFromEvent:theEvent];
+    [_bnView mouseDown:BNViewMouseButtonRight atX:p.x y:p.y];
 }
 
-- (void)scrollWheel:(NSEvent *) theEvent {
-    if (appContext && appContext->Input())
-    {
-        appContext->Input()->MouseWheel(Babylon::Plugins::NativeInput::MOUSEWHEEL_Y_ID, -theEvent.deltaY);
-    }
+- (void)rightMouseDragged:(NSEvent*)theEvent {
+    NSPoint p = [self logicalPointFromEvent:theEvent];
+    [_bnView mouseMoveAtX:p.x y:p.y];
 }
 
-- (IBAction)refresh:(id)__unused sender
-{
+- (void)rightMouseUp:(NSEvent*)theEvent {
+    NSPoint p = [self logicalPointFromEvent:theEvent];
+    [_bnView mouseUp:BNViewMouseButtonRight atX:p.x y:p.y];
+}
+
+- (void)scrollWheel:(NSEvent*)theEvent {
+    // Negate so scroll-up matches Babylon's negative-delta convention.
+    [_bnView mouseWheel:BNViewMouseWheelAxisY delta:-theEvent.deltaY];
+}
+
+- (IBAction)refresh:(id)__unused sender {
     [self refreshBabylon];
 }
 
diff --git a/Apps/Playground/macOS/main.mm b/Apps/Playground/macOS/main.mm
index d6965c2a2..2db32b7fb 100644
--- a/Apps/Playground/macOS/main.mm
+++ b/Apps/Playground/macOS/main.mm
@@ -1,12 +1,8 @@
 #import <Cocoa/Cocoa.h>
-#import <Babylon/DebugTrace.h>
 #import <Shared/Diagnostics.h>
 
 int main(int argc, const char * argv[]) {
     Diagnostics::Initialize();
 
-    Babylon::DebugTrace::EnableDebugTrace(true);
-    Babylon::DebugTrace::SetTraceOutput([](const char* trace) { NSLog(@"%s", trace); });
-
     return NSApplicationMain(argc, argv);
 }
diff --git a/Apps/Playground/visionOS/App.swift b/Apps/Playground/visionOS/App.swift
index 53607edf1..9179cba42 100644
--- a/Apps/Playground/visionOS/App.swift
+++ b/Apps/Playground/visionOS/App.swift
@@ -1,77 +1,132 @@
+// App.swift — visionOS Playground entry point.
+//
+// Built on the Babylon::Embedding Apple interop layer (BNRuntime /
+// BNView), the same one the iOS Playground uses. visionOS differs
+// from iOS in two small ways:
+//   1. SwiftUI app lifecycle (`@main App`) instead of
+//      `UIApplicationDelegate` — we own the BNRuntime as a top-level
+//      `@StateObject` and observe `scenePhase` for suspend/resume.
+//   2. No storyboards. `BabylonView` is a `UIViewRepresentable`
+//      wrapping an `MTKView`; BNView auto-installs its render delegate.
+
 import SwiftUI
+import MetalKit
+
+/// Owns the `BNRuntime` for the app's lifetime. Constructed once on
+/// app launch (so the JS engine + thread start immediately) and torn
+/// down with the app. Bootstrap scripts and the playground experience
+/// are queued here; they run after the first BNView attach inside
+/// `BabylonView` completes engine initialization on the JS thread.
+@MainActor
+final class BabylonRuntime: ObservableObject {
+    let bnRuntime: BNRuntime
+
+    init() {
+        let options = BNRuntimeOptions()
+        options.enableDebugger = true
+        options.enableDebugTrace = true
+        guard let bnRuntime = BNRuntime(options: options) else {
+            fatalError("Failed to construct BNRuntime")
+        }
+        self.bnRuntime = bnRuntime
 
-class MetalView: UIView {
-  override init(frame: CGRect) {
-    super.init(frame: frame)
-    self.backgroundColor = .clear
-  }
-  
-  required init?(coder: NSCoder) {
-    fatalError("init(coder:) has not been implemented")
-  }
-  
-  func setupMetalLayer() {
-    guard let bridge = LibNativeBridge.sharedInstance() else { return }
-    
-    if bridge.metalLayer != nil {
-      return
+        PlaygroundBootstrap.loadScripts(bnRuntime)
+        bnRuntime.loadScript("app:///Scripts/experience.js")
     }
-    
-    self.addGestureRecognizer(
-      UIBabylonGestureRecognizer(
-        target: self,
-        onTouchDown: bridge.setTouchDown,
-        onTouchMove: bridge.setTouchMove,
-        onTouchUp: bridge.setTouchUp
-      )
-    )
-    metalLayer.pixelFormat = .bgra8Unorm
-    metalLayer.framebufferOnly = true
-    
-    bridge.metalLayer = self.metalLayer
-    
-    let scale = UITraitCollection.current.displayScale
-    bridge.initialize(withWidth: Int(self.bounds.width * scale), height: Int(self.bounds.height * scale))
-  }
-  
-  var metalLayer: CAMetalLayer {
-    return layer as! CAMetalLayer
-  }
-  
-  override class var layerClass: AnyClass {
-    return CAMetalLayer.self
-  }
-  
-  override func layoutSubviews() {
-    super.layoutSubviews()
-    setupMetalLayer()
-    updateDrawableSize()
-  }
-  
-  private func updateDrawableSize() {
-    let scale = UITraitCollection.current.displayScale
-    LibNativeBridge.sharedInstance().drawableWillChangeSize(withWidth: Int(bounds.width * scale), height: Int(bounds.height * scale))
-    metalLayer.drawableSize = CGSize(width: bounds.width * scale, height: bounds.height * scale)
-  }
 }
 
-struct MetalViewRepresentable: UIViewRepresentable {
-  typealias UIViewType = MetalView
-  
-  func makeUIView(context: Context) -> MetalView {
-    MetalView(frame: .zero)
-  }
-  
-  func updateUIView(_ uiView: MetalView, context: Context) {}
+/// SwiftUI wrapper around the `MTKView` + `BNView` pair. BNView's
+/// auto-installed `BNViewDelegate` drives per-frame render; resize is
+/// driven from the MTKView's `layoutSubviews` (SwiftUI has no
+/// view-controller layout hook). We keep BNView alive for the lifetime
+/// of the MTKView (held in the Coordinator).
+struct BabylonView: UIViewRepresentable {
+    let runtime: BNRuntime
+
+    func makeCoordinator() -> Coordinator {
+        Coordinator()
+    }
+
+    func makeUIView(context: Context) -> MTKView {
+        let mtkView = BabylonMTKView()
+        let coordinator = context.coordinator
+
+        // First BNView attach on this runtime triggers GPU device
+        // construction + plugin initialization on the JS thread +
+        // queued-script flush.
+        coordinator.bnView = BNView(runtime: runtime, view: mtkView)
+
+        // Babylon Native owns the drawable size (BNView sets
+        // autoResizeDrawable = NO), so MTKView no longer reports size
+        // changes via its delegate. Drive resize from layout, passing
+        // logical points; BNView applies the device-pixel-ratio internally.
+        mtkView.onLayout = { [weak coordinator] size in
+            guard let bnView = coordinator?.bnView, size.width > 0, size.height > 0 else { return }
+            bnView.resize(width: UInt(size.width), height: UInt(size.height))
+        }
+
+        // Simple gesture recognizer: forwards touches to BNView. Same
+        // wiring as the iOS Playground.
+        let recognizer = UIBabylonGestureRecognizer(
+            target: coordinator,
+            onTouchDown: { [weak coordinator] (id, x, y) in
+                coordinator?.bnView?.pointerDown(id: Int(id), x: CGFloat(x), y: CGFloat(y))
+            },
+            onTouchMove: { [weak coordinator] (id, x, y) in
+                coordinator?.bnView?.pointerMove(id: Int(id), x: CGFloat(x), y: CGFloat(y))
+            },
+            onTouchUp: { [weak coordinator] (id, x, y) in
+                coordinator?.bnView?.pointerUp(id: Int(id), x: CGFloat(x), y: CGFloat(y))
+            }
+        )
+        mtkView.addGestureRecognizer(recognizer)
+
+        return mtkView
+    }
+
+    func updateUIView(_ uiView: MTKView, context: Context) {}
+
+    /// Holds the BNView strongly so it outlives `makeUIView`'s scope.
+    class Coordinator {
+        var bnView: BNView?
+    }
 }
 
+/// MTKView subclass that reports layout changes. SwiftUI has no
+/// view-controller layout hook, so we observe layout on the view itself
+/// to drive BNView resize — the same role `viewDidLayoutSubviews` plays
+/// on iOS and `viewDidLayout` on macOS.
+final class BabylonMTKView: MTKView {
+    var onLayout: ((CGSize) -> Void)?
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        onLayout?(bounds.size)
+    }
+}
 
 @main
 struct ExampleApp: App {
-  var body: some Scene {
-    WindowGroup {
-      MetalViewRepresentable()
-        .frame(maxWidth: .infinity, maxHeight: .infinity)
+    @StateObject private var runtime = BabylonRuntime()
+    @Environment(\.scenePhase) private var scenePhase
+
+    var body: some Scene {
+        WindowGroup {
+            BabylonView(runtime: runtime.bnRuntime)
+                .frame(maxWidth: .infinity, maxHeight: .infinity)
+                .onChange(of: scenePhase) { _, newPhase in
+                    // BNRuntime suspend/resume is refcounted, so this
+                    // composes safely with any other code that may
+                    // suspend the runtime (e.g. modal dialogs).
+                    switch newPhase {
+                    case .active:
+                        runtime.bnRuntime.resume()
+                    case .inactive, .background:
+                        runtime.bnRuntime.suspend()
+                    @unknown default:
+                        break
+                    }
+                }
+        }
     }
-  }
 }
diff --git a/Apps/Playground/visionOS/LibNativeBridge.h b/Apps/Playground/visionOS/LibNativeBridge.h
deleted file mode 100644
index 0489a7068..000000000
--- a/Apps/Playground/visionOS/LibNativeBridge.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#import <Foundation/Foundation.h>
-#import <CompositorServices/CompositorServices.h>
-
-@class CAMetalLayer;
-
-@interface LibNativeBridge : NSObject
-
-@property (nonatomic, assign, getter=isInitialized) BOOL initialized;
-@property (nonatomic, strong) CAMetalLayer *metalLayer;
-
-+ (instancetype)sharedInstance;
-
-- (void)setTouchDown:(int)pointerId x:(int)inX y:(int)inY;
-- (void)setTouchMove:(int)pointerId x:(int)inX y:(int)inY;
-- (void)setTouchUp:(int)pointerId x:(int)inX y:(int)inY;
-
-- (void)drawableWillChangeSizeWithWidth:(NSInteger)width height:(NSInteger)height;
-
-- (bool)initializeWithWidth:(NSInteger)width height:(NSInteger)height;
-- (void)shutdown;
-- (void)render;
-
-@end
-
diff --git a/Apps/Playground/visionOS/LibNativeBridge.mm b/Apps/Playground/visionOS/LibNativeBridge.mm
deleted file mode 100644
index c5a19a4b9..000000000
--- a/Apps/Playground/visionOS/LibNativeBridge.mm
+++ /dev/null
@@ -1,89 +0,0 @@
-#import "LibNativeBridge.h"
-#import <Shared/AppContext.h>
-
-@implementation LibNativeBridge {
-  std::optional<AppContext> _appContext;
-  CADisplayLink *_displayLink;
-}
-
-+ (instancetype)sharedInstance {
-  static LibNativeBridge *sharedInstance = nil;
-  static dispatch_once_t onceToken;
-  dispatch_once(&onceToken, ^{
-    sharedInstance = [[self alloc] init];
-  });
-  return sharedInstance;
-}
-
-- (bool)initializeWithWidth:(NSInteger)width height:(NSInteger)height {
-    if (self.initialized) {
-        return YES;
-    }
-  
-    _displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(render)];
-    [_displayLink addToRunLoop:NSRunLoop.mainRunLoop forMode:NSDefaultRunLoopMode];
-    
-    _appContext.emplace(
-        (__bridge CA::MetalLayer*)self.metalLayer,
-        static_cast<size_t>(width),
-        static_cast<size_t>(height),
-        [](const char* message) { NSLog(@"%s", message); });
-
-    _appContext->ScriptLoader().LoadScript("app:///Scripts/experience.js");
-
-    self.initialized = YES;
-    return true;
-}
-
-- (void)drawableWillChangeSizeWithWidth:(NSInteger)width height:(NSInteger)height {
-    if (_appContext) {
-        _appContext->Device().FinishRenderingCurrentFrame();
-
-        _appContext->Device().UpdateSize(static_cast<size_t>(width), static_cast<size_t>(height));
-
-        _appContext->Device().StartRenderingCurrentFrame();
-    }
-}
-
-- (void)setTouchDown:(int)pointerId x:(int)inX y:(int)inY {
-  if (_appContext && _appContext->Input()) {
-    _appContext->Input()->TouchDown(static_cast<int>(pointerId), static_cast<int>(inX), static_cast<int>(inY));
-  }
-}
-
-- (void)setTouchMove:(int)pointerId x:(int)inX y:(int)inY {
-  if (_appContext && _appContext->Input()) {
-    _appContext->Input()->TouchMove(static_cast<int>(pointerId), static_cast<int>(inX), static_cast<int>(inY));
-  }
-}
-
-- (void)setTouchUp:(int)pointerId x:(int)inX y:(int)inY {
-  if (_appContext && _appContext->Input()) {
-    _appContext->Input()->TouchUp(static_cast<int>(pointerId), static_cast<int>(inX), static_cast<int>(inY));
-  }
-}
-
-- (void)render {
-    if (_appContext && self.initialized) {
-        _appContext->Device().FinishRenderingCurrentFrame();
-        _appContext->Device().StartRenderingCurrentFrame();
-    }
-}
-
-- (void)shutdown {
-    if (!self.initialized) {
-        return;
-    }
-
-    _appContext.reset();
-
-    [_displayLink invalidate];
-    _displayLink = NULL;
-    self.initialized = NO;
-}
-
-- (void)dealloc {
-    [self shutdown];
-}
-
-@end
diff --git a/Apps/Playground/visionOS/Playground-Bridging-Header.h b/Apps/Playground/visionOS/Playground-Bridging-Header.h
new file mode 100644
index 000000000..5a9972399
--- /dev/null
+++ b/Apps/Playground/visionOS/Playground-Bridging-Header.h
@@ -0,0 +1,11 @@
+// Swift-Obj-C++ bridging header for the visionOS Playground app.
+//
+// Exposes both the Babylon::Embedding Apple interop layer
+// (`BNRuntime`, `BNView`) and the Playground-specific helper
+// (`PlaygroundBootstrap`) to the Swift sources.
+
+#pragma once
+
+#import <Babylon/Embedding/Apple/BabylonNativeEmbedding.h>
+
+#import "AppleShared/PlaygroundBootstrap.h"
diff --git a/CMakeLists.txt b/CMakeLists.txt
index ffe44c4de..8e23181a3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -136,8 +136,20 @@ option(BABYLON_NATIVE_PLUGIN_SHADERTOOL "Include Babylon Native Plugin ShaderToo
 option(BABYLON_NATIVE_PLUGIN_TESTUTILS "Include Babylon Native Plugin TestUtils." ON)
 
 # Polyfills
-option(BABYLON_NATIVE_POLYFILL_WINDOW "Include Babylon Native Polyfill Window." ON)
+option(BABYLON_NATIVE_POLYFILL_ABORTCONTROLLER "Include Babylon Native Polyfill AbortController." ON)
 option(BABYLON_NATIVE_POLYFILL_CANVAS "Include Babylon Native Polyfill Canvas." ON)
+option(BABYLON_NATIVE_POLYFILL_SCHEDULING "Include Babylon Native Polyfill Scheduling." ON)
+option(BABYLON_NATIVE_POLYFILL_URL "Include Babylon Native Polyfill URL." ON)
+option(BABYLON_NATIVE_POLYFILL_WEBSOCKET "Include Babylon Native Polyfill WebSocket." ON)
+option(BABYLON_NATIVE_POLYFILL_WINDOW "Include Babylon Native Polyfill Window." ON)
+
+# Embedding
+option(BABYLON_NATIVE_EMBEDDING "Build the cross-platform Babylon::Embedding facade (Runtime + View)." ON)
+option(BABYLON_NATIVE_EMBEDDING_ANDROID "Build the Android JNI interop layer for Babylon::Embedding." OFF)
+# Default ON for Apple platforms — the iOS Playground (and future
+# macOS / visionOS Playground migrations) consume it directly. Apple
+# hosts that don't want the interop layer can explicitly disable.
+option(BABYLON_NATIVE_EMBEDDING_APPLE "Build the Apple (iOS / macOS / visionOS) Obj-C++ interop layer for Babylon::Embedding." ${APPLE})
 
 # Sanitizers
 option(ENABLE_SANITIZERS "Enable AddressSanitizer and UBSan" OFF)
@@ -296,6 +308,10 @@ add_subdirectory(Core)
 add_subdirectory(Plugins)
 add_subdirectory(Polyfills)
 
+if(BABYLON_NATIVE_EMBEDDING)
+    add_subdirectory(Embedding)
+endif()
+
 if(BABYLON_NATIVE_BUILD_APPS)
     add_subdirectory(Apps)
 endif()
diff --git a/Core/Graphics/CMakeLists.txt b/Core/Graphics/CMakeLists.txt
index 6f3306998..690c83543 100644
--- a/Core/Graphics/CMakeLists.txt
+++ b/Core/Graphics/CMakeLists.txt
@@ -4,8 +4,9 @@ set(SOURCES
     "Include/Shared/Babylon/Graphics/Device.h"
     "InternalInclude/Babylon/Graphics/BgfxCallback.h"
     "InternalInclude/Babylon/Graphics/continuation_scheduler.h"
-    "InternalInclude/Babylon/Graphics/FrameBuffer.h"
     "InternalInclude/Babylon/Graphics/DeviceContext.h"
+    "InternalInclude/Babylon/Graphics/DeviceQueries.h"
+    "InternalInclude/Babylon/Graphics/FrameBuffer.h"
     "InternalInclude/Babylon/Graphics/Texture.h"
     "Source/BgfxCallback.cpp"
     "Source/FrameBuffer.cpp"
diff --git a/Core/Graphics/InternalInclude/Babylon/Graphics/DeviceQueries.h b/Core/Graphics/InternalInclude/Babylon/Graphics/DeviceQueries.h
new file mode 100644
index 000000000..51192c628
--- /dev/null
+++ b/Core/Graphics/InternalInclude/Babylon/Graphics/DeviceQueries.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <Babylon/Graphics/Platform.h>
+
+namespace Babylon::Graphics
+{
+    // Query the device-pixel-ratio for `window`. Free function so callers
+    // can obtain the ratio before a `Device` has been constructed (e.g.
+    // an interop layer converting physical → logical pixels for
+    // `Configuration::Width/Height` ahead of `Device::Device(config)`).
+    //
+    // For an existing Device, prefer `Device::GetDevicePixelRatio()` —
+    // that's this function's last-`UpdateWindow` return cached on the Device.
+    //
+    // Lives in InternalInclude/ to keep it off the public surface;
+    // reachable to in-tree consumers via the GraphicsDeviceContext target.
+    float GetDevicePixelRatio(WindowT window);
+}
diff --git a/Core/Graphics/Source/DeviceImpl.cpp b/Core/Graphics/Source/DeviceImpl.cpp
index 84783a606..3b449cd9d 100644
--- a/Core/Graphics/Source/DeviceImpl.cpp
+++ b/Core/Graphics/Source/DeviceImpl.cpp
@@ -1,5 +1,6 @@
 #include "DeviceImpl.h"
 
+#include <Babylon/Graphics/DeviceQueries.h>
 #include <Babylon/Graphics/Platform.h>
 #include <Babylon/Graphics/RendererType.h>
 #include <Babylon/JsRuntime.h>
@@ -49,6 +50,24 @@ namespace Babylon::Graphics
             init.type = s_bgfxRenderType;
         }
 
+        //
+        // init.platformData
+        //
+        // Configure the window/device BEFORE the resolution below. The
+        // first UpdateSize -> UpdateBgfxResolution syncs the render
+        // resolution onto the surface via ResizeRenderSurface, which reads
+        // m_state.Window — so the window must already be set. This also
+        // matches the re-attach ordering in ViewImpl::InitializeIfReady
+        // (UpdateWindow then UpdateSize).
+        //
+
+        UpdateWindow(config.Window);
+        UpdateDevice(config.Device);
+
+#ifdef GRAPHICS_BACK_BUFFER_SUPPORT
+        UpdateBackBuffer(config.BackBufferColor, config.BackBufferDepthStencil);
+#endif
+
         //
         // init.resolution
         //
@@ -73,17 +92,6 @@ namespace Babylon::Graphics
                 init.resolution.formatDepthStencil = bgfx::TextureFormat::D24S8;
                 break;
         }
-
-        //
-        // init.platformData
-        //
-
-        UpdateWindow(config.Window);
-        UpdateDevice(config.Device);
-
-#ifdef GRAPHICS_BACK_BUFFER_SUPPORT
-        UpdateBackBuffer(config.BackBufferColor, config.BackBufferDepthStencil);
-#endif
     }
 
     DeviceImpl::~DeviceImpl()
@@ -99,9 +107,10 @@ namespace Babylon::Graphics
     void DeviceImpl::UpdateWindow(WindowT window)
     {
         std::scoped_lock lock{m_state.Mutex};
+        m_state.Window = window;
         ConfigureBgfxPlatformData(m_state.Bgfx.InitState.platformData, window);
         ConfigureBgfxRenderType(m_state.Bgfx.InitState.platformData, m_state.Bgfx.InitState.type);
-        m_state.Resolution.DevicePixelRatio = GetDevicePixelRatio(window);
+        m_state.Resolution.DevicePixelRatio = Babylon::Graphics::GetDevicePixelRatio(window);
         m_state.Bgfx.Dirty = true;
     }
 
@@ -493,6 +502,11 @@ namespace Babylon::Graphics
         res.width = static_cast<uint32_t>(m_state.Resolution.Width / level);
         res.height = static_cast<uint32_t>(m_state.Resolution.Height / level);
         m_state.Bgfx.Dirty = true;
+
+        // Keep the native rendering surface in sync with the render resolution
+        // we just computed (platform/graphics-API specific; no-op where the
+        // surface size is driven elsewhere).
+        ResizeRenderSurface(m_state.Window, res.width, res.height);
     }
 
     void DeviceImpl::RequestScreenShots()
diff --git a/Core/Graphics/Source/DeviceImpl.h b/Core/Graphics/Source/DeviceImpl.h
index 9e2caf933..8f86412ba 100644
--- a/Core/Graphics/Source/DeviceImpl.h
+++ b/Core/Graphics/Source/DeviceImpl.h
@@ -118,7 +118,12 @@ namespace Babylon::Graphics
         static const bgfx::RendererType::Enum s_bgfxRenderType;
         static void ConfigureBgfxPlatformData(bgfx::PlatformData& pd, WindowT window);
         static void ConfigureBgfxRenderType(bgfx::PlatformData& pd, bgfx::RendererType::Enum& renderType);
-        static float GetDevicePixelRatio(WindowT window);
+
+        // Push the render resolution onto the native rendering surface so it
+        // matches what bgfx renders into. Implemented per graphics API. The
+        // window may be default-constructed (null) before UpdateWindow has run
+        // (e.g. during construction), in which case there's nothing to size.
+        static void ResizeRenderSurface(WindowT window, uint32_t width, uint32_t height);
 
         void UpdateBgfxState();
         void UpdateBgfxResolution();
@@ -146,6 +151,13 @@ namespace Babylon::Graphics
             // Mutable since const getters need to lock.
             mutable std::recursive_mutex Mutex{};
 
+            // The native window/surface we render into. Cached as WindowT (the
+            // handle in Bgfx.InitState.platformData is type-erased to void* and
+            // can't be cast back to WindowT portably) so ResizeRenderSurface can
+            // push the render resolution onto the surface. Null until
+            // UpdateWindow.
+            WindowT Window{};
+
             struct
             {
                 bgfx::Init InitState{};
diff --git a/Core/Graphics/Source/DeviceImpl_Android.cpp b/Core/Graphics/Source/DeviceImpl_Android.cpp
index 200eb39c1..9be4ac111 100644
--- a/Core/Graphics/Source/DeviceImpl_Android.cpp
+++ b/Core/Graphics/Source/DeviceImpl_Android.cpp
@@ -1,4 +1,5 @@
 #include <Babylon/Graphics/Platform.h>
+#include <Babylon/Graphics/DeviceQueries.h>
 #include "DeviceImpl.h"
 
 #include <AndroidExtensions/Globals.h>
@@ -20,7 +21,7 @@ namespace Babylon::Graphics
         }
     }
 
-    float DeviceImpl::GetDevicePixelRatio(WindowT)
+    float GetDevicePixelRatio(WindowT)
     {
         // In Android, the baseline DPI is 160dpi.
         // See https://developer.android.com/training/multiscreen/screendensities#dips-pels
diff --git a/Core/Graphics/Source/DeviceImpl_D3D11.cpp b/Core/Graphics/Source/DeviceImpl_D3D11.cpp
index 067774aef..ab94e5747 100644
--- a/Core/Graphics/Source/DeviceImpl_D3D11.cpp
+++ b/Core/Graphics/Source/DeviceImpl_D3D11.cpp
@@ -9,4 +9,9 @@ namespace Babylon::Graphics
     {
         return {static_cast<DeviceT>(bgfx::getInternalData()->context)};
     }
+
+    void DeviceImpl::ResizeRenderSurface(WindowT /*window*/, uint32_t /*width*/, uint32_t /*height*/)
+    {
+        // No-op: the swap chain size is managed elsewhere on this platform.
+    }
 }
diff --git a/Core/Graphics/Source/DeviceImpl_D3D12.cpp b/Core/Graphics/Source/DeviceImpl_D3D12.cpp
index 2a8357651..b34c50727 100644
--- a/Core/Graphics/Source/DeviceImpl_D3D12.cpp
+++ b/Core/Graphics/Source/DeviceImpl_D3D12.cpp
@@ -9,4 +9,9 @@ namespace Babylon::Graphics
     {
         return {static_cast<DeviceT>(bgfx::getInternalData()->context)};
     }
+
+    void DeviceImpl::ResizeRenderSurface(WindowT /*window*/, uint32_t /*width*/, uint32_t /*height*/)
+    {
+        // No-op: the swap chain size is managed elsewhere on this platform.
+    }
 }
diff --git a/Core/Graphics/Source/DeviceImpl_Metal.mm b/Core/Graphics/Source/DeviceImpl_Metal.mm
index 1f58fcc91..f9f2ae110 100644
--- a/Core/Graphics/Source/DeviceImpl_Metal.mm
+++ b/Core/Graphics/Source/DeviceImpl_Metal.mm
@@ -13,4 +13,17 @@
             reinterpret_cast<MTL::CommandQueue*>(internalData->commandQueue),
         };
     }
+
+    void DeviceImpl::ResizeRenderSurface(WindowT window, uint32_t width, uint32_t height)
+    {
+        // The window is the CAMetalLayer we render into. Resize its drawable to
+        // match the render resolution bgfx will use so the backbuffer and the
+        // layer stay in lockstep (e.g. across hardware scaling level changes).
+        // The window is null before the first UpdateWindow (e.g. during
+        // construction), in which case there's nothing to size.
+        if (window != nullptr)
+        {
+            window->setDrawableSize(CGSizeMake(static_cast<CGFloat>(width), static_cast<CGFloat>(height)));
+        }
+    }
 }
diff --git a/Core/Graphics/Source/DeviceImpl_OpenGL.cpp b/Core/Graphics/Source/DeviceImpl_OpenGL.cpp
index 618000a06..8f2e39fc2 100644
--- a/Core/Graphics/Source/DeviceImpl_OpenGL.cpp
+++ b/Core/Graphics/Source/DeviceImpl_OpenGL.cpp
@@ -9,4 +9,9 @@ namespace Babylon::Graphics
     {
         return {static_cast<DeviceT>(bgfx::getInternalData()->context)};
     }
+
+    void DeviceImpl::ResizeRenderSurface(WindowT /*window*/, uint32_t /*width*/, uint32_t /*height*/)
+    {
+        // No-op: the surface size is managed elsewhere on this platform.
+    }
 }
diff --git a/Core/Graphics/Source/DeviceImpl_Unix.cpp b/Core/Graphics/Source/DeviceImpl_Unix.cpp
index 4a39ddd99..0cc734718 100644
--- a/Core/Graphics/Source/DeviceImpl_Unix.cpp
+++ b/Core/Graphics/Source/DeviceImpl_Unix.cpp
@@ -1,6 +1,12 @@
 #include <Babylon/Graphics/Platform.h>
+#include <Babylon/Graphics/DeviceQueries.h>
 #include "DeviceImpl.h"
 
+#include <X11/Xresource.h>
+
+#include <cmath>
+#include <cstdlib>
+
 namespace Babylon::Graphics
 {
     void DeviceImpl::ConfigureBgfxPlatformData(bgfx::PlatformData& pd, WindowT window)
@@ -12,30 +18,70 @@ namespace Babylon::Graphics
     {
     }
 
-    float DeviceImpl::GetDevicePixelRatio(WindowT)
+    float GetDevicePixelRatio(WindowT)
     {
+        // The device pixel ratio is the desktop environment's scale factor
+        // (physical pixels per logical pixel), not the raw monitor pixel
+        // density. On X11 the configured scale is published as the "Xft.dpi"
+        // X resource (set by GNOME/KDE and tools such as xrandr/xsettingsd),
+        // so DPR = Xft.dpi / 96.
+        //
+        // We deliberately avoid deriving the ratio from DisplayWidthMM/EDID:
+        // physical-size reporting is unreliable, is absent under Xvfb, and
+        // pixel density is not the same thing as the user's chosen scale.
+        //
+        // Falls back to GDK_SCALE, then to 1.0 when nothing is configured
+        // (e.g. Xvfb, plain X sessions). The result is rounded to the nearest
+        // quarter so a value such as 96.02 dpi resolves to an exact 1.0 rather
+        // than 1.0002 (which would otherwise shrink a 600 px surface to 599 px).
+        //
         // TODO: We should persist a Display object instead of opening a new display.
         // See https://github.com/BabylonJS/BabylonNative/issues/625
 
-        auto display = XOpenDisplay(nullptr);
-        auto screen = DefaultScreen(display);
+        const auto roundToQuarter = [](float value) {
+            return std::round(value * 4.0f) / 4.0f;
+        };
 
-        auto width = DisplayWidthMM(display, screen);
-        auto pixelWidth = DisplayWidth(display, screen);
+        if (Display* display = XOpenDisplay(nullptr))
+        {
+            float dpr = 0.0f;
 
-        XCloseDisplay(display);
+            if (const char* resourceString = XResourceManagerString(display))
+            {
+                XrmInitialize();
+                if (XrmDatabase database = XrmGetStringDatabase(resourceString))
+                {
+                    char* type = nullptr;
+                    XrmValue value{};
+                    if (XrmGetResource(database, "Xft.dpi", "Xft.Dpi", &type, &value) && value.addr != nullptr)
+                    {
+                        const float dpi = std::strtof(value.addr, nullptr);
+                        if (dpi > 0.0f)
+                        {
+                            dpr = dpi / 96.0f;
+                        }
+                    }
+                    XrmDestroyDatabase(database);
+                }
+            }
 
-        if (width > 0)
-        {
-            constexpr float MILLIMETERS_TO_INCHES = 0.03937f;
-            auto dpi = pixelWidth / (width * MILLIMETERS_TO_INCHES);
+            XCloseDisplay(display);
 
-            // X11 does not enforce a default dpi.
-            // Use 96 dpi as our baseline DPI to match the behavior of Windows, and the default behavior of Linux Desktop Environments such as Gnome and KDE.
-            // See: https://scanline.ca/dpi/
-            return dpi / 96.0f;
+            if (dpr > 0.0f)
+            {
+                return roundToQuarter(dpr);
+            }
+        }
+
+        if (const char* gdkScale = std::getenv("GDK_SCALE"))
+        {
+            const float scale = std::strtof(gdkScale, nullptr);
+            if (scale > 0.0f)
+            {
+                return roundToQuarter(scale);
+            }
         }
 
-        return 1;
+        return 1.0f;
     }
-}
\ No newline at end of file
+}
diff --git a/Core/Graphics/Source/DeviceImpl_Win32.cpp b/Core/Graphics/Source/DeviceImpl_Win32.cpp
index 13464993f..63e6f0c33 100644
--- a/Core/Graphics/Source/DeviceImpl_Win32.cpp
+++ b/Core/Graphics/Source/DeviceImpl_Win32.cpp
@@ -1,4 +1,5 @@
 #include <Babylon/Graphics/Platform.h>
+#include <Babylon/Graphics/DeviceQueries.h>
 #include "DeviceImpl.h"
 #include <Windows.h>
 
@@ -13,7 +14,7 @@ namespace Babylon::Graphics
     {
     }
 
-    float DeviceImpl::GetDevicePixelRatio(WindowT window)
+    float GetDevicePixelRatio(WindowT window)
     {
         UINT dpi = GetDpiForWindow(window);
 
diff --git a/Core/Graphics/Source/DeviceImpl_WinRT.cpp b/Core/Graphics/Source/DeviceImpl_WinRT.cpp
index c813a32ec..e91bb6f5c 100644
--- a/Core/Graphics/Source/DeviceImpl_WinRT.cpp
+++ b/Core/Graphics/Source/DeviceImpl_WinRT.cpp
@@ -1,4 +1,5 @@
 #include <Babylon/Graphics/Platform.h>
+#include <Babylon/Graphics/DeviceQueries.h>
 #include "DeviceImpl.h"
 #include <Windows.UI.Core.h>
 #include <Windows.UI.Xaml.Controls.h>
@@ -24,7 +25,7 @@ namespace Babylon::Graphics
     {
     }
 
-    float DeviceImpl::GetDevicePixelRatio(WindowT window)
+    float GetDevicePixelRatio(WindowT window)
     {
         if (auto uiElement = window.try_as<ABI::Microsoft::UI::Xaml::IUIElement>())
         {
diff --git a/Core/Graphics/Source/DeviceImpl_iOS.mm b/Core/Graphics/Source/DeviceImpl_iOS.mm
index 011ce2692..8c1f900a5 100644
--- a/Core/Graphics/Source/DeviceImpl_iOS.mm
+++ b/Core/Graphics/Source/DeviceImpl_iOS.mm
@@ -1,5 +1,6 @@
 #include <cmath>
 #include <Babylon/Graphics/Platform.h>
+#include <Babylon/Graphics/DeviceQueries.h>
 #include "DeviceImpl.h"
 
 #import <QuartzCore/QuartzCore.h>
@@ -25,7 +26,7 @@ bool IsValidScale(float scale)
     {
     }
 
-    float DeviceImpl::GetDevicePixelRatio(WindowT window)
+    float GetDevicePixelRatio(WindowT window)
     {
         // contentsScale can return 0 if it hasn't been set yet.
         float scale = static_cast<float>(((CAMetalLayer*)window).contentsScale);
diff --git a/Core/Graphics/Source/DeviceImpl_macOS.mm b/Core/Graphics/Source/DeviceImpl_macOS.mm
index a589d9e14..4027c7cb9 100644
--- a/Core/Graphics/Source/DeviceImpl_macOS.mm
+++ b/Core/Graphics/Source/DeviceImpl_macOS.mm
@@ -1,5 +1,6 @@
 #include <cmath>
 #include <Babylon/Graphics/Platform.h>
+#include <Babylon/Graphics/DeviceQueries.h>
 #include "DeviceImpl.h"
 
 #import <AppKit/AppKit.h>
@@ -16,7 +17,7 @@
     {
     }
 
-    float DeviceImpl::GetDevicePixelRatio(WindowT window)
+    float GetDevicePixelRatio(WindowT window)
     {
         float scale = static_cast<float>(((CAMetalLayer*)window).contentsScale);
         if (std::isinf(scale) || scale <= 0)
diff --git a/Core/Graphics/Source/DeviceImpl_visionOS.mm b/Core/Graphics/Source/DeviceImpl_visionOS.mm
index e156145b2..1fb5c3dd3 100644
--- a/Core/Graphics/Source/DeviceImpl_visionOS.mm
+++ b/Core/Graphics/Source/DeviceImpl_visionOS.mm
@@ -1,4 +1,5 @@
 #include <Babylon/Graphics/Platform.h>
+#include <Babylon/Graphics/DeviceQueries.h>
 #include "DeviceImpl.h"
 
 namespace Babylon::Graphics
@@ -12,7 +13,7 @@
     {
     }
 
-    float DeviceImpl::GetDevicePixelRatio(WindowT)
+    float GetDevicePixelRatio(WindowT)
     {
       return [UITraitCollection currentTraitCollection].displayScale;
     }
diff --git a/Dependencies/CMakeLists.txt b/Dependencies/CMakeLists.txt
index 23040702a..58a82367f 100644
--- a/Dependencies/CMakeLists.txt
+++ b/Dependencies/CMakeLists.txt
@@ -208,27 +208,23 @@ if(APPLE)
         message(FATAL_ERROR "Failed to generate metal-cpp single header")
     endif()
 
-    # Generate source that includes the single header with the necessary implementation defines.
-    file(WRITE "${METAL_CPP_GENERATED_DIR}/Source/Metal.cpp"
-        "#define NS_PRIVATE_IMPLEMENTATION\n"
-        "#define MTL_PRIVATE_IMPLEMENTATION\n"
-        "#define CA_PRIVATE_IMPLEMENTATION\n"
-        "#include <Metal/Metal.hpp>\n")
-
-    set(SOURCES
-        "${METAL_CPP_GENERATED_DIR}/Include/Metal/Metal.hpp"
-        "${METAL_CPP_GENERATED_DIR}/Source/Metal.cpp")
-
-    add_library(metal-cpp ${SOURCES})
-    target_include_directories(metal-cpp SYSTEM PUBLIC "${METAL_CPP_GENERATED_DIR}/Include")
+    # metal-cpp is consumed as a header-only library. The metal-cpp
+    # implementation (the NS / MTL / CA `*_PRIVATE_IMPLEMENTATION` globals) is
+    # already compiled into bgfx's Metal renderer, which embeds and builds its
+    # own copy of metal-cpp (see bgfx's renderer_mtl.cpp). Compiling a second
+    # copy here would define those globals in both libmetal-cpp.a and libbgfx.a;
+    # whether that produces ~1900 "duplicate symbol" link errors then depends
+    # purely on the (fragile) order in which the two static archives appear on
+    # the link line. We instead expose metal-cpp as headers only and let the
+    # single bgfx-provided implementation satisfy the symbols at link time.
+    # Graphics — the only consumer — always links bgfx on Apple, so the
+    # implementation symbols always resolve.
+    add_library(metal-cpp INTERFACE)
+    target_include_directories(metal-cpp SYSTEM INTERFACE "${METAL_CPP_GENERATED_DIR}/Include")
     target_link_libraries(metal-cpp
-        PRIVATE "-framework Foundation"
-        PRIVATE "-framework Metal"
-        PRIVATE "-framework QuartzCore")
-
-    source_group(TREE "${metal-cpp_SOURCE_DIR}" FILES ${METAL_CPP_HEADERS})
-    source_group(TREE "${METAL_CPP_GENERATED_DIR}" FILES ${SOURCES})
-    set_property(TARGET metal-cpp PROPERTY FOLDER Dependencies)
+        INTERFACE "-framework Foundation"
+        INTERFACE "-framework Metal"
+        INTERFACE "-framework QuartzCore")
 endif()
 
 # --------------------------------------------------
diff --git a/Embedding/Android/CMakeLists.txt b/Embedding/Android/CMakeLists.txt
new file mode 100644
index 000000000..fa820b076
--- /dev/null
+++ b/Embedding/Android/CMakeLists.txt
@@ -0,0 +1,39 @@
+# Babylon::Embedding Android interop layer.
+#
+# Builds a shared library (`libBabylonNativeEmbedding.so`) containing
+# the JNI entry points declared in `BabylonNative.kt`. The host's
+# Android Studio / Gradle project consumes this CMakeLists via its
+# `externalNativeBuild { cmake { path "..." } }` hookup, alongside
+# adding `src/main/java/` to its `sourceSets`.
+#
+# Gated by BABYLON_NATIVE_EMBEDDING_ANDROID at the root.
+
+if(NOT ANDROID)
+    message(FATAL_ERROR
+        "Embedding/Android is Android-only. "
+        "Disable BABYLON_NATIVE_EMBEDDING_ANDROID for non-Android builds.")
+endif()
+
+set(ANDROID_EMBEDDING_INCLUDE_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../Include/Platform/Android")
+
+set(SOURCES
+    "${ANDROID_EMBEDDING_INCLUDE_ROOT}/Babylon/Embedding/Android/RuntimeHandle.h"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/main/cpp/BabylonNativeEmbedding.cpp")
+
+add_library(BabylonNativeEmbedding SHARED ${SOURCES})
+
+warnings_as_errors(BabylonNativeEmbedding)
+
+target_include_directories(BabylonNativeEmbedding PUBLIC "${ANDROID_EMBEDDING_INCLUDE_ROOT}")
+
+target_link_libraries(BabylonNativeEmbedding
+    PRIVATE Embedding
+    PRIVATE AndroidExtensions
+    PRIVATE android   # ANativeWindow_fromSurface
+    PRIVATE log
+    PRIVATE EGL       # required by bgfx GL backend
+    PRIVATE GLESv3
+    PRIVATE -lz)
+
+set_property(TARGET BabylonNativeEmbedding PROPERTY FOLDER Embedding)
+source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}/.." FILES ${SOURCES})
diff --git a/Embedding/Android/src/main/cpp/BabylonNativeEmbedding.cpp b/Embedding/Android/src/main/cpp/BabylonNativeEmbedding.cpp
new file mode 100644
index 000000000..4e506e025
--- /dev/null
+++ b/Embedding/Android/src/main/cpp/BabylonNativeEmbedding.cpp
@@ -0,0 +1,580 @@
+// JNI interop for Babylon::Embedding on Android.
+//
+// This file is the C++ side of the Android interop layer. It exposes
+// `extern "C" JNIEXPORT` entry points that any JVM-language host can call
+// via matching `external fun` / `native` declarations.
+//
+// We deliberately ship no Kotlin/Java class library on top — interop ends
+// at "Kotlin/Java can call into Babylon".
+//
+// Convention: opaque C++ pointers cross JNI as `jlong`.
+// `unique_ptr::release()` transfers ownership to the JVM side; the
+// matching `*Destroy` function `delete`s the raw pointer.
+//
+// Symbols here follow `Java_com_babylonjs_embedding_BabylonNative_*`.
+// Hosts can use any class name as long as Java signatures match.
+
+#include <Babylon/Embedding/Runtime.h>
+#include <Babylon/Embedding/View.h>
+#include <Babylon/Embedding/Android/RuntimeHandle.h>
+
+#include <AndroidExtensions/Globals.h>
+
+#include <android/log.h>
+#include <android/native_window.h>
+#include <android/native_window_jni.h>
+
+#include <jni.h>
+
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace
+{
+    using Babylon::Embedding::LogLevel;
+    using Babylon::Embedding::Runtime;
+    using Babylon::Embedding::RuntimeOptions;
+    using Babylon::Embedding::View;
+
+    // Wraps a Runtime plus two `android::global` event tickets that
+    // auto-Suspend/Resume on Activity lifecycle. Tickets are declared
+    // AFTER the Runtime so they're destroyed BEFORE it — guaranteeing no
+    // callback fires on a dead Runtime during teardown.
+    //
+    // Runtime is held by unique_ptr so its address is stable for the
+    // ticket lambdas (the tickets aren't move-assignable, so we have to
+    // know the address before constructing the wrapper).
+    //
+    // Runtime::Suspend/Resume are refcounted, so this composes safely
+    // with explicit host-side runtimeSuspend / runtimeResume calls.
+    struct AndroidRuntime
+    {
+        std::unique_ptr<Runtime> runtime;
+        android::global::AppStateChangedCallbackTicket pauseTicket;
+        android::global::AppStateChangedCallbackTicket resumeTicket;
+
+#if BABYLON_NATIVE_PLUGIN_NATIVEXR
+        // The ANativeWindow currently handed to Runtime::SetXrWindow.
+        // NativeXr stores the raw pointer without acquiring a reference (and
+        // only consumes it lazily at XR session creation on the JS thread),
+        // so the JNI layer owns this reference: it's acquired via
+        // ANativeWindow_fromSurface in runtimeSetXrSurface, released and
+        // replaced when the surface changes, and released in runtimeDestroy
+        // after the Runtime (and thus NativeXr) is torn down.
+        ANativeWindow* xrWindow{nullptr};
+#endif
+    };
+
+    AndroidRuntime* AsAndroidRuntime(jlong handle) { return reinterpret_cast<AndroidRuntime*>(handle); }
+    Runtime* AsRuntime(jlong handle) { return AsAndroidRuntime(handle)->runtime.get(); }
+    View* AsView(jlong handle) { return reinterpret_cast<View*>(handle); }
+
+    int LogPriorityFor(LogLevel level)
+    {
+        switch (level)
+        {
+            case LogLevel::Verbose: return ANDROID_LOG_VERBOSE;
+            case LogLevel::Log:     return ANDROID_LOG_INFO;
+            case LogLevel::Warn:    return ANDROID_LOG_WARN;
+            case LogLevel::Error:   return ANDROID_LOG_ERROR;
+            case LogLevel::Fatal:   return ANDROID_LOG_FATAL;
+        }
+        return ANDROID_LOG_INFO;
+    }
+
+    // Convert a jstring to std::string. Returns empty string if `jstr`
+    // is null or UTF lookup fails.
+    std::string ToStdString(JNIEnv* env, jstring jstr)
+    {
+        if (jstr == nullptr)
+        {
+            return {};
+        }
+        const char* utf = env->GetStringUTFChars(jstr, nullptr);
+        if (utf == nullptr)
+        {
+            return {};
+        }
+        std::string result{utf};
+        env->ReleaseStringUTFChars(jstr, utf);
+        return result;
+    }
+
+    // Throws a Java IllegalStateException. Used when a plugin wasn't
+    // compiled in, so the misconfiguration surfaces as a clean Java
+    // exception rather than UnsatisfiedLinkError or silent no-op.
+    // [[maybe_unused]]: when every plugin flag is enabled no `#else`
+    // branch references this and -Werror=unused-function would fail.
+    [[maybe_unused]] void ThrowPluginNotEnabled(JNIEnv* env, const char* message)
+    {
+        jclass excClass = env->FindClass("java/lang/IllegalStateException");
+        if (excClass != nullptr)
+        {
+            env->ThrowNew(excClass, message);
+        }
+    }
+
+    bool ApplyJavaRuntimeOptions(JNIEnv* env, jobject javaOptions, RuntimeOptions& options)
+    {
+        if (javaOptions == nullptr)
+        {
+            return true;
+        }
+
+        jclass optionsClass = env->GetObjectClass(javaOptions);
+        if (optionsClass == nullptr)
+        {
+            return false;
+        }
+
+        auto readBoolean = [&](const char* name, bool& target) {
+            jfieldID field = env->GetFieldID(optionsClass, name, "Z");
+            if (field == nullptr)
+            {
+                return false;
+            }
+            target = env->GetBooleanField(javaOptions, field) == JNI_TRUE;
+            return true;
+        };
+
+        if (!readBoolean("enableDebugger", options.enableDebugger) ||
+            !readBoolean("enableDebugTrace", options.enableDebugTrace) ||
+            !readBoolean("waitForDebugger", options.waitForDebugger))
+        {
+            env->DeleteLocalRef(optionsClass);
+            return false;
+        }
+
+        jfieldID msaaSamplesField = env->GetFieldID(optionsClass, "msaaSamples", "Ljava/lang/Integer;");
+        if (msaaSamplesField == nullptr)
+        {
+            env->DeleteLocalRef(optionsClass);
+            return false;
+        }
+
+        jobject msaaSamples = env->GetObjectField(javaOptions, msaaSamplesField);
+        if (msaaSamples != nullptr)
+        {
+            jclass integerClass = env->GetObjectClass(msaaSamples);
+            if (integerClass == nullptr)
+            {
+                env->DeleteLocalRef(msaaSamples);
+                env->DeleteLocalRef(optionsClass);
+                return false;
+            }
+
+            jmethodID intValue = env->GetMethodID(integerClass, "intValue", "()I");
+            if (intValue == nullptr)
+            {
+                env->DeleteLocalRef(integerClass);
+                env->DeleteLocalRef(msaaSamples);
+                env->DeleteLocalRef(optionsClass);
+                return false;
+            }
+
+            const jint value = env->CallIntMethod(msaaSamples, intValue);
+            options.msaaSamples = value >= 0 && value <= 255 ? static_cast<uint8_t>(value) : 0;
+            env->DeleteLocalRef(integerClass);
+            env->DeleteLocalRef(msaaSamples);
+        }
+
+        jfieldID shaderCachePathField = env->GetFieldID(optionsClass, "shaderCachePath", "Ljava/lang/String;");
+        if (shaderCachePathField == nullptr)
+        {
+            env->DeleteLocalRef(optionsClass);
+            return false;
+        }
+
+        auto shaderCachePath = static_cast<jstring>(env->GetObjectField(javaOptions, shaderCachePathField));
+        if (shaderCachePath != nullptr)
+        {
+#if BABYLON_NATIVE_PLUGIN_SHADERCACHE
+            options.shaderCachePath = ToStdString(env, shaderCachePath);
+            env->DeleteLocalRef(shaderCachePath);
+            if (env->ExceptionCheck())
+            {
+                env->DeleteLocalRef(optionsClass);
+                return false;
+            }
+#else
+            env->DeleteLocalRef(shaderCachePath);
+            env->DeleteLocalRef(optionsClass);
+            ThrowPluginNotEnabled(env,
+                "shaderCachePath was provided but BABYLON_NATIVE_PLUGIN_SHADERCACHE "
+                "was not enabled at native build time.");
+            return false;
+#endif
+        }
+
+        env->DeleteLocalRef(optionsClass);
+        return true;
+    }
+
+    // Shared body for the runtimeCreate JNI overloads. Installs the
+    // default logcat sink, constructs the Runtime, and registers
+    // Activity-lifecycle auto-Suspend/Resume tickets.
+    jlong MakeRuntimeHandle(RuntimeOptions options)
+    {
+        options.log = [](LogLevel level, std::string_view message) {
+            // logcat needs a NUL-terminated C string.
+            std::string text{message};
+            __android_log_write(LogPriorityFor(level), "BabylonNative", text.c_str());
+        };
+
+        auto runtime = std::make_unique<Runtime>(std::move(options));
+        Runtime* runtimePtr = runtime.get();
+
+        // Auto-Suspend/Resume on process-wide Activity lifecycle. Hosts
+        // call androidGlobalPause/Resume once per state change; every
+        // Runtime in the process reacts. Refcounted, so composes with
+        // any host-side explicit suspend/resume.
+        auto pauseTicket = android::global::AddPauseCallback([runtimePtr]() {
+            runtimePtr->Suspend();
+        });
+        auto resumeTicket = android::global::AddResumeCallback([runtimePtr]() {
+            runtimePtr->Resume();
+        });
+
+        auto wrapper = std::unique_ptr<AndroidRuntime>{new AndroidRuntime{
+            std::move(runtime),
+            std::move(pauseTicket),
+            std::move(resumeTicket),
+        }};
+
+        // Ownership transfers to the JVM side via the returned jlong.
+        return reinterpret_cast<jlong>(wrapper.release());
+    }
+}
+
+// Public handle-decoding entry point. Hosts that ship app-specific JNI
+// helpers in `libBabylonNativeEmbedding.so` must use this rather than
+// `reinterpret_cast<Runtime*>(handle)`, because each Runtime is wrapped
+// in `AndroidRuntime` to hold Activity-lifecycle tickets.
+namespace Babylon::Embedding::Android
+{
+    Runtime* RuntimeFromHandle(jlong handle)
+    {
+        return handle == 0 ? nullptr : AsRuntime(handle);
+    }
+}
+
+extern "C"
+{
+
+// =====================================================================
+// Android platform lifecycle (interop layer surface).
+//
+// Not part of the cross-platform Runtime/View API — exists because
+// plugins like NativeCamera require the host to register the JavaVM and
+// current Activity via AndroidExtensions::Globals.
+// =====================================================================
+
+// Set the application Context. Hosts call this once at app startup
+// (typically from Application.onCreate) before constructing any Runtime.
+// Calling more than once is harmless — Initialize replaces the existing
+// Context global ref.
+JNIEXPORT void JNICALL
+Java_com_babylonjs_embedding_BabylonNative_setContext(
+    JNIEnv* env, jclass, jobject context)
+{
+    JavaVM* javaVM{nullptr};
+    if (env->GetJavaVM(&javaVM) != JNI_OK)
+    {
+        return;
+    }
+    android::global::Initialize(javaVM, context);
+}
+
+JNIEXPORT void JNICALL
+Java_com_babylonjs_embedding_BabylonNative_setCurrentActivity(
+    JNIEnv*, jclass, jobject activity)
+{
+    android::global::SetCurrentActivity(activity);
+}
+
+JNIEXPORT void JNICALL
+Java_com_babylonjs_embedding_BabylonNative_pause(JNIEnv*, jclass)
+{
+    android::global::Pause();
+}
+
+JNIEXPORT void JNICALL
+Java_com_babylonjs_embedding_BabylonNative_resume(JNIEnv*, jclass)
+{
+    android::global::Resume();
+}
+
+JNIEXPORT void JNICALL
+Java_com_babylonjs_embedding_BabylonNative_requestPermissionsResult(
+    JNIEnv* env, jclass, jint requestCode, jobjectArray permissions, jintArray grantResults)
+{
+    std::vector<std::string> nativePermissions{};
+    const jsize permissionCount = env->GetArrayLength(permissions);
+    nativePermissions.reserve(static_cast<size_t>(permissionCount));
+    for (jsize i = 0; i < permissionCount; ++i)
+    {
+        auto perm = static_cast<jstring>(env->GetObjectArrayElement(permissions, i));
+        nativePermissions.push_back(ToStdString(env, perm));
+        env->DeleteLocalRef(perm);
+    }
+
+    std::vector<int32_t> nativeGrantResults{};
+    const jsize grantCount = env->GetArrayLength(grantResults);
+    if (grantCount > 0)
+    {
+        jint* grantElements = env->GetIntArrayElements(grantResults, nullptr);
+        nativeGrantResults.assign(grantElements, grantElements + grantCount);
+        env->ReleaseIntArrayElements(grantResults, grantElements, JNI_ABORT);
+    }
+
+    android::global::RequestPermissionsResult(
+        static_cast<int32_t>(requestCode),
+        nativePermissions,
+        nativeGrantResults);
+}
+
+// =====================================================================
+// Runtime
+// =====================================================================
+
+JNIEXPORT jlong JNICALL
+Java_com_babylonjs_embedding_BabylonNative_runtimeCreate__(JNIEnv*, jclass)
+{
+    // Default Android consumers want logcat output; Console polyfill,
+    // uncaught JS exceptions, and (when enabled) DebugTrace all route
+    // there. Hosts wanting different behavior use the C++ API directly.
+    RuntimeOptions options{};
+    return MakeRuntimeHandle(std::move(options));
+}
+
+JNIEXPORT jlong JNICALL
+Java_com_babylonjs_embedding_BabylonNative_runtimeCreate__Lcom_babylonjs_embedding_BabylonNative_00024RuntimeOptions_2(
+    JNIEnv* env, jclass, jobject javaOptions)
+{
+    // RuntimeOptions is a Java object so callers have a stable
+    // construction API as fields are added.
+    RuntimeOptions options{};
+    if (!ApplyJavaRuntimeOptions(env, javaOptions, options))
+    {
+        return 0;
+    }
+    return MakeRuntimeHandle(std::move(options));
+}
+
+JNIEXPORT void JNICALL
+Java_com_babylonjs_embedding_BabylonNative_runtimeDestroy(JNIEnv*, jclass, jlong handle)
+{
+    AndroidRuntime* androidRuntime = AsAndroidRuntime(handle);
+
+#if BABYLON_NATIVE_PLUGIN_NATIVEXR
+    // Grab the XR window before tearing down the Runtime; it can only be
+    // released once the Runtime (and NativeXr, which holds the raw pointer)
+    // is gone.
+    ANativeWindow* xrWindow = androidRuntime->xrWindow;
+#endif
+
+    // Reverse declaration order: tickets unsubscribe before the Runtime
+    // is destroyed, so no callback fires on a dead Runtime.
+    delete androidRuntime;
+
+#if BABYLON_NATIVE_PLUGIN_NATIVEXR
+    if (xrWindow != nullptr)
+    {
+        ANativeWindow_release(xrWindow);
+    }
+#endif
+}
+
+JNIEXPORT void JNICALL
+Java_com_babylonjs_embedding_BabylonNative_runtimeLoadScript(
+    JNIEnv* env, jclass, jlong handle, jstring url)
+{
+    AsRuntime(handle)->LoadScript(ToStdString(env, url));
+}
+
+JNIEXPORT void JNICALL
+Java_com_babylonjs_embedding_BabylonNative_runtimeEval(
+    JNIEnv* env, jclass, jlong handle, jstring source, jstring sourceUrl)
+{
+    AsRuntime(handle)->Eval(ToStdString(env, source), ToStdString(env, sourceUrl));
+}
+
+// No per-Runtime Suspend/Resume on the JNI surface: lifecycle wiring
+// happens automatically in MakeRuntimeHandle via the android::global
+// pause/resume tickets. Hosts call androidGlobalPause/Resume once per
+// Activity state change; every Runtime in the process reacts. Use the
+// C++ API for finer-grained control.
+
+JNIEXPORT void JNICALL
+Java_com_babylonjs_embedding_BabylonNative_runtimeSetXrSurface(
+    JNIEnv* env, jclass, jlong handle, jobject surface)
+{
+#if BABYLON_NATIVE_PLUGIN_NATIVEXR
+    AndroidRuntime* androidRuntime = AsAndroidRuntime(handle);
+
+    ANativeWindow* window{nullptr};
+    if (surface != nullptr)
+    {
+        // +1 reference owned by us; released when replaced below or in
+        // runtimeDestroy. NativeXr only stores the raw pointer.
+        window = ANativeWindow_fromSurface(env, surface);
+    }
+
+    androidRuntime->runtime->SetXrWindow(window);
+
+    // Release the previously-held window now that NativeXr has been pointed
+    // at the new one. Hosts must not swap the XR surface out from under an
+    // active session; the usual flow is set(surface) … set(null) bracketing
+    // a session.
+    if (androidRuntime->xrWindow != nullptr)
+    {
+        ANativeWindow_release(androidRuntime->xrWindow);
+    }
+    androidRuntime->xrWindow = window;
+#else
+    (void)handle;
+    (void)surface;
+    ThrowPluginNotEnabled(env,
+        "runtimeSetXrSurface was called but BABYLON_NATIVE_PLUGIN_NATIVEXR "
+        "was not enabled at native build time.");
+#endif
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_babylonjs_embedding_BabylonNative_runtimeIsXrActive(JNIEnv*, jclass, jlong handle)
+{
+#if BABYLON_NATIVE_PLUGIN_NATIVEXR
+    return AsRuntime(handle)->IsXrActive() ? JNI_TRUE : JNI_FALSE;
+#else
+    // Non-throwing: "no XR active" is correct when XR is off.
+    (void)handle;
+    return JNI_FALSE;
+#endif
+}
+
+// =====================================================================
+// View
+// =====================================================================
+
+JNIEXPORT jlong JNICALL
+Java_com_babylonjs_embedding_BabylonNative_viewAttach(
+    JNIEnv* env, jclass, jlong runtimeHandle, jobject surface)
+{
+    if (surface == nullptr)
+    {
+        return 0;
+    }
+    ANativeWindow* window = ANativeWindow_fromSurface(env, surface);
+    if (window == nullptr)
+    {
+        return 0;
+    }
+    View* view = nullptr;
+    try
+    {
+        view = new View{*AsRuntime(runtimeHandle), window};
+    }
+    catch (const std::exception&)
+    {
+        ANativeWindow_release(window);
+        return 0;
+    }
+
+    // Kick off the first resize using the surface's current pixel
+    // dimensions. Hosts will typically also wire their SurfaceHolder
+    // callback's `surfaceChanged(holder, format, w, h)` to `viewResize`
+    // for subsequent size changes — this initial call composes cleanly
+    // with that because `View::Resize` past the first call is an
+    // idempotent `Device::UpdateSize`. If the surface reports zero
+    // (rare; surface not fully realized yet), skip and rely on the
+    // host's `surfaceChanged` to deliver the first size.
+    const int32_t surfaceWidth = ANativeWindow_getWidth(window);
+    const int32_t surfaceHeight = ANativeWindow_getHeight(window);
+    if (surfaceWidth > 0 && surfaceHeight > 0)
+    {
+        view->Resize(static_cast<uint32_t>(surfaceWidth),
+                      static_cast<uint32_t>(surfaceHeight),
+                      Babylon::Embedding::CoordinateUnits::Physical);
+    }
+
+    // bgfx retains its own reference on the ANativeWindow for the
+    // surface-binding lifetime, so release our local acquire here.
+    ANativeWindow_release(window);
+    return reinterpret_cast<jlong>(view);
+}
+
+JNIEXPORT void JNICALL
+Java_com_babylonjs_embedding_BabylonNative_viewDetach(JNIEnv*, jclass, jlong handle)
+{
+    delete AsView(handle);
+}
+
+JNIEXPORT void JNICALL
+Java_com_babylonjs_embedding_BabylonNative_viewRenderFrame(JNIEnv*, jclass, jlong handle)
+{
+    AsView(handle)->RenderFrame();
+}
+
+JNIEXPORT void JNICALL
+Java_com_babylonjs_embedding_BabylonNative_viewResize(
+    JNIEnv*, jclass, jlong handle, jint width, jint height)
+{
+    // Java callers pass the SurfaceView's pixel-buffer dimensions
+    // (physical pixels on Android).
+    AsView(handle)->Resize(static_cast<uint32_t>(width),
+                            static_cast<uint32_t>(height),
+                            Babylon::Embedding::CoordinateUnits::Physical);
+}
+
+JNIEXPORT void JNICALL
+Java_com_babylonjs_embedding_BabylonNative_viewPointerDown(
+    JNIEnv* env, jclass, jlong handle, jint pointerId, jfloat x, jfloat y)
+{
+#if BABYLON_NATIVE_PLUGIN_NATIVEINPUT
+    (void)env;
+    // MotionEvent.getX/getY are physical pixels.
+    AsView(handle)->OnPointerDown(static_cast<int32_t>(pointerId), x, y,
+                                   Babylon::Embedding::CoordinateUnits::Physical);
+#else
+    (void)handle; (void)pointerId; (void)x; (void)y;
+    ThrowPluginNotEnabled(env,
+        "viewPointerDown was called but BABYLON_NATIVE_PLUGIN_NATIVEINPUT "
+        "was not enabled at native build time.");
+#endif
+}
+
+JNIEXPORT void JNICALL
+Java_com_babylonjs_embedding_BabylonNative_viewPointerMove(
+    JNIEnv* env, jclass, jlong handle, jint pointerId, jfloat x, jfloat y)
+{
+#if BABYLON_NATIVE_PLUGIN_NATIVEINPUT
+    (void)env;
+    AsView(handle)->OnPointerMove(static_cast<int32_t>(pointerId), x, y,
+                                   Babylon::Embedding::CoordinateUnits::Physical);
+#else
+    (void)handle; (void)pointerId; (void)x; (void)y;
+    ThrowPluginNotEnabled(env,
+        "viewPointerMove was called but BABYLON_NATIVE_PLUGIN_NATIVEINPUT "
+        "was not enabled at native build time.");
+#endif
+}
+
+JNIEXPORT void JNICALL
+Java_com_babylonjs_embedding_BabylonNative_viewPointerUp(
+    JNIEnv* env, jclass, jlong handle, jint pointerId, jfloat x, jfloat y)
+{
+#if BABYLON_NATIVE_PLUGIN_NATIVEINPUT
+    (void)env;
+    AsView(handle)->OnPointerUp(static_cast<int32_t>(pointerId), x, y,
+                                 Babylon::Embedding::CoordinateUnits::Physical);
+#else
+    (void)handle; (void)pointerId; (void)x; (void)y;
+    ThrowPluginNotEnabled(env,
+        "viewPointerUp was called but BABYLON_NATIVE_PLUGIN_NATIVEINPUT "
+        "was not enabled at native build time.");
+#endif
+}
+
+} // extern "C"
diff --git a/Embedding/Apple/CMakeLists.txt b/Embedding/Apple/CMakeLists.txt
new file mode 100644
index 000000000..6bea2bf8e
--- /dev/null
+++ b/Embedding/Apple/CMakeLists.txt
@@ -0,0 +1,50 @@
+# Babylon::Embedding Apple interop layer.
+#
+# Builds a static library producing Obj-C `BNRuntime` and `BNView`
+# classes, importable from Swift via the standard Obj-C bridge.
+# The host's Xcode project (or downstream CMake project) consumes
+# this directly.
+#
+# Gated by BABYLON_NATIVE_EMBEDDING_APPLE at the root.
+
+if(NOT APPLE)
+    message(FATAL_ERROR
+        "Embedding/Apple is for iOS / macOS / visionOS. "
+        "Disable BABYLON_NATIVE_EMBEDDING_APPLE for non-Apple builds.")
+endif()
+
+set(APPLE_EMBEDDING_INCLUDE_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../Include/Platform/Apple")
+
+set(SOURCES
+    "${APPLE_EMBEDDING_INCLUDE_ROOT}/Babylon/Embedding/Apple/BabylonNativeEmbedding.h"
+    "${APPLE_EMBEDDING_INCLUDE_ROOT}/Babylon/Embedding/Apple/BNRuntime.h"
+    "${APPLE_EMBEDDING_INCLUDE_ROOT}/Babylon/Embedding/Apple/BNRuntimeNative.h"
+    "${APPLE_EMBEDDING_INCLUDE_ROOT}/Babylon/Embedding/Apple/BNView.h"
+    "${CMAKE_CURRENT_SOURCE_DIR}/Source/BNRuntime.mm"
+    "${CMAKE_CURRENT_SOURCE_DIR}/Source/BNRuntimeInternal.h"
+    "${CMAKE_CURRENT_SOURCE_DIR}/Source/BNView.mm"
+    "${CMAKE_CURRENT_SOURCE_DIR}/Source/BNViewDelegate.mm")
+
+add_library(BabylonNativeEmbedding STATIC ${SOURCES})
+
+warnings_as_errors(BabylonNativeEmbedding)
+
+target_include_directories(BabylonNativeEmbedding
+    PUBLIC "${APPLE_EMBEDDING_INCLUDE_ROOT}"
+    PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/Source")
+
+target_link_libraries(BabylonNativeEmbedding
+    PUBLIC Embedding
+    PRIVATE "-framework Foundation"
+    PRIVATE "-framework QuartzCore"
+    PRIVATE "-framework MetalKit")
+
+# Enable ARC for the Obj-C++ files.
+set_source_files_properties(
+    "${CMAKE_CURRENT_SOURCE_DIR}/Source/BNRuntime.mm"
+    "${CMAKE_CURRENT_SOURCE_DIR}/Source/BNView.mm"
+    "${CMAKE_CURRENT_SOURCE_DIR}/Source/BNViewDelegate.mm"
+    PROPERTIES COMPILE_FLAGS "-fobjc-arc")
+
+set_property(TARGET BabylonNativeEmbedding PROPERTY FOLDER Embedding)
+source_group(TREE "${CMAKE_CURRENT_SOURCE_DIR}/.." FILES ${SOURCES})
diff --git a/Embedding/Apple/Source/BNRuntime.mm b/Embedding/Apple/Source/BNRuntime.mm
new file mode 100644
index 000000000..7c9e9817c
--- /dev/null
+++ b/Embedding/Apple/Source/BNRuntime.mm
@@ -0,0 +1,206 @@
+// BNRuntime.mm — Obj-C++ implementation bridging BNRuntime to
+// Babylon::Embedding::Runtime.
+
+#import "BNRuntimeInternal.h"
+#import <Babylon/Embedding/Apple/BNRuntimeNative.h>
+
+#import <Foundation/Foundation.h>
+#import <MetalKit/MetalKit.h>
+
+#include <os/log.h>
+
+#include <cstdint>
+#include <memory>
+
+namespace
+{
+    uint8_t ToRuntimeMSAASamples(NSNumber* msaaSamples)
+    {
+        const long long value = msaaSamples.longLongValue;
+        return value >= 0 && value <= UINT8_MAX ? static_cast<uint8_t>(value) : 0;
+    }
+
+    // Process-wide os_log channel for the default log sink. Subsystem
+    // matches the Babylon Native CFBundleIdentifier convention so
+    // Console.app / `log stream` can filter it.
+    os_log_t BabylonNativeLogger()
+    {
+        static os_log_t logger = os_log_create("com.babylonjs.babylonnative", "Runtime");
+        return logger;
+    }
+
+    // Map LogLevel onto os_log types. os_log has no distinct "warn", so
+    // Warn folds into DEFAULT (matches Apple's console.warn → default).
+    // DEBUG/INFO are filtered out of release builds and Console.app by
+    // default, so Verbose lands there to suppress DebugTrace noise.
+    os_log_type_t ToOSLogType(Babylon::Embedding::LogLevel level)
+    {
+        switch (level)
+        {
+            case Babylon::Embedding::LogLevel::Verbose: return OS_LOG_TYPE_DEBUG;
+            case Babylon::Embedding::LogLevel::Log:     return OS_LOG_TYPE_DEFAULT;
+            case Babylon::Embedding::LogLevel::Warn:    return OS_LOG_TYPE_DEFAULT;
+            case Babylon::Embedding::LogLevel::Error:   return OS_LOG_TYPE_ERROR;
+            case Babylon::Embedding::LogLevel::Fatal:   return OS_LOG_TYPE_FAULT;
+        }
+        return OS_LOG_TYPE_DEFAULT;
+    }
+}
+
+@implementation BNRuntimeOptions
+
+@end
+
+@implementation BNRuntime
+{
+    std::optional<Babylon::Embedding::Runtime> _runtime;
+    MTKView* _xrView;
+}
+
+- (instancetype)init
+{
+    return [self initWithOptions:nil];
+}
+
+- (nullable instancetype)initWithOptions:(nullable BNRuntimeOptions*)runtimeOptions
+{
+    if ((self = [super init]))
+    {
+        Babylon::Embedding::RuntimeOptions options{};
+        if (runtimeOptions != nil)
+        {
+            if (runtimeOptions.msaaSamples != nil)
+            {
+                options.msaaSamples = ToRuntimeMSAASamples(runtimeOptions.msaaSamples);
+            }
+            options.enableDebugger = runtimeOptions.enableDebugger ? true : false;
+            options.enableDebugTrace = runtimeOptions.enableDebugTrace ? true : false;
+            options.waitForDebugger = runtimeOptions.waitForDebugger ? true : false;
+        }
+        // Default log sink: route through os_log_with_type so the level
+        // reaches Console.app / `log stream`. Hosts wanting custom routing
+        // should use the C++ API. `%{public}.*s` is required — without
+        // `{public}` os_log redacts the payload as `<private>` in release.
+        options.log = [](Babylon::Embedding::LogLevel level, std::string_view message) {
+            os_log_with_type(BabylonNativeLogger(), ToOSLogType(level),
+                             "%{public}.*s",
+                             static_cast<int>(message.size()), message.data());
+        };
+        if (runtimeOptions.shaderCachePath != nil)
+        {
+#if BABYLON_NATIVE_PLUGIN_SHADERCACHE
+            options.shaderCachePath = runtimeOptions.shaderCachePath.UTF8String;
+#else
+            // Fail the initializer: a caller-supplied cache path can't be
+            // honored without the ShaderCache plugin. Return nil (rather than
+            // throwing) so the failure is catchable from Swift and consistent
+            // with BNView's failable init.
+            os_log_error(BabylonNativeLogger(),
+                "BNRuntime init failed: shaderCachePath was provided but "
+                "BABYLON_NATIVE_PLUGIN_SHADERCACHE was not enabled at native build time.");
+            return nil;
+#endif
+        }
+
+        try
+        {
+            _runtime.emplace(std::move(options));
+        }
+        catch (const std::exception& e)
+        {
+            os_log_error(BabylonNativeLogger(),
+                "BNRuntime init failed: %{public}s", e.what());
+            return nil;
+        }
+    }
+    return self;
+}
+
+- (void)loadScript:(NSString*)url
+{
+    if (url == nil)
+    {
+        return;
+    }
+    _runtime->LoadScript(url.UTF8String);
+}
+
+- (void)eval:(NSString*)source sourceURL:(NSString*)sourceURL
+{
+    if (source == nil)
+    {
+        return;
+    }
+    const char* src = source.UTF8String;
+    const char* url = sourceURL ? sourceURL.UTF8String : "";
+    _runtime->Eval(src, url);
+}
+
+- (void)suspend
+{
+    _runtime->Suspend();
+}
+
+- (void)resume
+{
+    _runtime->Resume();
+}
+
+- (BOOL)isSuspended
+{
+    return _runtime->IsSuspended() ? YES : NO;
+}
+
+- (void)setXrView:(MTKView*)xrView
+{
+#if BABYLON_NATIVE_PLUGIN_NATIVEXR
+    _xrView = xrView;
+    _runtime->SetXrWindow((__bridge void*)xrView);
+#else
+    (void)xrView;
+    @throw [NSException
+        exceptionWithName:@"BabylonNativePluginNotEnabledException"
+                   reason:@"setXrView: was called but BABYLON_NATIVE_PLUGIN_NATIVEXR was not enabled at native build time."
+                 userInfo:nil];
+#endif
+}
+
+- (BOOL)isXRActive
+{
+#if BABYLON_NATIVE_PLUGIN_NATIVEXR
+    return _runtime->IsXrActive() ? YES : NO;
+#else
+    // Non-throwing: "no XR active" is the correct answer when XR is off.
+    return NO;
+#endif
+}
+
+- (Babylon::Embedding::Runtime*)nativeRuntime
+{
+    return _runtime ? &*_runtime : nullptr;
+}
+
+- (void)updateXrViewIfNeeded
+{
+#if BABYLON_NATIVE_PLUGIN_NATIVEXR
+    if (_xrView != nil)
+    {
+        const BOOL shouldBeHidden = !_runtime->IsXrActive();
+        if (_xrView.hidden != shouldBeHidden)
+        {
+            _xrView.hidden = shouldBeHidden;
+        }
+    }
+#endif
+}
+
+@end
+
+namespace Babylon::Embedding::Apple
+{
+    Runtime* RuntimeFromBNRuntime(BNRuntime* runtime)
+    {
+        return runtime == nil ? nullptr : [runtime nativeRuntime];
+    }
+}
+
diff --git a/Embedding/Apple/Source/BNRuntimeInternal.h b/Embedding/Apple/Source/BNRuntimeInternal.h
new file mode 100644
index 000000000..071c74a7e
--- /dev/null
+++ b/Embedding/Apple/Source/BNRuntimeInternal.h
@@ -0,0 +1,22 @@
+// Internal Obj-C category exposing the underlying
+// `Babylon::Embedding::Runtime*` to BNView.mm. Not part of the
+// public Apple interop layer surface (Swift consumers don't see this).
+
+#pragma once
+
+#import <Babylon/Embedding/Apple/BNRuntime.h>
+
+#include <Babylon/Embedding/Runtime.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface BNRuntime ()
+- (Babylon::Embedding::Runtime*)nativeRuntime;
+
+/// Toggle the XR overlay view's visibility based on the runtime's
+/// current XR-active state. Called by BNView once per frame so the
+/// host doesn't have to manage XR overlay visibility itself.
+- (void)updateXrViewIfNeeded;
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/Embedding/Apple/Source/BNView.mm b/Embedding/Apple/Source/BNView.mm
new file mode 100644
index 000000000..77774149e
--- /dev/null
+++ b/Embedding/Apple/Source/BNView.mm
@@ -0,0 +1,321 @@
+// BNView.mm — Obj-C++ implementation bridging BNView to
+// Babylon::Embedding::View.
+
+#import "BNRuntimeInternal.h"
+#import <Babylon/Embedding/Apple/BNView.h>
+
+#import <MetalKit/MetalKit.h>
+#import <QuartzCore/CAMetalLayer.h>
+
+#include <Babylon/Embedding/View.h>
+
+#include <cstdint>
+#include <optional>
+
+namespace
+{
+    // Map the public BNView mouse enums onto the NativeInput button/axis IDs
+    // the C++ View expects, keeping the NativeInput numbering out of the
+    // public Obj-C/Swift surface.
+    uint32_t NativeMouseButtonId(BNViewMouseButton button)
+    {
+        switch (button)
+        {
+            case BNViewMouseButtonLeft:   return Babylon::Embedding::View::LeftMouseButton();
+            case BNViewMouseButtonMiddle: return Babylon::Embedding::View::MiddleMouseButton();
+            case BNViewMouseButtonRight:  return Babylon::Embedding::View::RightMouseButton();
+        }
+        return Babylon::Embedding::View::LeftMouseButton();
+    }
+
+    uint32_t NativeMouseWheelAxisId(BNViewMouseWheelAxis axis)
+    {
+        switch (axis)
+        {
+            case BNViewMouseWheelAxisY: return Babylon::Embedding::View::MouseWheelY();
+        }
+        return Babylon::Embedding::View::MouseWheelY();
+    }
+}
+
+@implementation BNView
+{
+    std::optional<Babylon::Embedding::View> _view;
+    BNRuntime* _runtime;
+    MTKView* _mtkView;
+
+    // When BNView auto-installs a default delegate, hold a strong ref
+    // here to outlive MTKView's `weak` delegate slot. Nil when the host
+    // installed their own delegate before constructing BNView.
+    BNViewDelegate* _managedDelegate;
+}
+
+- (instancetype)initWithRuntime:(BNRuntime*)runtime view:(MTKView*)view
+{
+    if (runtime == nil || view == nil)
+    {
+        return nil;
+    }
+
+    Babylon::Embedding::Runtime* nativeRuntime = runtime.nativeRuntime;
+    if (nativeRuntime == nullptr)
+    {
+        return nil;
+    }
+
+    if ((self = [super init]))
+    {
+        // Babylon Native must control the drawable size.
+        view.autoResizeDrawable = NO;
+
+        _runtime = runtime;
+        _mtkView = view;
+
+        // MTKView's layer is always CAMetalLayer (via +layerClass).
+        CAMetalLayer* layer = (CAMetalLayer*)view.layer;
+
+        // View construction is lightweight (just stashes the layer). Device
+        // construction is driven by the first `-resizeWithWidth:height:`
+        // call. Because BNView sets `autoResizeDrawable = NO` above
+        // (Babylon Native owns the drawable size), MTKView no longer
+        // reports size via `mtkView:drawableSizeWillChange:`; instead the
+        // host drives resize explicitly from a layout hook
+        // (`-viewDidLayoutSubviews` / `-viewDidLayout`), the same as every
+        // other platform. We still kick off an initial resize from the
+        // current bounds below so JS engine init can begin immediately
+        // when the view is already laid out at construction time; if
+        // bounds are still zero (view not yet laid out / in a window), the
+        // host's first layout pass delivers the size.
+        try
+        {
+            _view.emplace(*nativeRuntime, (__bridge CA::MetalLayer*)layer);
+        }
+        catch (const std::exception&)
+        {
+            _mtkView = nil;
+            return nil;
+        }
+
+        // If the host hasn't installed an MTKViewDelegate, install a
+        // default (render-only) BNViewDelegate. Done AFTER View
+        // construction so any delegate callback triggered by the
+        // assignment doesn't reach us before _view is constructed.
+        if (view.delegate == nil)
+        {
+            _managedDelegate = [[BNViewDelegate alloc] initWithView:self];
+            view.delegate = _managedDelegate;
+        }
+
+        // Kick off the first resize using the MTKView's bounds in
+        // logical units (points/DIPs). `View::Resize` handles the DPR
+        // conversion internally; passing Logical here matches the units
+        // the host's layout hook passes for subsequent resizes.
+        //
+        // If bounds are zero (e.g. MTKView not yet laid out / in a
+        // window), skip and rely on the host's first layout-driven
+        // `-resizeWithWidth:height:` to deliver the first size.
+        // `View::Resize` past the first call is just an idempotent
+        // `Device::UpdateSize`, so this explicit kick composes harmlessly
+        // with the host's subsequent resize calls.
+        const CGSize bounds = view.bounds.size;
+        if (bounds.width > 0 && bounds.height > 0)
+        {
+            if (_view)
+            {
+                _view->Resize(static_cast<uint32_t>(bounds.width),
+                               static_cast<uint32_t>(bounds.height),
+                               Babylon::Embedding::CoordinateUnits::Logical);
+            }
+        }
+    }
+    return self;
+}
+
+- (void)dealloc
+{
+    // Only clear if it's still ours; never disturb a host-installed delegate.
+    if (_managedDelegate != nil && _mtkView.delegate == _managedDelegate)
+    {
+        _mtkView.delegate = nil;
+    }
+}
+
+- (void)renderFrame
+{
+    // Skip rendering until the backing CAMetalLayer has a non-zero drawable;
+    // bgfx can't acquire a drawable at 0x0 and Metal validation fails with
+    // "no output textures defined for the render pass". The host's
+    // layout-driven -resizeWithWidth:height: delivers the real size.
+    //
+    // Read from the CAMetalLayer, not MTKView.drawableSize: BNView sets
+    // autoResizeDrawable = NO, so MTKView stops tracking drawableSize (stays
+    // 0x0) while Babylon Native writes the real size onto the layer. The
+    // guard lives here because the live drawable size is Apple-specific and
+    // -renderFrame is the single chokepoint for every render path.
+    CAMetalLayer* metalLayer = (CAMetalLayer*)_mtkView.layer;
+    const CGSize drawableSize = metalLayer.drawableSize;
+    if (drawableSize.width <= 0 || drawableSize.height <= 0)
+    {
+        return;
+    }
+
+    // The runtime owns the XR overlay view (via -setXrView:), so it's
+    // the natural place to keep its visibility in sync. Doing this here
+    // means hosts never need to manage the overlay themselves regardless
+    // of whether frames are driven by the auto-installed delegate, a
+    // host subclass, or a fully-custom delegate.
+    [_runtime updateXrViewIfNeeded];
+
+    if (_view)
+    {
+        _view->RenderFrame();
+    }
+}
+
+- (void)resizeWithWidth:(NSUInteger)width height:(NSUInteger)height
+{
+    if (_view)
+    {
+        // Host passes logical points (from the view's bounds); View::Resize
+        // converts to physical internally using the layer's DPR.
+        _view->Resize(static_cast<uint32_t>(width),
+                       static_cast<uint32_t>(height),
+                       Babylon::Embedding::CoordinateUnits::Logical);
+    }
+}
+
+#pragma mark - Pointer forwarding
+
+- (void)pointerDown:(NSInteger)pointerId atX:(CGFloat)x y:(CGFloat)y
+{
+#if BABYLON_NATIVE_PLUGIN_NATIVEINPUT
+    if (_view)
+    {
+        _view->OnPointerDown(static_cast<int32_t>(pointerId),
+                              static_cast<float>(x),
+                              static_cast<float>(y),
+                              Babylon::Embedding::CoordinateUnits::Logical);
+    }
+#else
+    (void)pointerId; (void)x; (void)y;
+    @throw [NSException
+        exceptionWithName:@"BabylonNativePluginNotEnabledException"
+                   reason:@"pointerDown:atX:y: was called but BABYLON_NATIVE_PLUGIN_NATIVEINPUT was not enabled at native build time."
+                 userInfo:nil];
+#endif
+}
+
+- (void)pointerMove:(NSInteger)pointerId atX:(CGFloat)x y:(CGFloat)y
+{
+#if BABYLON_NATIVE_PLUGIN_NATIVEINPUT
+    if (_view)
+    {
+        _view->OnPointerMove(static_cast<int32_t>(pointerId),
+                              static_cast<float>(x),
+                              static_cast<float>(y),
+                              Babylon::Embedding::CoordinateUnits::Logical);
+    }
+#else
+    (void)pointerId; (void)x; (void)y;
+    @throw [NSException
+        exceptionWithName:@"BabylonNativePluginNotEnabledException"
+                   reason:@"pointerMove:atX:y: was called but BABYLON_NATIVE_PLUGIN_NATIVEINPUT was not enabled at native build time."
+                 userInfo:nil];
+#endif
+}
+
+- (void)pointerUp:(NSInteger)pointerId atX:(CGFloat)x y:(CGFloat)y
+{
+#if BABYLON_NATIVE_PLUGIN_NATIVEINPUT
+    if (_view)
+    {
+        _view->OnPointerUp(static_cast<int32_t>(pointerId),
+                            static_cast<float>(x),
+                            static_cast<float>(y),
+                            Babylon::Embedding::CoordinateUnits::Logical);
+    }
+#else
+    (void)pointerId; (void)x; (void)y;
+    @throw [NSException
+        exceptionWithName:@"BabylonNativePluginNotEnabledException"
+                   reason:@"pointerUp:atX:y: was called but BABYLON_NATIVE_PLUGIN_NATIVEINPUT was not enabled at native build time."
+                 userInfo:nil];
+#endif
+}
+
+#pragma mark - Mouse forwarding
+
+- (void)mouseDown:(BNViewMouseButton)button atX:(CGFloat)x y:(CGFloat)y
+{
+#if BABYLON_NATIVE_PLUGIN_NATIVEINPUT
+    if (_view)
+    {
+        _view->OnMouseDown(NativeMouseButtonId(button),
+                            static_cast<float>(x),
+                            static_cast<float>(y),
+                            Babylon::Embedding::CoordinateUnits::Logical);
+    }
+#else
+    (void)button; (void)x; (void)y;
+    @throw [NSException
+        exceptionWithName:@"BabylonNativePluginNotEnabledException"
+                   reason:@"mouseDown:atX:y: was called but BABYLON_NATIVE_PLUGIN_NATIVEINPUT was not enabled at native build time."
+                 userInfo:nil];
+#endif
+}
+
+- (void)mouseUp:(BNViewMouseButton)button atX:(CGFloat)x y:(CGFloat)y
+{
+#if BABYLON_NATIVE_PLUGIN_NATIVEINPUT
+    if (_view)
+    {
+        _view->OnMouseUp(NativeMouseButtonId(button),
+                          static_cast<float>(x),
+                          static_cast<float>(y),
+                          Babylon::Embedding::CoordinateUnits::Logical);
+    }
+#else
+    (void)button; (void)x; (void)y;
+    @throw [NSException
+        exceptionWithName:@"BabylonNativePluginNotEnabledException"
+                   reason:@"mouseUp:atX:y: was called but BABYLON_NATIVE_PLUGIN_NATIVEINPUT was not enabled at native build time."
+                 userInfo:nil];
+#endif
+}
+
+- (void)mouseMoveAtX:(CGFloat)x y:(CGFloat)y
+{
+#if BABYLON_NATIVE_PLUGIN_NATIVEINPUT
+    if (_view)
+    {
+        _view->OnMouseMove(static_cast<float>(x),
+                            static_cast<float>(y),
+                            Babylon::Embedding::CoordinateUnits::Logical);
+    }
+#else
+    (void)x; (void)y;
+    @throw [NSException
+        exceptionWithName:@"BabylonNativePluginNotEnabledException"
+                   reason:@"mouseMoveAtX:y: was called but BABYLON_NATIVE_PLUGIN_NATIVEINPUT was not enabled at native build time."
+                 userInfo:nil];
+#endif
+}
+
+- (void)mouseWheel:(BNViewMouseWheelAxis)axis delta:(CGFloat)delta
+{
+#if BABYLON_NATIVE_PLUGIN_NATIVEINPUT
+    if (_view)
+    {
+        _view->OnMouseWheel(NativeMouseWheelAxisId(axis),
+                             static_cast<int32_t>(delta));
+    }
+#else
+    (void)axis; (void)delta;
+    @throw [NSException
+        exceptionWithName:@"BabylonNativePluginNotEnabledException"
+                   reason:@"mouseWheel:delta: was called but BABYLON_NATIVE_PLUGIN_NATIVEINPUT was not enabled at native build time."
+                 userInfo:nil];
+#endif
+}
+
+@end
diff --git a/Embedding/Apple/Source/BNViewDelegate.mm b/Embedding/Apple/Source/BNViewDelegate.mm
new file mode 100644
index 000000000..ee88baf05
--- /dev/null
+++ b/Embedding/Apple/Source/BNViewDelegate.mm
@@ -0,0 +1,55 @@
+// BNViewDelegate.mm — default `MTKViewDelegate` that drives a BNView's
+// per-frame rendering. Subclassable by hosts that want to insert
+// per-frame work; just override `drawInMTKView:` and call `super` to
+// keep the default render behavior.
+//
+// This delegate does NOT drive resize. BNView sets
+// `autoResizeDrawable = NO` so Babylon Native owns the drawable size,
+// which means MTKView no longer reports size changes via
+// `mtkView:drawableSizeWillChange:`. Hosts drive resize explicitly from
+// a layout hook (`-viewDidLayoutSubviews` on UIKit, `-viewDidLayout` on
+// AppKit), the same way every other platform does — see
+// `-[BNView resizeWithWidth:height:]`.
+
+#import <Babylon/Embedding/Apple/BNView.h>
+
+@implementation BNViewDelegate
+{
+    // BNView retains the auto-installed delegate strongly; host
+    // subclasses are typically held by the host's controller. Weak
+    // is sufficient and avoids retain cycles if a subclass captures
+    // the BNView.
+    __weak BNView* _view;
+}
+
+- (instancetype)initWithView:(BNView*)view
+{
+    if (view == nil)
+    {
+        return nil;
+    }
+    if ((self = [super init]))
+    {
+        _view = view;
+    }
+    return self;
+}
+
+#pragma mark - MTKViewDelegate
+
+- (void)mtkView:(MTKView* __unused)v drawableSizeWillChange:(CGSize __unused)size
+{
+    // Intentionally empty. BNView sets autoResizeDrawable = NO, so this
+    // callback no longer reports host-driven size changes; resize is
+    // driven explicitly by the host from a layout hook. Kept only to
+    // satisfy the (required) MTKViewDelegate protocol method.
+}
+
+- (void)drawInMTKView:(MTKView* __unused)v
+{
+    // [_view renderFrame] handles the XR overlay visibility toggle, so
+    // subclasses that override this and call super get it for free.
+    [_view renderFrame];
+}
+
+@end
diff --git a/Embedding/CMakeLists.txt b/Embedding/CMakeLists.txt
new file mode 100644
index 000000000..20715f0bb
--- /dev/null
+++ b/Embedding/CMakeLists.txt
@@ -0,0 +1,156 @@
+set(EMBEDDING_SHARED_INCLUDE_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/Include/Shared")
+
+set(SOURCES
+    "${EMBEDDING_SHARED_INCLUDE_ROOT}/Babylon/Embedding/LogLevel.h"
+    "${EMBEDDING_SHARED_INCLUDE_ROOT}/Babylon/Embedding/Runtime.h"
+    "${EMBEDDING_SHARED_INCLUDE_ROOT}/Babylon/Embedding/RuntimeOptions.h"
+    "${EMBEDDING_SHARED_INCLUDE_ROOT}/Babylon/Embedding/View.h"
+    "Source/Runtime.cpp"
+    "Source/RuntimeImpl.h"
+    "Source/View.cpp")
+
+add_library(Embedding ${SOURCES})
+
+warnings_as_errors(Embedding)
+
+target_include_directories(Embedding PUBLIC "${EMBEDDING_SHARED_INCLUDE_ROOT}")
+
+# Always-on dependencies. The Embedding layer formalizes the canonical
+# Babylon Native setup, so the standard polyfills (Blob / Console / Fetch /
+# File / Performance / TextDecoder / TextEncoder / XMLHttpRequest) are
+# always linked.
+target_link_libraries(Embedding
+    PUBLIC napi
+    # GraphicsDevice is PUBLIC because View.h (a public header)
+    # references `Babylon::Graphics::WindowT` from <Babylon/Graphics/Platform.h>.
+    PUBLIC GraphicsDevice
+    # GraphicsDeviceContext is PRIVATE — needed so View.cpp can see
+    # <Babylon/Graphics/DeviceQueries.h> for the free
+    # `Babylon::Graphics::GetDevicePixelRatio(window)` helper used to
+    # convert physical → logical pixels on the first `View::Resize`
+    # call (before the `Device` exists or while it is still bound to
+    # the previous window on a re-attach). Internal Graphics types are
+    # never exposed across the Embedding public surface.
+    PRIVATE GraphicsDeviceContext
+    PRIVATE arcana
+    PRIVATE AppRuntime
+    PRIVATE ScriptLoader
+    PRIVATE Blob
+    PRIVATE Console
+    PRIVATE Fetch
+    PRIVATE File
+    PRIVATE Performance
+    PRIVATE TextDecoder
+    PRIVATE TextEncoder
+    PRIVATE XMLHttpRequest)
+
+# ----- Conditionally-included polyfills -----
+#
+# Each flag is exposed as a PUBLIC compile definition so the public
+# headers (Runtime.h / View.h) and the impl source files can both gate
+# on the same value via `#if BABYLON_NATIVE_*`.
+
+if(BABYLON_NATIVE_POLYFILL_WINDOW)
+    target_compile_definitions(Embedding PUBLIC BABYLON_NATIVE_POLYFILL_WINDOW=1)
+    target_link_libraries(Embedding PRIVATE Window)
+endif()
+
+if(BABYLON_NATIVE_POLYFILL_CANVAS)
+    target_compile_definitions(Embedding PUBLIC BABYLON_NATIVE_POLYFILL_CANVAS=1)
+    target_link_libraries(Embedding PRIVATE Canvas)
+endif()
+
+if(BABYLON_NATIVE_POLYFILL_ABORTCONTROLLER)
+    target_compile_definitions(Embedding PUBLIC BABYLON_NATIVE_POLYFILL_ABORTCONTROLLER=1)
+    target_link_libraries(Embedding PRIVATE AbortController)
+endif()
+
+if(BABYLON_NATIVE_POLYFILL_SCHEDULING)
+    target_compile_definitions(Embedding PUBLIC BABYLON_NATIVE_POLYFILL_SCHEDULING=1)
+    target_link_libraries(Embedding PRIVATE Scheduling)
+endif()
+
+if(BABYLON_NATIVE_POLYFILL_URL)
+    target_compile_definitions(Embedding PUBLIC BABYLON_NATIVE_POLYFILL_URL=1)
+    target_link_libraries(Embedding PRIVATE URL)
+endif()
+
+if(BABYLON_NATIVE_POLYFILL_WEBSOCKET)
+    target_compile_definitions(Embedding PUBLIC BABYLON_NATIVE_POLYFILL_WEBSOCKET=1)
+    target_link_libraries(Embedding PRIVATE WebSocket)
+endif()
+
+# ----- Conditionally-included plugins -----
+
+if(BABYLON_NATIVE_PLUGIN_NATIVEENGINE)
+    target_compile_definitions(Embedding PUBLIC BABYLON_NATIVE_PLUGIN_NATIVEENGINE=1)
+    target_link_libraries(Embedding PRIVATE NativeEngine)
+endif()
+
+if(BABYLON_NATIVE_PLUGIN_NATIVEINPUT)
+    target_compile_definitions(Embedding PUBLIC BABYLON_NATIVE_PLUGIN_NATIVEINPUT=1)
+    target_link_libraries(Embedding PRIVATE NativeInput)
+endif()
+
+if(BABYLON_NATIVE_PLUGIN_NATIVECAMERA)
+    target_compile_definitions(Embedding PUBLIC BABYLON_NATIVE_PLUGIN_NATIVECAMERA=1)
+    target_link_libraries(Embedding PRIVATE NativeCamera)
+endif()
+
+if(BABYLON_NATIVE_PLUGIN_NATIVECAPTURE)
+    target_compile_definitions(Embedding PUBLIC BABYLON_NATIVE_PLUGIN_NATIVECAPTURE=1)
+    target_link_libraries(Embedding PRIVATE NativeCapture)
+endif()
+
+if(BABYLON_NATIVE_PLUGIN_NATIVEENCODING)
+    target_compile_definitions(Embedding PUBLIC BABYLON_NATIVE_PLUGIN_NATIVEENCODING=1)
+    target_link_libraries(Embedding PRIVATE NativeEncoding)
+endif()
+
+if(BABYLON_NATIVE_PLUGIN_NATIVEOPTIMIZATIONS)
+    target_compile_definitions(Embedding PUBLIC BABYLON_NATIVE_PLUGIN_NATIVEOPTIMIZATIONS=1)
+    target_link_libraries(Embedding PRIVATE NativeOptimizations)
+endif()
+
+if(BABYLON_NATIVE_PLUGIN_NATIVETRACING)
+    target_compile_definitions(Embedding PUBLIC BABYLON_NATIVE_PLUGIN_NATIVETRACING=1)
+    target_link_libraries(Embedding PRIVATE NativeTracing)
+endif()
+
+if(BABYLON_NATIVE_PLUGIN_NATIVEXR AND TARGET NativeXr)
+    # Public surface: Runtime::SetXrWindow / IsXrActive when this flag
+    # is set. RuntimeImpl.h includes <Babylon/Plugins/NativeXr.h>, but
+    # that's an internal header so the dependency stays PRIVATE here.
+    # NativeXr is only compiled on Android/iOS (see Plugins/CMakeLists.txt),
+    # so we additionally check `TARGET NativeXr` to skip XR support on
+    # platforms where the plugin isn't built even if the flag is ON.
+    target_compile_definitions(Embedding PUBLIC BABYLON_NATIVE_PLUGIN_NATIVEXR=1)
+    target_link_libraries(Embedding PRIVATE NativeXr)
+endif()
+
+if(BABYLON_NATIVE_PLUGIN_SHADERCACHE)
+    target_compile_definitions(Embedding PUBLIC BABYLON_NATIVE_PLUGIN_SHADERCACHE=1)
+    target_link_libraries(Embedding PRIVATE ShaderCache)
+endif()
+
+if(BABYLON_NATIVE_PLUGIN_TESTUTILS)
+    target_compile_definitions(Embedding PUBLIC BABYLON_NATIVE_PLUGIN_TESTUTILS=1)
+    target_link_libraries(Embedding PRIVATE TestUtils)
+endif()
+
+set_property(TARGET Embedding PROPERTY FOLDER Embedding)
+source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${SOURCES})
+
+# ----- Per-platform interop layers -----
+#
+# Each platform's interop layer lives in its own subdirectory and is
+# opt-in via its own CMake flag. They depend on the cross-platform
+# `Embedding` target above.
+
+if(BABYLON_NATIVE_EMBEDDING_ANDROID)
+    add_subdirectory(Android)
+endif()
+
+if(BABYLON_NATIVE_EMBEDDING_APPLE)
+    add_subdirectory(Apple)
+endif()
diff --git a/Embedding/Include/Platform/Android/Babylon/Embedding/Android/RuntimeHandle.h b/Embedding/Include/Platform/Android/Babylon/Embedding/Android/RuntimeHandle.h
new file mode 100644
index 000000000..e7008c3e5
--- /dev/null
+++ b/Embedding/Include/Platform/Android/Babylon/Embedding/Android/RuntimeHandle.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <Babylon/Embedding/Runtime.h>
+
+#include <jni.h>
+
+namespace Babylon::Embedding::Android
+{
+    // Convert a jlong handle from `runtimeCreate` back to a Runtime*.
+    // The JNI layer wraps each Runtime in an internal struct that also
+    // holds Activity-lifecycle tickets, so `reinterpret_cast<Runtime*>`
+    // is wrong — hosts shipping their own JNI helpers must go through
+    // this. Returns nullptr if handle is 0.
+    Runtime* RuntimeFromHandle(jlong handle);
+}
\ No newline at end of file
diff --git a/Embedding/Include/Platform/Apple/Babylon/Embedding/Apple/BNRuntime.h b/Embedding/Include/Platform/Apple/Babylon/Embedding/Apple/BNRuntime.h
new file mode 100644
index 000000000..cac73f4f7
--- /dev/null
+++ b/Embedding/Include/Platform/Apple/Babylon/Embedding/Apple/BNRuntime.h
@@ -0,0 +1,97 @@
+// BNRuntime.h — public Obj-C interface for the Babylon::Embedding
+// runtime on Apple platforms (iOS, macOS, visionOS).
+//
+// Swift consumers see this through the auto-generated Swift bridge
+// (BNRuntime is exposed to Swift as `BNRuntime`).
+
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+@class MTKView;
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface BNRuntimeOptions : NSObject
+
+/// Optional MSAA sample count for the back buffer. Valid values are 0, 2, 4, 8, and 16.
+/// Defaults to the shared C++ RuntimeOptions value when nil.
+@property (nonatomic, strong, nullable) NSNumber* msaaSamples;
+
+/// Enable the JavaScript debugger when supported by the configured JS engine.
+/// Defaults to NO, matching the shared C++ RuntimeOptions default.
+@property (nonatomic) BOOL enableDebugger;
+
+/// Enable Babylon::DebugTrace output through the default log sink.
+/// Defaults to NO, matching the shared C++ RuntimeOptions default.
+@property (nonatomic) BOOL enableDebugTrace;
+
+/// Block engine startup until a debugger attaches when supported by the configured JS engine.
+/// Defaults to NO, matching the shared C++ RuntimeOptions default.
+@property (nonatomic) BOOL waitForDebugger;
+
+/// Optional writable file path for a persistent on-disk GPU shader cache. Defaults to nil.
+@property (nonatomic, copy, nullable) NSString* shaderCachePath;
+
+@end
+
+@interface BNRuntime : NSObject
+
+/// Constructs the runtime: starts the JS engine/thread and sets up
+/// non-GPU polyfills/plugins. The GPU Device is deferred to the first
+/// `BNView` attach. Default options: debugger off, DebugTrace off,
+/// log routes to `os_log`.
+///
+/// Returns `nil` if the runtime can't be constructed (see
+/// `initWithOptions:`).
+- (nullable instancetype)init;
+
+/// Constructs the runtime with platform-friendly options (nil = same
+/// defaults as `init`).
+///
+/// `options.shaderCachePath`: loaded on first BNView attach; saved on
+/// `suspend` and on deallocation.
+///
+/// Returns `nil` on failure — e.g. `options.shaderCachePath` is non-nil
+/// but the native library was built without
+/// `BABYLON_NATIVE_PLUGIN_SHADERCACHE`, or the underlying engine fails to
+/// start. The reason is written to `os_log`. (Returning `nil` rather than
+/// raising keeps the failure catchable from Swift and consistent with
+/// `BNView`'s failable init.)
+- (nullable instancetype)initWithOptions:(nullable BNRuntimeOptions*)options NS_DESIGNATED_INITIALIZER;
+
+/// Load a script from a URL onto the JS thread. Calls made before the
+/// first `BNView` is created are queued and dispatched after engine
+/// init completes during that first attach; calls after first attach
+/// are dispatched immediately.
+- (void)loadScript:(NSString*)url;
+
+/// Evaluate JavaScript on the JS thread. Same queueing as `loadScript`.
+- (void)eval:(NSString*)source sourceURL:(NSString*)sourceURL;
+
+/// Reference-counted suspend. While suspended, JS timers pause and
+/// any attached `BNView` becomes a no-op for `renderFrame`.
+- (void)suspend;
+
+/// Decrement the suspend count; resume when it reaches zero.
+- (void)resume;
+
+/// Whether the runtime is currently suspended.
+@property (nonatomic, readonly, getter=isSuspended) BOOL suspended;
+
+/// Set the view that XR will render into (typically a transparent
+/// MTKView overlay distinct from the main view's Metal layer). Pass
+/// `nil` to clear. Safe to call before the first `BNView` attach;
+/// applied when NativeXr finishes initializing.
+///
+/// Raises `BabylonNativePluginNotEnabledException` when
+/// `BABYLON_NATIVE_PLUGIN_NATIVEXR` is not enabled at native build time.
+- (void)setXrView:(nullable MTKView*)xrView;
+
+/// `YES` while an XR session is active. Safe to poll from any thread.
+/// Returns `NO` when `BABYLON_NATIVE_PLUGIN_NATIVEXR` is not enabled.
+@property (nonatomic, readonly, getter=isXRActive) BOOL xrActive;
+
+@end
+
+NS_ASSUME_NONNULL_END
\ No newline at end of file
diff --git a/Embedding/Include/Platform/Apple/Babylon/Embedding/Apple/BNRuntimeNative.h b/Embedding/Include/Platform/Apple/Babylon/Embedding/Apple/BNRuntimeNative.h
new file mode 100644
index 000000000..b8c0b4681
--- /dev/null
+++ b/Embedding/Include/Platform/Apple/Babylon/Embedding/Apple/BNRuntimeNative.h
@@ -0,0 +1,25 @@
+// Obj-C++ escape hatch for host-specific helpers layered on top of
+// Babylon Native's Apple Embedding runtime.
+
+#pragma once
+
+#import <Babylon/Embedding/Apple/BNRuntime.h>
+
+#ifdef __cplusplus
+
+#include <Babylon/Embedding/Runtime.h>
+
+namespace Babylon::Embedding::Apple
+{
+    // Convert a BNRuntime wrapper back to its underlying C++ Runtime.
+    //
+    // Hosts that ship small app-specific Obj-C++ helpers alongside the
+    // Apple Embedding layer can use this to access C++ escape hatches
+    // such as Runtime::RunOnJsThread without making those concepts part
+    // of the Swift/Objective-C BNRuntime surface.
+    //
+    // Returns nullptr if runtime is nil.
+    Runtime* RuntimeFromBNRuntime(BNRuntime* runtime);
+}
+
+#endif
\ No newline at end of file
diff --git a/Embedding/Include/Platform/Apple/Babylon/Embedding/Apple/BNView.h b/Embedding/Include/Platform/Apple/Babylon/Embedding/Apple/BNView.h
new file mode 100644
index 000000000..6824d5294
--- /dev/null
+++ b/Embedding/Include/Platform/Apple/Babylon/Embedding/Apple/BNView.h
@@ -0,0 +1,140 @@
+// BNView.h — public Obj-C interface for the Babylon::Embedding view
+// on Apple platforms.
+//
+// Construct against a host-provided `MTKView`. The first BNView against
+// a given BNRuntime triggers GPU device construction, plugin init, and
+// queued-script flushing. Subsequent attaches are cheap surface rebinds.
+//
+// If the MTKView has no delegate when BNView is constructed, BNView
+// installs and retains a `BNViewDelegate` automatically. If the host
+// installed a delegate first (typically a BNViewDelegate subclass for
+// per-frame work), BNView leaves it alone.
+
+#pragma once
+
+#import <Foundation/Foundation.h>
+#import <CoreGraphics/CoreGraphics.h>
+#import <MetalKit/MTKView.h>
+
+@class BNRuntime;
+@class BNView;
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// Mouse buttons accepted by `-mouseDown:atX:y:` / `-mouseUp:atX:y:`.
+/// Obj-C can't nest a type in `@interface`, so the enum is prefixed and
+/// surfaced to Swift nested as `BNView.MouseButton` (`.left` / `.middle`
+/// / `.right`).
+typedef NS_ENUM(NSInteger, BNViewMouseButton) {
+    BNViewMouseButtonLeft,
+    BNViewMouseButtonMiddle,
+    BNViewMouseButtonRight,
+} NS_SWIFT_NAME(BNView.MouseButton);
+
+/// Scroll-wheel axes accepted by `-mouseWheel:delta:`.
+/// Surfaced to Swift nested as `BNView.MouseWheelAxis` (`.y`).
+typedef NS_ENUM(NSInteger, BNViewMouseWheelAxis) {
+    BNViewMouseWheelAxisY,
+} NS_SWIFT_NAME(BNView.MouseWheelAxis);
+
+/// Default `MTKViewDelegate` implementation that drives a BNView's
+/// per-frame rendering: forwards `drawInMTKView:` → `[bnView renderFrame]`.
+///
+/// It does NOT drive resize — BNView sets `autoResizeDrawable = NO`, so
+/// MTKView no longer reports size changes and the host drives resize
+/// explicitly from a layout hook (see `-[BNView resizeWithWidth:height:]`).
+///
+/// BNView installs and retains one automatically when constructed
+/// against an MTKView that has no delegate. To insert per-frame work,
+/// subclass this, override `drawInMTKView:`, and call `super`.
+@interface BNViewDelegate : NSObject <MTKViewDelegate>
+
+/// Initialize a delegate that drives `view`. The reference is weak;
+/// the host (or BNView, for the auto-installed instance) keeps the
+/// BNView alive.
+- (nullable instancetype)initWithView:(BNView*)view NS_DESIGNATED_INITIALIZER;
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+@end
+
+@interface BNView : NSObject
+
+/// Attach `runtime` to render into `view`. On the first attach for a
+/// given runtime this triggers GPU device construction and engine
+/// initialization; subsequent attaches just rebind the surface.
+///
+/// Returns `nil` if `runtime` or `view` is `nil`, or if constructing the
+/// underlying `Babylon::Embedding::View` throws (another View is
+/// already attached to the runtime).
+///
+/// **Delegate management:** If `view.delegate` is nil, BNView creates a
+/// BNViewDelegate and assigns it (held strongly for the BNView's
+/// lifetime, since MTKView.delegate is `weak`). If the host already
+/// set a delegate, BNView leaves it alone and the host drives
+/// `-renderFrame`. Either way the host must drive `-resizeWithWidth:height:`
+/// from a layout hook; the delegate never does (BNView sets
+/// `autoResizeDrawable = NO`, so MTKView reports no size changes).
+- (nullable instancetype)initWithRuntime:(BNRuntime*)runtime view:(MTKView*)view;
+
+/// Render exactly one frame. Call from your MTKViewDelegate's
+/// `drawInMTKView:`, or rely on the auto-installed BNViewDelegate.
+- (void)renderFrame;
+
+/// Inform the runtime that the view's size has changed. Call this from
+/// your view-controller layout hook — `-viewDidLayoutSubviews` on UIKit,
+/// `-viewDidLayout` on AppKit — passing the MTKView's `bounds.size`.
+///
+/// Sizes are in **logical** points (CSS pixels); BNView applies the
+/// device-pixel-ratio internally. Babylon's render resolution then
+/// follows the engine's hardware scaling level (logical by default, or
+/// physical when `adaptToDevicePixelRatio` is enabled).
+- (void)resizeWithWidth:(NSUInteger)width height:(NSUInteger)height
+    NS_SWIFT_NAME(resize(width:height:));
+
+/// Forward a pointer event. `x`, `y` are logical (CSS) pixels — pass
+/// `UITouch.location(in:)` (UIKit) or `NSEvent.locationInWindow`
+/// (AppKit) coordinates through unchanged.
+///
+/// Raises `BabylonNativePluginNotEnabledException` when
+/// `BABYLON_NATIVE_PLUGIN_NATIVEINPUT` is not enabled. Same applies to
+/// `pointerMove:` and `pointerUp:`.
+- (void)pointerDown:(NSInteger)pointerId atX:(CGFloat)x y:(CGFloat)y
+    NS_SWIFT_NAME(pointerDown(id:x:y:));
+
+- (void)pointerMove:(NSInteger)pointerId atX:(CGFloat)x y:(CGFloat)y
+    NS_SWIFT_NAME(pointerMove(id:x:y:));
+
+- (void)pointerUp:(NSInteger)pointerId atX:(CGFloat)x y:(CGFloat)y
+    NS_SWIFT_NAME(pointerUp(id:x:y:));
+
+/// Forward a mouse-button event. `button` selects which button. `x`, `y`
+/// are logical (CSS) pixels; AppKit hosts pass `NSEvent.locationInWindow`
+/// with the Y axis flipped to a top-left origin.
+///
+/// Raises `BabylonNativePluginNotEnabledException` when
+/// `BABYLON_NATIVE_PLUGIN_NATIVEINPUT` is not enabled. Same applies to
+/// `mouseUp:`, `mouseMove:`, and `mouseWheel:`.
+- (void)mouseDown:(BNViewMouseButton)button atX:(CGFloat)x y:(CGFloat)y
+    NS_SWIFT_NAME(mouseDown(button:x:y:));
+
+- (void)mouseUp:(BNViewMouseButton)button atX:(CGFloat)x y:(CGFloat)y
+    NS_SWIFT_NAME(mouseUp(button:x:y:));
+
+- (void)mouseMoveAtX:(CGFloat)x y:(CGFloat)y
+    NS_SWIFT_NAME(mouseMove(x:y:));
+
+/// Forward a scroll-wheel event. `axis` selects which axis. `delta` is the
+/// signed scroll amount; AppKit hosts pass `-NSEvent.deltaY` so scroll-up
+/// matches Babylon's negative convention. The fractional delta is truncated
+/// to an integer for the underlying input pipeline.
+- (void)mouseWheel:(BNViewMouseWheelAxis)axis delta:(CGFloat)delta
+    NS_SWIFT_NAME(mouseWheel(axis:delta:));
+
+- (instancetype)init NS_UNAVAILABLE;
++ (instancetype)new NS_UNAVAILABLE;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/Embedding/Include/Platform/Apple/Babylon/Embedding/Apple/BabylonNativeEmbedding.h b/Embedding/Include/Platform/Apple/Babylon/Embedding/Apple/BabylonNativeEmbedding.h
new file mode 100644
index 000000000..4350ddbe5
--- /dev/null
+++ b/Embedding/Include/Platform/Apple/Babylon/Embedding/Apple/BabylonNativeEmbedding.h
@@ -0,0 +1,8 @@
+// Umbrella header for the Babylon::Embedding Apple interop layer.
+// Import this from Swift via the bridging header (or from Obj-C).
+
+#pragma once
+
+#import <Babylon/Embedding/Apple/BNRuntime.h>
+#import <Babylon/Embedding/Apple/BNRuntimeNative.h>
+#import <Babylon/Embedding/Apple/BNView.h>
\ No newline at end of file
diff --git a/Embedding/Include/Shared/Babylon/Embedding/LogLevel.h b/Embedding/Include/Shared/Babylon/Embedding/LogLevel.h
new file mode 100644
index 000000000..457aa7214
--- /dev/null
+++ b/Embedding/Include/Shared/Babylon/Embedding/LogLevel.h
@@ -0,0 +1,23 @@
+#pragma once
+
+namespace Babylon::Embedding
+{
+    // Severity levels for the RuntimeOptions log callback. Ordered by
+    // increasing severity so hosts can do `level >= LogLevel::Warn` filtering.
+    //
+    //   Verbose : `Babylon::DebugTrace` messages (only when
+    //             `enableDebugTrace` is set).
+    //   Log/Warn/Error : `console.log/warn/error`. Mirrors
+    //             `Babylon::Polyfills::Console::LogLevel`.
+    //   Fatal   : uncaught JS exceptions that escaped every JS-side handler.
+    //             Engine state may be inconsistent after a Fatal; hosts can
+    //             terminate from the callback if desired.
+    enum class LogLevel
+    {
+        Verbose,
+        Log,
+        Warn,
+        Error,
+        Fatal,
+    };
+}
\ No newline at end of file
diff --git a/Embedding/Include/Shared/Babylon/Embedding/Runtime.h b/Embedding/Include/Shared/Babylon/Embedding/Runtime.h
new file mode 100644
index 000000000..c8c8d8bff
--- /dev/null
+++ b/Embedding/Include/Shared/Babylon/Embedding/Runtime.h
@@ -0,0 +1,113 @@
+#pragma once
+
+#include <Babylon/Embedding/RuntimeOptions.h>
+
+#include <napi/env.h>
+
+#include <functional>
+#include <memory>
+#include <string_view>
+
+namespace Babylon::Embedding
+{
+    class View;
+    struct RuntimeImpl;
+
+    // Long-lived: typically created once per app/process. Sets up the
+    // AppRuntime (JS thread + Napi env), JsRuntime, and non-GPU
+    // polyfills/plugins. Construction is cheap and synchronous; the GPU
+    // Device and plugins (NativeEngine, etc.) are deferred to the first
+    // attached `View`.
+    class Runtime
+    {
+    public:
+        explicit Runtime(RuntimeOptions options = {});
+
+        // // Future construction mode: adopt a host-owned Babylon::JsRuntime
+        // // (e.g. React Native with Hermes/JSC + CallInvoker). In Attach mode
+        // // `~Runtime` does NOT tear down the JS engine, and Suspend/Resume
+        // // only toggles Device rendering.
+        // static Runtime Adopt(Babylon::JsRuntime& jsRuntime,
+        //                      RuntimeOptions options = {});
+
+        ~Runtime();
+
+        // Non-copyable; movable. Cross-references point at the heap-allocated
+        // pimpls, so move-construction is always safe and never invalidates a
+        // back-pointer. Move-assignment is safe only when the destination has
+        // no View attached -- it destroys the destination's pimpl, which
+        // ~RuntimeImpl guards with assert(m_currentView == nullptr).
+        Runtime(const Runtime&) = delete;
+        Runtime& operator=(const Runtime&) = delete;
+        Runtime(Runtime&&) noexcept;
+        Runtime& operator=(Runtime&&) noexcept;
+
+        // ----- JS interaction -----
+        //
+        // Calls made before the first `View` is attached are queued and
+        // dispatched onto the JS thread after engine initialization
+        // completes during that first attach. Calls after first attach are
+        // dispatched immediately.
+        //
+        // Not internally synchronized — call from a single thread (typically
+        // the host's UI/main thread), matching `Babylon::ScriptLoader` /
+        // `AppRuntime::Dispatch`.
+        void LoadScript(std::string_view url);
+        void Eval(std::string_view source, std::string_view sourceUrl = {});
+
+        // Escape hatch: post `callback` onto the JS thread after engine
+        // initialization completes. Useful for installing custom Napi globals,
+        // registering ObjectWrap classes, or capturing FunctionReferences for
+        // native→JS calls. Same single-thread contract as LoadScript / Eval.
+        //
+        // `afterScriptLoad`:
+        //   false (default) — dispatch via `AppRuntime::Dispatch`. The callback
+        //     runs on the JS thread as soon as init is complete; it is NOT
+        //     serialized behind queued `LoadScript` / `Eval` calls and may
+        //     interleave with their execution.
+        //   true — dispatch via `ScriptLoader::Dispatch`. The callback is
+        //     serialized behind any earlier `LoadScript` / `Eval` / `RunOnJsThread(true)`
+        //     calls, so it observes the JS state after those have finished.
+        void RunOnJsThread(std::function<void(Napi::Env)> callback, bool afterScriptLoad = false);
+
+        // ----- Suspend / Resume -----
+        //
+        // Orthogonal to view attachment. Use for backgrounding, throttling,
+        // modal dialogs, etc. While suspended:
+        //   - JS timers (setTimeout/setInterval) pause.
+        //   - In-flight microtasks complete; no new tasks are dispatched.
+        //   - Any attached View's RenderFrame() becomes a no-op.
+        // Reference-counted; nesting is safe.
+        //
+        // `Suspend` / `Resume` must be called from the frame thread (same
+        // thread driving `View::RenderFrame` / `View::Resize`). Platform
+        // lifecycle callbacks fire on the main thread already, so wiring them
+        // up gets this for free. `IsSuspended` is atomic and safe from any
+        // thread.
+        void Suspend();
+        void Resume();
+        bool IsSuspended() const;
+
+#if BABYLON_NATIVE_PLUGIN_NATIVEXR
+        // ----- XR session control -----
+        //
+        // Set the platform window XR will render into:
+        //   Android : ANativeWindow*  (typically a transparent SurfaceView overlay)
+        //   Apple   : CAMetalLayer* / MTKView* (separate Metal layer from the main View)
+        //
+        // Pass nullptr to clear. Safe to call before the first `View` is
+        // attached (the window is applied when NativeXr finishes
+        // initializing) and from any thread.
+        void SetXrWindow(void* nativeWindow);
+
+        // True while an XR session is active. Atomic; safe to poll from any
+        // thread (e.g. a draw callback selecting render targets).
+        bool IsXrActive() const;
+#endif
+
+    private:
+        friend class View;
+
+        std::unique_ptr<RuntimeImpl> m_impl;
+    };
+}
\ No newline at end of file
diff --git a/Embedding/Include/Shared/Babylon/Embedding/RuntimeOptions.h b/Embedding/Include/Shared/Babylon/Embedding/RuntimeOptions.h
new file mode 100644
index 000000000..323d674e2
--- /dev/null
+++ b/Embedding/Include/Shared/Babylon/Embedding/RuntimeOptions.h
@@ -0,0 +1,58 @@
+#pragma once
+
+#include <Babylon/Embedding/LogLevel.h>
+
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <string_view>
+
+namespace Babylon::Embedding
+{
+    struct RuntimeOptions
+    {
+        // MSAA sample count for the back buffer. Valid values: 0, 2, 4, 8, 16.
+        // Anything else disables MSAA.
+        uint8_t msaaSamples{4};
+
+        // Enable the JavaScript debugger. Only implemented for V8 and Chakra.
+        bool enableDebugger{false};
+
+        // Enable Babylon::DebugTrace. If a log sink is provided, DebugTrace
+        // output is forwarded to it as LogLevel::Verbose.
+        bool enableDebugTrace{false};
+
+        // Block engine startup until a debugger has attached. Only
+        // implemented for V8.
+        bool waitForDebugger{false};
+
+        // Optional log sink. Receives:
+        //   - `console.{log,warn,error}`     → LogLevel::{Log,Warn,Error}
+        //   - `Babylon::DebugTrace` output    → LogLevel::Verbose (when
+        //                                       enableDebugTrace is true)
+        //   - Uncaught JS exceptions          → LogLevel::Fatal
+        //
+        // For Error and Fatal messages, a JS callstack is appended to the
+        // message body when the underlying JS engine can produce one. This
+        // is best-effort and silently omitted on engines / contexts that
+        // can't (the message body just won't contain a "JS callstack:" /
+        // "Stack:" trailer).
+        //
+        // If unset, log output is discarded and uncaught exceptions fall
+        // back to `Babylon::AppRuntime::DefaultUnhandledExceptionHandler`.
+        // Hosts that want process termination on uncaught exceptions can do
+        // so from this callback, e.g. `if (level == Fatal) std::quick_exit(1);`.
+        std::function<void(LogLevel, std::string_view)> log;
+
+#if BABYLON_NATIVE_PLUGIN_SHADERCACHE
+        // Optional path for persisting the GPU shader cache across sessions.
+        // If non-empty:
+        //   - Loaded synchronously during the first View attach (missing
+        //     or unreadable file: ignored).
+        //   - Saved synchronously during `Runtime::Suspend` (after the
+        //     in-flight frame is closed, when the engine is quiescent).
+        //   - Saved synchronously during `~Runtime`.
+        std::string shaderCachePath;
+#endif
+    };
+}
\ No newline at end of file
diff --git a/Embedding/Include/Shared/Babylon/Embedding/View.h b/Embedding/Include/Shared/Babylon/Embedding/View.h
new file mode 100644
index 000000000..1b31276ac
--- /dev/null
+++ b/Embedding/Include/Shared/Babylon/Embedding/View.h
@@ -0,0 +1,115 @@
+#pragma once
+
+#include <Babylon/Graphics/Platform.h>
+
+#include <cstdint>
+#include <memory>
+
+namespace Babylon::Embedding
+{
+    class Runtime;
+    struct ViewImpl;
+
+    // Units for coordinates / dimensions passed to View methods. Babylon.js
+    // works in **logical** (CSS / DIP) pixels; the View divides by the
+    // Device's device-pixel-ratio when given Physical values so hosts can
+    // pass whatever their native event/surface API delivers.
+    //
+    //   Physical: Android MotionEvent / ANativeWindow, Apple
+    //             CAMetalLayer.drawableSize, Win32 WM_POINTER* /
+    //             GetClientRect, X11 button events.
+    //   Logical:  iOS UITouch, macOS NSEvent, UWP PointerPoint /
+    //             CoreWindow.Bounds, or any code that already divided by DPR.
+    enum class CoordinateUnits
+    {
+        Physical,
+        Logical,
+    };
+
+    // Transient: constructed against a host surface, destroyed when the
+    // surface goes away. **At most one View may be attached to a Runtime
+    // at a time**; multiple sequential Views may share one Runtime over
+    // its lifetime. To switch surfaces, destroy the current View and
+    // construct a new one.
+    class View
+    {
+    public:
+        // Attach to `runtime`, binding `nativeWindow` (platform-specific
+        // surface handle: HWND on Win32, ANativeWindow* on Android,
+        // CA::MetalLayer* on Apple, X11 Window, winrt::IInspectable). The
+        // host owns the surface size; the View binds the window to the
+        // Device on the first `Resize`. Hosts MUST call `Resize` at least
+        // once with the surface's pixel dimensions before the first frame
+        // is rendered.
+        //
+        // Throws `std::runtime_error` if another View is already attached
+        // to this Runtime.
+        //
+        // The first attach for a given Runtime is the heavy step: the
+        // first `Resize` after this constructs the Device, initializes
+        // GPU plugins (`Device::AddToJavaScript`, `NativeEngine::Initialize`,
+        // `NativeInput::CreateForJavaScript`), flushes queued `LoadScript`
+        // calls, and opens the first frame. Subsequent attaches on the
+        // same Runtime just rebind the Device to the new surface.
+        // Destroying the View closes the in-flight frame; the Device
+        // persists on the Runtime so the next View is fast.
+        //
+        // Must be called from the "frame thread" — the same thread that
+        // will call `RenderFrame` and `Resize`.
+        View(Runtime& runtime, Babylon::Graphics::WindowT nativeWindow);
+
+        ~View();
+
+        View(const View&) = delete;
+        View& operator=(const View&) = delete;
+        View(View&&) noexcept;
+        View& operator=(View&&) noexcept;
+
+        // Render exactly one frame on the frame thread. No-op if the runtime
+        // is suspended. Called from the platform view/control's draw callback
+        // (WM_PAINT, MTKViewDelegate::draw, View.onDraw, ...).
+        void RenderFrame();
+
+        // Resize the bound surface. Pass whatever units your view layer reports;
+        // the View converts to logical internally when `units == Physical`.
+        // Must be called from the frame thread.
+        void Resize(uint32_t width, uint32_t height, CoordinateUnits units);
+
+#if BABYLON_NATIVE_PLUGIN_NATIVEINPUT
+        // Pointer / mouse input forwarding. Host calls these from its event
+        // loop while the view exists; routed to the JS thread via NativeInput
+        // and consumed by Babylon.js as PointerEvent.clientX/clientY (logical
+        // pixels). Pass whatever units your event system delivers — see
+        // CoordinateUnits above.
+        //
+        // OnPointer* / OnMouse* differ in pointerType ('touch' vs 'mouse').
+        // Touch-driven hosts (Android, iOS) use OnPointer*; cursor-driven hosts
+        // (Win32, macOS, UWP, X11) use OnMouse*.
+        //
+        // Keyboard input is not exposed; forward to JS via Runtime::RunOnJsThread.
+        //
+        // Safe to call from any thread.
+
+        void OnPointerDown(int32_t pointerId, float x, float y, CoordinateUnits units);
+        void OnPointerMove(int32_t pointerId, float x, float y, CoordinateUnits units);
+        void OnPointerUp(int32_t pointerId, float x, float y, CoordinateUnits units);
+
+        // Mouse events. `buttonIndex` is one of LeftMouseButton() /
+        // MiddleMouseButton() / RightMouseButton(); `wheelAxis` is MouseWheelY().
+        // These accessors return the matching NativeInput button/axis IDs
+        // without leaking the NativeInput header into this public View.h.
+        void OnMouseDown(uint32_t buttonIndex, float x, float y, CoordinateUnits units);
+        void OnMouseUp(uint32_t buttonIndex, float x, float y, CoordinateUnits units);
+        void OnMouseMove(float x, float y, CoordinateUnits units);
+        void OnMouseWheel(uint32_t wheelAxis, int32_t scrollValue);
+
+        static uint32_t LeftMouseButton();
+        static uint32_t MiddleMouseButton();
+        static uint32_t RightMouseButton();
+        static uint32_t MouseWheelY();
+#endif
+
+    private:
+        std::unique_ptr<ViewImpl> m_impl;
+    };
+}
\ No newline at end of file
diff --git a/Embedding/Source/Runtime.cpp b/Embedding/Source/Runtime.cpp
new file mode 100644
index 000000000..5a7acfa88
--- /dev/null
+++ b/Embedding/Source/Runtime.cpp
@@ -0,0 +1,458 @@
+#include "RuntimeImpl.h"
+
+#include <Babylon/DebugTrace.h>
+
+#if BABYLON_NATIVE_PLUGIN_NATIVEENGINE
+#include <Babylon/Plugins/NativeEngine.h>
+#endif
+#if BABYLON_NATIVE_PLUGIN_NATIVECAMERA
+#include <Babylon/Plugins/NativeCamera.h>
+#endif
+#if BABYLON_NATIVE_PLUGIN_NATIVECAPTURE
+#include <Babylon/Plugins/NativeCapture.h>
+#endif
+#if BABYLON_NATIVE_PLUGIN_NATIVEENCODING
+#include <Babylon/Plugins/NativeEncoding.h>
+#endif
+#if BABYLON_NATIVE_PLUGIN_NATIVEOPTIMIZATIONS
+#include <Babylon/Plugins/NativeOptimizations.h>
+#endif
+#if BABYLON_NATIVE_PLUGIN_NATIVETRACING
+#include <Babylon/Plugins/NativeTracing.h>
+#endif
+#if BABYLON_NATIVE_PLUGIN_SHADERCACHE
+#include <Babylon/Plugins/ShaderCache.h>
+#endif
+#if BABYLON_NATIVE_PLUGIN_TESTUTILS
+#include <Babylon/Plugins/TestUtils.h>
+#endif
+
+#include <Babylon/Polyfills/Blob.h>
+#include <Babylon/Polyfills/Console.h>
+#include <Babylon/Polyfills/Fetch.h>
+#include <Babylon/Polyfills/File.h>
+#include <Babylon/Polyfills/Performance.h>
+#include <Babylon/Polyfills/TextDecoder.h>
+#include <Babylon/Polyfills/TextEncoder.h>
+#include <Babylon/Polyfills/XMLHttpRequest.h>
+
+#if BABYLON_NATIVE_POLYFILL_ABORTCONTROLLER
+#include <Babylon/Polyfills/AbortController.h>
+#endif
+
+#if BABYLON_NATIVE_POLYFILL_SCHEDULING
+#include <Babylon/Polyfills/Scheduling.h>
+#endif
+
+#if BABYLON_NATIVE_POLYFILL_URL
+#include <Babylon/Polyfills/URL.h>
+#endif
+
+#if BABYLON_NATIVE_POLYFILL_WEBSOCKET
+#include <Babylon/Polyfills/WebSocket.h>
+#endif
+
+#if BABYLON_NATIVE_POLYFILL_WINDOW
+#include <Babylon/Polyfills/Window.h>
+#endif
+
+#include <cassert>
+#include <fstream>
+#include <sstream>
+#include <utility>
+
+namespace Babylon::Embedding
+{
+    namespace
+    {
+        // Forward Babylon Console levels to the public LogLevel enum so
+        // consumers don't need to depend on the Console polyfill header.
+        LogLevel ToEmbeddingLogLevel(Babylon::Polyfills::Console::LogLevel level)
+        {
+            switch (level)
+            {
+                case Babylon::Polyfills::Console::LogLevel::Log: return LogLevel::Log;
+                case Babylon::Polyfills::Console::LogLevel::Warn: return LogLevel::Warn;
+                case Babylon::Polyfills::Console::LogLevel::Error: return LogLevel::Error;
+            }
+            return LogLevel::Log;
+        }
+    }
+    RuntimeImpl::RuntimeImpl(RuntimeOptions options)
+        : m_options{std::move(options)}
+    {
+        // Forward DebugTrace through the host log callback (Verbose level
+        // for easy filtering). DebugTrace is process-wide.
+        if (m_options.log)
+        {
+            const auto& logCallback = m_options.log;
+            Babylon::DebugTrace::SetTraceOutput([logCallback](const char* message) {
+                logCallback(LogLevel::Verbose, message ? message : "");
+            });
+        }
+        Babylon::DebugTrace::EnableDebugTrace(m_options.enableDebugTrace);
+
+        // Construct AppRuntime: starts the JS thread and creates a Napi::Env.
+        // Plugin Initialize() calls are dispatched onto this thread by the
+        // first View attach.
+        Babylon::AppRuntime::Options appRuntimeOptions{};
+        appRuntimeOptions.EnableDebugger = m_options.enableDebugger;
+        appRuntimeOptions.WaitForDebugger = m_options.waitForDebugger;
+
+        // Route uncaught JS exceptions to the host log callback as Fatal.
+        // If no callback is set, the AppRuntime default writes to program output.
+        if (m_options.log)
+        {
+            const auto& logCallback = m_options.log;
+            appRuntimeOptions.UnhandledExceptionHandler = [logCallback](const Napi::Error& error) {
+                std::ostringstream ss{};
+                ss << "[Uncaught Error] " << Napi::GetErrorString(error);
+                logCallback(LogLevel::Fatal, ss.str());
+            };
+        }
+
+        m_appRuntime.emplace(std::move(appRuntimeOptions));
+
+        // ScriptLoader's dispatcher captures &m_appRuntime, so ~ScriptLoader
+        // must run before ~AppRuntime.
+        m_scriptLoader.emplace(*m_appRuntime);
+    }
+
+    RuntimeImpl::~RuntimeImpl()
+    {
+        // Host owns the ordering: destroy Views before their Runtime.
+        assert(m_currentView == nullptr && "View must be destroyed before its Runtime.");
+
+        // Teardown order:
+        //   1. SaveShaderCache: ~ViewImpl already ran ViewImpl::Suspend, so
+        //      the engine is quiescent and a host-thread Save is race-free.
+        //   2. ~ScriptLoader before ~AppRuntime (dispatcher captures it).
+        //   3. Canvas / NativeInput / NativeXr hold JS-thread-bound state;
+        //      drop them before joining the JS thread.
+        //   4. ~AppRuntime joins the JS thread.
+        //   5. ShaderCache::Disable balances first-attach Enable.
+        //   6. Device + DeviceUpdate last (JS thread referenced them).
+        //
+        // m_initTcs: if complete() was never called (no View ever attached),
+        // queued continuations are dropped on destruction, which is correct.
+#if BABYLON_NATIVE_PLUGIN_SHADERCACHE
+        SaveShaderCache();
+#endif
+
+        m_scriptLoader.reset();
+
+#if BABYLON_NATIVE_POLYFILL_CANVAS
+        m_canvas.reset();
+#endif
+
+#if BABYLON_NATIVE_PLUGIN_NATIVEINPUT
+        m_input = nullptr;
+#endif
+
+#if BABYLON_NATIVE_PLUGIN_NATIVEXR
+        m_nativeXr.reset();
+#endif
+
+        m_appRuntime.reset();
+
+#if BABYLON_NATIVE_PLUGIN_SHADERCACHE
+        if (m_device)
+        {
+            Babylon::Plugins::ShaderCache::Disable();
+        }
+#endif
+
+        m_deviceUpdate.reset();
+        m_device.reset();
+    }
+
+    // Dispatched onto the JS thread by the first View attach. Initializes
+    // all plugins/polyfills in the canonical Babylon Native order, then
+    // completes m_initTcs to unblock host calls that were queued before the
+    // first attach. Post-init, those host calls fire their continuation
+    // synchronously via inline_scheduler and submit straight to ScriptLoader.
+    void RuntimeImpl::RunFirstAttachInit(Babylon::Graphics::WindowT window)
+    {
+#if BABYLON_NATIVE_PLUGIN_SHADERCACHE
+        // Enable + hydrate before any JS-thread shader compilation. Both
+        // calls are host-thread safe since NativeEngine hasn't been
+        // initialized yet.
+        Babylon::Plugins::ShaderCache::Enable();
+        LoadShaderCache();
+#endif
+
+        m_appRuntime->Dispatch([implPtr = this, window](Napi::Env env) {
+            // 1. Make the Device available to JS.
+            implPtr->m_device->AddToJavaScript(env);
+
+            // 2. Polyfills (always-on).
+            Babylon::Polyfills::Blob::Initialize(env);
+            Babylon::Polyfills::File::Initialize(env);
+
+            {
+                const auto userLog = implPtr->m_options.log;
+                Babylon::Polyfills::Console::Initialize(env,
+                    [userLog, env](const char* message, Babylon::Polyfills::Console::LogLevel level) {
+                        if (!userLog || !message)
+                        {
+                            return;
+                        }
+
+                        // Promote console.error to "message + JS callstack" so
+                        // hosts get a usable diagnostic for recoverable JS
+                        // errors (Babylon.js routes most of its non-fatal
+                        // failures through console.error). Stack capture is
+                        // best-effort: engines without stack support return
+                        // empty, and we omit the trailer in that case.
+                        if (level == Babylon::Polyfills::Console::LogLevel::Error)
+                        {
+                            const auto jsStack = Babylon::Polyfills::Console::CaptureCurrentJsStack(env);
+                            if (!jsStack.empty())
+                            {
+                                std::string combined{message};
+                                combined.append("\nJS callstack:\n");
+                                combined.append(jsStack);
+                                userLog(LogLevel::Error, combined);
+                                return;
+                            }
+                        }
+
+                        userLog(ToEmbeddingLogLevel(level), message);
+                    });
+            }
+
+            Babylon::Polyfills::Performance::Initialize(env);
+
+#if BABYLON_NATIVE_POLYFILL_WINDOW
+            Babylon::Polyfills::Window::Initialize(env);
+#endif
+
+            Babylon::Polyfills::TextDecoder::Initialize(env);
+            Babylon::Polyfills::TextEncoder::Initialize(env);
+            Babylon::Polyfills::XMLHttpRequest::Initialize(env);
+            Babylon::Polyfills::Fetch::Initialize(env);
+
+#if BABYLON_NATIVE_POLYFILL_ABORTCONTROLLER
+            Babylon::Polyfills::AbortController::Initialize(env);
+#endif
+#if BABYLON_NATIVE_POLYFILL_SCHEDULING
+            Babylon::Polyfills::Scheduling::Initialize(env);
+#endif
+#if BABYLON_NATIVE_POLYFILL_URL
+            Babylon::Polyfills::URL::Initialize(env);
+#endif
+#if BABYLON_NATIVE_POLYFILL_WEBSOCKET
+            Babylon::Polyfills::WebSocket::Initialize(env);
+#endif
+
+#if BABYLON_NATIVE_POLYFILL_CANVAS
+            implPtr->m_canvas.emplace(Babylon::Polyfills::Canvas::Initialize(env));
+#endif
+
+            // 3. Plugins.
+#if BABYLON_NATIVE_PLUGIN_NATIVETRACING
+            Babylon::Plugins::NativeTracing::Initialize(env);
+#endif
+#if BABYLON_NATIVE_PLUGIN_NATIVEENCODING
+            Babylon::Plugins::NativeEncoding::Initialize(env);
+#endif
+#if BABYLON_NATIVE_PLUGIN_NATIVEENGINE
+            Babylon::Plugins::NativeEngine::Initialize(env);
+#endif
+#if BABYLON_NATIVE_PLUGIN_NATIVEOPTIMIZATIONS
+            Babylon::Plugins::NativeOptimizations::Initialize(env);
+#endif
+#if BABYLON_NATIVE_PLUGIN_NATIVECAPTURE
+            Babylon::Plugins::NativeCapture::Initialize(env);
+#endif
+#if BABYLON_NATIVE_PLUGIN_NATIVECAMERA
+            Babylon::Plugins::NativeCamera::Initialize(env);
+#endif
+#if BABYLON_NATIVE_PLUGIN_NATIVEINPUT
+            implPtr->m_input = &Babylon::Plugins::NativeInput::CreateForJavaScript(env);
+#endif
+#if BABYLON_NATIVE_PLUGIN_NATIVEXR
+            // Initialize NativeXr, apply any pending xr window from a prior
+            // SetXrWindow, and wire the session-state callback.
+            {
+                std::lock_guard<std::mutex> xrLock{implPtr->m_xrMutex};
+                implPtr->m_nativeXr.emplace(Babylon::Plugins::NativeXr::Initialize(env));
+                if (implPtr->m_xrWindow)
+                {
+                    implPtr->m_nativeXr->UpdateWindow(implPtr->m_xrWindow);
+                }
+                implPtr->m_nativeXr->SetSessionStateChangedCallback(
+                    [implPtr](bool isActive) {
+                        implPtr->m_isXrActive.store(isActive, std::memory_order_relaxed);
+                    });
+            }
+#endif
+#if BABYLON_NATIVE_PLUGIN_TESTUTILS
+            Babylon::Plugins::TestUtils::Initialize(env, window);
+#else
+            (void)window;
+#endif
+
+            // 4. Fire any host calls queued before the first View attach.
+            implPtr->m_initTcs.complete();
+        });
+    }
+
+    // Persistent shader cache (no-ops when shaderCachePath is empty).
+#if BABYLON_NATIVE_PLUGIN_SHADERCACHE
+    void RuntimeImpl::LoadShaderCache()
+    {
+        if (m_options.shaderCachePath.empty() || !Babylon::Plugins::ShaderCache::IsEnabled())
+        {
+            return;
+        }
+        std::ifstream stream{m_options.shaderCachePath, std::ios::binary};
+        if (stream.good())
+        {
+            Babylon::Plugins::ShaderCache::Load(stream);
+        }
+        // Missing/unreadable file: start with an empty cache.
+    }
+
+    void RuntimeImpl::SaveShaderCache()
+    {
+        if (m_options.shaderCachePath.empty() || !Babylon::Plugins::ShaderCache::IsEnabled())
+        {
+            return;
+        }
+        std::ofstream stream{m_options.shaderCachePath, std::ios::binary};
+        if (stream.good())
+        {
+            Babylon::Plugins::ShaderCache::Save(stream);
+        }
+    }
+#endif
+
+    Runtime::Runtime(RuntimeOptions options)
+        : m_impl{std::make_unique<RuntimeImpl>(std::move(options))}
+    {
+    }
+
+    Runtime::~Runtime() = default;
+    Runtime::Runtime(Runtime&&) noexcept = default;
+    Runtime& Runtime::operator=(Runtime&&) noexcept = default;
+
+    void Runtime::LoadScript(std::string_view url)
+    {
+        m_impl->m_initTcs.as_task().then(arcana::inline_scheduler, arcana::cancellation::none(),
+            [scriptLoader = &*m_impl->m_scriptLoader, url = std::string{url}]() mutable {
+                scriptLoader->LoadScript(std::move(url));
+            });
+    }
+
+    void Runtime::Eval(std::string_view source, std::string_view sourceUrl)
+    {
+        m_impl->m_initTcs.as_task().then(arcana::inline_scheduler, arcana::cancellation::none(),
+            [scriptLoader = &*m_impl->m_scriptLoader,
+             source = std::string{source},
+             url = std::string{sourceUrl}]() mutable {
+                scriptLoader->Eval(std::move(source), std::move(url));
+            });
+    }
+
+    void Runtime::RunOnJsThread(std::function<void(Napi::Env)> callback, bool afterScriptLoad)
+    {
+        if (!callback)
+        {
+            return;
+        }
+
+        m_impl->m_initTcs.as_task().then(arcana::inline_scheduler, arcana::cancellation::none(),
+            [appRuntime = &*m_impl->m_appRuntime,
+             scriptLoader = &*m_impl->m_scriptLoader,
+             cb = std::move(callback),
+             afterScriptLoad]() mutable {
+                if (afterScriptLoad)
+                {
+                    scriptLoader->Dispatch(std::move(cb));
+                }
+                else
+                {
+                    appRuntime->Dispatch(std::move(cb));
+                }
+            });
+    }
+
+    void Runtime::Suspend()
+    {
+        // Frame-thread only (see Runtime.h). The atomic is for cross-thread
+        // IsSuspended() reads, not for protecting the count.
+        if (m_impl->m_suspendCount.fetch_add(1, std::memory_order_relaxed) == 0)
+        {
+            // Close the in-flight frame on the attached View (if any) BEFORE
+            // blocking the JS thread: keeps the GPU side clean (no held
+            // drawable, no open DeviceUpdate safe-timespan). Composes
+            // correctly with ~ViewImpl (re-Suspend is a no-op) and with
+            // suspending while no View is attached.
+            if (m_impl->m_currentView)
+            {
+                m_impl->m_currentView->Suspend();
+            }
+#if BABYLON_NATIVE_PLUGIN_SHADERCACHE
+            // Engine is quiescent here (ViewImpl::Suspend just closed the
+            // frame and locked the update safe-timespan), so the save is
+            // race-free with any pending shader compilation.
+            m_impl->SaveShaderCache();
+#endif
+            m_impl->m_appRuntime->Suspend();
+        }
+    }
+
+    void Runtime::Resume()
+    {
+        // Frame-thread only (see Runtime.h).
+        if (m_impl->m_suspendCount.load(std::memory_order_relaxed) == 0)
+        {
+            // Mismatched Resume — ignore rather than underflow.
+            return;
+        }
+        if (m_impl->m_suspendCount.fetch_sub(1, std::memory_order_relaxed) == 1)
+        {
+            m_impl->m_appRuntime->Resume();
+            // Re-open the frame on the attached View. On a view that was
+            // attached but never sized, this also drives the deferred
+            // first-Resize init via InitializeIfReady.
+            if (m_impl->m_currentView)
+            {
+                m_impl->m_currentView->Resume();
+            }
+        }
+    }
+
+    bool Runtime::IsSuspended() const
+    {
+        return m_impl->m_suspendCount.load(std::memory_order_relaxed) > 0;
+    }
+
+#if BABYLON_NATIVE_PLUGIN_NATIVEXR
+    void Runtime::SetXrWindow(void* nativeWindow)
+    {
+        std::lock_guard<std::mutex> lock{m_impl->m_xrMutex};
+        m_impl->m_xrWindow = nativeWindow;
+        if (m_impl->m_nativeXr)
+        {
+            // NativeXr's entry points are JS-thread-only; dispatch the
+            // actual UpdateWindow call instead of touching it from
+            // whatever thread invoked SetXrWindow.
+            m_impl->m_appRuntime->Dispatch([implPtr = m_impl.get(), nativeWindow](Napi::Env) {
+                if (implPtr->m_nativeXr)
+                {
+                    implPtr->m_nativeXr->UpdateWindow(nativeWindow);
+                }
+            });
+        }
+        // If NativeXr isn't initialized yet (no View attach has happened),
+        // the value is applied by the first-attach init lambda.
+    }
+
+    bool Runtime::IsXrActive() const
+    {
+        return m_impl->m_isXrActive.load(std::memory_order_relaxed);
+    }
+#endif
+}
diff --git a/Embedding/Source/RuntimeImpl.h b/Embedding/Source/RuntimeImpl.h
new file mode 100644
index 000000000..6f2260b3b
--- /dev/null
+++ b/Embedding/Source/RuntimeImpl.h
@@ -0,0 +1,167 @@
+#pragma once
+
+#include <Babylon/Embedding/Runtime.h>
+#include <Babylon/Embedding/View.h>
+
+#include <Babylon/AppRuntime.h>
+#include <Babylon/Graphics/Device.h>
+#include <Babylon/ScriptLoader.h>
+
+#if BABYLON_NATIVE_POLYFILL_CANVAS
+#include <Babylon/Polyfills/Canvas.h>
+#endif
+
+#if BABYLON_NATIVE_PLUGIN_NATIVEINPUT
+#include <Babylon/Plugins/NativeInput.h>
+#endif
+
+#if BABYLON_NATIVE_PLUGIN_NATIVEXR
+#include <Babylon/Plugins/NativeXr.h>
+#endif
+
+#include <arcana/threading/task.h>
+
+#include <atomic>
+#include <mutex>
+#include <optional>
+#include <utility>
+
+namespace Babylon::Embedding
+{
+    // Internal implementation of Runtime. Lives in Source/ so View.cpp
+    // can reach into it without exposing internals on the public header.
+    struct RuntimeImpl
+    {
+        explicit RuntimeImpl(RuntimeOptions options);
+        ~RuntimeImpl();
+
+        RuntimeImpl(const RuntimeImpl&) = delete;
+        RuntimeImpl& operator=(const RuntimeImpl&) = delete;
+
+        // Configuration captured at construction.
+        RuntimeOptions m_options;
+
+        // Always-alive: JS engine + thread, plus the script loader that
+        // serializes LoadScript / Eval / Dispatch onto that thread.
+        std::optional<Babylon::AppRuntime> m_appRuntime;
+        std::optional<Babylon::ScriptLoader> m_scriptLoader;
+
+        // Lazily constructed during the first attached View.
+        std::optional<Babylon::Graphics::Device> m_device;
+        std::optional<Babylon::Graphics::DeviceUpdate> m_deviceUpdate;
+
+#if BABYLON_NATIVE_POLYFILL_CANVAS
+        std::optional<Babylon::Polyfills::Canvas> m_canvas;
+#endif
+
+#if BABYLON_NATIVE_PLUGIN_NATIVEINPUT
+        // Owned by the JS world (returned by NativeInput::CreateForJavaScript).
+        // We just keep a pointer for forwarding View::OnPointer* calls.
+        Babylon::Plugins::NativeInput* m_input{nullptr};
+#endif
+
+#if BABYLON_NATIVE_PLUGIN_NATIVEXR
+        // NativeXr is initialized during the first View attach (needs a
+        // Napi::Env). Until then, m_xrWindow holds the most recent
+        // SetXrWindow value for application post-init. m_xrMutex serializes
+        // these fields. m_isXrActive is written from the JS thread and
+        // polled from any thread.
+        std::optional<Babylon::Plugins::NativeXr> m_nativeXr;
+        void* m_xrWindow{nullptr};
+        mutable std::mutex m_xrMutex;
+        std::atomic<bool> m_isXrActive{false};
+#endif
+
+        // Pre-init queue for host LoadScript / Eval / RunOnJsThread.
+        // Each call chains its work off `m_initTcs.as_task().then(...)`.
+        // The first-attach init lambda calls `m_initTcs.complete()` after
+        // all plugins are initialized, firing every queued continuation
+        // (in registration order) on the JS thread. After completion,
+        // future `.then(inline_scheduler, ...)` calls run synchronously
+        // on the calling thread and submit to ScriptLoader directly.
+        //
+        // Host-side serialization is the host's responsibility (same
+        // contract as ScriptLoader); no outer mutex.
+        arcana::task_completion_source<void, std::exception_ptr> m_initTcs;
+
+        // Reference-counted suspend depth. Mutated only on the frame
+        // thread; atomic so `IsSuspended()` can be polled from any thread.
+        std::atomic<int> m_suspendCount{0};
+
+        // 0..1 — enforces "at most one View attached at a time". Points
+        // at the ViewImpl directly (not the outer View), so the back-ref
+        // stays valid across moves of the outer View.
+        ViewImpl* m_currentView{nullptr};
+
+        // Dispatched onto the JS thread by the very first View attach.
+        // Runs all plugin/polyfill Initialize calls, wires NativeXr
+        // callbacks, and completes m_initTcs. `window` is forwarded to
+        // TestUtils::Initialize; ignored otherwise.
+        void RunFirstAttachInit(Babylon::Graphics::WindowT window);
+
+#if BABYLON_NATIVE_PLUGIN_SHADERCACHE
+        // Persistent shader cache. No-ops when `m_options.shaderCachePath`
+        // is empty. Both run synchronously on the host thread at points
+        // where the engine is known not to be compiling shaders
+        // (first-attach, post-view-Suspend, ~RuntimeImpl) — no JS-thread
+        // coordination required.
+        void LoadShaderCache();
+        void SaveShaderCache();
+#endif
+    };
+
+    // Internal implementation of View. Owns the back-reference to its
+    // RuntimeImpl, the window handle captured at construction, the most
+    // recent Resize size, and the frame-lifecycle Suspend/Resume hooks.
+    //
+    // Construction is cheap: it just stashes the window and registers as
+    // the current view. All Device work runs in `InitializeIfReady`, which
+    // is gated on three preconditions:
+    //
+    //   1. `m_initialized == false`,
+    //   2. `m_size` is set (host has called Resize at least once), and
+    //   3. `RuntimeImpl::m_suspendCount == 0`.
+    //
+    // Called from `View::Resize` (satisfies #2) and `ViewImpl::Resume`
+    // (can clear #3); whichever caller satisfies the last precondition
+    // runs the init. Folding `UpdateWindow` + `UpdateSize` together
+    // inside this function is what keeps the bgfx pair safe.
+    //
+    // Once initialized, a Device frame is open iff `m_suspendCount == 0`.
+    // ViewImpl::Suspend/Resume toggle that frame on the 0↔1 transitions.
+    struct ViewImpl
+    {
+        explicit ViewImpl(RuntimeImpl& runtime) : m_runtime{runtime} {}
+        ~ViewImpl();
+
+        ViewImpl(const ViewImpl&) = delete;
+        ViewImpl& operator=(const ViewImpl&) = delete;
+
+        RuntimeImpl& m_runtime;
+
+        // Captured at construction; used by InitializeIfReady to
+        // construct (first-attach-ever) or rebind the Device.
+        Babylon::Graphics::WindowT m_window{};
+
+        // Most recent Resize size, in logical pixels. Empty until the
+        // host calls Resize.
+        std::optional<std::pair<uint32_t, uint32_t>> m_size;
+
+        // Latches true the first time InitializeIfReady succeeds; never
+        // flips back. A new ViewImpl is constructed per View attach.
+        bool m_initialized{false};
+
+        // Close the in-flight frame (called by Runtime::Suspend on 0→1
+        // and by ~ViewImpl). No-op when uninitialized.
+        void Suspend();
+
+        // Open a new frame (called by Runtime::Resume on 1→0). When
+        // uninitialized, retries InitializeIfReady — handles the case
+        // where the host attached and resized while suspended.
+        void Resume();
+
+        // Runs the deferred init iff all three preconditions hold.
+        // Safe to call from any caller that just satisfied one.
+        void InitializeIfReady();
+    };
+}
diff --git a/Embedding/Source/View.cpp b/Embedding/Source/View.cpp
new file mode 100644
index 000000000..916afc9d0
--- /dev/null
+++ b/Embedding/Source/View.cpp
@@ -0,0 +1,303 @@
+#include "RuntimeImpl.h"
+
+#include <Babylon/DebugTrace.h>
+#include <Babylon/Graphics/DeviceQueries.h>
+
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+namespace Babylon::Embedding
+{
+    namespace
+    {
+        // Convert (width, height) in `units` to logical pixels.
+        std::pair<uint32_t, uint32_t> ToLogicalSize(uint32_t width, uint32_t height,
+                                                    CoordinateUnits units, float dpr)
+        {
+            if (units == CoordinateUnits::Logical || dpr <= 0.0f)
+            {
+                return {width, height};
+            }
+            return {static_cast<uint32_t>(width / dpr),
+                    static_cast<uint32_t>(height / dpr)};
+        }
+
+        // Convert (x, y) in `units` to logical pixels.
+        std::pair<float, float> ToLogicalCoords(float x, float y,
+                                                CoordinateUnits units, float dpr)
+        {
+            if (units == CoordinateUnits::Logical || dpr <= 0.0f)
+            {
+                return {x, y};
+            }
+            return {x / dpr, y / dpr};
+        }
+
+        void ValidateNonZeroSize(uint32_t width, uint32_t height, const char* operation)
+        {
+            if (width == 0 || height == 0)
+            {
+                throw std::runtime_error{std::string{operation} + " requires non-zero width and height."};
+            }
+        }
+    }
+
+    View::View(Runtime& runtime, Babylon::Graphics::WindowT nativeWindow)
+    {
+        RuntimeImpl& runtimeImpl = *runtime.m_impl;
+        if (runtimeImpl.m_currentView != nullptr)
+        {
+            throw std::runtime_error{"Only one View may be attached to a Runtime at a time."};
+        }
+
+        m_impl = std::make_unique<ViewImpl>(runtimeImpl);
+        m_impl->m_window = nativeWindow;
+        runtimeImpl.m_currentView = m_impl.get();
+    }
+
+    View::~View() = default;
+    View::View(View&&) noexcept = default;
+    View& View::operator=(View&&) noexcept = default;
+
+    ViewImpl::~ViewImpl()
+    {
+        // Close the in-flight frame iff one is currently open: i.e. the
+        // view is initialized and the Runtime is not externally suspended
+        // (Suspend already closed the frame). The Device persists on the
+        // Runtime so the next View is cheap.
+        if (m_initialized &&
+            m_runtime.m_suspendCount.load(std::memory_order_relaxed) == 0)
+        {
+            m_runtime.m_device->FinishRenderingCurrentFrame();
+        }
+
+        m_runtime.m_currentView = nullptr;
+    }
+
+    // Called by Runtime::Suspend/Resume on the 0↔1 transition (and ~ViewImpl
+    // for teardown). When initialized, these are pure frame open/close.
+    // When uninitialized, Suspend is a no-op and Resume retries
+    // InitializeIfReady — the suspendCount drop may have been the last
+    // missing precondition.
+    void ViewImpl::Suspend()
+    {
+        if (!m_initialized)
+        {
+            return;
+        }
+        m_runtime.m_device->FinishRenderingCurrentFrame();
+    }
+
+    void ViewImpl::Resume()
+    {
+        if (!m_initialized)
+        {
+            // Suspend precondition just cleared. Succeeds if `Resize` has
+            // also run; otherwise silent no-op until it does.
+            InitializeIfReady();
+            return;
+        }
+        m_runtime.m_device->StartRenderingCurrentFrame();
+    }
+
+    // Single recipe for binding the Device to this view's window and
+    // opening the first frame. Gated on all three preconditions
+    // (initialized? sized? not suspended?) so it can be called eagerly
+    // from anywhere that satisfies one of them.
+    void ViewImpl::InitializeIfReady()
+    {
+        if (m_initialized || !m_size)
+        {
+            return;
+        }
+        if (m_runtime.m_suspendCount.load(std::memory_order_relaxed) > 0)
+        {
+            return;
+        }
+
+        const auto [lw, lh] = *m_size;
+        const bool firstAttachEver = !m_runtime.m_device;
+        if (firstAttachEver)
+        {
+            Babylon::Graphics::Configuration config{};
+            config.Window = m_window;
+            config.Width = lw;
+            config.Height = lh;
+            config.MSAASamples = m_runtime.m_options.msaaSamples;
+
+            m_runtime.m_device.emplace(config);
+        }
+        else
+        {
+            // Re-attach to an existing Runtime: rebind surface and size in
+            // lockstep. JS state (plugins, polyfills, scripts) is preserved.
+            m_runtime.m_device->UpdateWindow(m_window);
+            m_runtime.m_device->UpdateSize(lw, lh);
+        }
+
+        // Open the first frame inline. On the very first attach this MUST
+        // happen BEFORE dispatching RunFirstAttachInit, so the
+        // Device::AddToJavaScript inside that lambda sees an open frame to
+        // record into. Both run on the host thread, so the dispatched
+        // lambda always sees an open frame on the JS thread.
+        m_runtime.m_device->StartRenderingCurrentFrame();
+        m_initialized = true;
+
+        if (firstAttachEver)
+        {
+            m_runtime.RunFirstAttachInit(m_window);
+        }
+    }
+
+    void View::RenderFrame()
+    {
+        RuntimeImpl& impl = m_impl->m_runtime;
+
+        // Host may call unconditionally from its draw callback; the
+        // not-rendering cases early-out.
+        if (!m_impl->m_initialized)
+        {
+            // Flag pre-init so hosts can diagnose "my draw callback fires
+            // but nothing renders". The externally-suspended case is
+            // expected and stays silent.
+            DEBUG_TRACE("Babylon::Embedding::View::RenderFrame skipped: View has not yet been initialized. Call View::Resize with the surface's pixel dimensions to begin rendering.");
+            return;
+        }
+        if (impl.m_suspendCount.load(std::memory_order_relaxed) > 0)
+        {
+            return;
+        }
+
+        // Babylon's JS render loop runs between Start and Finish, scheduled
+        // via DeviceUpdate's SafeTimespanGuarantor onto the JS thread.
+        impl.m_device->FinishRenderingCurrentFrame();
+        impl.m_device->StartRenderingCurrentFrame();
+    }
+
+    // Stores the host-supplied size on the ViewImpl, then either pushes
+    // it through Device::UpdateSize (initialized) or drives
+    // InitializeIfReady (uninitialized). Single source of truth for
+    // surface size in the Embedding layer.
+    void View::Resize(uint32_t width, uint32_t height, CoordinateUnits units)
+    {
+        ValidateNonZeroSize(width, height, "View::Resize size");
+
+        RuntimeImpl& impl = m_impl->m_runtime;
+
+        // DPR source: before init, query the window directly (Device
+        // doesn't exist or is still bound to the previous attach). After
+        // init, the Device's stored DPR is authoritative.
+        const float dpr = !m_impl->m_initialized
+            ? Babylon::Graphics::GetDevicePixelRatio(m_impl->m_window)
+            : impl.m_device->GetDevicePixelRatio();
+        const auto [lw, lh] = ToLogicalSize(width, height, units, dpr);
+        ValidateNonZeroSize(lw, lh, "View::Resize logical size");
+
+        m_impl->m_size = {lw, lh};
+
+        if (m_impl->m_initialized)
+        {
+            impl.m_device->UpdateSize(lw, lh);
+        }
+        else
+        {
+            // "Size known" precondition just satisfied. Silent no-op if
+            // currently suspended; Runtime::Resume will retry.
+            m_impl->InitializeIfReady();
+        }
+    }
+
+#if BABYLON_NATIVE_PLUGIN_NATIVEINPUT
+    void View::OnPointerDown(int32_t pointerId, float x, float y, CoordinateUnits units)
+    {
+        RuntimeImpl& impl = m_impl->m_runtime;
+        if (impl.m_input && impl.m_device)
+        {
+            const auto [lx, ly] = ToLogicalCoords(x, y, units,
+                                                  impl.m_device->GetDevicePixelRatio());
+            impl.m_input->TouchDown(static_cast<uint32_t>(pointerId),
+                                     static_cast<int32_t>(lx),
+                                     static_cast<int32_t>(ly));
+        }
+    }
+
+    void View::OnPointerMove(int32_t pointerId, float x, float y, CoordinateUnits units)
+    {
+        RuntimeImpl& impl = m_impl->m_runtime;
+        if (impl.m_input && impl.m_device)
+        {
+            const auto [lx, ly] = ToLogicalCoords(x, y, units,
+                                                  impl.m_device->GetDevicePixelRatio());
+            impl.m_input->TouchMove(static_cast<uint32_t>(pointerId),
+                                     static_cast<int32_t>(lx),
+                                     static_cast<int32_t>(ly));
+        }
+    }
+
+    void View::OnPointerUp(int32_t pointerId, float x, float y, CoordinateUnits units)
+    {
+        RuntimeImpl& impl = m_impl->m_runtime;
+        if (impl.m_input && impl.m_device)
+        {
+            const auto [lx, ly] = ToLogicalCoords(x, y, units,
+                                                  impl.m_device->GetDevicePixelRatio());
+            impl.m_input->TouchUp(static_cast<uint32_t>(pointerId),
+                                   static_cast<int32_t>(lx),
+                                   static_cast<int32_t>(ly));
+        }
+    }
+
+    void View::OnMouseDown(uint32_t buttonIndex, float x, float y, CoordinateUnits units)
+    {
+        RuntimeImpl& impl = m_impl->m_runtime;
+        if (impl.m_input && impl.m_device)
+        {
+            const auto [lx, ly] = ToLogicalCoords(x, y, units,
+                                                  impl.m_device->GetDevicePixelRatio());
+            impl.m_input->MouseDown(buttonIndex,
+                                     static_cast<int32_t>(lx),
+                                     static_cast<int32_t>(ly));
+        }
+    }
+
+    void View::OnMouseUp(uint32_t buttonIndex, float x, float y, CoordinateUnits units)
+    {
+        RuntimeImpl& impl = m_impl->m_runtime;
+        if (impl.m_input && impl.m_device)
+        {
+            const auto [lx, ly] = ToLogicalCoords(x, y, units,
+                                                  impl.m_device->GetDevicePixelRatio());
+            impl.m_input->MouseUp(buttonIndex,
+                                   static_cast<int32_t>(lx),
+                                   static_cast<int32_t>(ly));
+        }
+    }
+
+    void View::OnMouseMove(float x, float y, CoordinateUnits units)
+    {
+        RuntimeImpl& impl = m_impl->m_runtime;
+        if (impl.m_input && impl.m_device)
+        {
+            const auto [lx, ly] = ToLogicalCoords(x, y, units,
+                                                  impl.m_device->GetDevicePixelRatio());
+            impl.m_input->MouseMove(static_cast<int32_t>(lx),
+                                     static_cast<int32_t>(ly));
+        }
+    }
+
+    void View::OnMouseWheel(uint32_t wheelAxis, int32_t scrollValue)
+    {
+        RuntimeImpl& impl = m_impl->m_runtime;
+        if (impl.m_input)
+        {
+            impl.m_input->MouseWheel(wheelAxis, scrollValue);
+        }
+    }
+
+    uint32_t View::LeftMouseButton()   { return Babylon::Plugins::NativeInput::LEFT_MOUSE_BUTTON_ID; }
+    uint32_t View::MiddleMouseButton() { return Babylon::Plugins::NativeInput::MIDDLE_MOUSE_BUTTON_ID; }
+    uint32_t View::RightMouseButton()  { return Babylon::Plugins::NativeInput::RIGHT_MOUSE_BUTTON_ID; }
+    uint32_t View::MouseWheelY()       { return Babylon::Plugins::NativeInput::MOUSEWHEEL_Y_ID; }
+#endif
+}
diff --git a/Install/Install.cmake b/Install/Install.cmake
index 6c6ad7785..d0fb5b1dd 100644
--- a/Install/Install.cmake
+++ b/Install/Install.cmake
@@ -244,3 +244,17 @@ if(TARGET XMLHttpRequest)
     install_lib(XMLHttpRequest)
     install_include(XMLHttpRequest)
 endif()
+
+# ----------------
+# Embedding
+# ----------------
+
+if(TARGET Embedding)
+    install_lib(Embedding)
+    install_include(Embedding)
+endif()
+
+if(TARGET BabylonNativeEmbedding)
+    install_lib(BabylonNativeEmbedding)
+    install_include(BabylonNativeEmbedding)
+endif()