diff --git a/thermion_dart/lib/src/bindings/src/ffi.dart b/thermion_dart/lib/src/bindings/src/ffi.dart
index 547314af..f271ca65 100644
--- a/thermion_dart/lib/src/bindings/src/ffi.dart
+++ b/thermion_dart/lib/src/bindings/src/ffi.dart
@@ -86,17 +86,28 @@ extension PCBF on DartPickCallbackFunction {
   }
 }
 
+int _requestId = 0;
+final _requests = <int, Completer>{};
+
+void _voidCallbackHandler(int requestId) {
+  _requests[requestId]!.complete();
+}
+
+late NativeCallable<Void Function(Int32)>
+    _voidCallbackNativeCallable = NativeCallable<Void Function(Int32)>.listener(_voidCallbackHandler);
+
 Future<void> withVoidCallback(
-    Function(Pointer<NativeFunction<Void Function()>>) func) async {
+    Function(int, Pointer<NativeFunction<Void Function(int)>>) func) async {
+  var requestId = _requestId;
+  _requestId++;
   final completer = Completer();
-  // ignore: prefer_function_declarations_over_variables
-  void Function() callback = () {
-    completer.complete();
-  };
-  final nativeCallable = NativeCallable<Void Function()>.listener(callback);
-  func.call(nativeCallable.nativeFunction);
+  _requests[requestId] = completer;
+  
+  _voidCallbackNativeCallable = NativeCallable<Void Function(Int32)>.listener(_voidCallbackHandler);
+  func.call(requestId, _voidCallbackNativeCallable.nativeFunction.cast());
+
   await completer.future;
-  nativeCallable.close();
+  // nativeCallable.close();
 }
 
 Future<Pointer<T>> withPointerCallback<T extends NativeType>(
diff --git a/thermion_dart/lib/src/bindings/src/thermion_dart_ffi.g.dart b/thermion_dart/lib/src/bindings/src/thermion_dart_ffi.g.dart
index d8b4e063..0c108d4a 100644
--- a/thermion_dart/lib/src/bindings/src/thermion_dart_ffi.g.dart
+++ b/thermion_dart/lib/src/bindings/src/thermion_dart_ffi.g.dart
@@ -1515,11 +1515,12 @@ external void RenderThread_addTask(
 );
 
 @ffi.Native<
-    ffi.Void Function(
-        ffi.Pointer<TRenderTicker>, ffi.Uint64, VoidCallback)>(isLeaf: true)
+    ffi.Void Function(ffi.Pointer<TRenderTicker>, ffi.Uint64, ffi.Uint32,
+        VoidCallback)>(isLeaf: true)
 external void RenderTicker_renderRenderThread(
   ffi.Pointer<TRenderTicker> tRenderTicker,
   int frameTimeInNanos,
+  int requestId,
   VoidCallback onComplete,
 );
 
@@ -1649,81 +1650,91 @@ external void Engine_buildMaterialRenderThread(
       onComplete,
 );
 
-@ffi.Native<ffi.Void Function(ffi.Pointer<TEngine>, VoidCallback)>(isLeaf: true)
+@ffi.Native<ffi.Void Function(ffi.Pointer<TEngine>, ffi.Uint32, VoidCallback)>(
+    isLeaf: true)
 external void Engine_destroyRenderThread(
   ffi.Pointer<TEngine> tEngine,
+  int requestId,
   VoidCallback onComplete,
 );
 
 @ffi.Native<
-    ffi.Void Function(ffi.Pointer<TEngine>, ffi.Pointer<TSwapChain>,
+    ffi.Void Function(ffi.Pointer<TEngine>, ffi.Pointer<TSwapChain>, ffi.Uint32,
         VoidCallback)>(isLeaf: true)
 external void Engine_destroySwapChainRenderThread(
   ffi.Pointer<TEngine> tEngine,
   ffi.Pointer<TSwapChain> tSwapChain,
+  int requestId,
   VoidCallback onComplete,
 );
 
 @ffi.Native<
-    ffi.Void Function(
-        ffi.Pointer<TEngine>, ffi.Pointer<TView>, VoidCallback)>(isLeaf: true)
+    ffi.Void Function(ffi.Pointer<TEngine>, ffi.Pointer<TView>, ffi.Uint32,
+        VoidCallback)>(isLeaf: true)
 external void Engine_destroyViewRenderThread(
   ffi.Pointer<TEngine> tEngine,
   ffi.Pointer<TView> tView,
+  int requestId,
   VoidCallback onComplete,
 );
 
 @ffi.Native<
-    ffi.Void Function(
-        ffi.Pointer<TEngine>, ffi.Pointer<TScene>, VoidCallback)>(isLeaf: true)
+    ffi.Void Function(ffi.Pointer<TEngine>, ffi.Pointer<TScene>, ffi.Uint32,
+        VoidCallback)>(isLeaf: true)
 external void Engine_destroySceneRenderThread(
   ffi.Pointer<TEngine> tEngine,
   ffi.Pointer<TScene> tScene,
+  int requestId,
   VoidCallback onComplete,
 );
 
 @ffi.Native<
     ffi.Void Function(ffi.Pointer<TEngine>, ffi.Pointer<TColorGrading>,
-        VoidCallback)>(isLeaf: true)
+        ffi.Uint32, VoidCallback)>(isLeaf: true)
 external void Engine_destroyColorGradingRenderThread(
   ffi.Pointer<TEngine> tEngine,
   ffi.Pointer<TColorGrading> tColorGrading,
+  int requestId,
   VoidCallback onComplete,
 );
 
 @ffi.Native<
-    ffi.Void Function(ffi.Pointer<TEngine>, ffi.Pointer<TMaterial>,
+    ffi.Void Function(ffi.Pointer<TEngine>, ffi.Pointer<TMaterial>, ffi.Uint32,
         VoidCallback)>(isLeaf: true)
 external void Engine_destroyMaterialRenderThread(
   ffi.Pointer<TEngine> tEngine,
   ffi.Pointer<TMaterial> tMaterial,
+  int requestId,
   VoidCallback onComplete,
 );
 
 @ffi.Native<
     ffi.Void Function(ffi.Pointer<TEngine>, ffi.Pointer<TMaterialInstance>,
-        VoidCallback)>(isLeaf: true)
+        ffi.Uint32, VoidCallback)>(isLeaf: true)
 external void Engine_destroyMaterialInstanceRenderThread(
   ffi.Pointer<TEngine> tEngine,
   ffi.Pointer<TMaterialInstance> tMaterialInstance,
+  int requestId,
   VoidCallback onComplete,
 );
 
 @ffi.Native<
-    ffi.Void Function(
-        ffi.Pointer<TEngine>, ffi.Pointer<TSkybox>, VoidCallback)>(isLeaf: true)
+    ffi.Void Function(ffi.Pointer<TEngine>, ffi.Pointer<TSkybox>, ffi.Uint32,
+        VoidCallback)>(isLeaf: true)
 external void Engine_destroySkyboxRenderThread(
   ffi.Pointer<TEngine> tEngine,
   ffi.Pointer<TSkybox> tSkybox,
+  int requestId,
   VoidCallback onComplete,
 );
 
 @ffi.Native<
     ffi.Void Function(ffi.Pointer<TEngine>, ffi.Pointer<TIndirectLight>,
-        VoidCallback)>(isLeaf: true)
+        ffi.Uint32, VoidCallback)>(isLeaf: true)
 external void Engine_destroyIndirectLightRenderThread(
   ffi.Pointer<TEngine> tEngine,
   ffi.Pointer<TIndirectLight> tIndirectLight,
+  int requestId,
   VoidCallback onComplete,
 );
 
@@ -1756,11 +1767,12 @@ external void Texture_buildRenderThread(
 );
 
 @ffi.Native<
-    ffi.Void Function(ffi.Pointer<TEngine>, ffi.Pointer<TTexture>,
+    ffi.Void Function(ffi.Pointer<TEngine>, ffi.Pointer<TTexture>, ffi.Uint32,
         VoidCallback)>(isLeaf: true)
 external void Engine_destroyTextureRenderThread(
   ffi.Pointer<TEngine> engine,
   ffi.Pointer<TTexture> tTexture,
+  int requestId,
   VoidCallback onComplete,
 );
 
@@ -1777,23 +1789,28 @@ external void Engine_createFenceRenderThread(
 );
 
 @ffi.Native<
-    ffi.Void Function(
-        ffi.Pointer<TEngine>, ffi.Pointer<TFence>, VoidCallback)>(isLeaf: true)
+    ffi.Void Function(ffi.Pointer<TEngine>, ffi.Pointer<TFence>, ffi.Uint32,
+        VoidCallback)>(isLeaf: true)
 external void Engine_destroyFenceRenderThread(
   ffi.Pointer<TEngine> tEngine,
   ffi.Pointer<TFence> tFence,
+  int requestId,
   VoidCallback onComplete,
 );
 
-@ffi.Native<ffi.Void Function(ffi.Pointer<TEngine>, VoidCallback)>(isLeaf: true)
+@ffi.Native<ffi.Void Function(ffi.Pointer<TEngine>, ffi.Uint32, VoidCallback)>(
+    isLeaf: true)
 external void Engine_flushAndWaitRenderThread(
   ffi.Pointer<TEngine> tEngine,
+  int requestId,
   VoidCallback onComplete,
 );
 
-@ffi.Native<ffi.Void Function(ffi.Pointer<TEngine>, VoidCallback)>(isLeaf: true)
+@ffi.Native<ffi.Void Function(ffi.Pointer<TEngine>, ffi.Uint32, VoidCallback)>(
+    isLeaf: true)
 external void Engine_executeRenderThread(
   ffi.Pointer<TEngine> tEngine,
+  int requestId,
   VoidCallback onComplete,
 );
 
@@ -1844,6 +1861,7 @@ external void Engine_buildIndirectLightRenderThread(
         ffi.Uint8,
         ffi.Bool,
         ffi.Bool,
+        ffi.Uint32,
         VoidCallback)>(isLeaf: true)
 external void Renderer_setClearOptionsRenderThread(
   ffi.Pointer<TRenderer> tRenderer,
@@ -1854,6 +1872,7 @@ external void Renderer_setClearOptionsRenderThread(
   int clearStencil,
   bool clear,
   bool discard,
+  int requestId,
   VoidCallback onComplete,
 );
 
@@ -1871,28 +1890,32 @@ external void Renderer_beginFrameRenderThread(
   ffi.Pointer<ffi.NativeFunction<ffi.Void Function(ffi.Bool)>> onComplete,
 );
 
-@ffi.Native<ffi.Void Function(ffi.Pointer<TRenderer>, VoidCallback)>(
-    isLeaf: true)
+@ffi.Native<
+    ffi.Void Function(
+        ffi.Pointer<TRenderer>, ffi.Uint32, VoidCallback)>(isLeaf: true)
 external void Renderer_endFrameRenderThread(
   ffi.Pointer<TRenderer> tRenderer,
+  int requestId,
   VoidCallback onComplete,
 );
 
 @ffi.Native<
-    ffi.Void Function(
-        ffi.Pointer<TRenderer>, ffi.Pointer<TView>, VoidCallback)>(isLeaf: true)
+    ffi.Void Function(ffi.Pointer<TRenderer>, ffi.Pointer<TView>, ffi.Uint32,
+        VoidCallback)>(isLeaf: true)
 external void Renderer_renderRenderThread(
   ffi.Pointer<TRenderer> tRenderer,
   ffi.Pointer<TView> tView,
+  int requestId,
   VoidCallback onComplete,
 );
 
 @ffi.Native<
-    ffi.Void Function(
-        ffi.Pointer<TRenderer>, ffi.Pointer<TView>, VoidCallback)>(isLeaf: true)
+    ffi.Void Function(ffi.Pointer<TRenderer>, ffi.Pointer<TView>, ffi.Uint32,
+        VoidCallback)>(isLeaf: true)
 external void Renderer_renderStandaloneViewRenderThread(
   ffi.Pointer<TRenderer> tRenderer,
   ffi.Pointer<TView> tView,
+  int requestId,
   VoidCallback onComplete,
 );
 
@@ -1905,6 +1928,7 @@ external void Renderer_renderStandaloneViewRenderThread(
         ffi.UnsignedInt,
         ffi.Pointer<ffi.Uint8>,
         ffi.Size,
+        ffi.Uint32,
         VoidCallback)>(isLeaf: true)
 external void Renderer_readPixelsRenderThread(
   ffi.Pointer<TRenderer> tRenderer,
@@ -1914,6 +1938,7 @@ external void Renderer_readPixelsRenderThread(
   int tPixelDataType,
   ffi.Pointer<ffi.Uint8> out,
   int outLength,
+  int requestId,
   VoidCallback onComplete,
 );
 
@@ -1973,36 +1998,41 @@ external void ColorGrading_createRenderThread(
 
 @ffi.Native<
     ffi.Void Function(ffi.Pointer<TView>, ffi.Pointer<TColorGrading>,
-        VoidCallback)>(isLeaf: true)
+        ffi.Uint32, VoidCallback)>(isLeaf: true)
 external void View_setColorGradingRenderThread(
   ffi.Pointer<TView> tView,
   ffi.Pointer<TColorGrading> tColorGrading,
+  int requestId,
   VoidCallback onComplete,
 );
 
 @ffi.Native<
-    ffi.Void Function(
-        ffi.Pointer<TView>, ffi.Bool, ffi.Double, VoidCallback)>(isLeaf: true)
+    ffi.Void Function(ffi.Pointer<TView>, ffi.Bool, ffi.Double, ffi.Uint32,
+        VoidCallback)>(isLeaf: true)
 external void View_setBloomRenderThread(
   ffi.Pointer<TView> tView,
   bool enabled,
   double strength,
+  int requestId,
+  VoidCallback onComplete,
+);
+
+@ffi.Native<
+    ffi.Void Function(ffi.Pointer<TView>, ffi.Pointer<TCamera>, ffi.Uint32,
+        VoidCallback)>(isLeaf: true)
+external void View_setCameraRenderThread(
+  ffi.Pointer<TView> tView,
+  ffi.Pointer<TCamera> tCamera,
+  int requestId,
   VoidCallback onComplete,
 );
 
 @ffi.Native<
     ffi.Void Function(
-        ffi.Pointer<TView>, ffi.Pointer<TCamera>, VoidCallback)>(isLeaf: true)
-external void View_setCameraRenderThread(
-  ffi.Pointer<TView> tView,
-  ffi.Pointer<TCamera> tCamera,
-  VoidCallback onComplete,
-);
-
-@ffi.Native<ffi.Void Function(ffi.Pointer<TSceneAsset>, VoidCallback)>(
-    isLeaf: true)
+        ffi.Pointer<TSceneAsset>, ffi.Uint32, VoidCallback)>(isLeaf: true)
 external void SceneAsset_destroyRenderThread(
   ffi.Pointer<TSceneAsset> tSceneAsset,
+  int requestId,
   VoidCallback onComplete,
 );
 
@@ -2166,10 +2196,12 @@ external void Image_getBytesRenderThread(
       onComplete,
 );
 
-@ffi.Native<ffi.Void Function(ffi.Pointer<TLinearImage>, VoidCallback)>(
-    isLeaf: true)
+@ffi.Native<
+    ffi.Void Function(
+        ffi.Pointer<TLinearImage>, ffi.Uint32, VoidCallback)>(isLeaf: true)
 external void Image_destroyRenderThread(
   ffi.Pointer<TLinearImage> tLinearImage,
+  int requestId,
   VoidCallback onComplete,
 );
 
@@ -2316,10 +2348,11 @@ external void RenderTarget_createRenderThread(
 
 @ffi.Native<
     ffi.Void Function(ffi.Pointer<TEngine>, ffi.Pointer<TRenderTarget>,
-        VoidCallback)>(isLeaf: true)
+        ffi.Uint32, VoidCallback)>(isLeaf: true)
 external void RenderTarget_destroyRenderThread(
   ffi.Pointer<TEngine> tEngine,
   ffi.Pointer<TRenderTarget> tRenderTarget,
+  int requestId,
   VoidCallback onComplete,
 );
 
@@ -2374,73 +2407,82 @@ external void TextureSampler_createWithComparisonRenderThread(
 );
 
 @ffi.Native<
-    ffi.Void Function(ffi.Pointer<TTextureSampler>, ffi.UnsignedInt,
+    ffi.Void Function(ffi.Pointer<TTextureSampler>, ffi.UnsignedInt, ffi.Uint32,
         VoidCallback)>(isLeaf: true)
 external void TextureSampler_setMinFilterRenderThread(
   ffi.Pointer<TTextureSampler> sampler,
   int filter,
+  int requestId,
   VoidCallback onComplete,
 );
 
 @ffi.Native<
-    ffi.Void Function(ffi.Pointer<TTextureSampler>, ffi.UnsignedInt,
+    ffi.Void Function(ffi.Pointer<TTextureSampler>, ffi.UnsignedInt, ffi.Uint32,
         VoidCallback)>(isLeaf: true)
 external void TextureSampler_setMagFilterRenderThread(
   ffi.Pointer<TTextureSampler> sampler,
   int filter,
+  int requestId,
   VoidCallback onComplete,
 );
 
 @ffi.Native<
-    ffi.Void Function(ffi.Pointer<TTextureSampler>, ffi.UnsignedInt,
+    ffi.Void Function(ffi.Pointer<TTextureSampler>, ffi.UnsignedInt, ffi.Uint32,
         VoidCallback)>(isLeaf: true)
 external void TextureSampler_setWrapModeSRenderThread(
   ffi.Pointer<TTextureSampler> sampler,
   int mode,
+  int requestId,
   VoidCallback onComplete,
 );
 
 @ffi.Native<
-    ffi.Void Function(ffi.Pointer<TTextureSampler>, ffi.UnsignedInt,
+    ffi.Void Function(ffi.Pointer<TTextureSampler>, ffi.UnsignedInt, ffi.Uint32,
         VoidCallback)>(isLeaf: true)
 external void TextureSampler_setWrapModeTRenderThread(
   ffi.Pointer<TTextureSampler> sampler,
   int mode,
+  int requestId,
+  VoidCallback onComplete,
+);
+
+@ffi.Native<
+    ffi.Void Function(ffi.Pointer<TTextureSampler>, ffi.UnsignedInt, ffi.Uint32,
+        VoidCallback)>(isLeaf: true)
+external void TextureSampler_setWrapModeRRenderThread(
+  ffi.Pointer<TTextureSampler> sampler,
+  int mode,
+  int requestId,
+  VoidCallback onComplete,
+);
+
+@ffi.Native<
+    ffi.Void Function(ffi.Pointer<TTextureSampler>, ffi.Double, ffi.Uint32,
+        VoidCallback)>(isLeaf: true)
+external void TextureSampler_setAnisotropyRenderThread(
+  ffi.Pointer<TTextureSampler> sampler,
+  double anisotropy,
+  int requestId,
   VoidCallback onComplete,
 );
 
 @ffi.Native<
     ffi.Void Function(ffi.Pointer<TTextureSampler>, ffi.UnsignedInt,
-        VoidCallback)>(isLeaf: true)
-external void TextureSampler_setWrapModeRRenderThread(
+        ffi.UnsignedInt, ffi.Uint32, VoidCallback)>(isLeaf: true)
+external void TextureSampler_setCompareModeRenderThread(
   ffi.Pointer<TTextureSampler> sampler,
   int mode,
+  int func,
+  int requestId,
   VoidCallback onComplete,
 );
 
 @ffi.Native<
     ffi.Void Function(
-        ffi.Pointer<TTextureSampler>, ffi.Double, VoidCallback)>(isLeaf: true)
-external void TextureSampler_setAnisotropyRenderThread(
-  ffi.Pointer<TTextureSampler> sampler,
-  double anisotropy,
-  VoidCallback onComplete,
-);
-
-@ffi.Native<
-    ffi.Void Function(ffi.Pointer<TTextureSampler>, ffi.UnsignedInt,
-        ffi.UnsignedInt, VoidCallback)>(isLeaf: true)
-external void TextureSampler_setCompareModeRenderThread(
-  ffi.Pointer<TTextureSampler> sampler,
-  int mode,
-  int func,
-  VoidCallback onComplete,
-);
-
-@ffi.Native<ffi.Void Function(ffi.Pointer<TTextureSampler>, VoidCallback)>(
-    isLeaf: true)
+        ffi.Pointer<TTextureSampler>, ffi.Uint32, VoidCallback)>(isLeaf: true)
 external void TextureSampler_destroyRenderThread(
   ffi.Pointer<TTextureSampler> sampler,
+  int requestId,
   VoidCallback onComplete,
 );
 
@@ -2463,11 +2505,12 @@ external void AnimationManager_setBoneTransformRenderThread(
 );
 
 @ffi.Native<
-    ffi.Void Function(
-        ffi.Pointer<TAnimationManager>, EntityId, VoidCallback)>(isLeaf: true)
+    ffi.Void Function(ffi.Pointer<TAnimationManager>, EntityId, ffi.Uint32,
+        VoidCallback)>(isLeaf: true)
 external void AnimationManager_resetToRestPoseRenderThread(
   ffi.Pointer<TAnimationManager> tAnimationManager,
   int entityId,
+  int requestId,
   VoidCallback onComplete,
 );
 
@@ -2504,10 +2547,11 @@ external void GltfResourceLoader_createRenderThread(
 
 @ffi.Native<
     ffi.Void Function(ffi.Pointer<TEngine>, ffi.Pointer<TGltfResourceLoader>,
-        VoidCallback)>(isLeaf: true)
+        ffi.Uint32, VoidCallback)>(isLeaf: true)
 external void GltfResourceLoader_destroyRenderThread(
   ffi.Pointer<TEngine> tEngine,
   ffi.Pointer<TGltfResourceLoader> tResourceLoader,
+  int requestId,
   VoidCallback onComplete,
 );
 
@@ -2524,13 +2568,19 @@ external void GltfResourceLoader_loadResourcesRenderThread(
 );
 
 @ffi.Native<
-    ffi.Void Function(ffi.Pointer<TGltfResourceLoader>, ffi.Pointer<ffi.Char>,
-        ffi.Pointer<ffi.Uint8>, ffi.Size, VoidCallback)>(isLeaf: true)
+    ffi.Void Function(
+        ffi.Pointer<TGltfResourceLoader>,
+        ffi.Pointer<ffi.Char>,
+        ffi.Pointer<ffi.Uint8>,
+        ffi.Size,
+        ffi.Uint32,
+        VoidCallback)>(isLeaf: true)
 external void GltfResourceLoader_addResourceDataRenderThread(
   ffi.Pointer<TGltfResourceLoader> tGltfResourceLoader,
   ffi.Pointer<ffi.Char> uri,
   ffi.Pointer<ffi.Uint8> data,
   int length,
+  int requestId,
   VoidCallback onComplete,
 );
 
@@ -2583,10 +2633,11 @@ external void GltfAssetLoader_loadRenderThread(
 
 @ffi.Native<
     ffi.Void Function(ffi.Pointer<TScene>, ffi.Pointer<TFilamentAsset>,
-        VoidCallback)>(isLeaf: true)
+        ffi.Uint32, VoidCallback)>(isLeaf: true)
 external void Scene_addFilamentAssetRenderThread(
   ffi.Pointer<TScene> tScene,
   ffi.Pointer<TFilamentAsset> tAsset,
+  int requestId,
   VoidCallback onComplete,
 );
 
@@ -3908,8 +3959,8 @@ sealed class TBackend {
   static const BACKEND_NOOP = 4;
 }
 
-typedef VoidCallbackFunction = ffi.Void Function();
-typedef DartVoidCallbackFunction = void Function();
+typedef VoidCallbackFunction = ffi.Void Function(ffi.Int32 requestId);
+typedef DartVoidCallbackFunction = void Function(int requestId);
 typedef VoidCallback = ffi.Pointer<ffi.NativeFunction<VoidCallbackFunction>>;
 typedef FilamentRenderCallbackFunction = ffi.Void Function(
     ffi.Pointer<ffi.Void> owner);
diff --git a/thermion_dart/lib/src/filament/src/implementation/ffi_asset.dart b/thermion_dart/lib/src/filament/src/implementation/ffi_asset.dart
index 40b0ae53..fd48f6ac 100644
--- a/thermion_dart/lib/src/filament/src/implementation/ffi_asset.dart
+++ b/thermion_dart/lib/src/filament/src/implementation/ffi_asset.dart
@@ -789,13 +789,13 @@ class FFIAsset extends ThermionAsset {
   Future<Matrix4> getLocalTransform({ThermionEntity? entity}) async {
     late Pointer stackPtr;
     if (FILAMENT_WASM) {
-      //stackPtr = stackSave();
+      stackPtr = stackSave();
     }
     entity ??= this.entity;
     final transform = double4x4ToMatrix4(
         TransformManager_getLocalTransform(app.transformManager, entity));
     if (FILAMENT_WASM) {
-      //stackRestore(stackPtr);
+      stackRestore(stackPtr);
     }
     return transform;
   }
@@ -806,13 +806,13 @@ class FFIAsset extends ThermionAsset {
   Future<Matrix4> getWorldTransform({ThermionEntity? entity}) async {
     late Pointer stackPtr;
     if (FILAMENT_WASM) {
-      //stackPtr = stackSave();
+      stackPtr = stackSave();
     }
     entity ??= this.entity;
     var transform = double4x4ToMatrix4(
         TransformManager_getWorldTransform(app.transformManager, entity));
     if (FILAMENT_WASM) {
-      //stackRestore(stackPtr);
+      stackRestore(stackPtr);
     }
     return transform;
   }
@@ -821,9 +821,16 @@ class FFIAsset extends ThermionAsset {
   ///
   ///
   Future setTransform(Matrix4 transform, {ThermionEntity? entity}) async {
+    late Pointer stackPtr;
+    if (FILAMENT_WASM) {
+      stackPtr = stackSave();
+    }
     entity ??= this.entity;
     TransformManager_setTransform(
         app.transformManager, entity, matrix4ToDouble4x4(transform));
+    if (FILAMENT_WASM) {
+      stackRestore(stackPtr);
+    }
   }
 
   ///
diff --git a/thermion_dart/lib/src/filament/src/implementation/ffi_filament_app.dart b/thermion_dart/lib/src/filament/src/implementation/ffi_filament_app.dart
index df15d17e..fb8a9887 100644
--- a/thermion_dart/lib/src/filament/src/implementation/ffi_filament_app.dart
+++ b/thermion_dart/lib/src/filament/src/implementation/ffi_filament_app.dart
@@ -203,9 +203,9 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
   ///
   Future destroySwapChain(SwapChain swapChain) async {
     _logger.info("Destroying swapchain");
-    await withVoidCallback((callback) {
+    await withVoidCallback((requestId, callback) {
       Engine_destroySwapChainRenderThread(
-          engine, (swapChain as FFISwapChain).swapChain, callback);
+          engine, (swapChain as FFISwapChain).swapChain, requestId, callback);
     });
     _swapChains.remove(swapChain);
     _logger.info("Destroyed swapchain");
diff --git a/thermion_dart/native/include/c_api/ThermionDartRenderThreadApi.h b/thermion_dart/native/include/c_api/ThermionDartRenderThreadApi.h
index 67227b3d..34cac45c 100644
--- a/thermion_dart/native/include/c_api/ThermionDartRenderThreadApi.h
+++ b/thermion_dart/native/include/c_api/ThermionDartRenderThreadApi.h
@@ -11,7 +11,7 @@ namespace thermion
     extern "C"
     {
 #endif
-        typedef void (*VoidCallback)();
+        typedef void (*VoidCallback)(int32_t requestId);
         typedef int32_t EntityId;
         typedef void (*FilamentRenderCallback)(void *const owner);
 
@@ -21,7 +21,7 @@ namespace thermion
         void RenderThread_setRenderTicker(TRenderTicker *tRenderTicker);
         void RenderThread_addTask(void (*task)());
         
-        void RenderTicker_renderRenderThread(TRenderTicker *tRenderTicker, uint64_t frameTimeInNanos, VoidCallback onComplete);
+        void RenderTicker_renderRenderThread(TRenderTicker *tRenderTicker, uint64_t frameTimeInNanos, uint32_t requestId, VoidCallback onComplete);
         void AnimationManager_createRenderThread(TEngine *tEngine, TScene *tScene, void (*onComplete)(TAnimationManager *));
 
         void Engine_createRenderThread(
@@ -38,15 +38,15 @@ namespace thermion
         void Engine_createCameraRenderThread(TEngine* tEngine, void (*onComplete)(TCamera *));
         void Engine_createViewRenderThread(TEngine *tEngine, void (*onComplete)(TView *));
         void Engine_buildMaterialRenderThread(TEngine *tEngine, const uint8_t *materialData, size_t length, void (*onComplete)(TMaterial *));
-        void Engine_destroyRenderThread(TEngine *tEngine, VoidCallback onComplete);
-        void Engine_destroySwapChainRenderThread(TEngine *tEngine, TSwapChain *tSwapChain, VoidCallback onComplete);
-        void Engine_destroyViewRenderThread(TEngine *tEngine, TView *tView, VoidCallback onComplete);
-        void Engine_destroySceneRenderThread(TEngine *tEngine, TScene *tScene, VoidCallback onComplete);
-        void Engine_destroyColorGradingRenderThread(TEngine *tEngine, TColorGrading *tColorGrading, VoidCallback onComplete);
-        void Engine_destroyMaterialRenderThread(TEngine *tEngine, TMaterial *tMaterial, VoidCallback onComplete);
-        void Engine_destroyMaterialInstanceRenderThread(TEngine *tEngine, TMaterialInstance *tMaterialInstance, VoidCallback onComplete);
-        void Engine_destroySkyboxRenderThread(TEngine *tEngine, TSkybox *tSkybox, VoidCallback onComplete);
-        void Engine_destroyIndirectLightRenderThread(TEngine *tEngine, TIndirectLight *tIndirectLight, VoidCallback onComplete);
+        void Engine_destroyRenderThread(TEngine *tEngine, uint32_t requestId, VoidCallback onComplete);
+        void Engine_destroySwapChainRenderThread(TEngine *tEngine, TSwapChain *tSwapChain, uint32_t requestId,  VoidCallback onComplete);
+        void Engine_destroyViewRenderThread(TEngine *tEngine, TView *tView, uint32_t requestId,  VoidCallback onComplete);
+        void Engine_destroySceneRenderThread(TEngine *tEngine, TScene *tScene, uint32_t requestId,  VoidCallback onComplete);
+        void Engine_destroyColorGradingRenderThread(TEngine *tEngine, TColorGrading *tColorGrading, uint32_t requestId,  VoidCallback onComplete);
+        void Engine_destroyMaterialRenderThread(TEngine *tEngine, TMaterial *tMaterial, uint32_t requestId,  VoidCallback onComplete);
+        void Engine_destroyMaterialInstanceRenderThread(TEngine *tEngine, TMaterialInstance *tMaterialInstance, uint32_t requestId,  VoidCallback onComplete);
+        void Engine_destroySkyboxRenderThread(TEngine *tEngine, TSkybox *tSkybox, uint32_t requestId,  VoidCallback onComplete);
+        void Engine_destroyIndirectLightRenderThread(TEngine *tEngine, TIndirectLight *tIndirectLight, uint32_t requestId,  VoidCallback onComplete);
         void Texture_buildRenderThread(TEngine *engine, 
             uint32_t width, 
             uint32_t height, 
@@ -59,19 +59,19 @@ namespace thermion
             void (*onComplete)(TTexture*)
         );
 
-        void Engine_destroyTextureRenderThread(TEngine *engine, TTexture* tTexture, VoidCallback onComplete);
+        void Engine_destroyTextureRenderThread(TEngine *engine, TTexture* tTexture, uint32_t requestId,  VoidCallback onComplete);
         void Engine_createFenceRenderThread(TEngine *tEngine, void (*onComplete)(TFence*));
-        void Engine_destroyFenceRenderThread(TEngine *tEngine, TFence *tFence, VoidCallback onComplete);
-        void Engine_flushAndWaitRenderThread(TEngine *tEngine, VoidCallback onComplete);
-        void Engine_executeRenderThread(TEngine *tEngine, VoidCallback onComplete);
+        void Engine_destroyFenceRenderThread(TEngine *tEngine, TFence *tFence, uint32_t requestId,  VoidCallback onComplete);
+        void Engine_flushAndWaitRenderThread(TEngine *tEngine, uint32_t requestId,  VoidCallback onComplete);
+        void Engine_executeRenderThread(TEngine *tEngine, uint32_t requestId,  VoidCallback onComplete);
         void Engine_buildSkyboxRenderThread(TEngine *tEngine, uint8_t *skyboxData, size_t length, void (*onComplete)(TSkybox *), void (*onTextureUploadComplete)());
         void Engine_buildIndirectLightRenderThread(TEngine *tEngine, uint8_t *iblData, size_t length, float intensity, void (*onComplete)(TIndirectLight *), void (*onTextureUploadComplete)());
 
-        void Renderer_setClearOptionsRenderThread(TRenderer *tRenderer, double clearR, double clearG, double clearB, double clearA, uint8_t clearStencil, bool clear, bool discard, VoidCallback onComplete);
+        void Renderer_setClearOptionsRenderThread(TRenderer *tRenderer, double clearR, double clearG, double clearB, double clearA, uint8_t clearStencil, bool clear, bool discard, uint32_t requestId,  VoidCallback onComplete);
         void Renderer_beginFrameRenderThread(TRenderer *tRenderer, TSwapChain *tSwapChain, uint64_t frameTimeInNanos, void (*onComplete)(bool));
-        void Renderer_endFrameRenderThread(TRenderer *tRenderer, VoidCallback onComplete);
-        void Renderer_renderRenderThread(TRenderer *tRenderer, TView *tView, VoidCallback onComplete);
-        void Renderer_renderStandaloneViewRenderThread(TRenderer *tRenderer, TView *tView, VoidCallback onComplete);
+        void Renderer_endFrameRenderThread(TRenderer *tRenderer, uint32_t requestId,  VoidCallback onComplete);
+        void Renderer_renderRenderThread(TRenderer *tRenderer, TView *tView, uint32_t requestId,  VoidCallback onComplete);
+        void Renderer_renderStandaloneViewRenderThread(TRenderer *tRenderer, TView *tView, uint32_t requestId,  VoidCallback onComplete);
         void Renderer_readPixelsRenderThread(
             TRenderer *tRenderer,
             TView *tView,
@@ -80,18 +80,18 @@ namespace thermion
             TPixelDataType tPixelDataType,
             uint8_t *out,
             size_t outLength,
-            VoidCallback onComplete);
+            uint32_t requestId,  VoidCallback onComplete);
 
         void Material_createInstanceRenderThread(TMaterial *tMaterial, void (*onComplete)(TMaterialInstance *));
         void Material_createImageMaterialRenderThread(TEngine *tEngine, void (*onComplete)(TMaterial *));
         void Material_createGizmoMaterialRenderThread(TEngine *tEngine, void (*onComplete)(TMaterial *));
 
         void ColorGrading_createRenderThread(TEngine *tEngine, TToneMapping toneMapping, void (*callback)(TColorGrading *));  
-        void View_setColorGradingRenderThread(TView *tView, TColorGrading *tColorGrading, VoidCallback onComplete);
-        void View_setBloomRenderThread(TView *tView, bool enabled, double strength, VoidCallback onComplete);
-        void View_setCameraRenderThread(TView *tView, TCamera *tCamera, VoidCallback onComplete);
+        void View_setColorGradingRenderThread(TView *tView, TColorGrading *tColorGrading, uint32_t requestId,  VoidCallback onComplete);
+        void View_setBloomRenderThread(TView *tView, bool enabled, double strength, uint32_t requestId,  VoidCallback onComplete);
+        void View_setCameraRenderThread(TView *tView, TCamera *tCamera, uint32_t requestId,  VoidCallback onComplete);
 
-        void SceneAsset_destroyRenderThread(TSceneAsset *tSceneAsset, VoidCallback onComplete);
+        void SceneAsset_destroyRenderThread(TSceneAsset *tSceneAsset, uint32_t requestId,  VoidCallback onComplete);
         void SceneAsset_createFromFilamentAssetRenderThread(
             TEngine *tEngine,
             TGltfAssetLoader *tAssetLoader,
@@ -133,7 +133,7 @@ namespace thermion
         void Image_createEmptyRenderThread(uint32_t width, uint32_t height, uint32_t channel, void (*onComplete)(TLinearImage *));
         void Image_decodeRenderThread(uint8_t* data, size_t length, const char* name, void (*onComplete)(TLinearImage *));
         void Image_getBytesRenderThread(TLinearImage *tLinearImage, void (*onComplete)(float *));
-        void Image_destroyRenderThread(TLinearImage *tLinearImage, VoidCallback onComplete);
+        void Image_destroyRenderThread(TLinearImage *tLinearImage, uint32_t requestId, VoidCallback onComplete);
         void Image_getWidthRenderThread(TLinearImage *tLinearImage, void (*onComplete)(uint32_t));
         void Image_getHeightRenderThread(TLinearImage *tLinearImage, void (*onComplete)(uint32_t));
         void Image_getChannelsRenderThread(TLinearImage *tLinearImage, void (*onComplete)(uint32_t));
@@ -189,7 +189,7 @@ namespace thermion
         void RenderTarget_destroyRenderThread(
             TEngine *tEngine,
             TRenderTarget *tRenderTarget,
-            VoidCallback onComplete
+            uint32_t requestId, VoidCallback onComplete
         );
 
 
@@ -211,42 +211,42 @@ namespace thermion
         void TextureSampler_setMinFilterRenderThread(
             TTextureSampler* sampler, 
             TSamplerMinFilter filter,
-            VoidCallback onComplete
+            uint32_t requestId, VoidCallback onComplete
         );
         void TextureSampler_setMagFilterRenderThread(
             TTextureSampler* sampler, 
             TSamplerMagFilter filter,
-            VoidCallback onComplete
+            uint32_t requestId, VoidCallback onComplete
         );
         void TextureSampler_setWrapModeSRenderThread(
             TTextureSampler* sampler, 
             TSamplerWrapMode mode,
-            VoidCallback onComplete
+            uint32_t requestId, VoidCallback onComplete
         );
         void TextureSampler_setWrapModeTRenderThread(
             TTextureSampler* sampler, 
             TSamplerWrapMode mode,
-            VoidCallback onComplete
+            uint32_t requestId, VoidCallback onComplete
         );
         void TextureSampler_setWrapModeRRenderThread(
             TTextureSampler* sampler, 
             TSamplerWrapMode mode,
-            VoidCallback onComplete
+            uint32_t requestId, VoidCallback onComplete
         );
         void TextureSampler_setAnisotropyRenderThread(
             TTextureSampler* sampler, 
             double anisotropy,
-            VoidCallback onComplete
+            uint32_t requestId, VoidCallback onComplete
         );
         void TextureSampler_setCompareModeRenderThread(
             TTextureSampler* sampler, 
             TSamplerCompareMode mode, 
             TTextureSamplerCompareFunc func,
-            VoidCallback onComplete
+            uint32_t requestId, VoidCallback onComplete
         );
         void TextureSampler_destroyRenderThread(
             TTextureSampler* sampler,
-            VoidCallback onComplete
+            uint32_t requestId, VoidCallback onComplete
         );
 
         void AnimationManager_setBoneTransformRenderThread(
@@ -257,13 +257,13 @@ namespace thermion
             const float *const transform,
             void (*callback)(bool));
 
-        void AnimationManager_resetToRestPoseRenderThread(TAnimationManager *tAnimationManager, EntityId entityId, VoidCallback onComplete);
+        void AnimationManager_resetToRestPoseRenderThread(TAnimationManager *tAnimationManager, EntityId entityId, uint32_t requestId, VoidCallback onComplete);
 
         void GltfAssetLoader_createRenderThread(TEngine *tEngine, TMaterialProvider *tMaterialProvider, void (*callback)(TGltfAssetLoader *));
-        void GltfResourceLoader_createRenderThread(TEngine *tEngine, void (*callback)(TGltfResourceLoader *));
-        void GltfResourceLoader_destroyRenderThread(TEngine *tEngine, TGltfResourceLoader *tResourceLoader, VoidCallback onComplete);
+        void GltfResourceLoader_createRenderThread(TEngine *tEngine, const char* relativeResourcePath, void (*callback)(TGltfResourceLoader *));
+        void GltfResourceLoader_destroyRenderThread(TEngine *tEngine, TGltfResourceLoader *tResourceLoader, uint32_t requestId, VoidCallback onComplete);
         void GltfResourceLoader_loadResourcesRenderThread(TGltfResourceLoader *tGltfResourceLoader, TFilamentAsset *tFilamentAsset, void (*callback)(bool));
-        void GltfResourceLoader_addResourceDataRenderThread(TGltfResourceLoader *tGltfResourceLoader, const char *uri, uint8_t *data, size_t length, VoidCallback onComplete);
+        void GltfResourceLoader_addResourceDataRenderThread(TGltfResourceLoader *tGltfResourceLoader, const char *uri, uint8_t *data, size_t length, uint32_t requestId, VoidCallback onComplete);
         void GltfResourceLoader_asyncBeginLoadRenderThread(TGltfResourceLoader *tGltfResourceLoader, TFilamentAsset *tFilamentAsset, void (*callback)(bool));
         void GltfResourceLoader_asyncUpdateLoadRenderThread(TGltfResourceLoader *tGltfResourceLoader);
         void GltfResourceLoader_asyncGetLoadProgressRenderThread(TGltfResourceLoader *tGltfResourceLoader, void (*callback)(float));
@@ -276,7 +276,7 @@ namespace thermion
             uint8_t numInstances,
             void (*callback)(TFilamentAsset *)
         );
-        void Scene_addFilamentAssetRenderThread(TScene* tScene, TFilamentAsset *tAsset, VoidCallback onComplete);
+        void Scene_addFilamentAssetRenderThread(TScene* tScene, TFilamentAsset *tAsset, uint32_t requestId, VoidCallback onComplete);
         void Gizmo_createRenderThread(
             TEngine *tEngine,
             TGltfAssetLoader *tAssetLoader,
diff --git a/thermion_dart/native/src/c_api/ThermionDartRenderThreadApi.cpp b/thermion_dart/native/src/c_api/ThermionDartRenderThreadApi.cpp
index 21352abf..1ab23cc6 100644
--- a/thermion_dart/native/src/c_api/ThermionDartRenderThreadApi.cpp
+++ b/thermion_dart/native/src/c_api/ThermionDartRenderThreadApi.cpp
@@ -101,12 +101,12 @@ extern "C"
     _renderThread->requestFrame();
   }
 
-  EMSCRIPTEN_KEEPALIVE void RenderTicker_renderRenderThread(TRenderTicker *tRenderTicker, uint64_t frameTimeInNanos, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void RenderTicker_renderRenderThread(TRenderTicker *tRenderTicker, uint64_t frameTimeInNanos, uint32_t requestId, VoidCallback onComplete) {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
         RenderTicker_render(tRenderTicker, frameTimeInNanos);
-        PROXY(onComplete());
+        PROXY(onComplete(requestId));
       });
     auto fut = _renderThread->add_task(lambda);
   }
@@ -159,32 +159,32 @@ extern "C"
     auto fut = _renderThread->add_task(lambda);
   }
   
-  EMSCRIPTEN_KEEPALIVE void Engine_destroySwapChainRenderThread(TEngine *tEngine, TSwapChain *tSwapChain, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Engine_destroySwapChainRenderThread(TEngine *tEngine, TSwapChain *tSwapChain, uint32_t requestId, VoidCallback onComplete) {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
         Engine_destroySwapChain(tEngine, tSwapChain);
-        PROXY(onComplete());
+        PROXY(onComplete(requestId));
       });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_destroyViewRenderThread(TEngine *tEngine, TView *tView, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Engine_destroyViewRenderThread(TEngine *tEngine, TView *tView, uint32_t requestId, VoidCallback onComplete) {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
         Engine_destroyView(tEngine, tView);
-        PROXY(onComplete());
+        PROXY(onComplete(requestId));
       });
     auto fut = _renderThread->add_task(lambda);
   }
     
-  EMSCRIPTEN_KEEPALIVE void Engine_destroySceneRenderThread(TEngine *tEngine, TScene *tScene, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Engine_destroySceneRenderThread(TEngine *tEngine, TScene *tScene, uint32_t requestId, VoidCallback onComplete) {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
         Engine_destroyScene(tEngine, tScene);
-        PROXY(onComplete());
+        PROXY(onComplete(requestId));
       });
     auto fut = _renderThread->add_task(lambda);
   }
@@ -209,43 +209,43 @@ extern "C"
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_destroyRenderThread(TEngine *tEngine, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Engine_destroyRenderThread(TEngine *tEngine, uint32_t requestId, VoidCallback onComplete) {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
         Engine_destroy(tEngine);
-        PROXY(onComplete());
+        PROXY(onComplete(requestId));
       });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_destroyTextureRenderThread(TEngine *engine, TTexture *tTexture, VoidCallback onComplete)
+  EMSCRIPTEN_KEEPALIVE void Engine_destroyTextureRenderThread(TEngine *engine, TTexture *tTexture, uint32_t requestId, VoidCallback onComplete)
   {
     std::packaged_task<void()> lambda(
         [=]() mutable
         {
           Engine_destroyTexture(engine, tTexture);
-          PROXY(onComplete());
+          PROXY(onComplete(requestId));
         });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_destroySkyboxRenderThread(TEngine *tEngine, TSkybox *tSkybox, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Engine_destroySkyboxRenderThread(TEngine *tEngine, TSkybox *tSkybox, uint32_t requestId, VoidCallback onComplete) {
       std::packaged_task<void()> lambda(
         [=]() mutable
         {
           Engine_destroySkybox(tEngine, tSkybox);
-          PROXY(onComplete());
+          PROXY(onComplete(requestId));
         });
     auto fut = _renderThread->add_task(lambda);
   }
     
-  EMSCRIPTEN_KEEPALIVE void Engine_destroyIndirectLightRenderThread(TEngine *tEngine, TIndirectLight *tIndirectLight, VoidCallback onComplete) { 
+  EMSCRIPTEN_KEEPALIVE void Engine_destroyIndirectLightRenderThread(TEngine *tEngine, TIndirectLight *tIndirectLight, uint32_t requestId, VoidCallback onComplete) { 
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
         Engine_destroyIndirectLight(tEngine, tIndirectLight);
-        PROXY(onComplete());
+        PROXY(onComplete(requestId));
       });
     auto fut = _renderThread->add_task(lambda);
   }
@@ -262,23 +262,23 @@ extern "C"
   }
 
 
-  EMSCRIPTEN_KEEPALIVE void Engine_destroyMaterialRenderThread(TEngine *tEngine, TMaterial *tMaterial, VoidCallback onComplete)
+  EMSCRIPTEN_KEEPALIVE void Engine_destroyMaterialRenderThread(TEngine *tEngine, TMaterial *tMaterial, uint32_t requestId, VoidCallback onComplete)
   {
     std::packaged_task<void()> lambda(
         [=]() mutable
         {
           Engine_destroyMaterial(tEngine, tMaterial);
-          PROXY(onComplete());
+          PROXY(onComplete(requestId));
         });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_destroyMaterialInstanceRenderThread(TEngine *tEngine, TMaterialInstance *tMaterialInstance, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Engine_destroyMaterialInstanceRenderThread(TEngine *tEngine, TMaterialInstance *tMaterialInstance, uint32_t requestId, VoidCallback onComplete) {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
         Engine_destroyMaterialInstance(tEngine, tMaterialInstance);
-        PROXY(onComplete());
+        PROXY(onComplete(requestId));
       });
       auto fut = _renderThread->add_task(lambda);
   }
@@ -293,38 +293,34 @@ extern "C"
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_destroyFenceRenderThread(TEngine *tEngine, TFence *tFence, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Engine_destroyFenceRenderThread(TEngine *tEngine, TFence *tFence, uint32_t requestId, VoidCallback onComplete) {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
         Engine_destroyFence(tEngine, tFence);
-        PROXY(onComplete());
+        PROXY(onComplete(requestId));
       });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_flushAndWaitRenderThread(TEngine *tEngine, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Engine_flushAndWaitRenderThread(TEngine *tEngine, uint32_t requestId, VoidCallback onComplete) {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
         Engine_flushAndWait(tEngine);
-        PROXY(onComplete());
+        PROXY(onComplete(requestId));
       });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_executeRenderThread(TEngine *tEngine, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Engine_executeRenderThread(TEngine *tEngine, uint32_t requestId, VoidCallback onComplete) {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
-        // auto executeStartTime = std::chrono::high_resolution_clock::now(); 
-        // Log("started Engine_execute at : % " PRId64 "ms", std::chrono::duration_cast<std::chrono::milliseconds>(executeStartTime.time_since_epoch()).count());
-    // /  _renderThread->queue.execute();
         Engine_execute(tEngine);
-        // PROXY(onComplete());
+        PROXY(onComplete(requestId));
       });
     auto fut = _renderThread->add_task(lambda);
-    onComplete();
   }
 
   EMSCRIPTEN_KEEPALIVE void execute_queue() {
@@ -362,32 +358,32 @@ extern "C"
       });
     auto fut = _renderThread->add_task(lambda);
   }
-  EMSCRIPTEN_KEEPALIVE void Renderer_endFrameRenderThread(TRenderer *tRenderer, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Renderer_endFrameRenderThread(TRenderer *tRenderer, uint32_t requestId, VoidCallback onComplete) {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
         Renderer_endFrame(tRenderer);
-        PROXY(onComplete());
+        PROXY(onComplete(requestId));
       });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Renderer_renderRenderThread(TRenderer *tRenderer, TView *tView, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Renderer_renderRenderThread(TRenderer *tRenderer, TView *tView, uint32_t requestId, VoidCallback onComplete) {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
         Renderer_render(tRenderer, tView);
-        PROXY(onComplete());
+        PROXY(onComplete(requestId));
       });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Renderer_renderStandaloneViewRenderThread(TRenderer *tRenderer, TView *tView, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Renderer_renderStandaloneViewRenderThread(TRenderer *tRenderer, TView *tView, uint32_t requestId, VoidCallback onComplete) {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
         Renderer_renderStandaloneView(tRenderer, tView);
-        PROXY(onComplete());
+        PROXY(onComplete(requestId));
       });
     auto fut = _renderThread->add_task(lambda);
   }
@@ -400,12 +396,12 @@ extern "C"
     double clearA,
     uint8_t clearStencil,
     bool clear,
-    bool discard, VoidCallback onComplete) {
+    bool discard, uint32_t requestId, VoidCallback onComplete) {
       std::packaged_task<void()> lambda(
         [=]() mutable
         {
           Renderer_setClearOptions(tRenderer, clearR, clearG, clearB, clearA, clearStencil, clear, discard);
-          PROXY(onComplete());
+          PROXY(onComplete(requestId));
         });
       auto fut = _renderThread->add_task(lambda);
   }
@@ -418,12 +414,12 @@ extern "C"
     TPixelDataType tPixelDataType,
     uint8_t *out,
     size_t outLength,
-    VoidCallback onComplete) {
+    uint32_t requestId, VoidCallback onComplete) {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
         Renderer_readPixels(tRenderer, tView, tRenderTarget, tPixelBufferFormat, tPixelDataType, out, outLength);
-        PROXY(onComplete());
+        PROXY(onComplete(requestId));
       });
     auto fut = _renderThread->add_task(lambda);
   }
@@ -460,12 +456,12 @@ extern "C"
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void SceneAsset_destroyRenderThread(TSceneAsset *tSceneAsset, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void SceneAsset_destroyRenderThread(TSceneAsset *tSceneAsset, uint32_t requestId, VoidCallback onComplete) {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
         SceneAsset_destroy(tSceneAsset);
-        PROXY(onComplete());
+        PROXY(onComplete(requestId));
       });
     auto fut = _renderThread->add_task(lambda);
   }
@@ -547,46 +543,46 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_destroyColorGradingRenderThread(TEngine *tEngine, TColorGrading *tColorGrading, VoidCallback onComplete)
+  EMSCRIPTEN_KEEPALIVE void Engine_destroyColorGradingRenderThread(TEngine *tEngine, TColorGrading *tColorGrading, uint32_t requestId, VoidCallback onComplete)
   {
     std::packaged_task<void()> lambda(
         [=]
         {
           Engine_destroyColorGrading(tEngine, tColorGrading);
-          PROXY(onComplete());
+          PROXY(onComplete(requestId));
         });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void View_setColorGradingRenderThread(TView *tView, TColorGrading *tColorGrading, VoidCallback onComplete)
+  EMSCRIPTEN_KEEPALIVE void View_setColorGradingRenderThread(TView *tView, TColorGrading *tColorGrading, uint32_t requestId, VoidCallback onComplete)
   {
     std::packaged_task<void()> lambda(
         [=]
         {
           View_setColorGrading(tView, tColorGrading);
-          PROXY(onComplete());
+          PROXY(onComplete(requestId));
         });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void View_setBloomRenderThread(TView *tView, bool enabled, double strength, VoidCallback onComplete)
+  EMSCRIPTEN_KEEPALIVE void View_setBloomRenderThread(TView *tView, bool enabled, double strength, uint32_t requestId, VoidCallback onComplete)
   {
     std::packaged_task<void()> lambda(
         [=]
         {
           View_setBloom(tView, enabled, strength);
-          PROXY(onComplete());
+          PROXY(onComplete(requestId));
         });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void View_setCameraRenderThread(TView *tView, TCamera *tCamera, VoidCallback onComplete)
+  EMSCRIPTEN_KEEPALIVE void View_setCameraRenderThread(TView *tView, TCamera *tCamera, uint32_t requestId, VoidCallback onComplete)
   {
     std::packaged_task<void()> lambda(
         [=]
         {
           View_setCamera(tView, tCamera);
-          PROXY(onComplete());
+          PROXY(onComplete(requestId));
         });
     auto fut = _renderThread->add_task(lambda);
   }
@@ -667,13 +663,13 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Image_destroyRenderThread(TLinearImage *tLinearImage, VoidCallback onComplete)
+  EMSCRIPTEN_KEEPALIVE void Image_destroyRenderThread(TLinearImage *tLinearImage, uint32_t requestId, VoidCallback onComplete)
   {
     std::packaged_task<void()> lambda(
         [=]() mutable
         {
           Image_destroy(tLinearImage);
-          PROXY(onComplete());
+          PROXY(onComplete(requestId));
         });
     auto fut = _renderThread->add_task(lambda);
   }
@@ -842,13 +838,13 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
   EMSCRIPTEN_KEEPALIVE void RenderTarget_destroyRenderThread(
     TEngine *tEngine,
     TRenderTarget *tRenderTarget,
-    VoidCallback onComplete
+    uint32_t requestId, VoidCallback onComplete
   ) {
     std::packaged_task<void()> lambda(
         [=]() mutable
         {
           RenderTarget_destroy(tEngine, tRenderTarget);
-          PROXY(onComplete());
+          PROXY(onComplete(requestId));
         });
     auto fut = _renderThread->add_task(lambda);
   }
@@ -899,13 +895,13 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
   EMSCRIPTEN_KEEPALIVE void TextureSampler_setMinFilterRenderThread(
       TTextureSampler *sampler,
       TSamplerMinFilter filter,
-      VoidCallback onComplete)
+      uint32_t requestId, VoidCallback onComplete)
   {
     std::packaged_task<void()> lambda(
         [=]() mutable
         {
           TextureSampler_setMinFilter(sampler, filter);
-          PROXY(onComplete());
+          PROXY(onComplete(requestId));
         });
     auto fut = _renderThread->add_task(lambda);
   }
@@ -913,13 +909,13 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
   EMSCRIPTEN_KEEPALIVE void TextureSampler_setMagFilterRenderThread(
       TTextureSampler *sampler,
       TSamplerMagFilter filter,
-      VoidCallback onComplete)
+      uint32_t requestId, VoidCallback onComplete)
   {
     std::packaged_task<void()> lambda(
         [=]() mutable
         {
           TextureSampler_setMagFilter(sampler, filter);
-          PROXY(onComplete());
+          PROXY(onComplete(requestId));
         });
     auto fut = _renderThread->add_task(lambda);
   }
@@ -927,13 +923,13 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
   EMSCRIPTEN_KEEPALIVE void TextureSampler_setWrapModeSRenderThread(
       TTextureSampler *sampler,
       TSamplerWrapMode mode,
-      VoidCallback onComplete)
+      uint32_t requestId, VoidCallback onComplete)
   {
     std::packaged_task<void()> lambda(
         [=]() mutable
         {
           TextureSampler_setWrapModeS(sampler, mode);
-          PROXY(onComplete());
+          PROXY(onComplete(requestId));
         });
     auto fut = _renderThread->add_task(lambda);
   }
@@ -941,13 +937,13 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
   EMSCRIPTEN_KEEPALIVE void TextureSampler_setWrapModeTRenderThread(
       TTextureSampler *sampler,
       TSamplerWrapMode mode,
-      VoidCallback onComplete)
+      uint32_t requestId, VoidCallback onComplete)
   {
     std::packaged_task<void()> lambda(
         [=]() mutable
         {
           TextureSampler_setWrapModeT(sampler, mode);
-          PROXY(onComplete());
+          PROXY(onComplete(requestId));
         });
     auto fut = _renderThread->add_task(lambda);
   }
@@ -955,13 +951,13 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
   EMSCRIPTEN_KEEPALIVE void TextureSampler_setWrapModeRRenderThread(
       TTextureSampler *sampler,
       TSamplerWrapMode mode,
-      VoidCallback onComplete)
+      uint32_t requestId, VoidCallback onComplete)
   {
     std::packaged_task<void()> lambda(
         [=]() mutable
         {
           TextureSampler_setWrapModeR(sampler, mode);
-          PROXY(onComplete());
+          PROXY(onComplete(requestId));
         });
     auto fut = _renderThread->add_task(lambda);
   }
@@ -969,13 +965,13 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
   EMSCRIPTEN_KEEPALIVE void TextureSampler_setAnisotropyRenderThread(
       TTextureSampler *sampler,
       double anisotropy,
-      VoidCallback onComplete)
+      uint32_t requestId, VoidCallback onComplete)
   {
     std::packaged_task<void()> lambda(
         [=]() mutable
         {
           TextureSampler_setAnisotropy(sampler, anisotropy);
-          PROXY(onComplete());
+          PROXY(onComplete(requestId));
         });
     auto fut = _renderThread->add_task(lambda);
   }
@@ -984,26 +980,26 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
       TTextureSampler *sampler,
       TSamplerCompareMode mode,
       TTextureSamplerCompareFunc func,
-      VoidCallback onComplete)
+      uint32_t requestId, VoidCallback onComplete)
   {
     std::packaged_task<void()> lambda(
         [=]() mutable
         {
           TextureSampler_setCompareMode(sampler, mode, func);
-          PROXY(onComplete());
+          PROXY(onComplete(requestId));
         });
     auto fut = _renderThread->add_task(lambda);
   }
 
   EMSCRIPTEN_KEEPALIVE void TextureSampler_destroyRenderThread(
       TTextureSampler *sampler,
-      VoidCallback onComplete)
+      uint32_t requestId, VoidCallback onComplete)
   {
     std::packaged_task<void()> lambda(
         [=]() mutable
         {
           TextureSampler_destroy(sampler);
-          PROXY(onComplete());
+          PROXY(onComplete(requestId));
         });
     auto fut = _renderThread->add_task(lambda);
   }
@@ -1028,12 +1024,12 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_destroyRenderThread(TEngine *tEngine, TGltfResourceLoader *tResourceLoader, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_destroyRenderThread(TEngine *tEngine, TGltfResourceLoader *tResourceLoader, uint32_t requestId, VoidCallback onComplete) {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
         GltfResourceLoader_destroy(tEngine, tResourceLoader);
-        PROXY(onComplete());
+        PROXY(onComplete(requestId));
       });
     auto fut = _renderThread->add_task(lambda);
   }
@@ -1053,12 +1049,12 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
     const char *uri,
     uint8_t *data,
     size_t length,
-    VoidCallback onComplete) {
+    uint32_t requestId, VoidCallback onComplete) {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
         GltfResourceLoader_addResourceData(tGltfResourceLoader, uri, data, length);
-        PROXY(onComplete());
+        PROXY(onComplete(requestId));
       });
     auto fut = _renderThread->add_task(lambda);
   }
@@ -1115,12 +1111,12 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Scene_addFilamentAssetRenderThread(TScene* tScene, TFilamentAsset *tAsset, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Scene_addFilamentAssetRenderThread(TScene* tScene, TFilamentAsset *tAsset, uint32_t requestId, VoidCallback onComplete) {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
         Scene_addFilamentAsset(tScene, tAsset);
-        PROXY(onComplete());
+        PROXY(onComplete(requestId));
       });
     auto fut = _renderThread->add_task(lambda);
   }