diff --git a/Cargo.lock b/Cargo.lock
index c1c55d7..edf7ba7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -15,7 +15,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f47983a1084940ba9a39c077a8c63e55c619388be5476ac04c804cfbd1e63459"
 dependencies = [
  "accesskit",
- "hashbrown 0.15.1",
+ "hashbrown 0.15.2",
  "immutable-chunkmap",
 ]
 
@@ -27,7 +27,7 @@ checksum = "7329821f3bd1101e03a7d2e03bd339e3ac0dc64c70b4c9f9ae1949e3ba8dece1"
 dependencies = [
  "accesskit",
  "accesskit_consumer",
- "hashbrown 0.15.1",
+ "hashbrown 0.15.2",
  "objc2",
  "objc2-app-kit",
  "objc2-foundation",
@@ -41,7 +41,7 @@ checksum = "24fcd5d23d70670992b823e735e859374d694a3d12bfd8dd32bd3bd8bedb5d81"
 dependencies = [
  "accesskit",
  "accesskit_consumer",
- "hashbrown 0.15.1",
+ "hashbrown 0.15.2",
  "paste",
  "static_assertions",
  "windows 0.58.0",
@@ -66,6 +66,7 @@ name = "actuate"
 version = "0.11.0"
 dependencies = [
  "actuate-macros",
+ "ahash",
  "bevy",
  "bevy_app",
  "bevy_ecs",
@@ -73,6 +74,9 @@ dependencies = [
  "bevy_math",
  "bevy_time",
  "bevy_utils",
+ "crossbeam-queue",
+ "futures",
+ "hashbrown 0.15.2",
  "reqwest",
  "serde",
  "slotmap",
@@ -1751,6 +1755,15 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "crossbeam-queue"
+version = "0.3.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df0346b5d5e76ac2fe4e327c5fd1118d6be7c51dfb18f9b7922923f287471e35"
+dependencies = [
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "crossbeam-utils"
 version = "0.8.20"
@@ -2106,6 +2119,21 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "futures"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
 [[package]]
 name = "futures-channel"
 version = "0.3.31"
@@ -2113,6 +2141,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
 dependencies = [
  "futures-core",
+ "futures-sink",
 ]
 
 [[package]]
@@ -2121,6 +2150,17 @@ version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
 
+[[package]]
+name = "futures-executor"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
 [[package]]
 name = "futures-io"
 version = "0.3.31"
@@ -2140,6 +2180,17 @@ dependencies = [
  "pin-project-lite",
 ]
 
+[[package]]
+name = "futures-macro"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "futures-sink"
 version = "0.3.31"
@@ -2158,10 +2209,16 @@ version = "0.3.31"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
 dependencies = [
+ "futures-channel",
  "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
  "futures-task",
+ "memchr",
  "pin-project-lite",
  "pin-utils",
+ "slab",
 ]
 
 [[package]]
@@ -2411,10 +2468,12 @@ dependencies = [
 
 [[package]]
 name = "hashbrown"
-version = "0.15.1"
+version = "0.15.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a9bfc1af68b1726ea47d3d5109de126281def866b33970e10fbab11b5dafab3"
+checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289"
 dependencies = [
+ "allocator-api2",
+ "equivalent",
  "foldhash",
 ]
 
@@ -2725,7 +2784,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "707907fe3c25f5424cce2cb7e1cbcafee6bdbe735ca90ef77c29e84591e5b9da"
 dependencies = [
  "equivalent",
- "hashbrown 0.15.1",
+ "hashbrown 0.15.2",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 0b5df63..6cb2dac 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,11 +9,12 @@ repository = "https://github.com/actuate-rs/actuate"
 [features]
 animation = ["ecs", "dep:bevy_math", "dep:bevy_time"]
 ecs = ["dep:bevy_app", "dep:bevy_ecs", "dep:bevy_hierarchy", "dep:bevy_utils"]
-executor = []
+executor = ["std", "dep:tokio"]
 rt = ["executor", "tokio/rt-multi-thread"]
+std = []
 tracing = ["dep:tracing"]
 full = ["animation", "ecs", "rt", "tracing"]
-default = []
+default = ["std"]
 
 [workspace]
 members = [
@@ -23,16 +24,20 @@ members = [
 
 [dependencies]
 actuate-macros = { version = "0.1.6", path = "macros" }
+ahash = { version = "0.8.11", default-features = false }
 bevy_app = { version = "0.15.0", optional = true }
 bevy_ecs = { version = "0.15.0", optional = true }
 bevy_hierarchy = { version = "0.15.0", optional = true }
 bevy_math = { version = "0.15.0", optional = true }
 bevy_time = { version = "0.15.0", optional = true }
 bevy_utils = { version = "0.15.0", optional = true }
+crossbeam-queue = { version = "0.3.11", default-features = false, features = ["alloc"] }
+futures = "0.3.31"
+hashbrown = "0.15.2"
 slotmap = "1.0.7"
 thiserror = "2.0.3"
 tracing = { version = "0.1.40", optional = true }
-tokio = { version = "1.41.1", features = ["sync"] }
+tokio = { version = "1.41.1", features = ["sync"], optional = true }
 typeid = "1.0.2"
 
 [dev-dependencies]
diff --git a/examples/core/composer.rs b/examples/core/composer.rs
index b3b88c7..f5b3afa 100644
--- a/examples/core/composer.rs
+++ b/examples/core/composer.rs
@@ -32,6 +32,7 @@ fn main() {
     .unwrap();
 
     let mut composer = Composer::new(App);
-    composer.compose().unwrap();
-    composer.compose().unwrap();
+    composer.try_compose().unwrap().unwrap();
+
+    assert!(composer.try_compose().is_none());
 }
diff --git a/examples/core/error_handling.rs b/examples/core/error_handling.rs
index 9368337..e3d55fa 100644
--- a/examples/core/error_handling.rs
+++ b/examples/core/error_handling.rs
@@ -35,5 +35,5 @@ fn main() {
     .unwrap();
 
     let mut composer = Composer::new(App);
-    assert!(composer.compose().is_ok());
+    assert!(composer.try_compose().unwrap().is_ok());
 }
diff --git a/src/animation.rs b/src/animation.rs
index 73787bb..b2787bf 100644
--- a/src/animation.rs
+++ b/src/animation.rs
@@ -17,10 +17,10 @@ struct State<T> {
 }
 
 /// Use an animated value.
-pub fn use_animated<T: VectorSpace + 'static>(
-    cx: ScopeState,
-    make_initial: impl FnOnce() -> T,
-) -> UseAnimated<T> {
+pub fn use_animated<T>(cx: ScopeState, make_initial: impl FnOnce() -> T) -> UseAnimated<T>
+where
+    T: VectorSpace + Send + 'static,
+{
     let start_cell = use_world_once(cx, |time: Res<Time>| Cell::new(Some(time.elapsed_secs())));
 
     let (controller, rx) = use_ref(cx, || {
diff --git a/src/compose.rs b/src/compose.rs
index 67505d1..dc00961 100644
--- a/src/compose.rs
+++ b/src/compose.rs
@@ -1,7 +1,7 @@
 use crate::{prelude::*, Memoize, ScopeData};
-use std::{
+use alloc::borrow::Cow;
+use core::{
     any::TypeId,
-    borrow::Cow,
     cell::{RefCell, UnsafeCell},
     error::Error as StdError,
     mem,
@@ -32,7 +32,7 @@ pub trait Compose: Data {
 
     #[doc(hidden)]
     fn name() -> Option<Cow<'static, str>> {
-        let name = std::any::type_name::<Self>();
+        let name = core::any::type_name::<Self>();
         Some(
             name.split('<')
                 .next()
@@ -91,7 +91,7 @@ impl<C: Compose> Compose for Option<C> {
 /// This can be handled by a parent composable with [`Catch`].
 #[derive(Data)]
 pub struct Error {
-    make_error: Box<dyn Fn() -> Box<dyn std::error::Error>>,
+    make_error: Box<dyn Fn() -> Box<dyn core::error::Error>>,
 }
 
 impl Error {
@@ -483,7 +483,7 @@ where
     }
 
     unsafe fn reborrow(&mut self, ptr: *mut ()) {
-        std::ptr::swap(self, ptr as _);
+        core::ptr::swap(self, ptr as _);
     }
 
     unsafe fn any_compose(&self, state: &ScopeData) {
diff --git a/src/composer.rs b/src/composer.rs
index 8c51132..534c8b5 100644
--- a/src/composer.rs
+++ b/src/composer.rs
@@ -1,49 +1,39 @@
 use crate::{prelude::*, ScopeData};
+use alloc::{rc::Rc, sync::Arc, task::Wake};
 use compose::{AnyCompose, CatchContext};
-use slotmap::{DefaultKey, SlotMap};
-use std::{
+use core::{
     any::TypeId,
     cell::{Cell, RefCell},
     error::Error,
     future::Future,
     pin::Pin,
-    rc::Rc,
-    sync::{mpsc, Arc},
-    task::{Context, Wake, Waker},
+    task::{Context, Poll, Waker},
 };
-use tokio::sync::{RwLock, RwLockWriteGuard};
-
-/// An update to apply to a composable.
-pub struct Update {
-    pub(crate) f: Box<dyn FnOnce()>,
-}
+use crossbeam_queue::SegQueue;
+use slotmap::{DefaultKey, SlotMap};
 
-impl Update {
-    /// Apply this update.
-    ///
-    /// # Safety
-    /// The caller must ensure the composable triggering this update still exists.
-    pub unsafe fn apply(self) {
-        (self.f)();
-    }
-}
+#[cfg(feature = "executor")]
+use tokio::sync::RwLock;
 
 type RuntimeFuture = Pin<Box<dyn Future<Output = ()>>>;
 
 /// Runtime for a [`Composer`].
 #[derive(Clone)]
 pub struct Runtime {
-    /// Updater for this runtime.
-    pub(crate) updater: Arc<dyn Updater>,
-
     /// Local task stored on this runtime.
     pub(crate) tasks: Rc<RefCell<SlotMap<DefaultKey, RuntimeFuture>>>,
 
-    /// Waker for local tasks.
-    pub(crate) task_tx: mpsc::Sender<DefaultKey>,
+    /// Queue for ready local tasks.
+    pub(crate) task_queue: Arc<SegQueue<DefaultKey>>,
+
+    /// Queue for updates that mutate the composition tree.
+    pub(crate) update_queue: Rc<SegQueue<Box<dyn FnMut()>>>,
 
+    #[cfg(feature = "executor")]
     /// Update lock for shared tasks.
     pub(crate) lock: Arc<RwLock<()>>,
+
+    pub(crate) waker: RefCell<Option<Waker>>,
 }
 
 impl Runtime {
@@ -69,63 +59,38 @@ impl Runtime {
     }
 
     /// Queue an update to run after [`Composer::compose`].
-    pub fn update(&self, f: impl FnOnce() + 'static) {
-        self.updater.update(Update { f: Box::new(f) });
-    }
-}
-
-thread_local! {
-    static RUNTIME: RefCell<Option<Runtime>> = const { RefCell::new(None) };
-}
+    pub fn update(&self, f: impl FnOnce() + Send + 'static) {
+        let mut f_cell = Some(f);
 
-/// Updater for a [`Composer`].
-pub trait Updater: Send + Sync {
-    /// Update the content of a [`Composer`].
-    fn update(&self, update: Update);
-}
+        #[cfg(feature = "executor")]
+        let lock = self.lock.clone();
 
-struct DefaultUpdater;
+        self.update_queue.push(Box::new(move || {
+            #[cfg(feature = "executor")]
+            let _guard = lock.blocking_write();
 
-impl Updater for DefaultUpdater {
-    fn update(&self, update: Update) {
-        unsafe {
-            update.apply();
-        }
+            let f = f_cell.take().unwrap();
+            f()
+        }));
     }
 }
 
-struct UpdateWrapper<U> {
-    updater: U,
-    lock: Arc<RwLock<()>>,
-}
-
-impl<U: Updater> Updater for UpdateWrapper<U> {
-    fn update(&self, update: Update) {
-        let lock = self.lock.clone();
-        self.updater.update(Update {
-            f: Box::new(move || {
-                let _guard = lock.blocking_write();
-                unsafe { update.apply() }
-            }),
-        });
-    }
+thread_local! {
+    static RUNTIME: RefCell<Option<Runtime>> = const { RefCell::new(None) };
 }
 
 struct TaskWaker {
     key: DefaultKey,
-    updater: Arc<dyn Updater>,
-    tx: mpsc::Sender<DefaultKey>,
+    queue: Arc<SegQueue<DefaultKey>>,
+    waker: Option<Waker>,
 }
 
 impl Wake for TaskWaker {
     fn wake(self: Arc<Self>) {
-        let key = self.key;
-        let pending = self.tx.clone();
-        self.updater.update(Update {
-            f: Box::new(move || {
-                pending.send(key).unwrap();
-            }),
-        });
+        self.queue.push(self.key);
+        if let Some(waker) = self.waker.as_ref() {
+            waker.wake_by_ref();
+        }
     }
 }
 
@@ -134,43 +99,40 @@ pub struct Composer {
     compose: Box<dyn AnyCompose>,
     scope_state: Box<ScopeData<'static>>,
     rt: Runtime,
-    task_rx: mpsc::Receiver<DefaultKey>,
+    task_queue: Arc<SegQueue<DefaultKey>>,
+    update_queue: Rc<SegQueue<Box<dyn FnMut()>>>,
+    is_initial: bool,
 }
 
 impl Composer {
-    /// Create a new [`Composer`] with the given content and default updater.
-    pub fn new(content: impl Compose + 'static) -> Self {
-        Self::with_updater(content, DefaultUpdater)
-    }
-
     /// Create a new [`Composer`] with the given content, updater, and task executor.
-    pub fn with_updater(content: impl Compose + 'static, updater: impl Updater + 'static) -> Self {
+    pub fn new(content: impl Compose + 'static) -> Self {
+        #[cfg(feature = "executor")]
         let lock = Arc::new(RwLock::new(()));
-        let updater = Arc::new(UpdateWrapper {
-            updater,
-            lock: lock.clone(),
-        });
-        let (task_tx, task_rx) = mpsc::channel();
+
+        let task_queue = Arc::new(SegQueue::new());
+        let update_queue = Rc::new(SegQueue::new());
 
         let scope_data = ScopeData::default();
         Self {
             compose: Box::new(content),
             scope_state: Box::new(scope_data),
             rt: Runtime {
-                updater: updater.clone(),
                 tasks: Rc::new(RefCell::new(SlotMap::new())),
-                task_tx,
+                task_queue: task_queue.clone(),
+                update_queue: update_queue.clone(),
+                waker: RefCell::new(None),
+                #[cfg(feature = "executor")]
                 lock,
             },
-            task_rx,
+            task_queue,
+            update_queue,
+            is_initial: true,
         }
     }
 
-    /// Compose the content of this composer.
-    pub fn compose(&mut self) -> Result<(), Box<dyn Error>> {
-        #[cfg(feature = "tracing")]
-        tracing::trace!("Composer::compose");
-
+    /// Try to immediately compose the content in this composer.
+    pub fn try_compose(&mut self) -> Option<Result<(), Box<dyn Error>>> {
         self.rt.enter();
 
         let error_cell = Rc::new(Cell::new(None));
@@ -182,28 +144,59 @@ impl Composer {
             })),
         );
 
-        while let Ok(key) = self.task_rx.try_recv() {
-            let waker = Waker::from(Arc::new(TaskWaker {
-                key,
-                updater: Runtime::current().updater.clone(),
-                tx: self.rt.task_tx.clone(),
-            }));
-            let mut cx = Context::from_waker(&waker);
-
-            let mut tasks = self.rt.tasks.borrow_mut();
-            let task = tasks.get_mut(key).unwrap();
-            let _ = task.as_mut().poll(&mut cx);
+        if !self.is_initial {
+            let mut is_ready = false;
+
+            while let Some(key) = self.task_queue.pop() {
+                let waker = Waker::from(Arc::new(TaskWaker {
+                    key,
+                    waker: self.rt.waker.borrow().clone(),
+                    queue: self.rt.task_queue.clone(),
+                }));
+                let mut cx = Context::from_waker(&waker);
+
+                let mut tasks = self.rt.tasks.borrow_mut();
+                let task = tasks.get_mut(key).unwrap();
+                let _ = task.as_mut().poll(&mut cx);
+
+                is_ready = true;
+            }
+
+            while let Some(mut update) = self.update_queue.pop() {
+                update();
+                is_ready = true;
+            }
+
+            if !is_ready {
+                return None;
+            }
+        } else {
+            self.is_initial = false;
         }
 
+        #[cfg(feature = "tracing")]
+        tracing::trace!("Start composition");
+
         // Safety: `self.compose` is guaranteed to live as long as `self.scope_state`.
         unsafe { self.compose.any_compose(&self.scope_state) };
 
-        error_cell.take().map(Err).unwrap_or(Ok(()))
+        Some(error_cell.take().map(Err).unwrap_or(Ok(())))
+    }
+
+    /// Poll a composition of the content in this composer.
+    pub fn poll_compose(&mut self, cx: &mut Context) -> Poll<Result<(), Box<dyn Error>>> {
+        *self.rt.waker.borrow_mut() = Some(cx.waker().clone());
+
+        if let Some(result) = self.try_compose() {
+            Poll::Ready(result)
+        } else {
+            Poll::Pending
+        }
     }
 
-    /// Lock updates to the content of this composer.
-    pub fn lock(&self) -> RwLockWriteGuard<()> {
-        self.rt.lock.blocking_write()
+    /// Compose the content of this composer.
+    pub async fn compose(&mut self) -> Result<(), Box<dyn Error>> {
+        futures::future::poll_fn(|cx| self.poll_compose(cx)).await
     }
 }
 
@@ -257,10 +250,10 @@ mod tests {
         let x = Rc::new(Cell::new(0));
         let mut composer = Composer::new(Wrap { x: x.clone() });
 
-        composer.compose().unwrap();
+        composer.try_compose().unwrap().unwrap();
         assert_eq!(x.get(), 1);
 
-        composer.compose().unwrap();
+        composer.try_compose().unwrap().unwrap();
         assert_eq!(x.get(), 2);
     }
 
@@ -282,10 +275,10 @@ mod tests {
         let x = Rc::new(Cell::new(0));
         let mut composer = Composer::new(Wrap { x: x.clone() });
 
-        composer.compose().unwrap();
+        composer.try_compose().unwrap().unwrap();
         assert_eq!(x.get(), 1);
 
-        composer.compose().unwrap();
+        assert!(composer.try_compose().is_none());
         assert_eq!(x.get(), 1);
     }
 
@@ -307,10 +300,10 @@ mod tests {
         let x = Rc::new(Cell::new(0));
         let mut composer = Composer::new(Wrap { x: x.clone() });
 
-        composer.compose().unwrap();
+        composer.try_compose().unwrap().unwrap();
         assert_eq!(x.get(), 1);
 
-        composer.compose().unwrap();
+        composer.try_compose().unwrap().unwrap();
         assert_eq!(x.get(), 2);
     }
 
@@ -340,12 +333,12 @@ mod tests {
         }
 
         let x = Rc::new(RefCell::new(0));
-        let mut compsoer = Composer::new(A { x: x.clone() });
+        let mut composer = Composer::new(A { x: x.clone() });
 
-        compsoer.compose().unwrap();
+        composer.try_compose().unwrap().unwrap();
         assert_eq!(*x.borrow(), 1);
 
-        compsoer.compose().unwrap();
+        assert!(composer.try_compose().is_none());
         assert_eq!(*x.borrow(), 1);
     }
 }
diff --git a/src/data.rs b/src/data.rs
index 529080b..f300d6b 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -1,5 +1,5 @@
-use crate::prelude::*;
-use std::{collections::HashMap, error::Error, future::Future, pin::Pin};
+use crate::{prelude::*, HashMap};
+use core::{error::Error, future::Future, pin::Pin};
 
 pub use actuate_macros::{data, Data};
 
@@ -47,7 +47,7 @@ unsafe impl Data for &str {}
 
 unsafe impl<T: Data> Data for Vec<T> {}
 
-unsafe impl<T: Data, U: Data> Data for HashMap<T, U> {}
+unsafe impl<T: Data, U: Data, S: 'static> Data for HashMap<T, U, S> {}
 
 unsafe impl<T: Data> Data for &T {}
 
diff --git a/src/ecs.rs b/src/ecs.rs
index d0f1b34..577e1ed 100644
--- a/src/ecs.rs
+++ b/src/ecs.rs
@@ -1,5 +1,5 @@
 use crate::{
-    composer::{Composer, Update, Updater},
+    composer::Composer,
     prelude::{Signal, *},
 };
 use bevy_app::{App, Plugin};
@@ -18,7 +18,7 @@ use std::{
     marker::PhantomData,
     mem, ptr,
     rc::Rc,
-    sync::{mpsc, Arc, Mutex},
+    sync::{Arc, Mutex},
 };
 use tokio::sync::RwLockWriteGuard;
 
@@ -87,23 +87,8 @@ thread_local! {
     static RUNTIME_CONTEXT: RefCell<Option<RuntimeContext>> = const { RefCell::new(None) };
 }
 
-struct RuntimeUpdater {
-    tx: mpsc::Sender<Update>,
-}
-
-impl Updater for RuntimeUpdater {
-    fn update(&self, update: Update) {
-        self.tx.send(update).unwrap();
-    }
-}
-
-unsafe impl Send for RuntimeUpdater {}
-
-unsafe impl Sync for RuntimeUpdater {}
-
 struct RuntimeComposer {
     composer: Composer,
-    rx: mpsc::Receiver<Update>,
 }
 
 struct Runtime {
@@ -167,16 +152,11 @@ where
                 let target = composition.target.unwrap_or(entity);
 
                 let rt = world.non_send_resource_mut::<Runtime>();
-                let (tx, rx) = mpsc::channel();
 
                 rt.composers.borrow_mut().insert(
                     entity,
                     RuntimeComposer {
-                        composer: Composer::with_updater(
-                            CompositionContent { content, target },
-                            RuntimeUpdater { tx },
-                        ),
-                        rx,
+                        composer: Composer::new(CompositionContent { content, target }),
                     },
                 );
             });
@@ -237,12 +217,8 @@ fn compose(world: &mut World) {
     let rt = &mut *world.non_send_resource_mut::<Runtime>();
     let mut composers = rt.composers.borrow_mut();
     for rt_composer in composers.values_mut() {
-        while let Ok(update) = rt_composer.rx.try_recv() {
-            unsafe { update.apply() }
-        }
-
         // TODO handle composition error.
-        rt_composer.composer.compose().unwrap();
+        let _ = rt_composer.composer.try_compose();
     }
 }
 
diff --git a/src/executor.rs b/src/executor.rs
index b6716a1..fd19d3e 100644
--- a/src/executor.rs
+++ b/src/executor.rs
@@ -1,4 +1,5 @@
-use std::{future::Future, pin::Pin, rc::Rc, sync::Arc};
+use alloc::{rc::Rc, sync::Arc};
+use core::{future::Future, pin::Pin};
 
 /// Executor for async tasks.
 pub trait Executor {
diff --git a/src/lib.rs b/src/lib.rs
index a94d18e..a034710 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -96,6 +96,8 @@
 //! ```
 //!
 //! ## Features
+//! - `std`: Enables features that use Rust's standard library (default).
+//!    With this feature disabled Actuate can be used in `#![no_std]` environments.
 //! - `animation`: Enables the `animation` module for animating values from the [Bevy](https://crates.io/crates/bevy) ECS.
 //!   (enables the `ecs` feature).
 //! - `ecs`: Enables the `ecs` module for bindings to the [Bevy](https://crates.io/crates/bevy) ECS.
@@ -108,23 +110,30 @@
 #![deny(missing_docs)]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
-use composer::Runtime;
-use std::{
+extern crate alloc;
+
+use ahash::AHasher;
+use alloc::rc::Rc;
+use core::{
     any::{Any, TypeId},
     cell::{Cell, RefCell, UnsafeCell},
-    collections::HashMap,
     fmt,
     future::Future,
-    hash::{Hash, Hasher},
+    hash::{BuildHasherDefault, Hash, Hasher},
     marker::PhantomData,
     mem,
     ops::Deref,
     pin::Pin,
     ptr::NonNull,
-    rc::Rc,
 };
 use thiserror::Error;
 
+#[cfg(not(feature = "std"))]
+use hashbrown::HashMap;
+
+#[cfg(feature = "std")]
+use std::collections::HashMap;
+
 /// Prelude of commonly used items.
 pub mod prelude {
     pub use crate::{
@@ -161,6 +170,7 @@ use self::compose::{AnyCompose, Compose};
 
 /// Low-level composer.
 pub mod composer;
+use self::composer::Runtime;
 
 /// Data trait and derive macro.
 pub mod data;
@@ -328,7 +338,7 @@ impl<C: Compose> Compose for RefMap<'_, C> {
 
 /// Mapped immutable reference to a value of type `T`.
 ///
-/// This can be created with [`Ref::map`].
+/// This can be created with [`Signal::map`].
 pub struct Map<'a, T> {
     ptr: *const (),
     map_fn: *const (),
@@ -415,6 +425,13 @@ impl<T> Hash for Signal<'_, T> {
     }
 }
 
+#[derive(Clone, Copy)]
+struct UnsafeWrap<T: ?Sized>(T);
+
+unsafe impl<T: ?Sized> Send for UnsafeWrap<T> {}
+
+unsafe impl<T: ?Sized> Sync for UnsafeWrap<T> {}
+
 /// Mutable reference to a value of type `T`.
 pub struct SignalMut<'a, T> {
     /// Pointer to the boxed value.
@@ -437,27 +454,31 @@ impl<'a, T: 'static> SignalMut<'a, T> {
     }
 
     /// Queue an update to this value, triggering an update to the component owning this value.
-    pub fn update(me: Self, f: impl FnOnce(&mut T) + 'static) {
-        let is_changed = me.scope_is_changed;
+    pub fn update(me: Self, f: impl FnOnce(&mut T) + Send + 'static) {
+        let is_changed = UnsafeWrap(me.scope_is_changed);
 
         Self::with(me, move |value| {
+            let is_changed = is_changed;
             // Set this scope as changed.
             // Safety: the pointer to this scope is guranteed to outlive `me`.
-            unsafe { (*is_changed).set(true) };
+            unsafe { (*is_changed.0).set(true) };
 
             f(value)
         })
     }
 
     /// Queue an update to this value, triggering an update to the component owning this value.
-    pub fn set(me: Self, value: T) {
+    pub fn set(me: Self, value: T)
+    where
+        T: Send,
+    {
         SignalMut::update(me, |x| *x = value)
     }
 
     /// Queue an update to this value if it is not equal to the given value.
     pub fn set_if_neq(me: Self, value: T)
     where
-        T: PartialEq,
+        T: PartialEq + Send,
     {
         if *me != value {
             SignalMut::set(me, value);
@@ -465,19 +486,23 @@ impl<'a, T: 'static> SignalMut<'a, T> {
     }
 
     /// Queue an update to this value wtihout triggering an update.
-    pub fn with(me: Self, f: impl FnOnce(&mut T) + 'static) {
-        let mut cell = Some(f);
-        let mut ptr = me.ptr;
-        let generation_ptr = me.generation;
+    pub fn with(me: Self, f: impl FnOnce(&mut T) + Send + 'static) {
+        let cell = UnsafeWrap(Some(f));
+        let ptr = UnsafeWrap(me.ptr);
+        let generation_ptr = UnsafeWrap(me.generation);
 
         Runtime::current().update(move || {
+            let mut cell = cell;
+            let mut ptr = ptr;
+            let generation_ptr = generation_ptr;
+
             // Safety: Updates are guaranteed to be called before any structural changes of the composition tree.
-            let value = unsafe { ptr.as_mut() };
-            cell.take().unwrap()(value);
+            let value = unsafe { ptr.0.as_mut() };
+            cell.0.take().unwrap()(value);
 
             // Increment the generation of this value.
             // Safety: the pointer to this scope's generation is guranteed to outlive `me`.
-            let generation = unsafe { &*generation_ptr };
+            let generation = unsafe { &*generation_ptr.0 };
             generation.set(generation.get() + 1)
         });
     }
@@ -554,7 +579,7 @@ impl_pointer!(Signal, Map, SignalMut);
 /// Map of [`TypeId`] to context values.
 #[derive(Clone, Default)]
 struct Contexts {
-    values: HashMap<TypeId, Rc<dyn Any>>,
+    values: HashMap<TypeId, Rc<dyn Any>, BuildHasherDefault<AHasher>>,
 }
 
 /// Scope state of a composable function.
@@ -602,7 +627,13 @@ impl ScopeData<'_> {
 
     /// Set this scope as changed during the next re-composition.
     pub fn set_changed(&self) {
-        self.is_changed.set(true)
+        let is_changed = UnsafeWrap(&self.is_changed as *const Cell<bool>);
+
+        Runtime::current().update(move || {
+            let is_changed = is_changed;
+            let is_changed = unsafe { &*is_changed.0 };
+            is_changed.set(true);
+        });
     }
 
     /// Returns `true` if an ancestor to this scope is changed.
@@ -759,7 +790,7 @@ pub struct ContextError<T> {
 impl<T> fmt::Debug for ContextError<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_tuple("ContextError")
-            .field(&std::any::type_name::<T>())
+            .field(&core::any::type_name::<T>())
             .finish()
     }
 }
@@ -768,7 +799,7 @@ impl<T> fmt::Display for ContextError<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_str(&format!(
             "Context value not found for type: {}",
-            std::any::type_name::<T>()
+            core::any::type_name::<T>()
         ))
     }
 }
@@ -898,7 +929,8 @@ where
 pub fn use_memo<D, T>(cx: ScopeState, dependency: D, make_value: impl FnOnce() -> T) -> Signal<T>
 where
     D: Memoize,
-    T: 'static,
+    D::Value: Send,
+    T: Send + 'static,
 {
     let mut dependency_cell = Some(dependency.memoized());
 
@@ -970,7 +1002,7 @@ where
 
         let rt = Runtime::current();
         let key = rt.tasks.borrow_mut().insert(task);
-        rt.task_tx.send(key).unwrap();
+        rt.task_queue.push(key);
         key
     });
 
@@ -984,7 +1016,7 @@ type BoxedFuture = Pin<Box<dyn Future<Output = ()> + Send>>;
 
 #[cfg(feature = "executor")]
 struct TaskFuture {
-    task: std::sync::Arc<std::sync::Mutex<Option<BoxedFuture>>>,
+    task: alloc::sync::Arc<std::sync::Mutex<Option<BoxedFuture>>>,
     rt: Runtime,
 }