react-native-wgpu 0.1.23 → 0.2.1

package/cpp/dawn_logging.cpp

@@ -0,0 +1,122 @@
+#include <sstream>
+#include <string>
+
+#ifdef __ANDROID__
+#include <android/log.h>
+#elif defined(__APPLE__)
+#include <os/log.h>
+#endif
+
+namespace dawn {
+
+enum class LogSeverity {
+    Debug,
+    Info,
+    Warning,
+    Error,
+};
+
+// Forward declare to match Dawn's exact interface
+class LogMessage {
+public:
+    explicit LogMessage(LogSeverity severity);
+    ~LogMessage();
+    
+    LogMessage(LogMessage&& other);
+    LogMessage& operator=(LogMessage&& other);
+    
+    template <typename T>
+    LogMessage& operator<<(T&& value) {
+        mStream << value;
+        return *this;
+    }
+
+private:
+    LogMessage(const LogMessage& other) = delete;
+    LogMessage& operator=(const LogMessage& other) = delete;
+    
+    LogSeverity mSeverity;
+    std::ostringstream mStream;
+};
+
+// Implementation of LogMessage methods
+LogMessage::LogMessage(LogSeverity severity) : mSeverity(severity) {}
+
+LogMessage::LogMessage(LogMessage&& other) 
+    : mSeverity(other.mSeverity), mStream(std::move(other.mStream)) {}
+
+LogMessage& LogMessage::operator=(LogMessage&& other) {
+    if (this != &other) {
+        mSeverity = other.mSeverity;
+        mStream = std::move(other.mStream);
+    }
+    return *this;
+}
+
+LogMessage::~LogMessage() {
+    std::string fullMessage = mStream.str();
+    
+    if (fullMessage.empty()) {
+        return;
+    }
+    
+    const char* severityName;
+    switch (mSeverity) {
+        case LogSeverity::Debug: severityName = "Debug"; break;
+        case LogSeverity::Info: severityName = "Info"; break;
+        case LogSeverity::Warning: severityName = "Warning"; break;
+        case LogSeverity::Error: severityName = "Error"; break;
+        default: severityName = "Unknown"; break;
+    }
+    
+#ifdef __ANDROID__
+    int androidPriority;
+    switch (mSeverity) {
+        case LogSeverity::Debug: androidPriority = ANDROID_LOG_DEBUG; break;
+        case LogSeverity::Info: androidPriority = ANDROID_LOG_INFO; break;
+        case LogSeverity::Warning: androidPriority = ANDROID_LOG_WARN; break;
+        case LogSeverity::Error: androidPriority = ANDROID_LOG_ERROR; break;
+        default: androidPriority = ANDROID_LOG_ERROR; break;
+    }
+    __android_log_print(androidPriority, "ReactNativeWebGPU", "%s: %s", severityName, fullMessage.c_str());
+#elif defined(__APPLE__)
+    os_log_type_t logType;
+    switch (mSeverity) {
+        case LogSeverity::Debug: logType = OS_LOG_TYPE_DEBUG; break;
+        case LogSeverity::Info: logType = OS_LOG_TYPE_INFO; break;
+        case LogSeverity::Warning: logType = OS_LOG_TYPE_DEFAULT; break;
+        case LogSeverity::Error: logType = OS_LOG_TYPE_ERROR; break;
+        default: logType = OS_LOG_TYPE_ERROR; break;
+    }
+    os_log_with_type(OS_LOG_DEFAULT, logType, "[ReactNativeWebGPU] %s: %s", severityName, fullMessage.c_str());
+#else
+    FILE* outputStream = (mSeverity == LogSeverity::Warning || mSeverity == LogSeverity::Error) ? stderr : stdout;
+    fprintf(outputStream, "[ReactNativeWebGPU] %s: %s\n", severityName, fullMessage.c_str());
+    fflush(outputStream);
+#endif
+}
+
+// Factory functions
+LogMessage DebugLog() {
+    return LogMessage(LogSeverity::Debug);
+}
+
+LogMessage InfoLog() {
+    return LogMessage(LogSeverity::Info);
+}
+
+LogMessage WarningLog() {
+    return LogMessage(LogSeverity::Warning);
+}
+
+LogMessage ErrorLog() {
+    return LogMessage(LogSeverity::Error);
+}
+
+LogMessage DebugLog(const char* file, const char* function, int line) {
+    LogMessage message = DebugLog();
+    message << file << ":" << line << "(" << function << ")";
+    return message;
+}
+
+} // namespace dawn

package/cpp/jsi/RNFJSIConverter.h

@@ -28,6 +28,9 @@
 #include "Dispatcher.h"
 #include "ThreadPool.h"
 
+// This number is the maximum integer that can be represented exactly as a double
+#define MAX_SAFE_INTEGER uint64_t(9007199254740991)
+
 #if __has_include(<cxxabi.h>)
 #include <cxxabi.h>
 #endif
@@ -122,7 +125,7 @@ template <> struct JSIConverter<uint64_t> {
   static uint64_t fromJSI(jsi::Runtime& runtime, const jsi::Value& arg, bool outOfBound) {
     if (arg.isNumber()) {
       double value = arg.asNumber();
-      if (value < 0 || value > static_cast<double>(std::numeric_limits<uint64_t>::max())) {
+      if (value < 0 || value > MAX_SAFE_INTEGER) {
         throw jsi::JSError(runtime, "Number out of range for uint64_t");
       }
       return static_cast<uint64_t>(value);
@@ -132,7 +135,7 @@ template <> struct JSIConverter<uint64_t> {
   }
 
   static jsi::Value toJSI(jsi::Runtime& runtime, uint64_t arg) {
-    if (arg <= static_cast<uint64_t>(std::numeric_limits<double>::max())) {
+    if (arg <= MAX_SAFE_INTEGER) {
       return jsi::Value(static_cast<double>(arg));
     } else {
       throw jsi::JSError(runtime, "Number too large to be represented as a double");

package/cpp/rnwgpu/SurfaceRegistry.h

@@ -38,6 +38,7 @@ public:
     config = newConfig;
     config.width = width;
     config.height = height;
+    config.presentMode = wgpu::PresentMode::Fifo;
     _configure();
   }
 
@@ -83,10 +84,10 @@ public:
       auto device = config.device;
       wgpu::CommandEncoder encoder = device.CreateCommandEncoder(&encoderDesc);
 
-      wgpu::ImageCopyTexture sourceTexture = {};
+      wgpu::TexelCopyTextureInfo sourceTexture = {};
       sourceTexture.texture = texture;
 
-      wgpu::ImageCopyTexture destinationTexture = {};
+      wgpu::TexelCopyTextureInfo destinationTexture = {};
       wgpu::SurfaceTexture surfaceTexture;
       surface.GetCurrentTexture(&surfaceTexture);
       destinationTexture.texture = surfaceTexture.texture;

package/cpp/rnwgpu/api/Convertors.h

@@ -309,7 +309,7 @@ public:
            Convert(out.label, in.label);
   }
 
-  [[nodiscard]] bool Convert(wgpu::ComputePassTimestampWrites &out,
+  [[nodiscard]] bool Convert(wgpu::PassTimestampWrites &out,
                              const GPUComputePassTimestampWrites &in) {
     return Convert(out.querySet, in.querySet) &&
            Convert(out.beginningOfPassWriteIndex,
@@ -348,74 +348,70 @@ public:
 
     if (in.requiredLimits.has_value()) {
       const auto &limits = in.requiredLimits.value();
-      auto *requiredLimits = Allocate<wgpu::RequiredLimits>();
+      auto *requiredLimits = Allocate<wgpu::Limits>();
       for (const auto &[key, value] : limits) {
         if (key == "maxTextureDimension1D") {
-          requiredLimits->limits.maxTextureDimension1D = value;
+          requiredLimits->maxTextureDimension1D = value;
         } else if (key == "maxTextureDimension2D") {
-          requiredLimits->limits.maxTextureDimension2D = value;
+          requiredLimits->maxTextureDimension2D = value;
         } else if (key == "maxTextureDimension3D") {
-          requiredLimits->limits.maxTextureDimension3D = value;
+          requiredLimits->maxTextureDimension3D = value;
         } else if (key == "maxTextureArrayLayers") {
-          requiredLimits->limits.maxTextureArrayLayers = value;
+          requiredLimits->maxTextureArrayLayers = value;
         } else if (key == "maxBindGroups") {
-          requiredLimits->limits.maxBindGroups = value;
+          requiredLimits->maxBindGroups = value;
         } else if (key == "maxBindGroupsPlusVertexBuffers") {
-          requiredLimits->limits.maxBindGroupsPlusVertexBuffers = value;
+          requiredLimits->maxBindGroupsPlusVertexBuffers = value;
         } else if (key == "maxBindingsPerBindGroup") {
-          requiredLimits->limits.maxBindingsPerBindGroup = value;
+          requiredLimits->maxBindingsPerBindGroup = value;
         } else if (key == "maxDynamicUniformBuffersPerPipelineLayout") {
-          requiredLimits->limits.maxDynamicUniformBuffersPerPipelineLayout =
-              value;
+          requiredLimits->maxDynamicUniformBuffersPerPipelineLayout = value;
         } else if (key == "maxDynamicStorageBuffersPerPipelineLayout") {
-          requiredLimits->limits.maxDynamicStorageBuffersPerPipelineLayout =
-              value;
+          requiredLimits->maxDynamicStorageBuffersPerPipelineLayout = value;
         } else if (key == "maxSampledTexturesPerShaderStage") {
-          requiredLimits->limits.maxSampledTexturesPerShaderStage = value;
+          requiredLimits->maxSampledTexturesPerShaderStage = value;
         } else if (key == "maxSamplersPerShaderStage") {
-          requiredLimits->limits.maxSamplersPerShaderStage = value;
+          requiredLimits->maxSamplersPerShaderStage = value;
         } else if (key == "maxStorageBuffersPerShaderStage") {
-          requiredLimits->limits.maxStorageBuffersPerShaderStage = value;
+          requiredLimits->maxStorageBuffersPerShaderStage = value;
         } else if (key == "maxStorageTexturesPerShaderStage") {
-          requiredLimits->limits.maxStorageTexturesPerShaderStage = value;
+          requiredLimits->maxStorageTexturesPerShaderStage = value;
         } else if (key == "maxUniformBuffersPerShaderStage") {
-          requiredLimits->limits.maxUniformBuffersPerShaderStage = value;
+          requiredLimits->maxUniformBuffersPerShaderStage = value;
         } else if (key == "maxUniformBufferBindingSize") {
-          requiredLimits->limits.maxUniformBufferBindingSize = value;
+          requiredLimits->maxUniformBufferBindingSize = value;
         } else if (key == "maxStorageBufferBindingSize") {
-          requiredLimits->limits.maxStorageBufferBindingSize = value;
+          requiredLimits->maxStorageBufferBindingSize = value;
         } else if (key == "minUniformBufferOffsetAlignment") {
-          requiredLimits->limits.minUniformBufferOffsetAlignment = value;
+          requiredLimits->minUniformBufferOffsetAlignment = value;
         } else if (key == "minStorageBufferOffsetAlignment") {
-          requiredLimits->limits.minStorageBufferOffsetAlignment = value;
+          requiredLimits->minStorageBufferOffsetAlignment = value;
         } else if (key == "maxVertexBuffers") {
-          requiredLimits->limits.maxVertexBuffers = value;
+          requiredLimits->maxVertexBuffers = value;
         } else if (key == "maxBufferSize") {
-          requiredLimits->limits.maxBufferSize = value;
+          requiredLimits->maxBufferSize = value;
         } else if (key == "maxVertexAttributes") {
-          requiredLimits->limits.maxVertexAttributes = value;
+          requiredLimits->maxVertexAttributes = value;
         } else if (key == "maxVertexBufferArrayStride") {
-          requiredLimits->limits.maxVertexBufferArrayStride = value;
-        } else if (key == "maxInterStageShaderComponents") {
-          requiredLimits->limits.maxInterStageShaderComponents = value;
+          requiredLimits->maxVertexBufferArrayStride = value;
         } else if (key == "maxInterStageShaderVariables") {
-          requiredLimits->limits.maxInterStageShaderVariables = value;
+          requiredLimits->maxInterStageShaderVariables = value;
         } else if (key == "maxColorAttachments") {
-          requiredLimits->limits.maxColorAttachments = value;
+          requiredLimits->maxColorAttachments = value;
         } else if (key == "maxColorAttachmentBytesPerSample") {
-          requiredLimits->limits.maxColorAttachmentBytesPerSample = value;
+          requiredLimits->maxColorAttachmentBytesPerSample = value;
         } else if (key == "maxComputeWorkgroupStorageSize") {
-          requiredLimits->limits.maxComputeWorkgroupStorageSize = value;
+          requiredLimits->maxComputeWorkgroupStorageSize = value;
         } else if (key == "maxComputeInvocationsPerWorkgroup") {
-          requiredLimits->limits.maxComputeInvocationsPerWorkgroup = value;
+          requiredLimits->maxComputeInvocationsPerWorkgroup = value;
         } else if (key == "maxComputeWorkgroupSizeX") {
-          requiredLimits->limits.maxComputeWorkgroupSizeX = value;
+          requiredLimits->maxComputeWorkgroupSizeX = value;
         } else if (key == "maxComputeWorkgroupSizeY") {
-          requiredLimits->limits.maxComputeWorkgroupSizeY = value;
+          requiredLimits->maxComputeWorkgroupSizeY = value;
         } else if (key == "maxComputeWorkgroupSizeZ") {
-          requiredLimits->limits.maxComputeWorkgroupSizeZ = value;
+          requiredLimits->maxComputeWorkgroupSizeZ = value;
         } else if (key == "maxComputeWorkgroupsPerDimension") {
-          requiredLimits->limits.maxComputeWorkgroupsPerDimension = value;
+          requiredLimits->maxComputeWorkgroupsPerDimension = value;
         }
       }
       out.requiredLimits = requiredLimits;
@@ -452,7 +448,7 @@ public:
            Convert(out.constants, out.constantCount, in.constants);
   }
 
-  [[nodiscard]] bool Convert(wgpu::ImageCopyBuffer &out,
+  [[nodiscard]] bool Convert(wgpu::TexelCopyBufferInfo &out,
                              const GPUImageCopyBuffer &in) {
     out = {};
     out.buffer = in.buffer->get();
@@ -461,13 +457,13 @@ public:
            Convert(out.layout.rowsPerImage, in.rowsPerImage);
   }
 
-  [[nodiscard]] bool Convert(wgpu::ImageCopyTexture &out,
+  [[nodiscard]] bool Convert(wgpu::TexelCopyTextureInfo &out,
                              const GPUImageCopyTexture &in) {
     return Convert(out.origin, in.origin) && Convert(out.texture, in.texture) &&
            Convert(out.mipLevel, in.mipLevel) && Convert(out.aspect, in.aspect);
   }
 
-  [[nodiscard]] bool Convert(wgpu::TextureDataLayout &out,
+  [[nodiscard]] bool Convert(wgpu::TexelCopyBufferLayout &out,
                              const GPUImageDataLayout &in) {
     out = {};
     return Convert(out.bytesPerRow, in.bytesPerRow) &&
@@ -502,7 +498,7 @@ public:
            Convert(out.cullMode, in.cullMode);
   }
 
-  [[nodiscard]] bool Convert(wgpu::ProgrammableStageDescriptor &out,
+  [[nodiscard]] bool Convert(wgpu::ComputeState &out,
                              const GPUProgrammableStage &in) {
     out = {};
     out.module = in.module->get();
@@ -554,7 +550,7 @@ public:
            Convert(out.stencilReadOnly, in.stencilReadOnly);
   }
 
-  [[nodiscard]] bool Convert(wgpu::RenderPassTimestampWrites &out,
+  [[nodiscard]] bool Convert(wgpu::PassTimestampWrites &out,
                              const GPURenderPassTimestampWrites &in) {
     return Convert(out.querySet, in.querySet) &&
            Convert(out.beginningOfPassWriteIndex,

package/cpp/rnwgpu/api/GPU.cpp

@@ -27,15 +27,16 @@ GPU::requestAdapter(
   aOptions.backendType = kDefaultBackendType;
   wgpu::Adapter adapter = nullptr;
   _instance.RequestAdapter(
-      &aOptions,
-      [](WGPURequestAdapterStatus, WGPUAdapter cAdapter,
-         const WGPUStringView message, void *userdata) {
+      &aOptions, wgpu::CallbackMode::AllowSpontaneous,
+      [](wgpu::RequestAdapterStatus status, wgpu::Adapter adapter,
+         wgpu::StringView message, wgpu::Adapter *userdata) {
         if (message.length) {
           fprintf(stderr, "%s", message.data);
           return;
         }
-        *static_cast<wgpu::Adapter *>(userdata) =
-            wgpu::Adapter::Acquire(cAdapter);
+        if (status == wgpu::RequestAdapterStatus::Success) {
+          *userdata = std::move(adapter);
+        }
       },
       &adapter);
   if (!adapter) {
@@ -47,38 +48,39 @@ GPU::requestAdapter(
 }
 
 std::unordered_set<std::string> GPU::getWgslLanguageFeatures() {
-  auto count = _instance.EnumerateWGSLLanguageFeatures(nullptr);
-  std::vector<wgpu::WGSLFeatureName> features(count);
-  _instance.EnumerateWGSLLanguageFeatures(features.data());
+  wgpu::SupportedWGSLLanguageFeatures supportedFeatures = {};
+  _instance.GetWGSLLanguageFeatures(&supportedFeatures);
+  
   std::unordered_set<std::string> result;
-  for (auto feature : features) {
+  for (size_t i = 0; i < supportedFeatures.featureCount; i++) {
+    wgpu::WGSLLanguageFeatureName feature = supportedFeatures.features[i];
     std::string name;
     switch (feature) {
-    case wgpu::WGSLFeatureName::ReadonlyAndReadwriteStorageTextures:
+    case wgpu::WGSLLanguageFeatureName::ReadonlyAndReadwriteStorageTextures:
       name = "readonly_and_readwrite_storage_textures";
       break;
-    case wgpu::WGSLFeatureName::Packed4x8IntegerDotProduct:
+    case wgpu::WGSLLanguageFeatureName::Packed4x8IntegerDotProduct:
       name = "packed_4x8_integer_dot_product";
       break;
-    case wgpu::WGSLFeatureName::UnrestrictedPointerParameters:
+    case wgpu::WGSLLanguageFeatureName::UnrestrictedPointerParameters:
       name = "unrestricted_pointer_parameters";
       break;
-    case wgpu::WGSLFeatureName::PointerCompositeAccess:
+    case wgpu::WGSLLanguageFeatureName::PointerCompositeAccess:
       name = "pointer_composite_access";
       break;
-    case wgpu::WGSLFeatureName::ChromiumTestingUnimplemented:
+    case wgpu::WGSLLanguageFeatureName::ChromiumTestingUnimplemented:
       name = "chromium_testing_unimplemented";
       break;
-    case wgpu::WGSLFeatureName::ChromiumTestingUnsafeExperimental:
+    case wgpu::WGSLLanguageFeatureName::ChromiumTestingUnsafeExperimental:
       name = "chromium_testing_unsafe_experimental";
       break;
-    case wgpu::WGSLFeatureName::ChromiumTestingExperimental:
+    case wgpu::WGSLLanguageFeatureName::ChromiumTestingExperimental:
       name = "chromium_testing_experimental";
       break;
-    case wgpu::WGSLFeatureName::ChromiumTestingShippedWithKillswitch:
+    case wgpu::WGSLLanguageFeatureName::ChromiumTestingShippedWithKillswitch:
       name = "chromium_testing_shipped_with_killswitch";
       break;
-    case wgpu::WGSLFeatureName::ChromiumTestingShipped:
+    case wgpu::WGSLLanguageFeatureName::ChromiumTestingShipped:
       name = "chromium_testing_shipped";
       break;
     }

package/cpp/rnwgpu/api/GPU.h

@@ -12,11 +12,15 @@
 
 #include "AsyncRunner.h"
 
+#include "dawn/dawn_proc.h"
+#include "dawn/native/DawnNative.h"
 #include "webgpu/webgpu_cpp.h"
 
 #include "GPUAdapter.h"
 #include "GPURequestAdapterOptions.h"
 
+#include <webgpu/webgpu.h>
+
 namespace rnwgpu {
 
 namespace m = margelo;
@@ -25,8 +29,8 @@ class GPU : public m::HybridObject {
 public:
   GPU() : HybridObject("GPU") {
     wgpu::InstanceDescriptor instanceDesc;
-    instanceDesc.features.timedWaitAnyEnable = true;
-    instanceDesc.features.timedWaitAnyMaxCount = 64;
+    instanceDesc.capabilities.timedWaitAnyEnable = true;
+    instanceDesc.capabilities.timedWaitAnyMaxCount = 64;
     _instance = wgpu::CreateInstance(&instanceDesc);
     auto instance = &_instance;
     _async = std::make_shared<AsyncRunner>(instance);

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -21,15 +21,17 @@ std::future<std::shared_ptr<GPUDevice>> GPUAdapter::requestDevice(
   if (!conv(aDescriptor, descriptor)) {
     throw std::runtime_error("Failed to convert GPUDeviceDescriptor");
   }
-  wgpu::DeviceLostCallbackInfo info = {
-      .callback = [](WGPUDevice const *device, WGPUDeviceLostReason reason,
-                     const WGPUStringView message, void *userdata) {
+  // Set device lost callback using new template API
+  aDescriptor.SetDeviceLostCallback(
+      wgpu::CallbackMode::AllowSpontaneous,
+      [](const wgpu::Device &device, wgpu::DeviceLostReason reason,
+         wgpu::StringView message) {
         const char *lostReason = "";
         switch (reason) {
-        case WGPUDeviceLostReason_Destroyed:
+        case wgpu::DeviceLostReason::Destroyed:
           lostReason = "Destroyed";
           break;
-        case WGPUDeviceLostReason_Unknown:
+        case wgpu::DeviceLostReason::Unknown:
           lostReason = "Unknown";
           break;
         default:
@@ -37,43 +39,46 @@ std::future<std::shared_ptr<GPUDevice>> GPUAdapter::requestDevice(
         }
         Logger::logToConsole("GPU Device Lost (%s): %s", lostReason,
                              message.data);
-      }};
-  aDescriptor.deviceLostCallbackInfo = info;
-  wgpu::UncapturedErrorCallbackInfo errorInfo;
-  errorInfo.userdata = static_cast<void *>(_creationRuntime);
-  errorInfo.callback = [](WGPUErrorType type, const WGPUStringView message,
-                          void *userdata) {
-    auto creationRuntime = static_cast<jsi::Runtime *>(userdata);
+      });
+
+  // Set uncaptured error callback using new template API
+  aDescriptor.SetUncapturedErrorCallback([](const wgpu::Device &device,
+                                            wgpu::ErrorType type,
+                                            wgpu::StringView message) {
     const char *errorType = "";
     switch (type) {
-    case WGPUErrorType_Validation:
+    case wgpu::ErrorType::Validation:
       errorType = "Validation";
       break;
-    case WGPUErrorType_OutOfMemory:
+    case wgpu::ErrorType::OutOfMemory:
       errorType = "Out of Memory";
       break;
-    case WGPUErrorType_Internal:
+    case wgpu::ErrorType::Internal:
       errorType = "Internal";
       break;
-    case WGPUErrorType_Unknown:
+    case wgpu::ErrorType::Unknown:
       errorType = "Unknown";
       break;
     default:
       errorType = "Unknown";
     }
-    std::string fullMessage = std::string(errorType) + ": " + message.data;
-    Logger::errorToJavascriptConsole(*creationRuntime, fullMessage);
-  };
-  aDescriptor.uncapturedErrorCallbackInfo = errorInfo;
+    std::string fullMessage =
+        message.length > 0 ? std::string(errorType) + ": " +
+                                 std::string(message.data, message.length)
+                           : "no message";
+    fprintf(stderr, "%s", fullMessage.c_str());
+  });
   _instance.RequestDevice(
-      &aDescriptor,
-      [](WGPURequestDeviceStatus status, WGPUDevice cDevice,
-         const WGPUStringView message, void *userdata) {
+      &aDescriptor, wgpu::CallbackMode::AllowSpontaneous,
+      [](wgpu::RequestDeviceStatus status, wgpu::Device device,
+         wgpu::StringView message, wgpu::Device *userdata) {
         if (message.length) {
           fprintf(stderr, "%s", message.data);
           return;
         }
-        *static_cast<wgpu::Device *>(userdata) = wgpu::Device::Acquire(cDevice);
+        if (status == wgpu::RequestDeviceStatus::Success) {
+          *userdata = std::move(device);
+        }
       },
       &device);
 
@@ -81,28 +86,32 @@ std::future<std::shared_ptr<GPUDevice>> GPUAdapter::requestDevice(
     throw std::runtime_error("Failed to request device");
   }
   device.SetLoggingCallback(
-      [](WGPULoggingType type, const WGPUStringView message, void *userdata) {
-        auto creationRuntime = static_cast<jsi::Runtime *>(userdata);
+      [creationRuntime = _creationRuntime](wgpu::LoggingType type,
+                                           wgpu::StringView message) {
         const char *logLevel = "";
         switch (type) {
-        case WGPULoggingType_Warning:
+        case wgpu::LoggingType::Warning:
           logLevel = "Warning";
-          Logger::warnToJavascriptConsole(*creationRuntime, message.data);
+          Logger::warnToJavascriptConsole(
+              *creationRuntime, std::string(message.data, message.length));
           break;
-        case WGPULoggingType_Error:
+        case wgpu::LoggingType::Error:
           logLevel = "Error";
-          Logger::errorToJavascriptConsole(*creationRuntime, message.data);
+          Logger::errorToJavascriptConsole(
+              *creationRuntime, std::string(message.data, message.length));
           break;
-        case WGPULoggingType_Verbose:
+        case wgpu::LoggingType::Verbose:
           logLevel = "Verbose";
-        case WGPULoggingType_Info:
+          break;
+        case wgpu::LoggingType::Info:
           logLevel = "Info";
+          break;
         default:
           logLevel = "Unknown";
-          Logger::logToConsole("%s: %s", logLevel, message);
+          Logger::logToConsole("%s: %.*s", logLevel,
+                               static_cast<int>(message.length), message.data);
         }
-      },
-      _creationRuntime);
+      });
   std::string label =
       descriptor.has_value() ? descriptor.value()->label.value_or("") : "";
   promise.set_value(
@@ -111,11 +120,11 @@ std::future<std::shared_ptr<GPUDevice>> GPUAdapter::requestDevice(
 }
 
 std::unordered_set<std::string> GPUAdapter::getFeatures() {
-  size_t count = _instance.EnumerateFeatures(nullptr);
-  std::vector<wgpu::FeatureName> features(count);
-  _instance.EnumerateFeatures(features.data());
+  wgpu::SupportedFeatures supportedFeatures;
+  _instance.GetFeatures(&supportedFeatures);
   std::unordered_set<std::string> result;
-  for (auto feature : features) {
+  for (size_t i = 0; i < supportedFeatures.featureCount; ++i) {
+    auto feature = supportedFeatures.features[i];
     std::string name;
     convertEnumToJSUnion(feature, &name);
     if (name != "") {
@@ -126,7 +135,7 @@ std::unordered_set<std::string> GPUAdapter::getFeatures() {
 }
 
 std::shared_ptr<GPUSupportedLimits> GPUAdapter::getLimits() {
-  wgpu::SupportedLimits limits{};
+  wgpu::Limits limits{};
   if (!_instance.GetLimits(&limits)) {
     throw std::runtime_error("Failed to get limits");
   }

package/cpp/rnwgpu/api/GPUBuffer.cpp

@@ -54,25 +54,27 @@ std::future<void> GPUBuffer::mapAsync(uint64_t modeIn,
     //     is already mapped"))); return future;
     //   }
     // }
-    wgpu::BufferMapCallbackInfo callback;
-    callback.mode = wgpu::CallbackMode::WaitAnyOnly;
-    callback.callback = [](WGPUBufferMapAsyncStatus status, void *userdata) {
-      switch (status) {
-      case WGPUBufferMapAsyncStatus_Success:
-        break;
-      case WGPUBufferMapAsyncStatus_InstanceDropped:
-        throw std::runtime_error("WGPUBufferMapAsyncStatus_InstanceDropped");
-        break;
-      case WGPUBufferMapAsyncStatus_ValidationError:
-        throw std::runtime_error("WGPUBufferMapAsyncStatus_ValidationError");
-        break;
-      default:
-        throw std::runtime_error("WGPUBufferMapAsyncStatus: " +
-                                 std::to_string(status));
-        break;
-      }
-    };
-    return _instance.MapAsync(mode, offset.value_or(0), rangeSize, callback);
+    return _instance.MapAsync(
+        mode, offset.value_or(0), rangeSize, wgpu::CallbackMode::WaitAnyOnly,
+        [](wgpu::MapAsyncStatus status, wgpu::StringView message) {
+          switch (status) {
+          case wgpu::MapAsyncStatus::Success:
+            break;
+          case wgpu::MapAsyncStatus::CallbackCancelled:
+            throw std::runtime_error("MapAsyncStatus::CallbackCancelled");
+            break;
+          case wgpu::MapAsyncStatus::Error:
+            throw std::runtime_error("MapAsyncStatus::Error");
+            break;
+          case wgpu::MapAsyncStatus::Aborted:
+            throw std::runtime_error("MapAsyncStatus::Aborted");
+            break;
+          default:
+            throw std::runtime_error("MapAsyncStatus: " +
+                                     std::to_string(static_cast<int>(status)));
+            break;
+          }
+        });
   });
 }
 

package/cpp/rnwgpu/api/GPUCanvasContext.cpp

@@ -28,6 +28,7 @@ void GPUCanvasContext::configure(
 #ifdef __APPLE__
   surfaceConfiguration.alphaMode = configuration->alphaMode;
 #endif
+  surfaceConfiguration.presentMode = wgpu::PresentMode::Fifo;
   _surfaceInfo->configure(surfaceConfiguration);
 }