diff --git a/bridge/core/api/executing_context.cc b/bridge/core/api/executing_context.cc
index fa809050a..6381decec 100644
--- a/bridge/core/api/executing_context.cc
+++ b/bridge/core/api/executing_context.cc
@@ -136,12 +136,22 @@ void ExecutingContextWebFMethods::ClearInterval(ExecutingContext* context,
   WindowOrWorkerGlobalScope::clearInterval(context, interval_id, shared_exception_state->exception_state);
 }
 
-void ExecutingContextWebFMethods::SetRunRustFutureTasks(ExecutingContext* context,
-                                                        WebFNativeFunctionContext* callback_context,
-                                                        SharedExceptionState* shared_exception_state) {
+void ExecutingContextWebFMethods::AddRustFutureTask(ExecutingContext* context,
+                                                    WebFNativeFunctionContext* callback_context,
+                                                    NativeLibrartMetaData* meta_data,
+                                                    SharedExceptionState* shared_exception_state) {
   auto callback_impl = WebFNativeFunction::Create(callback_context, shared_exception_state);
 
-  context->SetRunRustFutureTasks(callback_impl);
+  context->AddRustFutureTask(callback_impl, meta_data);
+}
+
+void ExecutingContextWebFMethods::RemoveRustFutureTask(ExecutingContext* context,
+                                                       WebFNativeFunctionContext* callback_context,
+                                                       NativeLibrartMetaData* meta_data,
+                                                       SharedExceptionState* shared_exception_state) {
+  auto callback_impl = WebFNativeFunction::Create(callback_context, shared_exception_state);
+
+  context->RemoveRustFutureTask(callback_impl, meta_data);
 }
 
 }  // namespace webf
diff --git a/bridge/core/dart_methods.h b/bridge/core/dart_methods.h
index a99cfad4f..74ca42a0c 100644
--- a/bridge/core/dart_methods.h
+++ b/bridge/core/dart_methods.h
@@ -11,6 +11,7 @@
 
 #include <memory>
 #include <thread>
+#include "core/native/native_loader.h"
 #include "foundation/native_string.h"
 #include "foundation/native_value.h"
 #include "include/dart_api.h"
@@ -36,8 +37,10 @@ using AsyncModuleCallback = NativeValue* (*)(void* callback_context,
                                              Dart_PersistentHandle persistent_handle,
                                              InvokeModuleResultCallback result_callback);
 
-using PluginLibraryEntryPoint = void* (*)(WebFValue<ExecutingContext, ExecutingContextWebFMethods> handle_context);
+using PluginLibraryEntryPoint = void* (*)(WebFValue<ExecutingContext, ExecutingContextWebFMethods> handle_context,
+                                          NativeLibrartMetaData* meta_data);
 using LoadNativeLibraryCallback = void (*)(PluginLibraryEntryPoint entry_point,
+                                           NativeValue* lib_name,
                                            void* initialize_data,
                                            double context_id,
                                            void* imported_data);
diff --git a/bridge/core/executing_context.cc b/bridge/core/executing_context.cc
index 32ee8f71f..388e378db 100644
--- a/bridge/core/executing_context.cc
+++ b/bridge/core/executing_context.cc
@@ -6,6 +6,7 @@
 
 #include <utility>
 #include "bindings/qjs/converter_impl.h"
+#include "bindings/qjs/script_promise_resolver.h"
 #include "built_in_string.h"
 #include "core/dom/document.h"
 #include "core/dom/mutation_observer.h"
@@ -392,16 +393,42 @@ void ExecutingContext::EnqueueMicrotask(MicrotaskCallback callback, void* data)
   JS_FreeValue(ctx(), proxy_data);
 }
 
-void ExecutingContext::SetRunRustFutureTasks(const std::shared_ptr<WebFNativeFunction>& run_future_task) {
-  run_rust_future_tasks_ = run_future_task;
+void ExecutingContext::AddRustFutureTask(const std::shared_ptr<WebFNativeFunction>& run_future_task,
+                                         NativeLibrartMetaData* meta_data) {
+  meta_data->callbacks.push_back(run_future_task);
+}
+
+void ExecutingContext::RemoveRustFutureTask(const std::shared_ptr<WebFNativeFunction>& run_future_task,
+                                            NativeLibrartMetaData* meta_data) {
+  // Add the callback to the removed_callbacks list to avoid removing the callback during the iteration.
+  meta_data->removed_callbacks.push_back(run_future_task);
 }
 
 void ExecutingContext::RunRustFutureTasks() {
-  if (run_rust_future_tasks_ == nullptr)
-    return;
-  dart_isolate_context_->profiler()->StartTrackAsyncEvaluation();
-  run_rust_future_tasks_->Invoke(this, 0, nullptr);
-  dart_isolate_context_->profiler()->FinishTrackAsyncEvaluation();
+  for (auto& meta_data : native_library_meta_data_contaner_) {
+    for (auto& callback : meta_data->callbacks) {
+      dart_isolate_context_->profiler()->StartTrackAsyncEvaluation();
+      callback->Invoke(this, 0, nullptr);
+      dart_isolate_context_->profiler()->FinishTrackAsyncEvaluation();
+    }
+    for (auto& removed_callback : meta_data->removed_callbacks) {
+      meta_data->callbacks.erase(std::remove_if(meta_data->callbacks.begin(), meta_data->callbacks.end(),
+                                                [&](const std::shared_ptr<WebFNativeFunction>& callback) {
+                                                  return callback->Matches(removed_callback);
+                                                }),
+                                 meta_data->callbacks.end());
+    }
+    meta_data->removed_callbacks.clear();
+    if (meta_data->callbacks.empty() && meta_data->load_context != nullptr) {
+      meta_data->load_context->promise_resolver->Resolve(JS_NULL);
+      delete meta_data->load_context;
+      meta_data->load_context = nullptr;
+    }
+  }
+}
+
+void ExecutingContext::RegisterNativeLibraryMetaData(NativeLibrartMetaData* meta_data) {
+  native_library_meta_data_contaner_.push_back(meta_data);
 }
 
 void ExecutingContext::DrainPendingPromiseJobs() {
diff --git a/bridge/core/executing_context.h b/bridge/core/executing_context.h
index 8b69e988c..7abdfec6f 100644
--- a/bridge/core/executing_context.h
+++ b/bridge/core/executing_context.h
@@ -101,8 +101,12 @@ class ExecutingContext {
   void ReportError(JSValueConst error, char** rust_errmsg, uint32_t* rust_errmsg_length);
   void DrainMicrotasks();
   void EnqueueMicrotask(MicrotaskCallback callback, void* data = nullptr);
-  void SetRunRustFutureTasks(const std::shared_ptr<WebFNativeFunction>& run_rust_future_tasks);
+  static void AddRustFutureTask(const std::shared_ptr<WebFNativeFunction>& run_rust_future_tasks,
+                                NativeLibrartMetaData* meta_data);
+  static void RemoveRustFutureTask(const std::shared_ptr<WebFNativeFunction>& run_rust_future_tasks,
+                                   NativeLibrartMetaData* meta_data);
   void RunRustFutureTasks();
+  void RegisterNativeLibraryMetaData(NativeLibrartMetaData* meta_data);
   void DefineGlobalProperty(const char* prop, JSValueConst value);
   ExecutionContextData* contextData();
   uint8_t* DumpByteCode(const char* code, uint32_t codeLength, const char* sourceURL, uint64_t* bytecodeLength);
@@ -228,8 +232,8 @@ class ExecutingContext {
   // Rust methods ptr should keep alive when ExecutingContext is disposing.
   const std::unique_ptr<ExecutingContextWebFMethods> public_method_ptr_ = nullptr;
 
-  // Rust future task queue run trigger
-  std::shared_ptr<WebFNativeFunction> run_rust_future_tasks_;
+  // Native library metadata
+  std::vector<NativeLibrartMetaData*> native_library_meta_data_contaner_;
 };
 
 class ObjectProperty {
diff --git a/bridge/core/native/native_function.h b/bridge/core/native/native_function.h
index 15a50b79d..d2d211296 100644
--- a/bridge/core/native/native_function.h
+++ b/bridge/core/native/native_function.h
@@ -48,6 +48,10 @@ class WebFNativeFunction : public Function {
     return callback_context_->callback(callback_context_, argc, argv, shared_exception_state_);
   }
 
+  [[nodiscard]] bool Matches(const std::shared_ptr<WebFNativeFunction>& other) {
+    return other && other->callback_context_ && other->callback_context_->callback == callback_context_->callback;
+  }
+
  private:
   WebFNativeFunctionContext* callback_context_;
   SharedExceptionState* shared_exception_state_;
diff --git a/bridge/core/native/native_loader.cc b/bridge/core/native/native_loader.cc
index 5192e61f6..f1786d7b1 100644
--- a/bridge/core/native/native_loader.cc
+++ b/bridge/core/native/native_loader.cc
@@ -10,18 +10,10 @@
 
 namespace webf {
 
-namespace {
-
-struct NativeLibraryLoadContext {
-  ExecutingContext* context{nullptr};
-  std::shared_ptr<ScriptPromiseResolver> promise_resolver{nullptr};
-};
-
-}  // namespace
-
 NativeLoader::NativeLoader(webf::ExecutingContext* context) : ScriptWrappable(context->ctx()) {}
 
 static void ExecuteNativeLibrary(PluginLibraryEntryPoint entry_point,
+                                 NativeValue* lib_name,
                                  NativeLibraryLoadContext* native_library_load_context,
                                  void* imported_data) {
   // Encounter loading error.
@@ -33,17 +25,18 @@ static void ExecuteNativeLibrary(PluginLibraryEntryPoint entry_point,
     native_library_load_context->promise_resolver->Reject(exception_value);
     JS_FreeValue(context->ctx(), exception_value);
   } else {
+    auto* meta_data = new NativeLibrartMetaData{lib_name, native_library_load_context};
     auto entry_data = WebFValue<ExecutingContext, ExecutingContextWebFMethods>{
         native_library_load_context->context, native_library_load_context->context->publicMethodPtr(),
         native_library_load_context->context->status()};
-    void* result = entry_point(entry_data);
+    void* result = entry_point(entry_data, meta_data);
+    native_library_load_context->context->RegisterNativeLibraryMetaData(meta_data);
     native_library_load_context->context->RunRustFutureTasks();
   }
-
-  delete native_library_load_context;
 }
 
 static void HandleNativeLibraryLoad(PluginLibraryEntryPoint entry_point,
+                                    NativeValue* lib_name,
                                     void* initialize_data_ptr,
                                     double context_id,
                                     void* imported_data) {
@@ -55,7 +48,8 @@ static void HandleNativeLibraryLoad(PluginLibraryEntryPoint entry_point,
     return;
 
   context->dartIsolateContext()->dispatcher()->PostToJs(context->isDedicated(), context_id, ExecuteNativeLibrary,
-                                                        entry_point, p_native_library_load_context, imported_data);
+                                                        entry_point, lib_name, p_native_library_load_context,
+                                                        imported_data);
 }
 
 ScriptPromise NativeLoader::loadNativeLibrary(const AtomicString& lib_name,
diff --git a/bridge/core/native/native_loader.h b/bridge/core/native/native_loader.h
index 89b958ec6..7a5db09a3 100644
--- a/bridge/core/native/native_loader.h
+++ b/bridge/core/native/native_loader.h
@@ -10,6 +10,21 @@
 
 namespace webf {
 
+class ScriptPromiseResolver;
+class WebFNativeFunction;
+
+struct NativeLibraryLoadContext {
+  ExecutingContext* context{nullptr};
+  std::shared_ptr<ScriptPromiseResolver> promise_resolver{nullptr};
+};
+
+struct NativeLibrartMetaData {
+  NativeValue* lib_name;
+  NativeLibraryLoadContext* load_context;
+  std::vector<std::shared_ptr<WebFNativeFunction>> callbacks;
+  std::vector<std::shared_ptr<WebFNativeFunction>> removed_callbacks;
+};
+
 class NativeLoader : public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
 
diff --git a/bridge/include/plugin_api/executing_context.h b/bridge/include/plugin_api/executing_context.h
index 2f16ddc98..a5f8945bc 100644
--- a/bridge/include/plugin_api/executing_context.h
+++ b/bridge/include/plugin_api/executing_context.h
@@ -6,6 +6,7 @@
 #define WEBF_CORE_RUST_API_EXECUTING_CONTEXT_H_
 
 #include "core/native/native_function.h"
+#include "core/native/native_loader.h"
 #include "document.h"
 #include "exception_state.h"
 #include "foundation/native_value.h"
@@ -42,10 +43,14 @@ using PublicContextSetInterval = int32_t (*)(ExecutingContext*,
                                              SharedExceptionState*);
 using PublicContextClearTimeout = void (*)(ExecutingContext*, int32_t, SharedExceptionState*);
 using PublicContextClearInterval = void (*)(ExecutingContext*, int32_t, SharedExceptionState*);
-using PublicContextSetRunRustFutureTasks = void (*)(ExecutingContext*,
-                                                    WebFNativeFunctionContext*,
-                                                    SharedExceptionState*);
-
+using PublicContextAddRustFutureTask = void (*)(ExecutingContext*,
+                                                WebFNativeFunctionContext*,
+                                                NativeLibrartMetaData*,
+                                                SharedExceptionState*);
+using PublicContextRemoveRustFutureTask = void (*)(ExecutingContext*,
+                                                   WebFNativeFunctionContext*,
+                                                   NativeLibrartMetaData*,
+                                                   SharedExceptionState*);
 // Memory aligned and readable from WebF side.
 // Only C type member can be included in this class, any C++ type and classes can is not allowed to use here.
 struct ExecutingContextWebFMethods {
@@ -82,9 +87,14 @@ struct ExecutingContextWebFMethods {
   static void ClearInterval(ExecutingContext* context,
                             int32_t interval_id,
                             SharedExceptionState* shared_exception_state);
-  static void SetRunRustFutureTasks(ExecutingContext* context,
-                                    WebFNativeFunctionContext* callback_context,
-                                    SharedExceptionState* shared_exception_state);
+  static void AddRustFutureTask(ExecutingContext* context,
+                                WebFNativeFunctionContext* callback_context,
+                                NativeLibrartMetaData* meta_data,
+                                SharedExceptionState* shared_exception_state);
+  static void RemoveRustFutureTask(ExecutingContext* context,
+                                   WebFNativeFunctionContext* callback_context,
+                                   NativeLibrartMetaData* meta_data,
+                                   SharedExceptionState* shared_exception_state);
 
   double version{1.0};
   PublicContextGetDocument context_get_document{document};
@@ -101,7 +111,8 @@ struct ExecutingContextWebFMethods {
   PublicContextSetInterval context_set_interval{SetInterval};
   PublicContextClearTimeout context_clear_timeout{ClearTimeout};
   PublicContextClearInterval context_clear_interval{ClearInterval};
-  PublicContextSetRunRustFutureTasks context_set_run_rust_future_tasks{SetRunRustFutureTasks};
+  PublicContextAddRustFutureTask context_add_rust_future_task{AddRustFutureTask};
+  PublicContextRemoveRustFutureTask context_remove_rust_future_task{RemoveRustFutureTask};
 };
 
 }  // namespace webf
diff --git a/bridge/rusty_webf_sys/src/dom/events/event_target.rs b/bridge/rusty_webf_sys/src/dom/events/event_target.rs
index 2f70de753..5b0e87b91 100644
--- a/bridge/rusty_webf_sys/src/dom/events/event_target.rs
+++ b/bridge/rusty_webf_sys/src/dom/events/event_target.rs
@@ -77,6 +77,7 @@ impl EventTarget {
     let callback_context_data = Box::new(EventCallbackContextData {
       executing_context_ptr: self.context().ptr,
       executing_context_method_pointer: self.context().method_pointer(),
+      executing_context_meta_data: self.context().meta_data,
       executing_context_status: self.context().status,
       func: callback,
     });
@@ -112,6 +113,7 @@ impl EventTarget {
     let callback_context_data = Box::new(EventCallbackContextData {
       executing_context_ptr: self.context().ptr,
       executing_context_method_pointer: self.context().method_pointer(),
+      executing_context_meta_data: self.context().meta_data,
       executing_context_status: self.context().status,
       func: callback,
     });
diff --git a/bridge/rusty_webf_sys/src/executing_context.rs b/bridge/rusty_webf_sys/src/executing_context.rs
index f8e092152..85eba4fe8 100644
--- a/bridge/rusty_webf_sys/src/executing_context.rs
+++ b/bridge/rusty_webf_sys/src/executing_context.rs
@@ -23,13 +23,19 @@ pub struct ExecutingContextRustMethods {
   pub set_interval: extern "C" fn(*const OpaquePtr, *const WebFNativeFunctionContext, c_int, *const OpaquePtr) -> c_int,
   pub clear_timeout: extern "C" fn(*const OpaquePtr, c_int, *const OpaquePtr),
   pub clear_interval: extern "C" fn(*const OpaquePtr, c_int, *const OpaquePtr),
-  pub set_run_rust_future_tasks: extern "C" fn(*const OpaquePtr, *const WebFNativeFunctionContext, *const OpaquePtr) -> c_void,
+  pub add_rust_future_task: extern "C" fn(*const OpaquePtr, *const WebFNativeFunctionContext, *const NativeLibraryMetaData, *const OpaquePtr) -> c_void,
+  pub remove_rust_future_task: extern "C" fn(*const OpaquePtr, *const WebFNativeFunctionContext, *const NativeLibraryMetaData, *const OpaquePtr) -> c_void,
 }
 
 pub type TimeoutCallback = Box<dyn Fn()>;
 pub type IntervalCallback = Box<dyn Fn()>;
 pub type RunRustFutureTasksCallback = Box<dyn Fn()>;
 
+#[repr(C)]
+pub struct NativeLibraryMetaData {
+  pub lib_name: *const NativeValue
+}
+
 /// An environment contains all the necessary running states of a web page.
 ///
 /// For Flutter apps, there could be many web pages running in the same Dart environment,
@@ -49,14 +55,16 @@ pub struct ExecutingContext {
   pub ptr: *const OpaquePtr,
   // Methods available for export from the C++ world for use.
   method_pointer: *const ExecutingContextRustMethods,
+  pub meta_data: *const NativeLibraryMetaData,
   pub status: *const RustValueStatus,
 }
 
 impl ExecutingContext {
-  pub fn initialize(ptr: *const OpaquePtr, method_pointer: *const ExecutingContextRustMethods, status: *const RustValueStatus) -> ExecutingContext {
+  pub fn initialize(ptr: *const OpaquePtr, method_pointer: *const ExecutingContextRustMethods, meta_data: *const NativeLibraryMetaData, status: *const RustValueStatus) -> ExecutingContext {
     ExecutingContext {
       ptr,
       method_pointer,
+      meta_data,
       status
     }
   }
@@ -268,7 +276,44 @@ impl ExecutingContext {
     }
   }
 
-  pub fn set_run_rust_future_tasks(&self, callback: RunRustFutureTasksCallback, exception_state: &ExceptionState) -> Result<(), String> {
+  pub fn add_rust_future_task(&self, callback: RunRustFutureTasksCallback, exception_state: &ExceptionState) -> Result<(), String> {
+    let general_callback: WebFNativeFunction = Box::new(move |argc, argv| {
+      if argc != 0 {
+        println!("Invalid argument count for run rust future tasks callback");
+        return NativeValue::new_null();
+      }
+      callback();
+      NativeValue::new_null()
+    });
+
+    let callback_data = Box::new(WebFNativeFunctionContextData {
+      func: general_callback,
+    });
+    let callback_context_data_ptr = Box::into_raw(callback_data);
+    let callback_context = Box::new(WebFNativeFunctionContext {
+      callback: invoke_webf_native_function,
+      free_ptr: release_webf_native_function,
+      ptr: callback_context_data_ptr,
+    });
+    let callback_context_ptr = Box::into_raw(callback_context);
+
+    unsafe {
+      ((*self.method_pointer).add_rust_future_task)(self.ptr, callback_context_ptr, self.meta_data, exception_state.ptr);
+    }
+
+    if exception_state.has_exception() {
+      unsafe {
+        let _ = Box::from_raw(callback_context_ptr);
+        let _ = Box::from_raw(callback_context_data_ptr);
+      }
+      return Err(exception_state.stringify(self));
+    }
+
+    Ok(())
+
+  }
+
+  pub fn remove_rust_future_task(&self, callback: RunRustFutureTasksCallback, exception_state: &ExceptionState) -> Result<(), String> {
     let general_callback: WebFNativeFunction = Box::new(move |argc, argv| {
       if argc != 0 {
         println!("Invalid argument count for run rust future tasks callback");
@@ -290,7 +335,7 @@ impl ExecutingContext {
     let callback_context_ptr = Box::into_raw(callback_context);
 
     unsafe {
-      ((*self.method_pointer).set_run_rust_future_tasks)(self.ptr, callback_context_ptr, exception_state.ptr);
+      ((*self.method_pointer).remove_rust_future_task)(self.ptr, callback_context_ptr, self.meta_data, exception_state.ptr);
     }
 
     if exception_state.has_exception() {
@@ -323,6 +368,7 @@ impl Clone for ExecutingContext {
     ExecutingContext {
       ptr: self.ptr,
       method_pointer: self.method_pointer,
+      meta_data: self.meta_data,
       status: self.status,
     }
   }
diff --git a/bridge/rusty_webf_sys/src/lib.rs b/bridge/rusty_webf_sys/src/lib.rs
index e460959a2..e47b23c40 100644
--- a/bridge/rusty_webf_sys/src/lib.rs
+++ b/bridge/rusty_webf_sys/src/lib.rs
@@ -47,8 +47,8 @@ pub struct RustValue<T> {
   pub status: *const RustValueStatus,
 }
 
-pub fn initialize_webf_api(value: RustValue<ExecutingContextRustMethods>) -> ExecutingContext {
-  ExecutingContext::initialize(value.value, value.method_pointer, value.status)
+pub fn initialize_webf_api(value: RustValue<ExecutingContextRustMethods>, meta_data: *const NativeLibraryMetaData) -> ExecutingContext {
+  ExecutingContext::initialize(value.value, value.method_pointer, meta_data, value.status)
 }
 
 // This is the entrypoint when your rust app compiled as dynamic library and loaded & executed by WebF.
diff --git a/bridge/rusty_webf_sys/src/webf_event_listener.rs b/bridge/rusty_webf_sys/src/webf_event_listener.rs
index ca27aca67..3ffebd90b 100644
--- a/bridge/rusty_webf_sys/src/webf_event_listener.rs
+++ b/bridge/rusty_webf_sys/src/webf_event_listener.rs
@@ -9,6 +9,7 @@ pub type EventListenerCallback = Box<dyn Fn(&Event)>;
 pub struct EventCallbackContextData {
   pub executing_context_ptr: *const OpaquePtr,
   pub executing_context_method_pointer: *const ExecutingContextRustMethods,
+  pub executing_context_meta_data: *const NativeLibraryMetaData,
   pub executing_context_status: *const RustValueStatus,
   pub func: EventListenerCallback,
 }
@@ -49,7 +50,7 @@ pub extern "C" fn invoke_event_listener_callback(
   unsafe {
     let func = &(*callback_context_data).func;
     let callback_data = &(*callback_context_data);
-    let executing_context = ExecutingContext::initialize(callback_data.executing_context_ptr, callback_data.executing_context_method_pointer, callback_data.executing_context_status);
+    let executing_context = ExecutingContext::initialize(callback_data.executing_context_ptr, callback_data.executing_context_method_pointer, callback_context_data.executing_context_meta_data, callback_data.executing_context_status);
     let event = Event::initialize(event_ptr, &executing_context, event_method_pointer, status);
     func(&event);
   }
diff --git a/bridge/rusty_webf_sys/src/webf_future.rs b/bridge/rusty_webf_sys/src/webf_future.rs
index 6018774ac..d8192d718 100644
--- a/bridge/rusty_webf_sys/src/webf_future.rs
+++ b/bridge/rusty_webf_sys/src/webf_future.rs
@@ -11,12 +11,16 @@ type Task = Pin<Box<dyn Future<Output = ()>>>;
 
 pub struct FutureRuntime {
   tasks: VecDeque<Task>,
+  context: ExecutingContext,
+  callback: Option<Box<dyn Fn()>>,
 }
 
 impl FutureRuntime {
-  pub fn new() -> FutureRuntime {
+  pub fn new(context: ExecutingContext) -> FutureRuntime {
     FutureRuntime {
       tasks: VecDeque::new(),
+      context,
+      callback: None,
     }
   }
 
@@ -39,7 +43,16 @@ impl FutureRuntime {
       }
     }
 
-    self.tasks.append(&mut unfinished_tasks);
+    if !unfinished_tasks.is_empty() {
+      self.tasks.append(&mut unfinished_tasks);
+      return;
+    }
+
+    if let Some(callback) = self.callback.take() {
+      let exception_state = self.context.create_exception_state();
+      self.context.remove_rust_future_task(callback, &exception_state);
+    }
+
   }
 }
 
@@ -96,11 +109,13 @@ pub fn spawn<F>(context: ExecutingContext, future: F)
 where
   F: Future<Output = ()> + 'static,
 {
-  let runtime = Rc::new(RefCell::new(FutureRuntime::new()));
+  let runtime = Rc::new(RefCell::new(FutureRuntime::new(context.clone())));
+  let runtime_clone = runtime.clone();
   runtime.borrow_mut().spawn(future);
   let runtime_run_task_callback = Box::new(move || {
     runtime.borrow_mut().run();
   });
+  runtime_clone.borrow_mut().callback = Some(runtime_run_task_callback.clone());
   let exception_state = context.create_exception_state();
-  context.set_run_rust_future_tasks(runtime_run_task_callback, &exception_state).unwrap();
+  context.add_rust_future_task(runtime_run_task_callback, &exception_state).unwrap();
 }
diff --git a/integration_tests/rust_builder/rust/src/lib.rs b/integration_tests/rust_builder/rust/src/lib.rs
index 44d3c5060..44b8427ec 100644
--- a/integration_tests/rust_builder/rust/src/lib.rs
+++ b/integration_tests/rust_builder/rust/src/lib.rs
@@ -1,14 +1,14 @@
 use std::ffi::c_void;
 use webf_sys::executing_context::ExecutingContextRustMethods;
-use webf_sys::{initialize_webf_api, ExecutingContext, RustValue};
+use webf_sys::{initialize_webf_api, ExecutingContext, NativeLibraryMetaData, RustValue};
 
 pub mod async_storage;
 pub mod navigator;
 pub mod storage;
 
 #[no_mangle]
-pub extern "C" fn init_webf_test_app(handle: RustValue<ExecutingContextRustMethods>) -> *mut c_void {
-  let context: ExecutingContext = initialize_webf_api(handle);
+pub extern "C" fn init_webf_test_app(handle: RustValue<ExecutingContextRustMethods>, meta_data: *const NativeLibraryMetaData) -> *mut c_void {
+  let context: ExecutingContext = initialize_webf_api(handle, meta_data);
 
   webf_test_utils::sync_runner::run_tests(context.clone());
 
diff --git a/webf/example/rust_builder/rust/src/lib.rs b/webf/example/rust_builder/rust/src/lib.rs
index 7ae47566c..7b9332715 100644
--- a/webf/example/rust_builder/rust/src/lib.rs
+++ b/webf/example/rust_builder/rust/src/lib.rs
@@ -1,13 +1,13 @@
 use std::ffi::c_void;
 use webf_sys::event::Event;
 use webf_sys::executing_context::ExecutingContextRustMethods;
-use webf_sys::{initialize_webf_api, AddEventListenerOptions, EventTargetMethods, RustValue};
+use webf_sys::{initialize_webf_api, AddEventListenerOptions, EventTargetMethods, NativeLibraryMetaData, RustValue};
 use webf_sys::element::Element;
 use webf_sys::node::NodeMethods;
 
 #[no_mangle]
-pub extern "C" fn init_webf_app(handle: RustValue<ExecutingContextRustMethods>) -> *mut c_void {
-  let context = initialize_webf_api(handle);
+pub extern "C" fn init_webf_app(handle: RustValue<ExecutingContextRustMethods>, meta_data: *const NativeLibraryMetaData) -> *mut c_void {
+  let context = initialize_webf_api(handle, meta_data);
   println!("Context created");
   let exception_state = context.create_exception_state();
   let document = context.document();
diff --git a/webf/lib/src/bridge/from_native.dart b/webf/lib/src/bridge/from_native.dart
index 47714fa75..c12c34799 100644
--- a/webf/lib/src/bridge/from_native.dart
+++ b/webf/lib/src/bridge/from_native.dart
@@ -458,9 +458,11 @@ typedef NativeLoadNativeLibrary = Void Function(
     Pointer<NativeFunction<NativeLoadNativeLibraryCallback>> callback);
 typedef NativeLoadNativeLibraryCallback = Pointer<Void> Function(
     Pointer<NativeFunction<StandardWebFPluginExternalSymbol>> entryPoint,
+    Pointer<NativeString> libName,
     Pointer<Void> initializeData, Double contextId, Pointer<Void> exportData);
 typedef DartLoadNativeLibraryCallback = Pointer<Void> Function(
     Pointer<NativeFunction<StandardWebFPluginExternalSymbol>> entryPoint,
+    Pointer<NativeString> libName,
     Pointer<Void> initializeData, double contextId, Pointer<Void> exportData);
 
 typedef StandardWebFPluginExternalSymbol = Void Function();
@@ -489,10 +491,10 @@ void _loadNativeLibrary(double contextId, Pointer<NativeString> nativeLibName, P
     Pointer<NativeFunction<StandardWebFPluginExternalSymbol>> nativeFunction =
       library.lookup<NativeFunction<StandardWebFPluginExternalSymbol>>(entrySymbol);
 
-    callback(nativeFunction, initializeData, contextId, importData);
+    callback(nativeFunction, nativeLibName, initializeData, contextId, importData);
   } catch (e, stack) {
     String errmsg = '$e\n$stack';
-    callback(nullptr, initializeData, contextId, errmsg.toNativeUtf8().cast<Void>());
+    callback(nullptr, nativeLibName, initializeData, contextId, errmsg.toNativeUtf8().cast<Void>());
   }
 }