From 20da18b4b00b8e3d1d10fed0bcf359fe9aac77e0 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Tue, 14 Jul 2026 10:13:19 +0000
Subject: [PATCH 01/27] Add Event ffi type

---
 oneapi-rs-sys/include/types.hpp | 1 +
 oneapi-rs-sys/src/types-sys.rs  | 7 +++++++
 2 files changed, 8 insertions(+)

diff --git a/oneapi-rs-sys/include/types.hpp b/oneapi-rs-sys/include/types.hpp
index f97d0af..82e9bbb 100644
--- a/oneapi-rs-sys/include/types.hpp
+++ b/oneapi-rs-sys/include/types.hpp
@@ -14,4 +14,5 @@ namespace sycl_shims {
 using Device = sycl::device;
 using Platform = sycl::platform;
 using Queue = sycl::queue;
+using Event = sycl::event;
 }
diff --git a/oneapi-rs-sys/src/types-sys.rs b/oneapi-rs-sys/src/types-sys.rs
index 5075deb..8c87cda 100644
--- a/oneapi-rs-sys/src/types-sys.rs
+++ b/oneapi-rs-sys/src/types-sys.rs
@@ -13,6 +13,7 @@ pub mod ffi {
         type Device;
         type Platform;
         type Queue;
+        type Event;
     }
 
     // This is a workaround - cxx currently doesn't support passing
@@ -26,6 +27,10 @@ pub mod ffi {
     struct PlatformPtr {
         ptr: UniquePtr<Platform>
     }
+    
+    struct EventPtr {
+        ptr: UniquePtr<Event>
+    }
 
     #[derive(Debug)]
     enum DeviceType {
@@ -41,7 +46,9 @@ pub mod ffi {
     impl UniquePtr<Device> {}
     impl UniquePtr<Platform> {}
     impl UniquePtr<Queue> {}
+    impl UniquePtr<Event> {}
 
     impl Vec<DevicePtr> {}
     impl Vec<PlatformPtr> {}
+    impl Vec<EventPtr> {}
 }

From 2325ffdfc517d8d8a02f5b8b64d39c3fc75c477b Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Tue, 14 Jul 2026 10:37:06 +0000
Subject: [PATCH 02/27] Add C++ event::wait shim

---
 oneapi-rs-sys/build.rs          |  3 +++
 oneapi-rs-sys/include/event.hpp | 18 ++++++++++++++++++
 oneapi-rs-sys/src/event-sys.rs  | 19 +++++++++++++++++++
 oneapi-rs-sys/src/event.cpp     | 16 ++++++++++++++++
 oneapi-rs-sys/src/lib.rs        |  3 +++
 5 files changed, 59 insertions(+)
 create mode 100644 oneapi-rs-sys/include/event.hpp
 create mode 100644 oneapi-rs-sys/src/event-sys.rs
 create mode 100644 oneapi-rs-sys/src/event.cpp

diff --git a/oneapi-rs-sys/build.rs b/oneapi-rs-sys/build.rs
index dae79ad..c57aa82 100644
--- a/oneapi-rs-sys/build.rs
+++ b/oneapi-rs-sys/build.rs
@@ -19,6 +19,7 @@ fn main() {
         "src/device-sys.rs",
         "src/queue-sys.rs",
         "src/usm-sys.rs",
+        "src/event-sys.rs",
     ];
 
     let cpp_sources = [
@@ -26,6 +27,7 @@ fn main() {
         "src/device.cpp",
         "src/queue.cpp",
         "src/usm.cpp",
+        "src/event.cpp",
     ];
 
     let cpp_headers = [
@@ -34,6 +36,7 @@ fn main() {
         "include/device.hpp",
         "include/queue.hpp",
         "include/usm.hpp",
+        "include/event.hpp",
     ];
 
     cxx_build::bridges(&rust_sources)
diff --git a/oneapi-rs-sys/include/event.hpp b/oneapi-rs-sys/include/event.hpp
new file mode 100644
index 0000000..ae3a84e
--- /dev/null
+++ b/oneapi-rs-sys/include/event.hpp
@@ -0,0 +1,18 @@
+//
+// Copyright (C) 2026 Intel Corporation
+//
+// Under the MIT License or the Apache License v2.0.
+// See LICENSE-MIT and LICENSE-APACHE for license information.
+// SPDX-License-Identifier: MIT OR Apache-2.0
+//
+
+#pragma once
+
+#include "oneapi-rs-sys/include/types.hpp"
+#include "rust/cxx.h"
+
+#include <memory>
+
+namespace sycl_shims::event {
+void wait(Event &);
+} // namespace sycl_shims::event
diff --git a/oneapi-rs-sys/src/event-sys.rs b/oneapi-rs-sys/src/event-sys.rs
new file mode 100644
index 0000000..ccf854e
--- /dev/null
+++ b/oneapi-rs-sys/src/event-sys.rs
@@ -0,0 +1,19 @@
+//
+// Copyright (C) 2026 Intel Corporation
+//
+// Under the MIT License or the Apache License v2.0.
+// See LICENSE-MIT and LICENSE-APACHE for license information.
+// SPDX-License-Identifier: MIT OR Apache-2.0
+//
+
+#[cxx::bridge(namespace = "sycl_shims::event")]
+pub mod ffi {
+    unsafe extern "C++" {
+        include!("oneapi-rs-sys/include/event.hpp");
+
+        #[namespace = "sycl_shims"]
+        type Event = crate::types::ffi::Event;
+
+        fn wait(event: Pin<&mut Event>);
+    }
+}
diff --git a/oneapi-rs-sys/src/event.cpp b/oneapi-rs-sys/src/event.cpp
new file mode 100644
index 0000000..77fcd56
--- /dev/null
+++ b/oneapi-rs-sys/src/event.cpp
@@ -0,0 +1,16 @@
+//
+// Copyright (C) 2026 Intel Corporation
+//
+// Under the MIT License or the Apache License v2.0.
+// See LICENSE-MIT and LICENSE-APACHE for license information.
+// SPDX-License-Identifier: MIT OR Apache-2.0
+//
+
+#include "oneapi-rs-sys/include/event.hpp"
+#include "oneapi-rs-sys/src/event-sys.rs.h"
+
+namespace sycl_shims::event {
+void wait(Event & event) {
+  event.wait();
+}
+} // namespace sycl_shims::event
diff --git a/oneapi-rs-sys/src/lib.rs b/oneapi-rs-sys/src/lib.rs
index 9f71b49..f2f723d 100644
--- a/oneapi-rs-sys/src/lib.rs
+++ b/oneapi-rs-sys/src/lib.rs
@@ -20,3 +20,6 @@ pub mod queue;
 
 #[path = "usm-sys.rs"]
 pub mod usm;
+
+#[path = "event-sys.rs"]
+pub mod event;

From 10e67f6bd046093e20b330a9f93de971392c3aa8 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Wed, 15 Jul 2026 09:09:23 +0000
Subject: [PATCH 03/27] Make queues in-order

---
 oneapi-rs-sys/src/queue.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/oneapi-rs-sys/src/queue.cpp b/oneapi-rs-sys/src/queue.cpp
index 22e012c..52d86cf 100644
--- a/oneapi-rs-sys/src/queue.cpp
+++ b/oneapi-rs-sys/src/queue.cpp
@@ -9,11 +9,13 @@
 #include "oneapi-rs-sys/include/queue.hpp"
 #include "oneapi-rs-sys/src/queue-sys.rs.h"
 
+using sycl::property::queue::in_order;
+
 namespace sycl_shims::queue {
 std::unique_ptr<Queue> new_queue() {
-  return std::make_unique<Queue>(sycl::queue());
+  return std::make_unique<Queue>(sycl::queue({in_order()}));
 }
 std::unique_ptr<Queue> new_queue_from_device(Device const & device) {
-  return std::make_unique<Queue>(sycl::queue(device));
+  return std::make_unique<Queue>(sycl::queue(device, {in_order()}));
 }
 } // namespace sycl_shims::queue

From b3ec0e3b9149c5852de579c38b70d67830b7c019 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Wed, 15 Jul 2026 10:37:58 +0000
Subject: [PATCH 04/27] Add Rust Event bindings

---
 oneapi-rs-sys/include/event.hpp |  2 +-
 oneapi-rs-sys/src/event-sys.rs  |  2 +-
 oneapi-rs-sys/src/event.cpp     |  4 ++--
 oneapi-rs/src/event.rs          | 23 +++++++++++++++++++++++
 oneapi-rs/src/lib.rs            |  1 +
 5 files changed, 28 insertions(+), 4 deletions(-)
 create mode 100644 oneapi-rs/src/event.rs

diff --git a/oneapi-rs-sys/include/event.hpp b/oneapi-rs-sys/include/event.hpp
index ae3a84e..1992738 100644
--- a/oneapi-rs-sys/include/event.hpp
+++ b/oneapi-rs-sys/include/event.hpp
@@ -14,5 +14,5 @@
 #include <memory>
 
 namespace sycl_shims::event {
-void wait(Event &);
+void wait(std::unique_ptr<Event> &);
 } // namespace sycl_shims::event
diff --git a/oneapi-rs-sys/src/event-sys.rs b/oneapi-rs-sys/src/event-sys.rs
index ccf854e..5f3b697 100644
--- a/oneapi-rs-sys/src/event-sys.rs
+++ b/oneapi-rs-sys/src/event-sys.rs
@@ -14,6 +14,6 @@ pub mod ffi {
         #[namespace = "sycl_shims"]
         type Event = crate::types::ffi::Event;
 
-        fn wait(event: Pin<&mut Event>);
+        fn wait(event: &mut UniquePtr<Event>);
     }
 }
diff --git a/oneapi-rs-sys/src/event.cpp b/oneapi-rs-sys/src/event.cpp
index 77fcd56..82cbac9 100644
--- a/oneapi-rs-sys/src/event.cpp
+++ b/oneapi-rs-sys/src/event.cpp
@@ -10,7 +10,7 @@
 #include "oneapi-rs-sys/src/event-sys.rs.h"
 
 namespace sycl_shims::event {
-void wait(Event & event) {
-  event.wait();
+void wait(std::unique_ptr<Event> & event) {
+  event->wait();
 }
 } // namespace sycl_shims::event
diff --git a/oneapi-rs/src/event.rs b/oneapi-rs/src/event.rs
new file mode 100644
index 0000000..96b18d1
--- /dev/null
+++ b/oneapi-rs/src/event.rs
@@ -0,0 +1,23 @@
+//
+// Copyright (C) 2026 Intel Corporation
+//
+// Under the MIT License or the Apache License v2.0.
+// See LICENSE-MIT and LICENSE-APACHE for license information.
+// SPDX-License-Identifier: MIT OR Apache-2.0
+//
+
+use oneapi_rs_sys::event::ffi;
+
+pub struct Event(pub(crate) cxx::UniquePtr<ffi::Event>);
+
+impl Event {
+    pub fn wait(&mut self) {
+        ffi::wait(&mut self.0);
+    }
+}
+
+impl From<cxx::UniquePtr<ffi::Event>> for Event {
+    fn from(value: cxx::UniquePtr<ffi::Event>) -> Self {
+        Self(value)
+    }
+}
diff --git a/oneapi-rs/src/lib.rs b/oneapi-rs/src/lib.rs
index 82cd93a..1f7a5b7 100644
--- a/oneapi-rs/src/lib.rs
+++ b/oneapi-rs/src/lib.rs
@@ -12,3 +12,4 @@ pub mod device;
 pub mod queue;
 pub mod usm;
 pub mod buffer;
+pub mod event;

From 02bc883f1b2c50834886a1a1021511e6d50812a4 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Wed, 15 Jul 2026 10:38:13 +0000
Subject: [PATCH 05/27] Add Rust memset bindings

---
 oneapi-rs-sys/include/queue.hpp | 1 +
 oneapi-rs-sys/src/queue-sys.rs  | 3 +++
 oneapi-rs-sys/src/queue.cpp     | 3 +++
 oneapi-rs/src/buffer.rs         | 8 ++++++++
 oneapi-rs/src/queue.rs          | 8 +++++++-
 5 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/oneapi-rs-sys/include/queue.hpp b/oneapi-rs-sys/include/queue.hpp
index 55a6877..603e641 100644
--- a/oneapi-rs-sys/include/queue.hpp
+++ b/oneapi-rs-sys/include/queue.hpp
@@ -16,4 +16,5 @@
 namespace sycl_shims::queue {
 std::unique_ptr<Queue> new_queue();
 std::unique_ptr<Queue> new_queue_from_device(Device const &);
+std::unique_ptr<Event> memset(std::unique_ptr<Queue> &, std::uint8_t * ptr, int value, std::size_t num_bytes);
 } // namespace sycl_shims::queue
diff --git a/oneapi-rs-sys/src/queue-sys.rs b/oneapi-rs-sys/src/queue-sys.rs
index b7b1c65..d76d33f 100644
--- a/oneapi-rs-sys/src/queue-sys.rs
+++ b/oneapi-rs-sys/src/queue-sys.rs
@@ -15,8 +15,11 @@ pub mod ffi {
         type Queue = crate::types::ffi::Queue;
         #[namespace = "sycl_shims"]
         type Device = crate::types::ffi::Device;
+        #[namespace = "sycl_shims"]
+        type Event = crate::types::ffi::Event;
 
         fn new_queue() -> UniquePtr<Queue>;
         fn new_queue_from_device(device: &Device) -> UniquePtr<Queue>;
+        unsafe fn memset(queue: &mut UniquePtr<Queue>, ptr: *mut u8, value: i32, num_bytes: usize) -> UniquePtr<Event>;
     }
 }
diff --git a/oneapi-rs-sys/src/queue.cpp b/oneapi-rs-sys/src/queue.cpp
index 52d86cf..cbf2c58 100644
--- a/oneapi-rs-sys/src/queue.cpp
+++ b/oneapi-rs-sys/src/queue.cpp
@@ -18,4 +18,7 @@ std::unique_ptr<Queue> new_queue() {
 std::unique_ptr<Queue> new_queue_from_device(Device const & device) {
   return std::make_unique<Queue>(sycl::queue(device, {in_order()}));
 }
+std::unique_ptr<Event> memset(std::unique_ptr<Queue> & queue, std::uint8_t * ptr, int value, std::size_t num_bytes) {
+  return std::make_unique<Event>(queue->memset(ptr, value, num_bytes));
+}
 } // namespace sycl_shims::queue
diff --git a/oneapi-rs/src/buffer.rs b/oneapi-rs/src/buffer.rs
index c174815..be96c96 100644
--- a/oneapi-rs/src/buffer.rs
+++ b/oneapi-rs/src/buffer.rs
@@ -46,6 +46,14 @@ impl<T, A: UsmAlloc> Buffer<T, A> {
             allocator,
         }
     }
+
+    pub(crate) fn get_byte_ptr(&mut self) -> *mut u8 {
+        self.data.as_ptr().cast()
+    }
+
+    pub(crate) fn get_byte_size(&self) -> usize {
+        self.layout.size()
+    }
 }
 
 impl<T, A: UsmAlloc> Deref for Buffer<T, A> {
diff --git a/oneapi-rs/src/queue.rs b/oneapi-rs/src/queue.rs
index d1000e9..846fc8b 100644
--- a/oneapi-rs/src/queue.rs
+++ b/oneapi-rs/src/queue.rs
@@ -8,7 +8,7 @@
 
 use oneapi_rs_sys::queue::ffi;
 
-use crate::{buffer::Buffer, device::Device, usm::{HostAllocator, SharedAllocator, UsmAllocator}};
+use crate::{buffer::Buffer, device::Device, event::Event, usm::{HostAllocator, SharedAllocator, UsmAlloc, UsmAllocator}};
 
 /// The `Queue` connects a host program to a single device. Programs submit tasks to a device via the
 /// `Queue` and may monitor the `Queue` for completion. A program initiates the task by submitting
@@ -34,6 +34,12 @@ impl Queue {
         let allocator = UsmAllocator::from(self);
         unsafe { Buffer::new(allocator, len) }
     }
+
+    pub unsafe fn memset<T, A: UsmAlloc>(&mut self, buffer: &mut Buffer<T, A>, value: i32) -> Event {
+        let ptr = buffer.get_byte_ptr();
+        let num_bytes = buffer.get_byte_size();
+        unsafe { ffi::memset(&mut self.0, ptr, value, num_bytes) }.into()
+    }
 }
 
 impl From<&Device> for Queue {

From 3e3b5fd0f0559d03f076f28d1e8c626923854de0 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Wed, 15 Jul 2026 11:03:04 +0000
Subject: [PATCH 06/27] Add bytemuck dependency

---
 Cargo.lock           | 7 +++++++
 oneapi-rs/Cargo.toml | 1 +
 2 files changed, 8 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index ac1796a..f6819ec 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -14,6 +14,12 @@ version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
 
+[[package]]
+name = "bytemuck"
+version = "1.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6aedf8ae72766347502cf3cb4f41cf5e9cc37d28bee90f1fdaaae15f9cf9424"
+
 [[package]]
 name = "cc"
 version = "1.2.65"
@@ -177,6 +183,7 @@ name = "oneapi-rs"
 version = "0.1.0"
 dependencies = [
  "allocator-api2",
+ "bytemuck",
  "cxx",
  "oneapi-rs-sys",
  "thiserror",
diff --git a/oneapi-rs/Cargo.toml b/oneapi-rs/Cargo.toml
index 3bb6be3..08844f1 100644
--- a/oneapi-rs/Cargo.toml
+++ b/oneapi-rs/Cargo.toml
@@ -6,6 +6,7 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 allocator-api2 = "0.4.0"
+bytemuck = "1.25.1"
 cxx = "1.0.194"
 oneapi-rs-sys = { path = "../oneapi-rs-sys" }
 thiserror = "2.0.18"

From 341e4c7183dc07fbfc84475007f7ab6c72d46b51 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Wed, 15 Jul 2026 11:55:33 +0000
Subject: [PATCH 07/27] Add Clone impl for Queue

---
 oneapi-rs-sys/include/queue.hpp |  1 +
 oneapi-rs-sys/src/queue-sys.rs  |  1 +
 oneapi-rs-sys/src/queue.cpp     |  3 +++
 oneapi-rs/src/queue.rs          | 12 ++++++++++++
 4 files changed, 17 insertions(+)

diff --git a/oneapi-rs-sys/include/queue.hpp b/oneapi-rs-sys/include/queue.hpp
index 603e641..b54cd4f 100644
--- a/oneapi-rs-sys/include/queue.hpp
+++ b/oneapi-rs-sys/include/queue.hpp
@@ -16,5 +16,6 @@
 namespace sycl_shims::queue {
 std::unique_ptr<Queue> new_queue();
 std::unique_ptr<Queue> new_queue_from_device(Device const &);
+std::unique_ptr<Queue> clone(Queue const &);
 std::unique_ptr<Event> memset(std::unique_ptr<Queue> &, std::uint8_t * ptr, int value, std::size_t num_bytes);
 } // namespace sycl_shims::queue
diff --git a/oneapi-rs-sys/src/queue-sys.rs b/oneapi-rs-sys/src/queue-sys.rs
index d76d33f..b95918c 100644
--- a/oneapi-rs-sys/src/queue-sys.rs
+++ b/oneapi-rs-sys/src/queue-sys.rs
@@ -20,6 +20,7 @@ pub mod ffi {
 
         fn new_queue() -> UniquePtr<Queue>;
         fn new_queue_from_device(device: &Device) -> UniquePtr<Queue>;
+        fn clone(queue: &Queue) -> UniquePtr<Queue>;
         unsafe fn memset(queue: &mut UniquePtr<Queue>, ptr: *mut u8, value: i32, num_bytes: usize) -> UniquePtr<Event>;
     }
 }
diff --git a/oneapi-rs-sys/src/queue.cpp b/oneapi-rs-sys/src/queue.cpp
index cbf2c58..17b0701 100644
--- a/oneapi-rs-sys/src/queue.cpp
+++ b/oneapi-rs-sys/src/queue.cpp
@@ -18,6 +18,9 @@ std::unique_ptr<Queue> new_queue() {
 std::unique_ptr<Queue> new_queue_from_device(Device const & device) {
   return std::make_unique<Queue>(sycl::queue(device, {in_order()}));
 }
+std::unique_ptr<Queue> clone(Queue const & queue) {
+  return std::make_unique<Queue>(sycl::queue(queue));
+}
 std::unique_ptr<Event> memset(std::unique_ptr<Queue> & queue, std::uint8_t * ptr, int value, std::size_t num_bytes) {
   return std::make_unique<Event>(queue->memset(ptr, value, num_bytes));
 }
diff --git a/oneapi-rs/src/queue.rs b/oneapi-rs/src/queue.rs
index 846fc8b..a0c0c12 100644
--- a/oneapi-rs/src/queue.rs
+++ b/oneapi-rs/src/queue.rs
@@ -47,3 +47,15 @@ impl From<&Device> for Queue {
         Self(ffi::new_queue_from_device(&value.0))
     }
 }
+
+impl From<cxx::UniquePtr<ffi::Queue>> for Queue {
+    fn from(value: cxx::UniquePtr<ffi::Queue>) -> Self {
+        Self(value)
+    }
+}
+
+impl Clone for Queue {
+    fn clone(&self) -> Self {
+        ffi::clone(&self.0).into()
+    }
+}

From af3ef5835c1679976fd7ef6cdbbcd2b8d37202e0 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Wed, 15 Jul 2026 11:59:10 +0000
Subject: [PATCH 08/27] Remove lifetime requirement from USM allocators

---
 oneapi-rs/src/queue.rs |  4 ++--
 oneapi-rs/src/usm.rs   | 14 +++++++-------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/oneapi-rs/src/queue.rs b/oneapi-rs/src/queue.rs
index a0c0c12..7d45d6b 100644
--- a/oneapi-rs/src/queue.rs
+++ b/oneapi-rs/src/queue.rs
@@ -23,14 +23,14 @@ impl Queue {
 
     /// Allocates memory and creates a host-side [`Buffer`] that can store an array of T.
     /// Safety: the buffer contents are uninitialized.
-    pub unsafe fn alloc_uninit_host<T>(&self, len: usize) -> Buffer<T, UsmAllocator<'_, HostAllocator>> {
+    pub unsafe fn alloc_uninit_host<T>(&self, len: usize) -> Buffer<T, UsmAllocator<HostAllocator>> {
         let allocator = UsmAllocator::from(self);
         unsafe { Buffer::new(allocator, len) }
     }
 
     /// Allocates memory and creates a shared [`Buffer`] that can store an array of T.
     /// Safety: the buffer contents are uninitialized.
-    pub unsafe fn alloc_uninit_shared<T>(&self, len: usize) -> Buffer<T, UsmAllocator<'_, SharedAllocator>> {
+    pub unsafe fn alloc_uninit_shared<T>(&self, len: usize) -> Buffer<T, UsmAllocator<SharedAllocator>> {
         let allocator = UsmAllocator::from(self);
         unsafe { Buffer::new(allocator, len) }
     }
diff --git a/oneapi-rs/src/usm.rs b/oneapi-rs/src/usm.rs
index a4d0060..39b41fd 100644
--- a/oneapi-rs/src/usm.rs
+++ b/oneapi-rs/src/usm.rs
@@ -16,30 +16,30 @@ use std::{alloc::Layout, marker::PhantomData, ptr::NonNull};
 type CxxResult<T> = cxx::core::result::Result<T, cxx::Exception>;
 
 /// An instance of a USM allocator.
-pub struct UsmAllocator<'a, T: UsmAllocatorKind> {
-    queue: &'a Queue,
+pub struct UsmAllocator<T: UsmAllocatorKind> {
+    queue: Queue,
     _kind: PhantomData<T>
 }
 
 /// A marker trait for USM allocators.
 pub unsafe trait UsmAlloc : Allocator {}
 
-unsafe impl<'a, T: UsmAllocatorKind> UsmAlloc for UsmAllocator<'a, T> {}
+unsafe impl<T: UsmAllocatorKind> UsmAlloc for UsmAllocator<T> {}
 
 pub trait UsmAllocatorKind {
     unsafe fn alloc(alignment: usize, num_bytes: usize, queue: &Queue) -> CxxResult<*mut u8>;
 }
 
-impl<'a, T: UsmAllocatorKind> From<&'a Queue> for UsmAllocator<'a, T> {
-    fn from(queue: &'a Queue) -> Self {
+impl<T: UsmAllocatorKind> From<&Queue> for UsmAllocator<T> {
+    fn from(queue: &Queue) -> Self {
         Self {
-            queue,
+            queue: queue.clone(),
             _kind: PhantomData
         }
     }
 }
 
-unsafe impl<T: UsmAllocatorKind> Allocator for UsmAllocator<'_, T> {
+unsafe impl<T: UsmAllocatorKind> Allocator for UsmAllocator<T> {
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
         let ptr = unsafe { T::alloc(layout.align(), layout.size(), &self.queue) }
             .map_err(|_e| AllocError)?;

From 7258e4add3197730c7a4d0470c72ebd5cd362c24 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Wed, 15 Jul 2026 12:08:31 +0000
Subject: [PATCH 09/27] Add safe Buffer allocation functions

---
 oneapi-rs/src/queue.rs | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/oneapi-rs/src/queue.rs b/oneapi-rs/src/queue.rs
index 7d45d6b..55264a5 100644
--- a/oneapi-rs/src/queue.rs
+++ b/oneapi-rs/src/queue.rs
@@ -6,6 +6,7 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 //
 
+use bytemuck::Pod;
 use oneapi_rs_sys::queue::ffi;
 
 use crate::{buffer::Buffer, device::Device, event::Event, usm::{HostAllocator, SharedAllocator, UsmAlloc, UsmAllocator}};
@@ -21,6 +22,24 @@ impl Queue {
         Self(ffi::new_queue())
     }
 
+    /// Allocates zeroed memory and creates a host-side [`Buffer`] that can store an array of T.
+    pub fn alloc_host<T: Pod>(&mut self, len: usize) -> Buffer<T, UsmAllocator<HostAllocator>> {
+        unsafe {
+            let mut buffer = self.alloc_uninit_host(len);
+            self.memset(&mut buffer, 0).wait();
+            buffer
+        }
+    }
+
+    /// Allocates zeroed memory and creates a shared [`Buffer`] that can store an array of T.
+    pub fn alloc_shared<T: Pod>(&mut self, len: usize) -> Buffer<T, UsmAllocator<SharedAllocator>> {
+        unsafe {
+            let mut buffer = self.alloc_uninit_shared(len);
+            self.memset(&mut buffer, 0).wait();
+            buffer
+        }
+    }
+
     /// Allocates memory and creates a host-side [`Buffer`] that can store an array of T.
     /// Safety: the buffer contents are uninitialized.
     pub unsafe fn alloc_uninit_host<T>(&self, len: usize) -> Buffer<T, UsmAllocator<HostAllocator>> {

From 5cc7a102afacbe857d5cb6e9c87a6a2c28831457 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Wed, 15 Jul 2026 12:08:51 +0000
Subject: [PATCH 10/27] Update alloc example

---
 oneapi-rs/examples/alloc.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/oneapi-rs/examples/alloc.rs b/oneapi-rs/examples/alloc.rs
index 5cecde4..a3fe0a6 100644
--- a/oneapi-rs/examples/alloc.rs
+++ b/oneapi-rs/examples/alloc.rs
@@ -9,8 +9,14 @@
 use oneapi_rs::queue::Queue;
 
 fn main() {
-    let queue = Queue::new();
-    let mut buffer = unsafe { queue.alloc_uninit_shared::<u32>(10) };
+    let mut queue = Queue::new();
+    let mut buffer = queue.alloc_shared::<u32>(10);
+
+    for e in buffer.iter() { 
+        print!("{e} ")
+    }
+
+    println!();
 
     for i in 0..buffer.len() {
         buffer[i] = i as u32;

From 356d334eafe5d0f63ac5baa87e0954be9e7f5743 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Wed, 15 Jul 2026 12:25:56 +0000
Subject: [PATCH 11/27] Add Clone impl for Event

---
 oneapi-rs-sys/include/event.hpp | 1 +
 oneapi-rs-sys/src/event-sys.rs  | 1 +
 oneapi-rs-sys/src/event.cpp     | 3 +++
 oneapi-rs/src/event.rs          | 6 ++++++
 4 files changed, 11 insertions(+)

diff --git a/oneapi-rs-sys/include/event.hpp b/oneapi-rs-sys/include/event.hpp
index 1992738..e774fb8 100644
--- a/oneapi-rs-sys/include/event.hpp
+++ b/oneapi-rs-sys/include/event.hpp
@@ -15,4 +15,5 @@
 
 namespace sycl_shims::event {
 void wait(std::unique_ptr<Event> &);
+std::unique_ptr<Event> clone(Event const &);
 } // namespace sycl_shims::event
diff --git a/oneapi-rs-sys/src/event-sys.rs b/oneapi-rs-sys/src/event-sys.rs
index 5f3b697..26a9293 100644
--- a/oneapi-rs-sys/src/event-sys.rs
+++ b/oneapi-rs-sys/src/event-sys.rs
@@ -15,5 +15,6 @@ pub mod ffi {
         type Event = crate::types::ffi::Event;
 
         fn wait(event: &mut UniquePtr<Event>);
+        fn clone(event: &Event) -> UniquePtr<Event>;
     }
 }
diff --git a/oneapi-rs-sys/src/event.cpp b/oneapi-rs-sys/src/event.cpp
index 82cbac9..91f6869 100644
--- a/oneapi-rs-sys/src/event.cpp
+++ b/oneapi-rs-sys/src/event.cpp
@@ -13,4 +13,7 @@ namespace sycl_shims::event {
 void wait(std::unique_ptr<Event> & event) {
   event->wait();
 }
+std::unique_ptr<Event> clone(Event const & event) {
+  return std::make_unique<Event>(sycl::event(event));
+}
 } // namespace sycl_shims::event
diff --git a/oneapi-rs/src/event.rs b/oneapi-rs/src/event.rs
index 96b18d1..bdde0b4 100644
--- a/oneapi-rs/src/event.rs
+++ b/oneapi-rs/src/event.rs
@@ -21,3 +21,9 @@ impl From<cxx::UniquePtr<ffi::Event>> for Event {
         Self(value)
     }
 }
+
+impl Clone for Event {
+    fn clone(&self) -> Self {
+        ffi::clone(&self.0).into()
+    }
+}

From 5a17d982f2095c225a3f1d48f9fbff1b6c66c71d Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Thu, 16 Jul 2026 09:29:35 +0000
Subject: [PATCH 12/27] Add C++ event info binding

---
 oneapi-rs-sys/include/event.hpp |  5 +++++
 oneapi-rs-sys/src/event-sys.rs  |  7 +++++++
 oneapi-rs-sys/src/event.cpp     | 15 +++++++++++++++
 oneapi-rs-sys/src/types-sys.rs  |  8 ++++++++
 4 files changed, 35 insertions(+)

diff --git a/oneapi-rs-sys/include/event.hpp b/oneapi-rs-sys/include/event.hpp
index e774fb8..7bb4eeb 100644
--- a/oneapi-rs-sys/include/event.hpp
+++ b/oneapi-rs-sys/include/event.hpp
@@ -13,7 +13,12 @@
 
 #include <memory>
 
+namespace sycl_shims {
+enum class EventCommandStatus : std::uint8_t;
+} // namespace sycl_shims
+
 namespace sycl_shims::event {
 void wait(std::unique_ptr<Event> &);
+EventCommandStatus get_command_execution_status(Event const &);
 std::unique_ptr<Event> clone(Event const &);
 } // namespace sycl_shims::event
diff --git a/oneapi-rs-sys/src/event-sys.rs b/oneapi-rs-sys/src/event-sys.rs
index 26a9293..c269ca1 100644
--- a/oneapi-rs-sys/src/event-sys.rs
+++ b/oneapi-rs-sys/src/event-sys.rs
@@ -8,6 +8,12 @@
 
 #[cxx::bridge(namespace = "sycl_shims::event")]
 pub mod ffi {
+    #[namespace = "sycl_shims"]
+    extern "C++" {
+        include!("oneapi-rs-sys/src/types-sys.rs.h");
+        type EventCommandStatus = crate::types::ffi::EventCommandStatus;
+    }
+
     unsafe extern "C++" {
         include!("oneapi-rs-sys/include/event.hpp");
 
@@ -15,6 +21,7 @@ pub mod ffi {
         type Event = crate::types::ffi::Event;
 
         fn wait(event: &mut UniquePtr<Event>);
+        fn get_command_execution_status(event: &Event) -> EventCommandStatus;
         fn clone(event: &Event) -> UniquePtr<Event>;
     }
 }
diff --git a/oneapi-rs-sys/src/event.cpp b/oneapi-rs-sys/src/event.cpp
index 91f6869..8cfbccc 100644
--- a/oneapi-rs-sys/src/event.cpp
+++ b/oneapi-rs-sys/src/event.cpp
@@ -9,6 +9,8 @@
 #include "oneapi-rs-sys/include/event.hpp"
 #include "oneapi-rs-sys/src/event-sys.rs.h"
 
+using sycl::info::event_command_status;
+
 namespace sycl_shims::event {
 void wait(std::unique_ptr<Event> & event) {
   event->wait();
@@ -16,4 +18,17 @@ void wait(std::unique_ptr<Event> & event) {
 std::unique_ptr<Event> clone(Event const & event) {
   return std::make_unique<Event>(sycl::event(event));
 }
+EventCommandStatus get_command_execution_status(Event const & event) {
+  auto status = event.get_info<sycl::info::event::command_execution_status>();
+  switch (status) {
+    case event_command_status::submitted:
+      return EventCommandStatus::Submitted;
+    case event_command_status::running:
+      return EventCommandStatus::Running;
+    case event_command_status::complete:
+      return EventCommandStatus::Complete;
+    default:
+      return EventCommandStatus::Unknown;
+  }
+}
 } // namespace sycl_shims::event
diff --git a/oneapi-rs-sys/src/types-sys.rs b/oneapi-rs-sys/src/types-sys.rs
index 8c87cda..f8d995c 100644
--- a/oneapi-rs-sys/src/types-sys.rs
+++ b/oneapi-rs-sys/src/types-sys.rs
@@ -43,6 +43,14 @@ pub mod ffi {
         Unimplemented
     }
 
+    #[derive(Debug)]
+    enum EventCommandStatus {
+        Submitted,
+        Running,
+        Complete,
+        Unknown
+    }
+
     impl UniquePtr<Device> {}
     impl UniquePtr<Platform> {}
     impl UniquePtr<Queue> {}

From 22b29cbe5d550d9ef9ce8ab24c8de35f56b02f8b Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Thu, 16 Jul 2026 09:51:08 +0000
Subject: [PATCH 13/27] Add Rust Event info binding

---
 oneapi-rs/src/event.rs           |  6 ++++++
 oneapi-rs/src/info.rs            |  6 ++++++
 oneapi-rs/src/info/event-info.rs | 24 ++++++++++++++++++++++++
 3 files changed, 36 insertions(+)
 create mode 100644 oneapi-rs/src/info/event-info.rs

diff --git a/oneapi-rs/src/event.rs b/oneapi-rs/src/event.rs
index bdde0b4..d2ee81a 100644
--- a/oneapi-rs/src/event.rs
+++ b/oneapi-rs/src/event.rs
@@ -8,12 +8,18 @@
 
 use oneapi_rs_sys::event::ffi;
 
+use crate::info::event::EventInfo;
+
 pub struct Event(pub(crate) cxx::UniquePtr<ffi::Event>);
 
 impl Event {
     pub fn wait(&mut self) {
         ffi::wait(&mut self.0);
     }
+
+    pub fn get_info<T: EventInfo>(&self) -> T::Item {
+        T::get_item(self)
+    }
 }
 
 impl From<cxx::UniquePtr<ffi::Event>> for Event {
diff --git a/oneapi-rs/src/info.rs b/oneapi-rs/src/info.rs
index b7a1883..9811994 100644
--- a/oneapi-rs/src/info.rs
+++ b/oneapi-rs/src/info.rs
@@ -12,5 +12,11 @@ pub mod platform;
 #[path = "./info/device-info.rs"]
 pub mod device;
 
+#[path = "./info/event-info.rs"]
+pub mod event;
+
 /// The type of the SYCL device.
 pub use oneapi_rs_sys::device::ffi::DeviceType;
+
+/// Event status of the contained action associated with this event.
+pub use oneapi_rs_sys::event::ffi::EventCommandStatus;
diff --git a/oneapi-rs/src/info/event-info.rs b/oneapi-rs/src/info/event-info.rs
new file mode 100644
index 0000000..1a8e6bf
--- /dev/null
+++ b/oneapi-rs/src/info/event-info.rs
@@ -0,0 +1,24 @@
+//
+// Copyright (C) 2026 Intel Corporation
+//
+// Under the MIT License or the Apache License v2.0.
+// See LICENSE-MIT and LICENSE-APACHE for license information.
+// SPDX-License-Identifier: MIT OR Apache-2.0
+//
+
+use crate::event::Event;
+use oneapi_rs_sys::event::ffi;
+
+pub trait EventInfo {
+    type Item;
+    fn get_item(event: &Event) -> Self::Item;
+}
+
+/// Returns the event status of the action associated with this event.
+pub struct CommandExecutionStatus;
+impl EventInfo for CommandExecutionStatus {
+    type Item = crate::info::EventCommandStatus;
+    fn get_item(event: &Event) -> Self::Item {
+        ffi::get_command_execution_status(&event.0)
+    }
+}

From f93db0947b83b6aaf26dce88a3402d4f9c636802 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Thu, 16 Jul 2026 12:28:56 +0000
Subject: [PATCH 14/27] Add Rust->C++ waker bindings

---
 oneapi-rs-sys/include/event.hpp |  2 ++
 oneapi-rs-sys/src/event-sys.rs  | 12 ++++++++++++
 oneapi-rs-sys/src/event.cpp     |  7 ++++++-
 oneapi-rs-sys/src/types-sys.rs  |  3 +++
 4 files changed, 23 insertions(+), 1 deletion(-)

diff --git a/oneapi-rs-sys/include/event.hpp b/oneapi-rs-sys/include/event.hpp
index 7bb4eeb..bdf6004 100644
--- a/oneapi-rs-sys/include/event.hpp
+++ b/oneapi-rs-sys/include/event.hpp
@@ -9,6 +9,7 @@
 #pragma once
 
 #include "oneapi-rs-sys/include/types.hpp"
+#include "oneapi-rs-sys/src/event-sys.rs.h"
 #include "rust/cxx.h"
 
 #include <memory>
@@ -19,6 +20,7 @@ enum class EventCommandStatus : std::uint8_t;
 
 namespace sycl_shims::event {
 void wait(std::unique_ptr<Event> &);
+void register_callback(Event const &, rust::Box<Waker>);
 EventCommandStatus get_command_execution_status(Event const &);
 std::unique_ptr<Event> clone(Event const &);
 } // namespace sycl_shims::event
diff --git a/oneapi-rs-sys/src/event-sys.rs b/oneapi-rs-sys/src/event-sys.rs
index c269ca1..013d0db 100644
--- a/oneapi-rs-sys/src/event-sys.rs
+++ b/oneapi-rs-sys/src/event-sys.rs
@@ -6,6 +6,8 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 //
 
+use crate::types::Waker;
+
 #[cxx::bridge(namespace = "sycl_shims::event")]
 pub mod ffi {
     #[namespace = "sycl_shims"]
@@ -21,7 +23,17 @@ pub mod ffi {
         type Event = crate::types::ffi::Event;
 
         fn wait(event: &mut UniquePtr<Event>);
+        fn register_callback(event: &Event, waker: Box<Waker>);
         fn get_command_execution_status(event: &Event) -> EventCommandStatus;
         fn clone(event: &Event) -> UniquePtr<Event>;
     }
+
+    extern "Rust" {
+        type Waker;
+        fn wake(waker: &Box<Waker>);
+    }
+}
+
+fn wake(waker: &Box<Waker>) {
+    waker.0.wake_by_ref();
 }
diff --git a/oneapi-rs-sys/src/event.cpp b/oneapi-rs-sys/src/event.cpp
index 8cfbccc..910af8c 100644
--- a/oneapi-rs-sys/src/event.cpp
+++ b/oneapi-rs-sys/src/event.cpp
@@ -7,7 +7,6 @@
 //
 
 #include "oneapi-rs-sys/include/event.hpp"
-#include "oneapi-rs-sys/src/event-sys.rs.h"
 
 using sycl::info::event_command_status;
 
@@ -31,4 +30,10 @@ EventCommandStatus get_command_execution_status(Event const & event) {
       return EventCommandStatus::Unknown;
   }
 }
+void register_callback(Event const & event, rust::Box<Waker> waker) {
+  sycl::queue().submit([waker = std::move(waker), event](sycl::handler& cgh) {
+    cgh.depends_on(event);
+    cgh.host_task([&]() mutable { wake(waker); });
+  });
+}
 } // namespace sycl_shims::event
diff --git a/oneapi-rs-sys/src/types-sys.rs b/oneapi-rs-sys/src/types-sys.rs
index f8d995c..fe582d3 100644
--- a/oneapi-rs-sys/src/types-sys.rs
+++ b/oneapi-rs-sys/src/types-sys.rs
@@ -6,6 +6,9 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 //
 
+// cxx requires Rust opaque types to be defined in the current crate.
+pub struct Waker(pub std::task::Waker);
+
 #[cxx::bridge(namespace = "sycl_shims")]
 pub mod ffi {
     unsafe extern "C++" {

From d48f9cf0b52125d59a8f40506cc8ac041105ff68 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Thu, 16 Jul 2026 12:56:15 +0000
Subject: [PATCH 15/27] Add IntoFuture impl for Event

---
 Cargo.lock                     | 21 +++++++++++++++++
 oneapi-rs-sys/src/types-sys.rs |  5 ++++
 oneapi-rs/Cargo.toml           |  1 +
 oneapi-rs/src/event.rs         | 43 +++++++++++++++++++++++++++++++++-
 4 files changed, 69 insertions(+), 1 deletion(-)

diff --git a/Cargo.lock b/Cargo.lock
index f6819ec..eddcc4b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -186,6 +186,7 @@ dependencies = [
  "bytemuck",
  "cxx",
  "oneapi-rs-sys",
+ "pin-project",
  "thiserror",
 ]
 
@@ -198,6 +199,26 @@ dependencies = [
  "which",
 ]
 
+[[package]]
+name = "pin-project"
+version = "1.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2466b2336ed02bcdca6b294417127b90ec92038d1d5c4fbeac971a922e0e0924"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c96395f0a926bc13b1c17622aaddda1ecb55d49c8f1bf9777e4d877800a43f8b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.106"
diff --git a/oneapi-rs-sys/src/types-sys.rs b/oneapi-rs-sys/src/types-sys.rs
index fe582d3..1b485e0 100644
--- a/oneapi-rs-sys/src/types-sys.rs
+++ b/oneapi-rs-sys/src/types-sys.rs
@@ -8,6 +8,11 @@
 
 // cxx requires Rust opaque types to be defined in the current crate.
 pub struct Waker(pub std::task::Waker);
+impl From<std::task::Waker> for Waker {
+    fn from(value: std::task::Waker) -> Self {
+        Waker(value)
+    }
+}
 
 #[cxx::bridge(namespace = "sycl_shims")]
 pub mod ffi {
diff --git a/oneapi-rs/Cargo.toml b/oneapi-rs/Cargo.toml
index 08844f1..0c67ce7 100644
--- a/oneapi-rs/Cargo.toml
+++ b/oneapi-rs/Cargo.toml
@@ -9,4 +9,5 @@ allocator-api2 = "0.4.0"
 bytemuck = "1.25.1"
 cxx = "1.0.194"
 oneapi-rs-sys = { path = "../oneapi-rs-sys" }
+pin-project = "1.1.13"
 thiserror = "2.0.18"
diff --git a/oneapi-rs/src/event.rs b/oneapi-rs/src/event.rs
index d2ee81a..398fcb7 100644
--- a/oneapi-rs/src/event.rs
+++ b/oneapi-rs/src/event.rs
@@ -6,9 +6,13 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 //
 
+use std::{pin::Pin, task::{Context, Poll}};
+
 use oneapi_rs_sys::event::ffi;
 
-use crate::info::event::EventInfo;
+use pin_project::pin_project;
+
+use crate::info::{EventCommandStatus, event::{CommandExecutionStatus, EventInfo}};
 
 pub struct Event(pub(crate) cxx::UniquePtr<ffi::Event>);
 
@@ -33,3 +37,40 @@ impl Clone for Event {
         ffi::clone(&self.0).into()
     }
 }
+
+#[pin_project]
+pub struct EventFuture {
+    event: Event,
+    set_callback: bool
+}
+
+impl Future for EventFuture {
+    type Output = ();
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        if self.event.get_info::<CommandExecutionStatus>() == EventCommandStatus::Complete {
+            Poll::Ready(())
+        }
+        else {
+            if self.set_callback == false {
+                let this = self.project();
+                *this.set_callback = true;
+                let waker = Box::new(cx.waker().clone().into());
+                ffi::register_callback(&this.event.0, waker);
+            }
+            Poll::Pending
+        }
+    }
+}
+
+impl IntoFuture for Event {
+    type Output = ();
+    type IntoFuture = EventFuture;
+
+    fn into_future(self) -> Self::IntoFuture {
+        EventFuture {
+            event: self,
+            set_callback: false
+        }
+    }
+}

From be2a3717e948ab70071e997f9b1d8d1cb0b04a49 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Thu, 16 Jul 2026 14:14:13 +0000
Subject: [PATCH 16/27] Add await buffer creation support

---
 Cargo.lock                  | 28 +++++++++++++++++++
 oneapi-rs/Cargo.toml        |  3 +++
 oneapi-rs/examples/alloc.rs |  2 +-
 oneapi-rs/src/buffer.rs     | 54 +++++++++++++++++++++++++++++++++++--
 oneapi-rs/src/queue.rs      | 14 +++++-----
 5 files changed, 91 insertions(+), 10 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index eddcc4b..6d1491e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -188,6 +188,7 @@ dependencies = [
  "oneapi-rs-sys",
  "pin-project",
  "thiserror",
+ "tokio",
 ]
 
 [[package]]
@@ -219,6 +220,12 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "pin-project-lite"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.106"
@@ -325,6 +332,27 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "tokio"
+version = "1.52.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fc7f01b389ac15039e4dc9531aa973a135d7a4135281b12d7c1bc79fd57fffe"
+dependencies = [
+ "pin-project-lite",
+ "tokio-macros",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "385a6cb71ab9ab790c5fe8d67f1645e6c450a7ce006a33de03daa956cf70a496"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.24"
diff --git a/oneapi-rs/Cargo.toml b/oneapi-rs/Cargo.toml
index 0c67ce7..4a9876e 100644
--- a/oneapi-rs/Cargo.toml
+++ b/oneapi-rs/Cargo.toml
@@ -11,3 +11,6 @@ cxx = "1.0.194"
 oneapi-rs-sys = { path = "../oneapi-rs-sys" }
 pin-project = "1.1.13"
 thiserror = "2.0.18"
+
+[dev-dependencies]
+tokio = { version = "1.52.3", features = ["macros", "rt", "rt-multi-thread"] }
diff --git a/oneapi-rs/examples/alloc.rs b/oneapi-rs/examples/alloc.rs
index a3fe0a6..2e8476b 100644
--- a/oneapi-rs/examples/alloc.rs
+++ b/oneapi-rs/examples/alloc.rs
@@ -10,7 +10,7 @@ use oneapi_rs::queue::Queue;
 
 fn main() {
     let mut queue = Queue::new();
-    let mut buffer = queue.alloc_shared::<u32>(10);
+    let mut buffer = queue.alloc_shared::<u32>(10).wait();
 
     for e in buffer.iter() { 
         print!("{e} ")
diff --git a/oneapi-rs/src/buffer.rs b/oneapi-rs/src/buffer.rs
index be96c96..b014075 100644
--- a/oneapi-rs/src/buffer.rs
+++ b/oneapi-rs/src/buffer.rs
@@ -6,9 +6,11 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 //
 
-use std::{alloc::{Layout, handle_alloc_error}, ops::{Deref, DerefMut}, ptr::NonNull, slice};
+use std::{alloc::{Layout, handle_alloc_error}, ops::{Deref, DerefMut}, pin::Pin, ptr::NonNull, slice, task::{Context, Poll}};
 
-use crate::usm::UsmAlloc;
+use pin_project::pin_project;
+
+use crate::{event::{Event, EventFuture}, usm::UsmAlloc};
 
 /// The Buffer struct defines a shared array of one, two or three dimensions that can be used
 /// by the SYCL kernel. Buffers are templated on the type of their data, and the number of
@@ -78,3 +80,51 @@ impl<T, A: UsmAlloc> Drop for Buffer<T, A> {
         unsafe { self.allocator.deallocate(self.data.cast(), self.layout); }
     }
 }
+
+pub struct BufferInProgress<T, A: UsmAlloc> {
+    buffer: Buffer<T, A>,
+    event: Event
+}
+
+impl<T, A: UsmAlloc> BufferInProgress<T, A> {
+    pub(crate) fn new(buffer: Buffer<T, A>, event: Event) -> Self {
+        Self {
+            buffer,
+            event
+        }
+    }
+}
+
+impl<T, A: UsmAlloc> BufferInProgress<T, A> {
+    pub fn wait(mut self) -> Buffer<T, A> {
+        self.event.wait();
+        self.buffer
+    }
+}
+
+#[pin_project]
+pub struct BufferFuture<T, A: UsmAlloc> {
+    buffer: Option<Buffer<T, A>>,
+    #[pin]
+    event_future: EventFuture
+}
+
+impl<T, A: UsmAlloc> Future for BufferFuture<T, A> {
+    type Output = Buffer<T, A>;
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let this = self.project();
+        this.event_future.poll(cx).map(|_| this.buffer.take().unwrap())
+    }
+}
+
+impl<T, A: UsmAlloc> IntoFuture for BufferInProgress<T, A> {
+    type Output = Buffer<T, A>;
+    type IntoFuture = BufferFuture<T, A>;
+
+    fn into_future(self) -> Self::IntoFuture {
+        Self::IntoFuture {
+            buffer: Some(self.buffer),
+            event_future: self.event.into_future()
+        }
+    }
+}
diff --git a/oneapi-rs/src/queue.rs b/oneapi-rs/src/queue.rs
index 55264a5..f812706 100644
--- a/oneapi-rs/src/queue.rs
+++ b/oneapi-rs/src/queue.rs
@@ -9,7 +9,7 @@
 use bytemuck::Pod;
 use oneapi_rs_sys::queue::ffi;
 
-use crate::{buffer::Buffer, device::Device, event::Event, usm::{HostAllocator, SharedAllocator, UsmAlloc, UsmAllocator}};
+use crate::{buffer::{Buffer, BufferInProgress}, device::Device, event::Event, usm::{HostAllocator, SharedAllocator, UsmAlloc, UsmAllocator}};
 
 /// The `Queue` connects a host program to a single device. Programs submit tasks to a device via the
 /// `Queue` and may monitor the `Queue` for completion. A program initiates the task by submitting
@@ -23,20 +23,20 @@ impl Queue {
     }
 
     /// Allocates zeroed memory and creates a host-side [`Buffer`] that can store an array of T.
-    pub fn alloc_host<T: Pod>(&mut self, len: usize) -> Buffer<T, UsmAllocator<HostAllocator>> {
+    pub fn alloc_host<T: Pod>(&mut self, len: usize) -> BufferInProgress<T, UsmAllocator<HostAllocator>> {
         unsafe {
             let mut buffer = self.alloc_uninit_host(len);
-            self.memset(&mut buffer, 0).wait();
-            buffer
+            let event = self.memset(&mut buffer, 0);
+            BufferInProgress::new(buffer, event)
         }
     }
 
     /// Allocates zeroed memory and creates a shared [`Buffer`] that can store an array of T.
-    pub fn alloc_shared<T: Pod>(&mut self, len: usize) -> Buffer<T, UsmAllocator<SharedAllocator>> {
+    pub fn alloc_shared<T: Pod>(&mut self, len: usize) -> BufferInProgress<T, UsmAllocator<SharedAllocator>> {
         unsafe {
             let mut buffer = self.alloc_uninit_shared(len);
-            self.memset(&mut buffer, 0).wait();
-            buffer
+            let event = self.memset(&mut buffer, 0);
+            BufferInProgress::new(buffer, event)
         }
     }
 

From 80cf30f6bebd7c187e29da43783287a5e25a3cf6 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Thu, 16 Jul 2026 14:14:26 +0000
Subject: [PATCH 17/27] Add async usage example

---
 oneapi-rs/examples/async.rs | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 oneapi-rs/examples/async.rs

diff --git a/oneapi-rs/examples/async.rs b/oneapi-rs/examples/async.rs
new file mode 100644
index 0000000..ad54f51
--- /dev/null
+++ b/oneapi-rs/examples/async.rs
@@ -0,0 +1,31 @@
+//
+// Copyright (C) 2026 Intel Corporation
+//
+// Under the MIT License or the Apache License v2.0.
+// See LICENSE-MIT and LICENSE-APACHE for license information.
+// SPDX-License-Identifier: MIT OR Apache-2.0
+//
+
+use oneapi_rs::queue::Queue;
+
+#[tokio::main]
+async fn main() {
+    let mut queue = Queue::new();
+    let mut buffer = queue.alloc_shared::<u32>(10).await;
+
+    for e in buffer.iter() { 
+        print!("{e} ")
+    }
+
+    println!();
+
+    for i in 0..buffer.len() {
+        buffer[i] = i as u32;
+    }
+
+    for e in buffer.iter() { 
+        print!("{e} ")
+    }
+
+    println!();
+}

From d3b67a2e94026380a2cefffcc9e3804a20dfcd1f Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Thu, 16 Jul 2026 14:24:52 +0000
Subject: [PATCH 18/27] Add immediate queue binding

---
 oneapi-rs-sys/include/queue.hpp |  1 +
 oneapi-rs-sys/src/queue-sys.rs  |  1 +
 oneapi-rs-sys/src/queue.cpp     | 11 ++++++++++-
 oneapi-rs/src/queue.rs          |  5 +++++
 4 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/oneapi-rs-sys/include/queue.hpp b/oneapi-rs-sys/include/queue.hpp
index b54cd4f..53aca6a 100644
--- a/oneapi-rs-sys/include/queue.hpp
+++ b/oneapi-rs-sys/include/queue.hpp
@@ -15,6 +15,7 @@
 
 namespace sycl_shims::queue {
 std::unique_ptr<Queue> new_queue();
+std::unique_ptr<Queue> new_queue_immediate();
 std::unique_ptr<Queue> new_queue_from_device(Device const &);
 std::unique_ptr<Queue> clone(Queue const &);
 std::unique_ptr<Event> memset(std::unique_ptr<Queue> &, std::uint8_t * ptr, int value, std::size_t num_bytes);
diff --git a/oneapi-rs-sys/src/queue-sys.rs b/oneapi-rs-sys/src/queue-sys.rs
index b95918c..812467e 100644
--- a/oneapi-rs-sys/src/queue-sys.rs
+++ b/oneapi-rs-sys/src/queue-sys.rs
@@ -19,6 +19,7 @@ pub mod ffi {
         type Event = crate::types::ffi::Event;
 
         fn new_queue() -> UniquePtr<Queue>;
+        fn new_queue_immediate() -> UniquePtr<Queue>;
         fn new_queue_from_device(device: &Device) -> UniquePtr<Queue>;
         fn clone(queue: &Queue) -> UniquePtr<Queue>;
         unsafe fn memset(queue: &mut UniquePtr<Queue>, ptr: *mut u8, value: i32, num_bytes: usize) -> UniquePtr<Event>;
diff --git a/oneapi-rs-sys/src/queue.cpp b/oneapi-rs-sys/src/queue.cpp
index 17b0701..27c2d4b 100644
--- a/oneapi-rs-sys/src/queue.cpp
+++ b/oneapi-rs-sys/src/queue.cpp
@@ -10,10 +10,19 @@
 #include "oneapi-rs-sys/src/queue-sys.rs.h"
 
 using sycl::property::queue::in_order;
+using sycl::ext::intel::property::queue::immediate_command_list;
 
 namespace sycl_shims::queue {
 std::unique_ptr<Queue> new_queue() {
-  return std::make_unique<Queue>(sycl::queue({in_order()}));
+  return std::make_unique<Queue>(sycl::queue({
+    in_order()
+  }));
+}
+std::unique_ptr<Queue> new_queue_immediate() {
+  return std::make_unique<Queue>(sycl::queue({
+    in_order(),
+    immediate_command_list()
+  }));
 }
 std::unique_ptr<Queue> new_queue_from_device(Device const & device) {
   return std::make_unique<Queue>(sycl::queue(device, {in_order()}));
diff --git a/oneapi-rs/src/queue.rs b/oneapi-rs/src/queue.rs
index f812706..193b9b3 100644
--- a/oneapi-rs/src/queue.rs
+++ b/oneapi-rs/src/queue.rs
@@ -22,6 +22,11 @@ impl Queue {
         Self(ffi::new_queue())
     }
 
+    /// Construct an immediate `Queue` based on the device returned from the default selector.
+    pub fn new_immediate() -> Self {
+        Self(ffi::new_queue_immediate())
+    }
+
     /// Allocates zeroed memory and creates a host-side [`Buffer`] that can store an array of T.
     pub fn alloc_host<T: Pod>(&mut self, len: usize) -> BufferInProgress<T, UsmAllocator<HostAllocator>> {
         unsafe {

From 108e74cb124f6b11abb77b84645c90312a881fdb Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Fri, 17 Jul 2026 08:17:58 +0000
Subject: [PATCH 19/27] Move callback queue lifetime handling to Rust

---
 oneapi-rs-sys/include/event.hpp | 2 +-
 oneapi-rs-sys/src/event-sys.rs  | 5 ++++-
 oneapi-rs-sys/src/event.cpp     | 8 +++++---
 oneapi-rs/src/event.rs          | 8 +++++---
 4 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/oneapi-rs-sys/include/event.hpp b/oneapi-rs-sys/include/event.hpp
index bdf6004..e799771 100644
--- a/oneapi-rs-sys/include/event.hpp
+++ b/oneapi-rs-sys/include/event.hpp
@@ -20,7 +20,7 @@ enum class EventCommandStatus : std::uint8_t;
 
 namespace sycl_shims::event {
 void wait(std::unique_ptr<Event> &);
-void register_callback(Event const &, rust::Box<Waker>);
+void register_callback(std::unique_ptr<Queue> &, Event const &, rust::Box<Waker>);
 EventCommandStatus get_command_execution_status(Event const &);
 std::unique_ptr<Event> clone(Event const &);
 } // namespace sycl_shims::event
diff --git a/oneapi-rs-sys/src/event-sys.rs b/oneapi-rs-sys/src/event-sys.rs
index 013d0db..c94f99c 100644
--- a/oneapi-rs-sys/src/event-sys.rs
+++ b/oneapi-rs-sys/src/event-sys.rs
@@ -22,8 +22,11 @@ pub mod ffi {
         #[namespace = "sycl_shims"]
         type Event = crate::types::ffi::Event;
 
+        #[namespace = "sycl_shims"]
+        type Queue = crate::types::ffi::Queue;
+
         fn wait(event: &mut UniquePtr<Event>);
-        fn register_callback(event: &Event, waker: Box<Waker>);
+        fn register_callback(queue: &mut UniquePtr<Queue>, event: &Event, waker: Box<Waker>);
         fn get_command_execution_status(event: &Event) -> EventCommandStatus;
         fn clone(event: &Event) -> UniquePtr<Event>;
     }
diff --git a/oneapi-rs-sys/src/event.cpp b/oneapi-rs-sys/src/event.cpp
index 910af8c..b3725c0 100644
--- a/oneapi-rs-sys/src/event.cpp
+++ b/oneapi-rs-sys/src/event.cpp
@@ -10,6 +10,8 @@
 
 using sycl::info::event_command_status;
 
+namespace syclintel = sycl::ext::intel;
+
 namespace sycl_shims::event {
 void wait(std::unique_ptr<Event> & event) {
   event->wait();
@@ -30,10 +32,10 @@ EventCommandStatus get_command_execution_status(Event const & event) {
       return EventCommandStatus::Unknown;
   }
 }
-void register_callback(Event const & event, rust::Box<Waker> waker) {
-  sycl::queue().submit([waker = std::move(waker), event](sycl::handler& cgh) {
+void register_callback(std::unique_ptr<Queue> & queue, Event const & event, rust::Box<Waker> waker) {
+  queue->submit([waker = std::move(waker), event](sycl::handler& cgh) {
     cgh.depends_on(event);
-    cgh.host_task([&]() mutable { wake(waker); });
+    cgh.host_task([&]() { wake(waker); });
   });
 }
 } // namespace sycl_shims::event
diff --git a/oneapi-rs/src/event.rs b/oneapi-rs/src/event.rs
index 398fcb7..206dfd6 100644
--- a/oneapi-rs/src/event.rs
+++ b/oneapi-rs/src/event.rs
@@ -12,7 +12,7 @@ use oneapi_rs_sys::event::ffi;
 
 use pin_project::pin_project;
 
-use crate::info::{EventCommandStatus, event::{CommandExecutionStatus, EventInfo}};
+use crate::{info::{EventCommandStatus, event::{CommandExecutionStatus, EventInfo}}, queue::Queue};
 
 pub struct Event(pub(crate) cxx::UniquePtr<ffi::Event>);
 
@@ -41,7 +41,8 @@ impl Clone for Event {
 #[pin_project]
 pub struct EventFuture {
     event: Event,
-    set_callback: bool
+    set_callback: bool,
+    queue: Queue,
 }
 
 impl Future for EventFuture {
@@ -56,7 +57,7 @@ impl Future for EventFuture {
                 let this = self.project();
                 *this.set_callback = true;
                 let waker = Box::new(cx.waker().clone().into());
-                ffi::register_callback(&this.event.0, waker);
+                ffi::register_callback(&mut this.queue.0, &this.event.0, waker);
             }
             Poll::Pending
         }
@@ -69,6 +70,7 @@ impl IntoFuture for Event {
 
     fn into_future(self) -> Self::IntoFuture {
         EventFuture {
+            queue: Queue::new_immediate(),
             event: self,
             set_callback: false
         }

From 98bc89750b47c529c75944c6aae225a2ddc9b490 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Fri, 17 Jul 2026 09:07:06 +0000
Subject: [PATCH 20/27] Add C++ barrier binding

---
 oneapi-rs-sys/include/queue.hpp | 1 +
 oneapi-rs-sys/src/queue-sys.rs  | 1 +
 oneapi-rs-sys/src/queue.cpp     | 3 +++
 3 files changed, 5 insertions(+)

diff --git a/oneapi-rs-sys/include/queue.hpp b/oneapi-rs-sys/include/queue.hpp
index 53aca6a..886c135 100644
--- a/oneapi-rs-sys/include/queue.hpp
+++ b/oneapi-rs-sys/include/queue.hpp
@@ -19,4 +19,5 @@ std::unique_ptr<Queue> new_queue_immediate();
 std::unique_ptr<Queue> new_queue_from_device(Device const &);
 std::unique_ptr<Queue> clone(Queue const &);
 std::unique_ptr<Event> memset(std::unique_ptr<Queue> &, std::uint8_t * ptr, int value, std::size_t num_bytes);
+std::unique_ptr<Event> barrier(std::unique_ptr<Queue> &);
 } // namespace sycl_shims::queue
diff --git a/oneapi-rs-sys/src/queue-sys.rs b/oneapi-rs-sys/src/queue-sys.rs
index 812467e..8f9b30d 100644
--- a/oneapi-rs-sys/src/queue-sys.rs
+++ b/oneapi-rs-sys/src/queue-sys.rs
@@ -23,5 +23,6 @@ pub mod ffi {
         fn new_queue_from_device(device: &Device) -> UniquePtr<Queue>;
         fn clone(queue: &Queue) -> UniquePtr<Queue>;
         unsafe fn memset(queue: &mut UniquePtr<Queue>, ptr: *mut u8, value: i32, num_bytes: usize) -> UniquePtr<Event>;
+        fn barrier(queue: &mut UniquePtr<Queue>) -> UniquePtr<Event>;
     }
 }
diff --git a/oneapi-rs-sys/src/queue.cpp b/oneapi-rs-sys/src/queue.cpp
index 27c2d4b..5b3b464 100644
--- a/oneapi-rs-sys/src/queue.cpp
+++ b/oneapi-rs-sys/src/queue.cpp
@@ -33,4 +33,7 @@ std::unique_ptr<Queue> clone(Queue const & queue) {
 std::unique_ptr<Event> memset(std::unique_ptr<Queue> & queue, std::uint8_t * ptr, int value, std::size_t num_bytes) {
   return std::make_unique<Event>(queue->memset(ptr, value, num_bytes));
 }
+std::unique_ptr<Event> barrier(std::unique_ptr<Queue> & queue) {
+  return std::make_unique<Event>(queue->ext_oneapi_submit_barrier());
+}
 } // namespace sycl_shims::queue

From 96511dc408d421cf8c40cc79d7454460aa9f8fc4 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Fri, 17 Jul 2026 09:09:00 +0000
Subject: [PATCH 21/27] Add Rust barrier binding

---
 oneapi-rs/src/queue.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/oneapi-rs/src/queue.rs b/oneapi-rs/src/queue.rs
index 193b9b3..8ae74fb 100644
--- a/oneapi-rs/src/queue.rs
+++ b/oneapi-rs/src/queue.rs
@@ -64,6 +64,10 @@ impl Queue {
         let num_bytes = buffer.get_byte_size();
         unsafe { ffi::memset(&mut self.0, ptr, value, num_bytes) }.into()
     }
+
+    pub fn barrier(&mut self) -> Event {
+        ffi::barrier(&mut self.0).into()
+    }
 }
 
 impl From<&Device> for Queue {

From 63a04070b16a2432a023a33f4451f9e1b24f3701 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Fri, 17 Jul 2026 09:19:36 +0000
Subject: [PATCH 22/27] Add queue::wait C++ binding

---
 oneapi-rs-sys/include/queue.hpp | 1 +
 oneapi-rs-sys/src/queue-sys.rs  | 1 +
 oneapi-rs-sys/src/queue.cpp     | 3 +++
 3 files changed, 5 insertions(+)

diff --git a/oneapi-rs-sys/include/queue.hpp b/oneapi-rs-sys/include/queue.hpp
index 886c135..9a22e77 100644
--- a/oneapi-rs-sys/include/queue.hpp
+++ b/oneapi-rs-sys/include/queue.hpp
@@ -20,4 +20,5 @@ std::unique_ptr<Queue> new_queue_from_device(Device const &);
 std::unique_ptr<Queue> clone(Queue const &);
 std::unique_ptr<Event> memset(std::unique_ptr<Queue> &, std::uint8_t * ptr, int value, std::size_t num_bytes);
 std::unique_ptr<Event> barrier(std::unique_ptr<Queue> &);
+void wait(std::unique_ptr<Queue> &);
 } // namespace sycl_shims::queue
diff --git a/oneapi-rs-sys/src/queue-sys.rs b/oneapi-rs-sys/src/queue-sys.rs
index 8f9b30d..0d60d64 100644
--- a/oneapi-rs-sys/src/queue-sys.rs
+++ b/oneapi-rs-sys/src/queue-sys.rs
@@ -24,5 +24,6 @@ pub mod ffi {
         fn clone(queue: &Queue) -> UniquePtr<Queue>;
         unsafe fn memset(queue: &mut UniquePtr<Queue>, ptr: *mut u8, value: i32, num_bytes: usize) -> UniquePtr<Event>;
         fn barrier(queue: &mut UniquePtr<Queue>) -> UniquePtr<Event>;
+        fn wait(queue: &mut UniquePtr<Queue>);
     }
 }
diff --git a/oneapi-rs-sys/src/queue.cpp b/oneapi-rs-sys/src/queue.cpp
index 5b3b464..9a9596c 100644
--- a/oneapi-rs-sys/src/queue.cpp
+++ b/oneapi-rs-sys/src/queue.cpp
@@ -36,4 +36,7 @@ std::unique_ptr<Event> memset(std::unique_ptr<Queue> & queue, std::uint8_t * ptr
 std::unique_ptr<Event> barrier(std::unique_ptr<Queue> & queue) {
   return std::make_unique<Event>(queue->ext_oneapi_submit_barrier());
 }
+void wait(std::unique_ptr<Queue> & queue) {
+  queue->wait();
+}
 } // namespace sycl_shims::queue

From b6a48cf0ff3660b7ee28b0951174418eda20d1d7 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Fri, 17 Jul 2026 09:20:37 +0000
Subject: [PATCH 23/27] Add Rust Queue::wait binding

---
 oneapi-rs/src/queue.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/oneapi-rs/src/queue.rs b/oneapi-rs/src/queue.rs
index 8ae74fb..d291fed 100644
--- a/oneapi-rs/src/queue.rs
+++ b/oneapi-rs/src/queue.rs
@@ -68,6 +68,10 @@ impl Queue {
     pub fn barrier(&mut self) -> Event {
         ffi::barrier(&mut self.0).into()
     }
+
+    pub fn wait(&mut self) {
+        ffi::wait(&mut self.0);
+    }
 }
 
 impl From<&Device> for Queue {

From d624fe1c2f2dd1f780768c14c5cc1992c1efb4bd Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Fri, 17 Jul 2026 09:55:27 +0000
Subject: [PATCH 24/27] Add dependent events support for memset

---
 oneapi-rs-sys/include/queue.hpp | 12 +++++++++++-
 oneapi-rs-sys/src/queue-sys.rs  | 14 +++++++++++++-
 oneapi-rs-sys/src/queue.cpp     | 13 +++++++++++--
 oneapi-rs/src/queue.rs          | 17 +++++++++++++++--
 4 files changed, 50 insertions(+), 6 deletions(-)

diff --git a/oneapi-rs-sys/include/queue.hpp b/oneapi-rs-sys/include/queue.hpp
index 9a22e77..da95c21 100644
--- a/oneapi-rs-sys/include/queue.hpp
+++ b/oneapi-rs-sys/include/queue.hpp
@@ -13,12 +13,22 @@
 
 #include <memory>
 
+namespace sycl_shims {
+struct EventPtr;
+} // namespace sycl_shims
+
 namespace sycl_shims::queue {
 std::unique_ptr<Queue> new_queue();
 std::unique_ptr<Queue> new_queue_immediate();
 std::unique_ptr<Queue> new_queue_from_device(Device const &);
 std::unique_ptr<Queue> clone(Queue const &);
-std::unique_ptr<Event> memset(std::unique_ptr<Queue> &, std::uint8_t * ptr, int value, std::size_t num_bytes);
+std::unique_ptr<Event> memset(
+  std::unique_ptr<Queue> &,
+  std::uint8_t * ptr,
+  int value,
+  std::size_t num_bytes,
+  rust::Vec<EventPtr> dep_events
+);
 std::unique_ptr<Event> barrier(std::unique_ptr<Queue> &);
 void wait(std::unique_ptr<Queue> &);
 } // namespace sycl_shims::queue
diff --git a/oneapi-rs-sys/src/queue-sys.rs b/oneapi-rs-sys/src/queue-sys.rs
index 0d60d64..30ee56f 100644
--- a/oneapi-rs-sys/src/queue-sys.rs
+++ b/oneapi-rs-sys/src/queue-sys.rs
@@ -8,6 +8,12 @@
 
 #[cxx::bridge(namespace = "sycl_shims::queue")]
 pub mod ffi {
+    #[namespace = "sycl_shims"]
+    extern "C++" {
+        include!("oneapi-rs-sys/src/types-sys.rs.h");
+        type EventPtr = crate::types::ffi::EventPtr;
+    }
+
     unsafe extern "C++" {
         include!("oneapi-rs-sys/include/queue.hpp");
 
@@ -22,7 +28,13 @@ pub mod ffi {
         fn new_queue_immediate() -> UniquePtr<Queue>;
         fn new_queue_from_device(device: &Device) -> UniquePtr<Queue>;
         fn clone(queue: &Queue) -> UniquePtr<Queue>;
-        unsafe fn memset(queue: &mut UniquePtr<Queue>, ptr: *mut u8, value: i32, num_bytes: usize) -> UniquePtr<Event>;
+        unsafe fn memset(
+            queue: &mut UniquePtr<Queue>,
+            ptr: *mut u8,
+            value: i32,
+            num_bytes: usize,
+            dep_events: Vec<EventPtr>
+        ) -> UniquePtr<Event>;
         fn barrier(queue: &mut UniquePtr<Queue>) -> UniquePtr<Event>;
         fn wait(queue: &mut UniquePtr<Queue>);
     }
diff --git a/oneapi-rs-sys/src/queue.cpp b/oneapi-rs-sys/src/queue.cpp
index 9a9596c..5f8ad04 100644
--- a/oneapi-rs-sys/src/queue.cpp
+++ b/oneapi-rs-sys/src/queue.cpp
@@ -30,8 +30,17 @@ std::unique_ptr<Queue> new_queue_from_device(Device const & device) {
 std::unique_ptr<Queue> clone(Queue const & queue) {
   return std::make_unique<Queue>(sycl::queue(queue));
 }
-std::unique_ptr<Event> memset(std::unique_ptr<Queue> & queue, std::uint8_t * ptr, int value, std::size_t num_bytes) {
-  return std::make_unique<Event>(queue->memset(ptr, value, num_bytes));
+std::unique_ptr<Event> memset(
+  std::unique_ptr<Queue> & queue,
+  std::uint8_t * ptr,
+  int value,
+  std::size_t num_bytes,
+  rust::Vec<EventPtr> dep_events
+) {
+  std::vector<sycl::event> deps;
+  for (auto&& e: dep_events)
+    deps.push_back(std::move(*e.ptr.release()));
+  return std::make_unique<Event>(queue->memset(ptr, value, num_bytes, deps));
 }
 std::unique_ptr<Event> barrier(std::unique_ptr<Queue> & queue) {
   return std::make_unique<Event>(queue->ext_oneapi_submit_barrier());
diff --git a/oneapi-rs/src/queue.rs b/oneapi-rs/src/queue.rs
index d291fed..4f5ed72 100644
--- a/oneapi-rs/src/queue.rs
+++ b/oneapi-rs/src/queue.rs
@@ -7,7 +7,7 @@
 //
 
 use bytemuck::Pod;
-use oneapi_rs_sys::queue::ffi;
+use oneapi_rs_sys::{queue::ffi, types::ffi::EventPtr};
 
 use crate::{buffer::{Buffer, BufferInProgress}, device::Device, event::Event, usm::{HostAllocator, SharedAllocator, UsmAlloc, UsmAllocator}};
 
@@ -60,9 +60,22 @@ impl Queue {
     }
 
     pub unsafe fn memset<T, A: UsmAlloc>(&mut self, buffer: &mut Buffer<T, A>, value: i32) -> Event {
+        unsafe { self.memset_with_deps(buffer, value, &[]) }
+    }
+
+    pub unsafe fn memset_with_deps<T, A: UsmAlloc>(
+        &mut self,
+        buffer: &mut Buffer<T, A>,
+        value: i32,
+        dep_events: &[&Event]
+    ) -> Event {
         let ptr = buffer.get_byte_ptr();
         let num_bytes = buffer.get_byte_size();
-        unsafe { ffi::memset(&mut self.0, ptr, value, num_bytes) }.into()
+        let dep_events = dep_events
+            .iter()
+            .map(|e| EventPtr { ptr: (*e).clone().0 })
+            .collect::<Vec<_>>();
+        unsafe { ffi::memset(&mut self.0, ptr, value, num_bytes, dep_events) }.into()
     }
 
     pub fn barrier(&mut self) -> Event {

From 406cc32833e89bd5d8298b0140a012b02360a9f8 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Fri, 17 Jul 2026 10:06:46 +0000
Subject: [PATCH 25/27] Add dependent events support for barrier

---
 oneapi-rs-sys/include/queue.hpp |  4 ++--
 oneapi-rs-sys/src/queue-sys.rs  |  2 +-
 oneapi-rs-sys/src/queue.cpp     |  7 +++++--
 oneapi-rs/src/queue.rs          | 10 +++++++++-
 4 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/oneapi-rs-sys/include/queue.hpp b/oneapi-rs-sys/include/queue.hpp
index da95c21..344102e 100644
--- a/oneapi-rs-sys/include/queue.hpp
+++ b/oneapi-rs-sys/include/queue.hpp
@@ -27,8 +27,8 @@ std::unique_ptr<Event> memset(
   std::uint8_t * ptr,
   int value,
   std::size_t num_bytes,
-  rust::Vec<EventPtr> dep_events
+  rust::Vec<EventPtr>
 );
-std::unique_ptr<Event> barrier(std::unique_ptr<Queue> &);
+std::unique_ptr<Event> barrier(std::unique_ptr<Queue> &, rust::Vec<EventPtr>);
 void wait(std::unique_ptr<Queue> &);
 } // namespace sycl_shims::queue
diff --git a/oneapi-rs-sys/src/queue-sys.rs b/oneapi-rs-sys/src/queue-sys.rs
index 30ee56f..d9f7a1f 100644
--- a/oneapi-rs-sys/src/queue-sys.rs
+++ b/oneapi-rs-sys/src/queue-sys.rs
@@ -35,7 +35,7 @@ pub mod ffi {
             num_bytes: usize,
             dep_events: Vec<EventPtr>
         ) -> UniquePtr<Event>;
-        fn barrier(queue: &mut UniquePtr<Queue>) -> UniquePtr<Event>;
+        fn barrier(queue: &mut UniquePtr<Queue>, dep_events: Vec<EventPtr>) -> UniquePtr<Event>;
         fn wait(queue: &mut UniquePtr<Queue>);
     }
 }
diff --git a/oneapi-rs-sys/src/queue.cpp b/oneapi-rs-sys/src/queue.cpp
index 5f8ad04..13695bd 100644
--- a/oneapi-rs-sys/src/queue.cpp
+++ b/oneapi-rs-sys/src/queue.cpp
@@ -42,8 +42,11 @@ std::unique_ptr<Event> memset(
     deps.push_back(std::move(*e.ptr.release()));
   return std::make_unique<Event>(queue->memset(ptr, value, num_bytes, deps));
 }
-std::unique_ptr<Event> barrier(std::unique_ptr<Queue> & queue) {
-  return std::make_unique<Event>(queue->ext_oneapi_submit_barrier());
+std::unique_ptr<Event> barrier(std::unique_ptr<Queue> & queue, rust::Vec<EventPtr> dep_events) {
+  std::vector<sycl::event> deps;
+  for (auto&& e: dep_events)
+    deps.push_back(std::move(*e.ptr.release()));
+  return std::make_unique<Event>(queue->ext_oneapi_submit_barrier(deps));
 }
 void wait(std::unique_ptr<Queue> & queue) {
   queue->wait();
diff --git a/oneapi-rs/src/queue.rs b/oneapi-rs/src/queue.rs
index 4f5ed72..e6db6a6 100644
--- a/oneapi-rs/src/queue.rs
+++ b/oneapi-rs/src/queue.rs
@@ -79,7 +79,15 @@ impl Queue {
     }
 
     pub fn barrier(&mut self) -> Event {
-        ffi::barrier(&mut self.0).into()
+        self.barrier_with_deps(&[])
+    }
+
+    pub fn barrier_with_deps(&mut self, dep_events: &[&Event]) -> Event {
+        let dep_events = dep_events
+            .iter()
+            .map(|e| EventPtr { ptr: (*e).clone().0 })
+            .collect::<Vec<_>>();
+        ffi::barrier(&mut self.0, dep_events).into()
     }
 
     pub fn wait(&mut self) {

From 5fb435f19a7bcb3c86e10583249f9788e2c49219 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Fri, 17 Jul 2026 10:22:37 +0000
Subject: [PATCH 26/27] Document new Queue methods

---
 oneapi-rs/src/queue.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/oneapi-rs/src/queue.rs b/oneapi-rs/src/queue.rs
index e6db6a6..6a73f5a 100644
--- a/oneapi-rs/src/queue.rs
+++ b/oneapi-rs/src/queue.rs
@@ -59,10 +59,14 @@ impl Queue {
         unsafe { Buffer::new(allocator, len) }
     }
 
+    /// Sets memory allocated with USM allocations.
+    /// Safety: the caller must make sure the underlying memory isn't being aliased somewhere else.
     pub unsafe fn memset<T, A: UsmAlloc>(&mut self, buffer: &mut Buffer<T, A>, value: i32) -> Event {
         unsafe { self.memset_with_deps(buffer, value, &[]) }
     }
 
+    /// Sets memory allocated with USM allocations after all specified events finish.
+    /// Safety: the caller must make sure the underlying memory isn't being aliased somewhere else.
     pub unsafe fn memset_with_deps<T, A: UsmAlloc>(
         &mut self,
         buffer: &mut Buffer<T, A>,
@@ -78,10 +82,12 @@ impl Queue {
         unsafe { ffi::memset(&mut self.0, ptr, value, num_bytes, dep_events) }.into()
     }
 
+    /// Submits a barrier to the queue.
     pub fn barrier(&mut self) -> Event {
         self.barrier_with_deps(&[])
     }
 
+    /// Submits a barrier to the queue after all specified events finish.
     pub fn barrier_with_deps(&mut self, dep_events: &[&Event]) -> Event {
         let dep_events = dep_events
             .iter()
@@ -90,6 +96,7 @@ impl Queue {
         ffi::barrier(&mut self.0, dep_events).into()
     }
 
+    /// Performs a blocking wait for the completion of all enqueued tasks in the queue.
     pub fn wait(&mut self) {
         ffi::wait(&mut self.0);
     }

From 3818c670efb13abe7b95d070b89b1c9deaaa1213 Mon Sep 17 00:00:00 2001
From: Szymon Zadworny <szymon.zadworny@intel.com>
Date: Fri, 17 Jul 2026 10:31:39 +0000
Subject: [PATCH 27/27] Document new Buffer methods

---
 oneapi-rs/src/buffer.rs | 11 +++++++----
 oneapi-rs/src/queue.rs  | 10 +++++-----
 2 files changed, 12 insertions(+), 9 deletions(-)

diff --git a/oneapi-rs/src/buffer.rs b/oneapi-rs/src/buffer.rs
index b014075..e1fa270 100644
--- a/oneapi-rs/src/buffer.rs
+++ b/oneapi-rs/src/buffer.rs
@@ -81,12 +81,13 @@ impl<T, A: UsmAlloc> Drop for Buffer<T, A> {
     }
 }
 
-pub struct BufferInProgress<T, A: UsmAlloc> {
+/// A [`Buffer`] whose initialization has been enqueued. You need to wait/await it.
+pub struct EnqueuedBuffer<T, A: UsmAlloc> {
     buffer: Buffer<T, A>,
     event: Event
 }
 
-impl<T, A: UsmAlloc> BufferInProgress<T, A> {
+impl<T, A: UsmAlloc> EnqueuedBuffer<T, A> {
     pub(crate) fn new(buffer: Buffer<T, A>, event: Event) -> Self {
         Self {
             buffer,
@@ -95,7 +96,8 @@ impl<T, A: UsmAlloc> BufferInProgress<T, A> {
     }
 }
 
-impl<T, A: UsmAlloc> BufferInProgress<T, A> {
+impl<T, A: UsmAlloc> EnqueuedBuffer<T, A> {
+    /// Waits for [`Buffer`] initialization to finish.
     pub fn wait(mut self) -> Buffer<T, A> {
         self.event.wait();
         self.buffer
@@ -103,6 +105,7 @@ impl<T, A: UsmAlloc> BufferInProgress<T, A> {
 }
 
 #[pin_project]
+/// A [`Future`] which represents a pending [`Buffer`] allocation.
 pub struct BufferFuture<T, A: UsmAlloc> {
     buffer: Option<Buffer<T, A>>,
     #[pin]
@@ -117,7 +120,7 @@ impl<T, A: UsmAlloc> Future for BufferFuture<T, A> {
     }
 }
 
-impl<T, A: UsmAlloc> IntoFuture for BufferInProgress<T, A> {
+impl<T, A: UsmAlloc> IntoFuture for EnqueuedBuffer<T, A> {
     type Output = Buffer<T, A>;
     type IntoFuture = BufferFuture<T, A>;
 
diff --git a/oneapi-rs/src/queue.rs b/oneapi-rs/src/queue.rs
index 6a73f5a..a7bd77a 100644
--- a/oneapi-rs/src/queue.rs
+++ b/oneapi-rs/src/queue.rs
@@ -9,7 +9,7 @@
 use bytemuck::Pod;
 use oneapi_rs_sys::{queue::ffi, types::ffi::EventPtr};
 
-use crate::{buffer::{Buffer, BufferInProgress}, device::Device, event::Event, usm::{HostAllocator, SharedAllocator, UsmAlloc, UsmAllocator}};
+use crate::{buffer::{Buffer, EnqueuedBuffer}, device::Device, event::Event, usm::{HostAllocator, SharedAllocator, UsmAlloc, UsmAllocator}};
 
 /// The `Queue` connects a host program to a single device. Programs submit tasks to a device via the
 /// `Queue` and may monitor the `Queue` for completion. A program initiates the task by submitting
@@ -28,20 +28,20 @@ impl Queue {
     }
 
     /// Allocates zeroed memory and creates a host-side [`Buffer`] that can store an array of T.
-    pub fn alloc_host<T: Pod>(&mut self, len: usize) -> BufferInProgress<T, UsmAllocator<HostAllocator>> {
+    pub fn alloc_host<T: Pod>(&mut self, len: usize) -> EnqueuedBuffer<T, UsmAllocator<HostAllocator>> {
         unsafe {
             let mut buffer = self.alloc_uninit_host(len);
             let event = self.memset(&mut buffer, 0);
-            BufferInProgress::new(buffer, event)
+            EnqueuedBuffer::new(buffer, event)
         }
     }
 
     /// Allocates zeroed memory and creates a shared [`Buffer`] that can store an array of T.
-    pub fn alloc_shared<T: Pod>(&mut self, len: usize) -> BufferInProgress<T, UsmAllocator<SharedAllocator>> {
+    pub fn alloc_shared<T: Pod>(&mut self, len: usize) -> EnqueuedBuffer<T, UsmAllocator<SharedAllocator>> {
         unsafe {
             let mut buffer = self.alloc_uninit_shared(len);
             let event = self.memset(&mut buffer, 0);
-            BufferInProgress::new(buffer, event)
+            EnqueuedBuffer::new(buffer, event)
         }
     }