react-native-wgpu 0.4.2 → 0.5.0

package/cpp/jsi/RuntimeAwareCache.h

@@ -0,0 +1,100 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <cassert>
+#include <memory>
+#include <unordered_map>
+#include <utility>
+
+#include "RuntimeLifecycleMonitor.h"
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+class BaseRuntimeAwareCache {
+public:
+  static void setMainJsRuntime(jsi::Runtime *rt) { _mainRuntime = rt; }
+  static jsi::Runtime *getMainJsRuntime() {
+    assert(_mainRuntime != nullptr &&
+           "Expected main Javascript runtime to be set in the "
+           "BaseRuntimeAwareCache class.");
+
+    return _mainRuntime;
+  }
+
+private:
+  static jsi::Runtime *_mainRuntime;
+};
+
+/**
+ * Provides a way to keep data specific to a jsi::Runtime instance that gets
+ * cleaned up when that runtime is destroyed. This is necessary because JSI does
+ * not allow for its associated objects to be retained past the runtime
+ * lifetime. If an object (e.g. jsi::Values or jsi::Function instances) is kept
+ * after the runtime is torn down, its destructor (once it is destroyed
+ * eventually) will result in a crash (JSI objects keep a pointer to memory
+ * managed by the runtime, accessing that portion of the memory after runtime is
+ * deleted is the root cause of that crash).
+ *
+ * In order to provide an efficient implementation that does not add an overhead
+ * for the cases when only a single runtime is used, which is the primary
+ * usecase, the following assumption has been made: Only for secondary runtimes
+ * we track destruction and clean up the store associated with that runtime. For
+ * the first runtime we assume that the object holding the store is destroyed
+ * prior to the destruction of that runtime.
+ *
+ * The above assumption makes it work without any overhead when only single
+ * runtime is in use. Specifically, we don't perform any additional operations
+ * related to tracking runtime lifecycle when only a single runtime is used.
+ */
+template <typename T>
+class RuntimeAwareCache : public BaseRuntimeAwareCache,
+                          public RuntimeLifecycleListener {
+
+public:
+  void onRuntimeDestroyed(jsi::Runtime *rt) override {
+    if (getMainJsRuntime() != rt) {
+      // We are removing a secondary runtime
+      _secondaryRuntimeCaches.erase(rt);
+    }
+  }
+
+  ~RuntimeAwareCache() {
+    for (auto &cache : _secondaryRuntimeCaches) {
+      RuntimeLifecycleMonitor::removeListener(
+          *static_cast<jsi::Runtime *>(cache.first), this);
+    }
+  }
+
+  T &get(jsi::Runtime &rt) {
+    // We check if we're accessing the main runtime - this is the happy path
+    // to avoid us having to lookup by runtime for caches that only has a single
+    // runtime
+    if (getMainJsRuntime() == &rt) {
+      return _primaryCache;
+    } else {
+      if (_secondaryRuntimeCaches.count(&rt) == 0) {
+        // we only add listener when the secondary runtime is used, this assumes
+        // that the secondary runtime is terminated first. This lets us avoid
+        // additional complexity for the majority of cases when objects are not
+        // shared between runtimes. Otherwise we'd have to register all objecrts
+        // with the RuntimeMonitor as opposed to only registering ones that are
+        // used in secondary runtime. Note that we can't register listener here
+        // with the primary runtime as it may run on a separate thread.
+        RuntimeLifecycleMonitor::addListener(rt, this);
+
+        T cache;
+        _secondaryRuntimeCaches.emplace(&rt, std::move(cache));
+      }
+    }
+    return _secondaryRuntimeCaches.at(&rt);
+  }
+
+private:
+  std::unordered_map<void *, T> _secondaryRuntimeCaches;
+  T _primaryCache;
+};
+
+} // namespace rnwgpu

package/cpp/jsi/RuntimeLifecycleMonitor.cpp

@@ -0,0 +1,72 @@
+#include "RuntimeLifecycleMonitor.h"
+
+#include <mutex>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+
+namespace rnwgpu {
+
+static std::unordered_map<jsi::Runtime *,
+                          std::unordered_set<RuntimeLifecycleListener *>>
+    listeners;
+static std::mutex listenersMutex;
+
+struct RuntimeLifecycleMonitorObject : public jsi::HostObject {
+  jsi::Runtime *_rt;
+  explicit RuntimeLifecycleMonitorObject(jsi::Runtime *rt) : _rt(rt) {}
+  ~RuntimeLifecycleMonitorObject() {
+    std::unordered_set<RuntimeLifecycleListener *> listenersCopy;
+    {
+      std::lock_guard<std::mutex> lock(listenersMutex);
+      auto listenersSet = listeners.find(_rt);
+      if (listenersSet != listeners.end()) {
+        listenersCopy = listenersSet->second;
+        listeners.erase(listenersSet);
+      }
+    }
+    for (auto listener : listenersCopy) {
+      listener->onRuntimeDestroyed(_rt);
+    }
+  }
+};
+
+void RuntimeLifecycleMonitor::addListener(jsi::Runtime &rt,
+                                          RuntimeLifecycleListener *listener) {
+  bool shouldInstallMonitor = false;
+  {
+    std::lock_guard<std::mutex> lock(listenersMutex);
+    auto listenersSet = listeners.find(&rt);
+    if (listenersSet == listeners.end()) {
+      std::unordered_set<RuntimeLifecycleListener *> newSet;
+      newSet.insert(listener);
+      listeners.emplace(&rt, std::move(newSet));
+      shouldInstallMonitor = true;
+    } else {
+      listenersSet->second.insert(listener);
+    }
+  }
+  if (shouldInstallMonitor) {
+    // We install a global host object in the provided runtime, this way we can
+    // use that host object destructor to get notified when the runtime is being
+    // terminated. We use a unique name for the object as it gets saved with the
+    // runtime's global object.
+    rt.global().setProperty(
+        rt, "__rnwgpu_rt_lifecycle_monitor",
+        jsi::Object::createFromHostObject(
+            rt, std::make_shared<RuntimeLifecycleMonitorObject>(&rt)));
+  }
+}
+
+void RuntimeLifecycleMonitor::removeListener(
+    jsi::Runtime &rt, RuntimeLifecycleListener *listener) {
+  std::lock_guard<std::mutex> lock(listenersMutex);
+  auto listenersSet = listeners.find(&rt);
+  if (listenersSet == listeners.end()) {
+    // nothing to do here
+  } else {
+    listenersSet->second.erase(listener);
+  }
+}
+
+} // namespace rnwgpu

package/cpp/jsi/RuntimeLifecycleMonitor.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <memory>
+
+namespace rnwgpu {
+
+namespace jsi = facebook::jsi;
+
+/**
+ * Listener interface that allows for getting notified when a jsi::Runtime
+ * instance is destroyed.
+ */
+struct RuntimeLifecycleListener {
+  virtual ~RuntimeLifecycleListener() {}
+  virtual void onRuntimeDestroyed(jsi::Runtime *) = 0;
+};
+
+/**
+ * This class provides an API via static methods for registering and
+ * unregistering runtime lifecycle listeners. The listeners can be used to
+ * cleanup any data that references a given jsi::Runtime instance before it gets
+ * destroyed.
+ */
+struct RuntimeLifecycleMonitor {
+  static void addListener(jsi::Runtime &rt, RuntimeLifecycleListener *listener);
+  static void removeListener(jsi::Runtime &rt,
+                             RuntimeLifecycleListener *listener);
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/ArrayBuffer.h

@@ -3,7 +3,7 @@
 
 #include <memory>
 
-#include "RNFJSIConverter.h"
+#include "JSIConverter.h"
 
 namespace rnwgpu {
 
@@ -24,21 +24,17 @@ struct ArrayBuffer : jsi::MutableBuffer {
   size_t _bytesPerElement;
 };
 
-} // namespace rnwgpu
-
-namespace margelo {
-
-static std::shared_ptr<rnwgpu::ArrayBuffer>
+static std::shared_ptr<ArrayBuffer>
 createArrayBufferFromJSI(jsi::Runtime &runtime,
                          const jsi::ArrayBuffer &arrayBuffer,
                          size_t bytesPerElement) {
   auto size = arrayBuffer.size(runtime);
-  return std::make_shared<rnwgpu::ArrayBuffer>(arrayBuffer.data(runtime), size,
-                                               bytesPerElement);
+  return std::make_shared<ArrayBuffer>(arrayBuffer.data(runtime), size,
+                                       bytesPerElement);
 }
 
-template <> struct JSIConverter<std::shared_ptr<rnwgpu::ArrayBuffer>> {
-  static std::shared_ptr<rnwgpu::ArrayBuffer>
+template <> struct JSIConverter<std::shared_ptr<ArrayBuffer>> {
+  static std::shared_ptr<ArrayBuffer>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBound) {
     if (arg.isObject()) {
       auto obj = arg.getObject(runtime);
@@ -64,9 +60,9 @@ template <> struct JSIConverter<std::shared_ptr<rnwgpu::ArrayBuffer>> {
   }
 
   static jsi::Value toJSI(jsi::Runtime &runtime,
-                          std::shared_ptr<rnwgpu::ArrayBuffer> arg) {
+                          std::shared_ptr<ArrayBuffer> arg) {
     return jsi::ArrayBuffer(runtime, arg);
   }
 };
 
-} // namespace margelo
+} // namespace rnwgpu

package/cpp/rnwgpu/RNWebGPUManager.cpp

@@ -1,8 +1,42 @@
 #include "RNWebGPUManager.h"
 
 #include "GPU.h"
+#include "NativeObject.h"
 #include "RNWebGPU.h"
 
+// GPU API classes (for instanceof support)
+#include "GPUAdapter.h"
+#include "GPUAdapterInfo.h"
+#include "GPUBindGroup.h"
+#include "GPUBindGroupLayout.h"
+#include "GPUBuffer.h"
+#include "GPUCanvasContext.h"
+#include "GPUCommandBuffer.h"
+#include "GPUCommandEncoder.h"
+#include "GPUCompilationInfo.h"
+#include "GPUCompilationMessage.h"
+#include "GPUComputePassEncoder.h"
+#include "GPUComputePipeline.h"
+#include "GPUDevice.h"
+#include "GPUDeviceLostInfo.h"
+#include "GPUError.h"
+#include "GPUExternalTexture.h"
+#include "GPUInternalError.h"
+#include "GPUOutOfMemoryError.h"
+#include "GPUPipelineLayout.h"
+#include "GPUQuerySet.h"
+#include "GPUQueue.h"
+#include "GPURenderBundle.h"
+#include "GPURenderBundleEncoder.h"
+#include "GPURenderPassEncoder.h"
+#include "GPURenderPipeline.h"
+#include "GPUSampler.h"
+#include "GPUShaderModule.h"
+#include "GPUSupportedLimits.h"
+#include "GPUTexture.h"
+#include "GPUTextureView.h"
+#include "GPUValidationError.h"
+
 // Enums
 #include "GPUBufferUsage.h"
 #include "GPUColorWrite.h"
@@ -22,37 +56,162 @@ RNWebGPUManager::RNWebGPUManager(
     : _jsRuntime(jsRuntime), _jsCallInvoker(jsCallInvoker),
       _platformContext(platformContext) {
 
+  // Register main runtime for RuntimeAwareCache
+  BaseRuntimeAwareCache::setMainJsRuntime(_jsRuntime);
+
   auto gpu = std::make_shared<GPU>(*_jsRuntime);
   auto rnWebGPU = std::make_shared<RNWebGPU>(gpu, _platformContext);
   _gpu = gpu->get();
-  _jsRuntime->global().setProperty(
-      *_jsRuntime, "RNWebGPU",
-      jsi::Object::createFromHostObject(*_jsRuntime, rnWebGPU));
-
-  auto bufferUsage = std::make_shared<GPUBufferUsage>();
-  _jsRuntime->global().setProperty(
-      *_jsRuntime, "GPUBufferUsage",
-      jsi::Object::createFromHostObject(*_jsRuntime, std::move(bufferUsage)));
-
-  auto colorWrite = std::make_shared<GPUColorWrite>();
-  _jsRuntime->global().setProperty(
-      *_jsRuntime, "GPUColorWrite",
-      jsi::Object::createFromHostObject(*_jsRuntime, std::move(colorWrite)));
-
-  auto mapMode = std::make_shared<GPUMapMode>();
-  _jsRuntime->global().setProperty(
-      *_jsRuntime, "GPUMapMode",
-      jsi::Object::createFromHostObject(*_jsRuntime, std::move(mapMode)));
-
-  auto shaderStage = std::make_shared<GPUShaderStage>();
-  _jsRuntime->global().setProperty(
-      *_jsRuntime, "GPUShaderStage",
-      jsi::Object::createFromHostObject(*_jsRuntime, std::move(shaderStage)));
-
-  auto textureUsage = std::make_shared<GPUTextureUsage>();
-  _jsRuntime->global().setProperty(
-      *_jsRuntime, "GPUTextureUsage",
-      jsi::Object::createFromHostObject(*_jsRuntime, std::move(textureUsage)));
+  _jsRuntime->global().setProperty(*_jsRuntime, "RNWebGPU",
+                                   RNWebGPU::create(*_jsRuntime, rnWebGPU));
+
+  // Install constructors for instanceof support
+  GPU::installConstructor(*_jsRuntime);
+  GPUAdapter::installConstructor(*_jsRuntime);
+  GPUAdapterInfo::installConstructor(*_jsRuntime);
+  GPUBindGroup::installConstructor(*_jsRuntime);
+  GPUBindGroupLayout::installConstructor(*_jsRuntime);
+  GPUBuffer::installConstructor(*_jsRuntime);
+  GPUCanvasContext::installConstructor(*_jsRuntime);
+  GPUCommandBuffer::installConstructor(*_jsRuntime);
+  GPUCommandEncoder::installConstructor(*_jsRuntime);
+  GPUCompilationInfo::installConstructor(*_jsRuntime);
+  GPUCompilationMessage::installConstructor(*_jsRuntime);
+  GPUComputePassEncoder::installConstructor(*_jsRuntime);
+  GPUComputePipeline::installConstructor(*_jsRuntime);
+  GPUDevice::installConstructor(*_jsRuntime);
+  GPUDeviceLostInfo::installConstructor(*_jsRuntime);
+  GPUError::installConstructor(*_jsRuntime);
+  GPUExternalTexture::installConstructor(*_jsRuntime);
+  GPUInternalError::installConstructor(*_jsRuntime);
+  GPUOutOfMemoryError::installConstructor(*_jsRuntime);
+  GPUValidationError::installConstructor(*_jsRuntime);
+  GPUPipelineLayout::installConstructor(*_jsRuntime);
+  GPUQuerySet::installConstructor(*_jsRuntime);
+  GPUQueue::installConstructor(*_jsRuntime);
+  GPURenderBundle::installConstructor(*_jsRuntime);
+  GPURenderBundleEncoder::installConstructor(*_jsRuntime);
+  GPURenderPassEncoder::installConstructor(*_jsRuntime);
+  GPURenderPipeline::installConstructor(*_jsRuntime);
+  GPUSampler::installConstructor(*_jsRuntime);
+  GPUShaderModule::installConstructor(*_jsRuntime);
+  GPUSupportedLimits::installConstructor(*_jsRuntime);
+  GPUTexture::installConstructor(*_jsRuntime);
+  GPUTextureView::installConstructor(*_jsRuntime);
+
+  // Install constant objects as plain JS objects with own properties
+  _jsRuntime->global().setProperty(*_jsRuntime, "GPUBufferUsage",
+                                   GPUBufferUsage::create(*_jsRuntime));
+  _jsRuntime->global().setProperty(*_jsRuntime, "GPUColorWrite",
+                                   GPUColorWrite::create(*_jsRuntime));
+  _jsRuntime->global().setProperty(*_jsRuntime, "GPUMapMode",
+                                   GPUMapMode::create(*_jsRuntime));
+  _jsRuntime->global().setProperty(*_jsRuntime, "GPUShaderStage",
+                                   GPUShaderStage::create(*_jsRuntime));
+  _jsRuntime->global().setProperty(*_jsRuntime, "GPUTextureUsage",
+                                   GPUTextureUsage::create(*_jsRuntime));
+
+  // Install global helper functions for Worklets serialization
+  // These are standalone functions that don't require RNWebGPU instance
+  installWebGPUWorkletHelpers(*_jsRuntime);
+}
+
+void RNWebGPUManager::installWebGPUWorkletHelpers(jsi::Runtime &runtime) {
+  // __webgpuIsWebGPUObject - checks if a value is a WebGPU NativeObject
+  auto isWebGPUObjectFunc = jsi::Function::createFromHostFunction(
+      runtime, jsi::PropNameID::forUtf8(runtime, "__webgpuIsWebGPUObject"), 1,
+      [](jsi::Runtime &rt, const jsi::Value & /*thisVal*/,
+         const jsi::Value *args, size_t count) -> jsi::Value {
+        if (count < 1 || !args[0].isObject()) {
+          return jsi::Value(false);
+        }
+        auto obj = args[0].getObject(rt);
+
+        // Check if it has native state
+        if (!obj.hasNativeState(rt)) {
+          return jsi::Value(false);
+        }
+
+        // Check if it has Symbol.toStringTag on its prototype (WebGPU objects
+        // do)
+        auto objectCtor = rt.global().getPropertyAsObject(rt, "Object");
+        auto getPrototypeOf =
+            objectCtor.getPropertyAsFunction(rt, "getPrototypeOf");
+        auto proto = getPrototypeOf.call(rt, obj);
+
+        if (!proto.isObject()) {
+          return jsi::Value(false);
+        }
+
+        auto protoObj = proto.getObject(rt);
+        auto symbolCtor = rt.global().getPropertyAsObject(rt, "Symbol");
+        auto toStringTag = symbolCtor.getProperty(rt, "toStringTag");
+        if (toStringTag.isUndefined()) {
+          return jsi::Value(false);
+        }
+
+        auto getOwnPropertyDescriptor =
+            objectCtor.getPropertyAsFunction(rt, "getOwnPropertyDescriptor");
+        auto desc = getOwnPropertyDescriptor.call(rt, protoObj, toStringTag);
+        return jsi::Value(desc.isObject());
+      });
+  runtime.global().setProperty(runtime, "__webgpuIsWebGPUObject",
+                               std::move(isWebGPUObjectFunc));
+
+  // __webgpuBox - boxes a WebGPU object for Worklets serialization
+  auto boxFunc = jsi::Function::createFromHostFunction(
+      runtime, jsi::PropNameID::forUtf8(runtime, "__webgpuBox"), 1,
+      [](jsi::Runtime &rt, const jsi::Value & /*thisVal*/,
+         const jsi::Value *args, size_t count) -> jsi::Value {
+        if (count < 1 || !args[0].isObject()) {
+          throw jsi::JSError(rt,
+                             "__webgpuBox() requires a WebGPU object argument");
+        }
+
+        auto obj = args[0].getObject(rt);
+
+        // Check if it has native state
+        if (!obj.hasNativeState(rt)) {
+          throw jsi::JSError(
+              rt, "Object has no native state - not a WebGPU object");
+        }
+
+        // Get the brand name from Symbol.toStringTag on the prototype
+        auto objectCtor = rt.global().getPropertyAsObject(rt, "Object");
+        auto getPrototypeOf =
+            objectCtor.getPropertyAsFunction(rt, "getPrototypeOf");
+        auto proto = getPrototypeOf.call(rt, obj);
+
+        std::string brand;
+        if (proto.isObject()) {
+          auto protoObj = proto.getObject(rt);
+          auto symbolCtor = rt.global().getPropertyAsObject(rt, "Symbol");
+          auto toStringTag = symbolCtor.getProperty(rt, "toStringTag");
+          if (!toStringTag.isUndefined()) {
+            auto getOwnPropertyDescriptor = objectCtor.getPropertyAsFunction(
+                rt, "getOwnPropertyDescriptor");
+            auto desc =
+                getOwnPropertyDescriptor.call(rt, protoObj, toStringTag);
+            if (desc.isObject()) {
+              auto descObj = desc.getObject(rt);
+              auto value = descObj.getProperty(rt, "value");
+              if (value.isString()) {
+                brand = value.getString(rt).utf8(rt);
+              }
+            }
+          }
+        }
+
+        if (brand.empty()) {
+          throw jsi::JSError(rt, "Cannot determine WebGPU object type - no "
+                                 "Symbol.toStringTag found");
+        }
+
+        auto nativeState = obj.getNativeState(rt);
+        auto boxed = std::make_shared<BoxedWebGPUObject>(nativeState, brand);
+        return jsi::Object::createFromHostObject(rt, boxed);
+      });
+  runtime.global().setProperty(runtime, "__webgpuBox", std::move(boxFunc));
 }
 
 RNWebGPUManager::~RNWebGPUManager() {

package/cpp/rnwgpu/RNWebGPUManager.h

@@ -27,6 +27,13 @@ public:
                   std::shared_ptr<PlatformContext> platformContext);
   ~RNWebGPUManager();
 
+  /**
+   * Install global helper functions for Worklets serialization.
+   * This installs __webgpuIsWebGPUObject and __webgpuBox on the global object.
+   * Can be called on any runtime (main JS, UI, or custom worklet runtimes).
+   */
+  static void installWebGPUWorkletHelpers(jsi::Runtime &runtime);
+
 private:
   jsi::Runtime *_jsRuntime;
   std::shared_ptr<facebook::react::CallInvoker> _jsCallInvoker;

package/cpp/rnwgpu/api/Canvas.h

@@ -7,16 +7,18 @@
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-class Canvas : public m::HybridObject {
+class Canvas : public NativeObject<Canvas> {
 public:
+  static constexpr const char *CLASS_NAME = "Canvas";
+
   explicit Canvas(void *surface, const int width, const int height)
-      : HybridObject("Canvas"), _surface(surface), _width(width),
+      : NativeObject(CLASS_NAME), _surface(surface), _width(width),
         _height(height), _clientWidth(width), _clientHeight(height) {}
 
   int getWidth() { return _width; }
@@ -34,14 +36,14 @@ public:
 
   void *getSurface() { return _surface; }
 
-  void loadHybridMethods() override {
-    registerHybridGetter("surface", &Canvas::getSurface, this);
-    registerHybridGetter("width", &Canvas::getWidth, this);
-    registerHybridGetter("height", &Canvas::getHeight, this);
-    registerHybridGetter("clientWidth", &Canvas::getClientWidth, this);
-    registerHybridGetter("clientHeight", &Canvas::getClientHeight, this);
-    registerHybridSetter("width", &Canvas::setWidth, this);
-    registerHybridSetter("height", &Canvas::setHeight, this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "surface", &Canvas::getSurface);
+    installGetterSetter(runtime, prototype, "width", &Canvas::getWidth,
+                        &Canvas::setWidth);
+    installGetterSetter(runtime, prototype, "height", &Canvas::getHeight,
+                        &Canvas::setHeight);
+    installGetter(runtime, prototype, "clientWidth", &Canvas::getClientWidth);
+    installGetter(runtime, prototype, "clientHeight", &Canvas::getClientHeight);
   }
 
 private:

package/cpp/rnwgpu/api/GPU.cpp

@@ -8,12 +8,12 @@
 #include <vector>
 
 #include "Convertors.h"
-#include "RNFJSIConverter.h"
+#include "JSIConverter.h"
 #include "rnwgpu/async/JSIMicrotaskDispatcher.h"
 
 namespace rnwgpu {
 
-GPU::GPU(jsi::Runtime &runtime) : HybridObject("GPU") {
+GPU::GPU(jsi::Runtime &runtime) : NativeObject(CLASS_NAME) {
   static const auto kTimedWaitAny = wgpu::InstanceFeatureName::TimedWaitAny;
   wgpu::InstanceDescriptor instanceDesc{.requiredFeatureCount = 1,
                                         .requiredFeatures = &kTimedWaitAny};
@@ -59,8 +59,7 @@ async::AsyncTaskHandle GPU::requestAdapter(
                         adapterHost);
                 resolve([result =
                              std::move(result)](jsi::Runtime &runtime) mutable {
-                  return margelo::JSIConverter<decltype(result)>::toJSI(runtime,
-                                                                        result);
+                  return JSIConverter<decltype(result)>::toJSI(runtime, result);
                 });
               } else {
                 auto result =
@@ -68,8 +67,7 @@ async::AsyncTaskHandle GPU::requestAdapter(
                         nullptr);
                 resolve([result =
                              std::move(result)](jsi::Runtime &runtime) mutable {
-                  return margelo::JSIConverter<decltype(result)>::toJSI(runtime,
-                                                                        result);
+                  return JSIConverter<decltype(result)>::toJSI(runtime, result);
                 });
               }
             });

package/cpp/rnwgpu/api/GPU.h

@@ -7,7 +7,7 @@
 
 #include "Unions.h"
 
-#include "RNFHybridObject.h"
+#include "NativeObject.h"
 
 #include "rnwgpu/async/AsyncRunner.h"
 #include "rnwgpu/async/AsyncTaskHandle.h"
@@ -21,14 +21,16 @@
 
 namespace rnwgpu {
 
-namespace m = margelo;
+namespace jsi = facebook::jsi;
 
-class GPU : public m::HybridObject {
+class GPU : public NativeObject<GPU> {
 public:
+  static constexpr const char *CLASS_NAME = "GPU";
+
   explicit GPU(jsi::Runtime &runtime);
 
 public:
-  std::string getBrand() { return _name; }
+  std::string getBrand() { return CLASS_NAME; }
 
   async::AsyncTaskHandle requestAdapter(
       std::optional<std::shared_ptr<GPURequestAdapterOptions>> options);
@@ -36,13 +38,13 @@ public:
 
   std::unordered_set<std::string> getWgslLanguageFeatures();
 
-  void loadHybridMethods() override {
-    registerHybridGetter("__brand", &GPU::getBrand, this);
-    registerHybridMethod("requestAdapter", &GPU::requestAdapter, this);
-    registerHybridMethod("getPreferredCanvasFormat",
-                         &GPU::getPreferredCanvasFormat, this);
-    registerHybridGetter("wgslLanguageFeatures", &GPU::getWgslLanguageFeatures,
-                         this);
+  static void definePrototype(jsi::Runtime &runtime, jsi::Object &prototype) {
+    installGetter(runtime, prototype, "__brand", &GPU::getBrand);
+    installMethod(runtime, prototype, "requestAdapter", &GPU::requestAdapter);
+    installMethod(runtime, prototype, "getPreferredCanvasFormat",
+                  &GPU::getPreferredCanvasFormat);
+    installGetter(runtime, prototype, "wgslLanguageFeatures",
+                  &GPU::getWgslLanguageFeatures);
   }
 
   inline const wgpu::Instance get() { return _instance; }

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -10,7 +10,7 @@
 #include "Convertors.h"
 
 #include "GPUFeatures.h"
-#include "RNFJSIConverter.h"
+#include "JSIConverter.h"
 #include "WGPULogger.h"
 
 namespace rnwgpu {
@@ -82,16 +82,16 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
   auto creationRuntime = getCreationRuntime();
   return _async->postTask(
       [this, aDescriptor, descriptor, label = std::move(label),
-       deviceLostBinding, creationRuntime](
-          const async::AsyncTaskHandle::ResolveFunction &resolve,
-          const async::AsyncTaskHandle::RejectFunction &reject) {
+       deviceLostBinding,
+       creationRuntime](const async::AsyncTaskHandle::ResolveFunction &resolve,
+                        const async::AsyncTaskHandle::RejectFunction &reject) {
         (void)descriptor;
         _instance.RequestDevice(
             &aDescriptor, wgpu::CallbackMode::AllowProcessEvents,
-            [asyncRunner = _async, resolve, reject, label,
-             creationRuntime, deviceLostBinding](
-                wgpu::RequestDeviceStatus status, wgpu::Device device,
-                wgpu::StringView message) mutable {
+            [asyncRunner = _async, resolve, reject, label, creationRuntime,
+             deviceLostBinding](wgpu::RequestDeviceStatus status,
+                                wgpu::Device device,
+                                wgpu::StringView message) mutable {
               if (message.length) {
                 fprintf(stderr, "%s", message.data);
               }
@@ -140,7 +140,7 @@ async::AsyncTaskHandle GPUAdapter::requestDevice(
               *deviceLostBinding = deviceHost;
               resolve([deviceHost = std::move(deviceHost)](
                           jsi::Runtime &runtime) mutable {
-                return margelo::JSIConverter<std::shared_ptr<GPUDevice>>::toJSI(
+                return JSIConverter<std::shared_ptr<GPUDevice>>::toJSI(
                     runtime, deviceHost);
               });
             });