diff --git a/capnp-futures/Cargo.toml b/capnp-futures/Cargo.toml
index 104e0de8d..2c7f8d4b3 100644
--- a/capnp-futures/Cargo.toml
+++ b/capnp-futures/Cargo.toml
@@ -13,16 +13,16 @@ keywords = ["async"]
 
 [dependencies]
 capnp = { version = "0.23.0-alpha", path = "../capnp" }
+embedded-io-async = { version = "0.7.0", optional = true }
 
 [dependencies.futures-channel]
 version = "0.3.0"
 default-features = false
-features = ["std"]
 
 [dependencies.futures-util]
 version = "0.3.0"
 default-features = false
-features = ["io", "std"]
+features = ["io"]
 
 [dev-dependencies.futures]
 version = "0.3.0"
@@ -33,5 +33,12 @@ features = ["executor"]
 capnp = { version = "0.23.0", path = "../capnp", features = ["quickcheck"] }
 quickcheck = "1"
 
+
+[features]
+default = ["std"]
+std = ["futures-channel/std", "futures-util/std", "embedded-io-async?/std", "alloc"]
+alloc = ["futures/alloc", "embedded-io-async?/alloc"]
+embedded-io = ["dep:embedded-io-async"]
+
 [lints]
 workspace = true
diff --git a/capnp-futures/src/lib.rs b/capnp-futures/src/lib.rs
index 40caac42c..9021b0135 100644
--- a/capnp-futures/src/lib.rs
+++ b/capnp-futures/src/lib.rs
@@ -18,6 +18,11 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(feature = "alloc")]
+extern crate alloc;
+
 pub use read_stream::ReadStream;
 pub use write_queue::{write_queue, Sender};
 
diff --git a/capnp-futures/src/read_stream.rs b/capnp-futures/src/read_stream.rs
index eceece0e2..2cf75e547 100644
--- a/capnp-futures/src/read_stream.rs
+++ b/capnp-futures/src/read_stream.rs
@@ -18,9 +18,9 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-use std::future::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
+use core::future::Future;
+use core::pin::Pin;
+use core::task::{Context, Poll};
 
 use capnp::{message, Error};
 use futures_util::stream::Stream;
diff --git a/capnp-futures/src/serialize.rs b/capnp-futures/src/serialize.rs
index 96d94ae74..4f6755b8a 100644
--- a/capnp-futures/src/serialize.rs
+++ b/capnp-futures/src/serialize.rs
@@ -178,7 +178,7 @@ where
     }
 }
 
-impl<A> AsOutputSegments for ::std::rc::Rc<message::Builder<A>>
+impl<A> AsOutputSegments for ::alloc::rc::Rc<message::Builder<A>>
 where
     A: message::Allocator,
 {
@@ -187,7 +187,7 @@ where
     }
 }
 
-impl<A> AsOutputSegments for ::std::sync::Arc<message::Builder<A>>
+impl<A> AsOutputSegments for ::alloc::sync::Arc<message::Builder<A>>
 where
     A: message::Allocator,
 {
@@ -238,7 +238,7 @@ where
                 buf[(idx - 1) * 4..idx * 4]
                     .copy_from_slice(&((segments[idx].len() / 8) as u32).to_le_bytes());
             }
-            if segment_count % 2 == 0 {
+            if segment_count.is_multiple_of(2) {
                 for idx in (buf.len() - 4)..(buf.len()) {
                     buf[idx] = 0
                 }
diff --git a/capnp-futures/src/serialize_packed.rs b/capnp-futures/src/serialize_packed.rs
index b50179fde..30b78d582 100644
--- a/capnp-futures/src/serialize_packed.rs
+++ b/capnp-futures/src/serialize_packed.rs
@@ -22,8 +22,8 @@
 //! Asynchronous reading and writing of messages using the
 //! [packed stream encoding](https://capnproto.org/encoding.html#packing).
 
-use std::pin::Pin;
-use std::task::{Context, Poll};
+use core::pin::Pin;
+use core::task::{Context, Poll};
 
 use capnp::serialize::OwnedSegments;
 use capnp::{message, Result};
@@ -82,9 +82,9 @@ where
 {
     fn poll_read(
         mut self: Pin<&mut Self>,
-        cx: &mut std::task::Context<'_>,
+        cx: &mut core::task::Context<'_>,
         outbuf: &mut [u8],
-    ) -> Poll<std::result::Result<usize, std::io::Error>> {
+    ) -> Poll<core::result::Result<usize, std::io::Error>> {
         let Self {
             stage,
             inner,
@@ -129,7 +129,7 @@ where
                     }
                 }
                 PackedReadStage::WritingZeroes => {
-                    let num_zeroes = std::cmp::min(outbuf.len(), *num_run_bytes_remaining);
+                    let num_zeroes = core::cmp::min(outbuf.len(), *num_run_bytes_remaining);
 
                     for value in outbuf.iter_mut().take(num_zeroes) {
                         *value = 0;
@@ -186,7 +186,7 @@ where
                     return Poll::Ready(Ok(ii));
                 }
                 PackedReadStage::WritingPassthrough => {
-                    let upper_bound = std::cmp::min(*num_run_bytes_remaining, outbuf.len());
+                    let upper_bound = core::cmp::min(*num_run_bytes_remaining, outbuf.len());
                     if upper_bound == 0 {
                         *stage = PackedReadStage::Start;
                     } else {
@@ -281,11 +281,11 @@ where
     }
 }
 
-impl<W> std::future::Future for FinishPendingWrites<W>
+impl<W> core::future::Future for FinishPendingWrites<W>
 where
     W: AsyncWrite + Unpin,
 {
-    type Output = std::result::Result<(), capnp::Error>;
+    type Output = core::result::Result<(), capnp::Error>;
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
         match self.inner.finish_pending_writes(cx)? {
             Poll::Ready(()) => Poll::Ready(Ok(())),
@@ -332,7 +332,7 @@ where
         &mut self,
         cx: &mut Context<'_>,
         mut inbuf: &[u8],
-    ) -> Poll<std::result::Result<usize, std::io::Error>> {
+    ) -> Poll<core::result::Result<usize, std::io::Error>> {
         let mut inbuf_bytes_consumed: usize = 0;
         let Self {
             stage,
@@ -352,7 +352,7 @@ where
 
                     // copy inbuf into buf
                     let buf_bytes_remaining = 8 - *buf_pos;
-                    let bytes_to_copy = std::cmp::min(buf_bytes_remaining, inbuf.len());
+                    let bytes_to_copy = core::cmp::min(buf_bytes_remaining, inbuf.len());
                     buf[*buf_pos..(*buf_pos + bytes_to_copy)]
                         .copy_from_slice(&inbuf[..bytes_to_copy]);
                     inbuf = &inbuf[bytes_to_copy..];
@@ -488,7 +488,7 @@ where
     fn finish_pending_writes(
         &mut self,
         cx: &mut Context<'_>,
-    ) -> Poll<std::result::Result<(), std::io::Error>> {
+    ) -> Poll<core::result::Result<(), std::io::Error>> {
         while self.stage == PackedWriteStage::WriteWord
             || self.stage == PackedWriteStage::WriteRunWordCount
         {
@@ -509,14 +509,14 @@ where
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
         inbuf: &[u8],
-    ) -> Poll<std::result::Result<usize, std::io::Error>> {
+    ) -> Poll<core::result::Result<usize, std::io::Error>> {
         (*self).poll_write_aux(cx, inbuf)
     }
 
     fn poll_flush(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<std::result::Result<(), std::io::Error>> {
+    ) -> Poll<core::result::Result<(), std::io::Error>> {
         match (*self).finish_pending_writes(cx)? {
             Poll::Pending => return Poll::Pending,
             Poll::Ready(_) => (),
@@ -528,7 +528,7 @@ where
     fn poll_close(
         mut self: Pin<&mut Self>,
         cx: &mut Context<'_>,
-    ) -> Poll<std::result::Result<(), std::io::Error>> {
+    ) -> Poll<core::result::Result<(), std::io::Error>> {
         Pin::new(&mut self.inner).poll_close(cx)
     }
 }
diff --git a/capnp-futures/src/write_queue.rs b/capnp-futures/src/write_queue.rs
index 65ad1afa9..90f93459f 100644
--- a/capnp-futures/src/write_queue.rs
+++ b/capnp-futures/src/write_queue.rs
@@ -18,7 +18,7 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-use std::future::Future;
+use core::future::Future;
 
 use futures_channel::oneshot;
 use futures_util::{AsyncWrite, AsyncWriteExt, StreamExt, TryFutureExt};
@@ -41,7 +41,7 @@ where
     M: AsOutputSegments,
 {
     sender: futures_channel::mpsc::UnboundedSender<Item<M>>,
-    in_flight: std::sync::Arc<std::sync::atomic::AtomicI32>,
+    in_flight: alloc::sync::Arc<core::sync::atomic::AtomicI32>,
 }
 
 impl<M> Clone for Sender<M>
@@ -69,7 +69,7 @@ where
 {
     let (tx, mut rx) = futures_channel::mpsc::unbounded::<Item<M>>();
 
-    let in_flight = std::sync::Arc::new(std::sync::atomic::AtomicI32::new(0));
+    let in_flight = alloc::sync::Arc::new(core::sync::atomic::AtomicI32::new(0));
 
     let sender = Sender {
         sender: tx,
@@ -81,7 +81,7 @@ where
             match item {
                 Item::Message(m, returner) => {
                     let result = crate::serialize::write_message(&mut writer, &m).await;
-                    in_flight.fetch_sub(1, std::sync::atomic::Ordering::SeqCst);
+                    in_flight.fetch_sub(1, core::sync::atomic::Ordering::SeqCst);
                     result?;
                     writer.flush().await?;
                     let _ = returner.send(m);
@@ -123,7 +123,7 @@ where
     /// has completed. Dropping the returned future does *not* cancel the write.
     pub fn send(&mut self, message: M) -> impl Future<Output = Result<M, Error>> + Unpin {
         self.in_flight
-            .fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+            .fetch_add(1, core::sync::atomic::Ordering::SeqCst);
         let (complete, oneshot) = oneshot::channel();
 
         let _ = self.sender.unbounded_send(Item::Message(message, complete));
@@ -133,7 +133,7 @@ where
 
     /// Returns the number of messages queued to be written.
     pub fn len(&self) -> usize {
-        let result = self.in_flight.load(std::sync::atomic::Ordering::SeqCst);
+        let result = self.in_flight.load(core::sync::atomic::Ordering::SeqCst);
         assert!(result >= 0);
         result as usize
     }
diff --git a/capnp-rpc/Cargo.toml b/capnp-rpc/Cargo.toml
index 63acd4551..70ba605f8 100644
--- a/capnp-rpc/Cargo.toml
+++ b/capnp-rpc/Cargo.toml
@@ -16,11 +16,17 @@ readme = "README.md"
 [dependencies.futures]
 version = "0.3.0"
 default-features = false
-features = ["std"]
 
 [dependencies]
-capnp-futures = { version = "0.23.0", path = "../capnp-futures" }
+capnp-futures = { version = "0.23.0", path = "../capnp-futures", default-features = false }
 capnp = {version = "0.23.0", path = "../capnp"}
+embedded-io-async = { version = "0.7.0", optional = true }
+
+[features]
+default = ["std"]
+std = ["futures/std", "embedded-io-async?/std", "capnp-futures/std", "alloc"]
+alloc = ["futures/alloc", "embedded-io-async?/alloc", "capnp-futures/alloc"]
+embedded-io = ["dep:embedded-io-async"]
 
 #[lints]
 #workspace = true
diff --git a/capnp-rpc/src/attach.rs b/capnp-rpc/src/attach.rs
index 4a392e561..540371abf 100644
--- a/capnp-rpc/src/attach.rs
+++ b/capnp-rpc/src/attach.rs
@@ -18,9 +18,9 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+use core::pin::Pin;
+use core::task::{Context, Poll};
 use futures::Future;
-use std::pin::Pin;
-use std::task::{Context, Poll};
 
 pub struct AttachFuture<F, T>
 where
diff --git a/capnp-rpc/src/broken.rs b/capnp-rpc/src/broken.rs
index c6dbbd98b..a1e6b2bc9 100644
--- a/capnp-rpc/src/broken.rs
+++ b/capnp-rpc/src/broken.rs
@@ -19,6 +19,8 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+use alloc::boxed::Box;
+use alloc::vec::Vec;
 use capnp::any_pointer;
 use capnp::private::capability::{
     ClientHook, ParamsHook, PipelineHook, PipelineOp, RequestHook, ResultsHook,
@@ -28,7 +30,7 @@ use capnp::Error;
 use capnp::capability::{Promise, RemotePromise};
 use capnp::traits::ImbueMut;
 
-use std::rc::Rc;
+use alloc::rc::Rc;
 
 pub struct Pipeline {
     error: Error,
diff --git a/capnp-rpc/src/flow_control.rs b/capnp-rpc/src/flow_control.rs
index afbe3cbf7..7b703c1cc 100644
--- a/capnp-rpc/src/flow_control.rs
+++ b/capnp-rpc/src/flow_control.rs
@@ -1,10 +1,10 @@
 use capnp::capability::Promise;
 use capnp::Error;
 
+use alloc::{boxed::Box, rc::Rc, vec, vec::Vec};
+use core::cell::RefCell;
 use futures::channel::oneshot;
 use futures::TryFutureExt;
-use std::cell::RefCell;
-use std::rc::Rc;
 
 use crate::task_set::{TaskReaper, TaskSet, TaskSetHandle};
 
@@ -47,7 +47,7 @@ impl TaskReaper<Error> for Reaper {
     fn task_failed(&mut self, error: Error) {
         let mut inner = self.inner.borrow_mut();
         if let State::Running(ref mut blocked_sends) = &mut inner.state {
-            for s in std::mem::take(blocked_sends) {
+            for s in core::mem::take(blocked_sends) {
                 let _ = s.send(Err(error.clone()));
             }
             inner.state = State::Failed(error)
@@ -99,7 +99,7 @@ impl crate::FlowController for FixedWindowFlowController {
             match inner.state {
                 State::Running(ref mut blocked_sends) => {
                     if is_ready {
-                        for s in std::mem::take(blocked_sends) {
+                        for s in core::mem::take(blocked_sends) {
                             let _ = s.send(Ok(()));
                         }
                     }
diff --git a/capnp-rpc/src/lib.rs b/capnp-rpc/src/lib.rs
index b3cb32c2b..79f789c56 100644
--- a/capnp-rpc/src/lib.rs
+++ b/capnp-rpc/src/lib.rs
@@ -58,15 +58,24 @@
 //!
 //! For a more complete example, see <https://github.com/capnproto/capnproto-rust/tree/master/capnp-rpc/examples/calculator>
 
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(feature = "alloc")]
+extern crate alloc;
+
+use alloc::boxed::Box;
+use alloc::format;
+use alloc::rc::{Rc, Weak};
+use alloc::string::ToString;
+use alloc::vec::Vec;
 use capnp::capability::Promise;
 use capnp::private::capability::ClientHook;
 use capnp::Error;
+use core::cell::RefCell;
+use core::pin::Pin;
+use core::task::{Context, Poll};
 use futures::channel::oneshot;
 use futures::{Future, FutureExt, TryFutureExt};
-use std::cell::RefCell;
-use std::pin::Pin;
-use std::rc::{Rc, Weak};
-use std::task::{Context, Poll};
 
 pub use crate::rpc::Disconnector;
 use crate::task_set::TaskSet;
@@ -402,8 +411,11 @@ pub struct CapabilityServerSet<S, C>
 where
     C: capnp::capability::FromServer<S>,
 {
+    #[cfg(feature = "std")]
     caps: std::collections::HashMap<usize, Weak<S>>,
-    marker: std::marker::PhantomData<C>,
+    #[cfg(not(feature = "std"))]
+    caps: alloc::collections::BTreeMap<usize, Weak<S>>,
+    marker: core::marker::PhantomData<C>,
 }
 
 impl<S, C> Default for CapabilityServerSet<S, C>
@@ -412,8 +424,8 @@ where
 {
     fn default() -> Self {
         Self {
-            caps: std::default::Default::default(),
-            marker: std::marker::PhantomData,
+            caps: core::default::Default::default(),
+            marker: core::marker::PhantomData,
         }
     }
 }
@@ -501,7 +513,16 @@ where
 struct SystemTaskReaper;
 impl crate::task_set::TaskReaper<Error> for SystemTaskReaper {
     fn task_failed(&mut self, error: Error) {
-        println!("ERROR: {error}");
+        #[cfg(feature = "std")]
+        {
+            println!("ERROR: {error}");
+        }
+
+        #[cfg(not(feature = "std"))]
+        {
+            // In no_std environments we can't print the error, so just do nothing.
+            drop(error);
+        }
     }
 }
 
diff --git a/capnp-rpc/src/local.rs b/capnp-rpc/src/local.rs
index 18a864c3d..2fb87e45c 100644
--- a/capnp-rpc/src/local.rs
+++ b/capnp-rpc/src/local.rs
@@ -18,6 +18,8 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+use alloc::boxed::Box;
+use alloc::{vec, vec::Vec};
 use capnp::capability::{self, Promise};
 use capnp::private::capability::{
     ClientHook, ParamsHook, PipelineHook, PipelineOp, RequestHook, ResponseHook, ResultsHook,
@@ -29,8 +31,8 @@ use capnp::{any_pointer, message};
 use futures::channel::oneshot;
 use futures::TryFutureExt;
 
-use std::cell::RefCell;
-use std::rc::Rc;
+use alloc::rc::Rc;
+use core::cell::RefCell;
 
 pub trait ResultsDoneHook {
     fn add_ref(&self) -> Box<dyn ResultsDoneHook>;
@@ -107,7 +109,7 @@ impl Drop for Results {
         if let (Some(message), Some(fulfiller)) =
             (self.message.take(), self.results_done_fulfiller.take())
         {
-            let cap_table = ::std::mem::take(&mut self.cap_table);
+            let cap_table = ::core::mem::take(&mut self.cap_table);
             let _ = fulfiller.send(Box::new(ResultsDone::new(message, cap_table)));
         } else {
             unreachable!()
diff --git a/capnp-rpc/src/queued.rs b/capnp-rpc/src/queued.rs
index 506becc8f..a7924cee4 100644
--- a/capnp-rpc/src/queued.rs
+++ b/capnp-rpc/src/queued.rs
@@ -19,6 +19,8 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+use alloc::boxed::Box;
+use alloc::vec::Vec;
 use capnp::any_pointer;
 use capnp::capability::Promise;
 use capnp::private::capability::{ClientHook, ParamsHook, PipelineHook, PipelineOp, ResultsHook};
@@ -26,8 +28,8 @@ use capnp::Error;
 
 use futures::{Future, FutureExt, TryFutureExt};
 
-use std::cell::RefCell;
-use std::rc::{Rc, Weak};
+use alloc::rc::{Rc, Weak};
+use core::cell::RefCell;
 
 use crate::attach::Attach;
 use crate::sender_queue::SenderQueue;
diff --git a/capnp-rpc/src/reconnect.rs b/capnp-rpc/src/reconnect.rs
index 8f4b03cda..6819d0e03 100644
--- a/capnp-rpc/src/reconnect.rs
+++ b/capnp-rpc/src/reconnect.rs
@@ -1,6 +1,7 @@
-use std::cell::RefCell;
-use std::marker::PhantomData;
-use std::rc::Rc;
+use alloc::boxed::Box;
+use alloc::rc::Rc;
+use core::cell::RefCell;
+use core::marker::PhantomData;
 
 use capnp::capability::{FromClientHook, Promise};
 use capnp::private::capability::{ClientHook, RequestHook};
diff --git a/capnp-rpc/src/rpc.rs b/capnp-rpc/src/rpc.rs
index 4214b85ae..adf8fbe2f 100644
--- a/capnp-rpc/src/rpc.rs
+++ b/capnp-rpc/src/rpc.rs
@@ -19,9 +19,14 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-use std::pin::Pin;
-use std::task::{Context, Poll};
-
+use core::pin::Pin;
+use core::task::{Context, Poll};
+
+use alloc::borrow::ToOwned;
+use alloc::boxed::Box;
+use alloc::string::ToString;
+use alloc::vec::Vec;
+use alloc::{format, vec};
 use capnp::any_pointer;
 use capnp::capability::Promise;
 use capnp::private::capability::{
@@ -32,12 +37,17 @@ use capnp::Error;
 use futures::channel::oneshot;
 use futures::{future, Future, FutureExt, TryFutureExt};
 
-use std::cell::{Cell, RefCell};
-use std::cmp::Reverse;
-use std::collections::binary_heap::BinaryHeap;
-use std::collections::hash_map::{self, HashMap};
-use std::mem;
-use std::rc::{Rc, Weak};
+use alloc::collections::binary_heap::BinaryHeap;
+use alloc::rc::{Rc, Weak};
+use core::cell::{Cell, RefCell};
+use core::cmp::Reverse;
+use core::mem;
+
+#[cfg(feature = "std")]
+use std::collections::hash_map::{Entry, HashMap};
+
+#[cfg(not(feature = "std"))]
+use alloc::collections::{btree_map::Entry, BTreeMap as HashMap};
 
 use crate::attach::Attach;
 use crate::local::ResultsDoneHook;
@@ -80,7 +90,7 @@ where
     idx: usize,
 }
 
-impl<'a, T> ::std::iter::Iterator for ExportTableIter<'a, T>
+impl<'a, T> ::core::iter::Iterator for ExportTableIter<'a, T>
 where
     T: 'a,
 {
@@ -441,7 +451,7 @@ where
     embargoes: RefCell<ExportTable<Embargo>>,
 
     tasks: RefCell<Option<crate::task_set::TaskSetHandle<capnp::Error>>>,
-    connection: RefCell<::std::result::Result<Box<dyn crate::Connection<VatId>>, ::capnp::Error>>,
+    connection: RefCell<::core::result::Result<Box<dyn crate::Connection<VatId>>, ::capnp::Error>>,
     disconnect_fulfiller: RefCell<Option<oneshot::Sender<Promise<(), Error>>>>,
 
     client_downcast_map: RefCell<HashMap<usize, WeakClient<VatId>>>,
@@ -774,7 +784,7 @@ impl<VatId> ConnectionState<VatId> {
         };
 
         let slots = &mut connection_state.answers.borrow_mut().slots;
-        let hash_map::Entry::Vacant(slot) = slots.entry(answer_id) else {
+        let Entry::Vacant(slot) = slots.entry(answer_id) else {
             connection_state.release_exports(&result_exports)?;
             return Err(Error::failed("questionId is already in use".to_string()));
         };
@@ -796,18 +806,18 @@ impl<VatId> ConnectionState<VatId> {
 
         let answers_slots = &mut connection_state.answers.borrow_mut().slots;
         match answers_slots.entry(answer_id) {
-            hash_map::Entry::Vacant(_) => {
+            Entry::Vacant(_) => {
                 // The `Finish` message targets a question ID that isn't present in our answer table.
                 // Probably, we sent a `Return` with `noFinishNeeded = true`, but the other side didn't
                 // recognize this hint and sent a `Finish` anyway, or the `Finish` was already in-flight at
                 // the time we sent the `Return`. We can silently ignore this.
             }
-            hash_map::Entry::Occupied(mut entry) => {
+            Entry::Occupied(mut entry) => {
                 let answer = entry.get_mut();
                 answer.received_finish.set(true);
 
                 if finish.get_release_result_caps() {
-                    exports_to_release = ::std::mem::take(&mut answer.result_exports);
+                    exports_to_release = ::core::mem::take(&mut answer.result_exports);
                 }
 
                 // If the pipeline has not been cloned, the following two lines cancel the call.
@@ -1015,7 +1025,7 @@ impl<VatId> ConnectionState<VatId> {
 
                 {
                     let slots = &mut connection_state.answers.borrow_mut().slots;
-                    let hash_map::Entry::Vacant(slot) = slots.entry(question_id) else {
+                    let Entry::Vacant(slot) = slots.entry(question_id) else {
                         return Err(Error::failed("questionId is already in use".to_string()));
                     };
                     slot.insert(answer);
@@ -1174,7 +1184,7 @@ impl<VatId> ConnectionState<VatId> {
 
     fn answer_has_sent_return(&self, id: AnswerId, result_exports: Vec<ExportId>) {
         let answers_slots = &mut self.answers.borrow_mut().slots;
-        let hash_map::Entry::Occupied(mut entry) = answers_slots.entry(id) else {
+        let Entry::Occupied(mut entry) = answers_slots.entry(id) else {
             unreachable!()
         };
         let a = entry.get_mut();
@@ -1359,8 +1369,8 @@ impl<VatId> ConnectionState<VatId> {
 
                             let replacement_export_id =
                                 match exports_by_cap.entry(exp.client_hook.get_ptr()) {
-                                    hash_map::Entry::Occupied(occ) => *occ.get(),
-                                    hash_map::Entry::Vacant(vac) => {
+                                    Entry::Occupied(occ) => *occ.get(),
+                                    Entry::Vacant(vac) => {
                                         // The replacement capability isn't previously exported,
                                         // so assign it to the existing table entry.
                                         vac.insert(export_id);
@@ -1498,12 +1508,12 @@ impl<VatId> ConnectionState<VatId> {
     fn import(state: &Rc<Self>, import_id: ImportId, is_promise: bool) -> Box<dyn ClientHook> {
         let import_client = {
             match state.imports.borrow_mut().slots.entry(import_id) {
-                hash_map::Entry::Occupied(occ) => occ
+                Entry::Occupied(occ) => occ
                     .get()
                     .import_client
                     .upgrade()
                     .expect("dangling ref to import client?"),
-                hash_map::Entry::Vacant(v) => {
+                Entry::Vacant(v) => {
                     let import_client = ImportClient::new(state, import_id);
                     v.insert(Import::new(&import_client));
                     import_client
diff --git a/capnp-rpc/src/sender_queue.rs b/capnp-rpc/src/sender_queue.rs
index a45cacc29..53ed1c4b6 100644
--- a/capnp-rpc/src/sender_queue.rs
+++ b/capnp-rpc/src/sender_queue.rs
@@ -22,13 +22,13 @@
 use futures::channel::oneshot;
 use futures::{FutureExt, TryFutureExt};
 
-use std::cell::RefCell;
-use std::rc::{Rc, Weak};
+use alloc::rc::{Rc, Weak};
+use core::cell::RefCell;
 
 use capnp::capability::Promise;
 use capnp::Error;
 
-use std::collections::BTreeMap;
+use alloc::collections::BTreeMap;
 
 struct Inner<In, Out>
 where
@@ -133,7 +133,7 @@ where
             ..
         } = *self.inner.borrow_mut();
         *next_id = 0;
-        let map = ::std::mem::take(map);
+        let map = ::core::mem::take(map);
         Drain {
             iter: map.into_iter(),
         }
@@ -145,10 +145,10 @@ where
     In: 'static,
     Out: 'static,
 {
-    iter: ::std::collections::btree_map::IntoIter<u64, (In, oneshot::Sender<Out>)>,
+    iter: ::alloc::collections::btree_map::IntoIter<u64, (In, oneshot::Sender<Out>)>,
 }
 
-impl<In, Out> ::std::iter::Iterator for Drain<In, Out>
+impl<In, Out> ::core::iter::Iterator for Drain<In, Out>
 where
     In: 'static,
     Out: 'static,
diff --git a/capnp-rpc/src/split.rs b/capnp-rpc/src/split.rs
index 69f851d5e..d39316a1c 100644
--- a/capnp-rpc/src/split.rs
+++ b/capnp-rpc/src/split.rs
@@ -21,8 +21,8 @@
 
 use futures::{Future, FutureExt};
 
-use std::cell::RefCell;
-use std::rc::Rc;
+use alloc::rc::Rc;
+use core::cell::RefCell;
 
 pub fn split<F, T1, T2, E>(
     f: F,
diff --git a/capnp-rpc/src/task_set.rs b/capnp-rpc/src/task_set.rs
index ef8b11490..578473f86 100644
--- a/capnp-rpc/src/task_set.rs
+++ b/capnp-rpc/src/task_set.rs
@@ -18,14 +18,16 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+use alloc::boxed::Box;
+use alloc::{vec, vec::Vec};
+use core::pin::Pin;
+use core::task::{Context, Poll};
 use futures::channel::{mpsc, oneshot};
 use futures::stream::FuturesUnordered;
 use futures::{Future, FutureExt, Stream};
-use std::pin::Pin;
-use std::task::{Context, Poll};
 
-use std::cell::RefCell;
-use std::rc::Rc;
+use alloc::rc::Rc;
+use core::cell::RefCell;
 
 enum EnqueuedTask<E> {
     Task(Pin<Box<dyn Future<Output = Result<(), E>>>>),
@@ -74,7 +76,7 @@ where
     pub fn new(reaper: Box<dyn TaskReaper<E>>) -> (TaskSetHandle<E>, Self)
     where
         E: 'static,
-        E: ::std::fmt::Debug,
+        E: ::core::fmt::Debug,
     {
         let (sender, receiver) = mpsc::unbounded();
 
@@ -98,7 +100,7 @@ where
     fn update_on_empty_fulfillers(&mut self) {
         // There is always the one pending() future that we added in `new()`.
         if self.in_progress.len() <= 1 {
-            for f in std::mem::take(&mut self.on_empty_fulfillers) {
+            for f in core::mem::take(&mut self.on_empty_fulfillers) {
                 let _ = f.send(());
             }
         }
diff --git a/capnp-rpc/src/twoparty.rs b/capnp-rpc/src/twoparty.rs
index d14ad93ef..e3df41201 100644
--- a/capnp-rpc/src/twoparty.rs
+++ b/capnp-rpc/src/twoparty.rs
@@ -22,13 +22,26 @@
 //! An implementation of [`VatNetwork`](crate::VatNetwork) for the common case
 //! of a client-server connection.
 
+use alloc::boxed::Box;
+use alloc::string::ToString;
 use capnp::capability::Promise;
 use capnp::message::ReaderOptions;
 use futures::channel::oneshot;
-use futures::{AsyncRead, AsyncWrite, FutureExt, TryFutureExt};
+use futures::{FutureExt, TryFutureExt};
+#[cfg(not(feature = "embedded-io"))]
+use futures::AsyncWrite;
+#[cfg(not(feature = "embedded-io"))]
+use futures::AsyncRead;
 
-use std::cell::RefCell;
-use std::rc::{Rc, Weak};
+#[cfg(feature = "embedded-io")]
+use embedded_io_async::Write as AsyncWrite;
+
+#[cfg(feature = "embedded-io")]
+use embedded_io_async::Read as AsyncRead;
+
+
+use alloc::rc::{Rc, Weak};
+use core::cell::RefCell;
 
 pub type VatId = crate::rpc_twoparty_capnp::Side;