diff --git a/capnp/Cargo.toml b/capnp/Cargo.toml
index dc8bc965e..2905ea961 100644
--- a/capnp/Cargo.toml
+++ b/capnp/Cargo.toml
@@ -20,13 +20,16 @@ path = "src/lib.rs"
 
 [dependencies]
 quickcheck = { version = "0.2", optional = true }
+core_io = { version = "0.1.20190701", features = [ "alloc", "collections" ], optional = true }
 
 [dev-dependencies]
 quickcheck = "0.2"
 
 [features]
+no_std = ["core_io"]
 rpc = ["futures"]
 rpc_try = []
+default = []
 
 [dependencies.futures]
 version = "0.1"
diff --git a/capnp/src/any_pointer.rs b/capnp/src/any_pointer.rs
index 365fde975..aeecb3368 100644
--- a/capnp/src/any_pointer.rs
+++ b/capnp/src/any_pointer.rs
@@ -21,6 +21,9 @@
 
 //! Dynamically typed value.
 
+#[cfg(feature = "no_std")]
+use crate::io::prelude::*;
+
 use crate::capability::FromClientHook;
 use crate::private::capability::{ClientHook, PipelineHook, PipelineOp};
 use crate::private::layout::{PointerReader, PointerBuilder};
diff --git a/capnp/src/any_pointer_list.rs b/capnp/src/any_pointer_list.rs
index 683494408..1dd6f796d 100644
--- a/capnp/src/any_pointer_list.rs
+++ b/capnp/src/any_pointer_list.rs
@@ -23,6 +23,7 @@
 //! Note: this cannot be used for a list of structs, since such lists are not encoded
 //! as pointer lists.
 
+use core;
 use crate::traits::{FromPointerReader, FromPointerBuilder, ListIter, IndexMove};
 use crate::private::layout::{ListReader, ListBuilder, PointerReader, PointerBuilder, Pointer};
 use crate::Result;
@@ -124,7 +125,7 @@ impl <'a> crate::traits::SetPointerBuilder<Builder<'a>> for Reader<'a> {
     }
 }
 
-impl <'a> ::std::iter::IntoIterator for Reader<'a> {
+impl <'a> core::iter::IntoIterator for Reader<'a> {
     type Item = Result<crate::any_pointer::Reader<'a>>;
     type IntoIter = ListIter<Reader<'a>, Self::Item>;
 
diff --git a/capnp/src/capability.rs b/capnp/src/capability.rs
index adef7ffe2..7e4324940 100644
--- a/capnp/src/capability.rs
+++ b/capnp/src/capability.rs
@@ -23,6 +23,10 @@
 //!
 //! Roughly corresponds to capability.h in the C++ implementation.
 
+#[cfg(feature = "no_std")]
+use crate::io::prelude::*;
+use core::marker::PhantomData;
+
 use crate::{any_pointer, Error, MessageSize};
 use crate::traits::{Pipelined, Owned};
 use crate::private::capability::{ClientHook, ParamsHook, RequestHook, ResponseHook, ResultsHook};
@@ -32,8 +36,6 @@ use futures::Future;
 #[cfg(feature = "rpc_try")]
 use std::ops::Try;
 
-use std::marker::PhantomData;
-
 /// A computation that might eventually resolve to a value of type `T` or to an error
 ///  of type `E`. Dropping the promise cancels the computation.
 #[must_use = "futures do nothing unless polled"]
diff --git a/capnp/src/capability_list.rs b/capnp/src/capability_list.rs
index e82eed3af..31c8013c8 100644
--- a/capnp/src/capability_list.rs
+++ b/capnp/src/capability_list.rs
@@ -20,7 +20,9 @@
 
 //! List of capabilities.
 
-use std::marker::PhantomData;
+#[cfg(feature = "no_std")]
+use crate::io::prelude::*;
+use core::{self, marker::PhantomData};
 
 use crate::capability::{FromClientHook};
 use crate::private::capability::ClientHook;
@@ -152,7 +154,7 @@ impl <'a, T> crate::traits::SetPointerBuilder<Builder<'a, T>> for Reader<'a, T>
     }
 }
 
-impl <'a, T> ::std::iter::IntoIterator for Reader<'a, T>
+impl <'a, T> core::iter::IntoIterator for Reader<'a, T>
     where T: FromClientHook
 {
     type Item = Result<T>;
diff --git a/capnp/src/constant.rs b/capnp/src/constant.rs
index 44369a17c..cbd5e2dd5 100644
--- a/capnp/src/constant.rs
+++ b/capnp/src/constant.rs
@@ -23,8 +23,7 @@
 //! `constant::Reader` does not do bounds-checking, so it is unsafe to
 //! manually construct one of these.
 
-use std::marker::PhantomData;
-
+use core::marker::PhantomData;
 use crate::any_pointer;
 use crate::private::layout::PointerReader;
 use crate::traits::Owned;
diff --git a/capnp/src/data.rs b/capnp/src/data.rs
index d19f6f490..ec1679700 100644
--- a/capnp/src/data.rs
+++ b/capnp/src/data.rs
@@ -21,6 +21,7 @@
 
 //! Sequence of bytes.
 
+use core;
 use crate::private::layout::{PointerBuilder, PointerReader};
 use crate::Result;
 
@@ -35,7 +36,7 @@ impl<'a> crate::traits::Owned<'a> for Owned {
 pub type Reader<'a> = &'a [u8];
 
 pub fn new_reader<'a>(p : *const u8, len : u32) -> Reader<'a> {
-    unsafe { ::std::slice::from_raw_parts(p, len as usize) }
+    unsafe { core::slice::from_raw_parts(p, len as usize) }
 }
 
 impl <'a> crate::traits::FromPointerReader<'a> for Reader<'a> {
@@ -47,7 +48,7 @@ impl <'a> crate::traits::FromPointerReader<'a> for Reader<'a> {
 pub type Builder<'a> = &'a mut [u8];
 
 pub fn new_builder<'a>(p : *mut u8, len : u32) -> Builder<'a> {
-    unsafe { ::std::slice::from_raw_parts_mut(p, len as usize) }
+    unsafe { core::slice::from_raw_parts_mut(p, len as usize) }
 }
 
 impl <'a> crate::traits::FromPointerBuilder<'a> for Builder<'a> {
diff --git a/capnp/src/data_list.rs b/capnp/src/data_list.rs
index 785657e0c..d23a18e51 100644
--- a/capnp/src/data_list.rs
+++ b/capnp/src/data_list.rs
@@ -21,6 +21,7 @@
 
 //! List of sequences of bytes.
 
+use core;
 use crate::traits::{FromPointerReader, FromPointerBuilder, IndexMove, ListIter};
 use crate::private::layout::*;
 use crate::Result;
@@ -133,7 +134,7 @@ impl <'a> crate::traits::SetPointerBuilder<Builder<'a>> for Reader<'a> {
     }
 }
 
-impl <'a> ::std::iter::IntoIterator for Reader<'a> {
+impl <'a> core::iter::IntoIterator for Reader<'a> {
     type Item = Result<crate::data::Reader<'a>>;
     type IntoIter = ListIter<Reader<'a>, Self::Item>;
 
diff --git a/capnp/src/enum_list.rs b/capnp/src/enum_list.rs
index c5e8f2d85..4da244aa3 100644
--- a/capnp/src/enum_list.rs
+++ b/capnp/src/enum_list.rs
@@ -21,14 +21,14 @@
 
 //! List of enums.
 
+use core::{self, marker::PhantomData};
+
 use crate::traits::{FromPointerReader, FromPointerBuilder,
                     ToU16, FromU16, ListIter, IndexMove};
 use crate::private::layout::{ListReader, ListBuilder, PointerReader, PointerBuilder,
                              TwoBytes, PrimitiveElement};
 use crate::{NotInSchema, Result};
 
-use std::marker::PhantomData;
-
 #[derive(Clone, Copy)]
 pub struct Owned<T> {
     marker: PhantomData<T>,
@@ -52,7 +52,7 @@ impl <'a, T: FromU16> Reader<'a, T> {
 
     pub fn len(&self) -> u32 { self.reader.len() }
 
-    pub fn iter(self) -> ListIter<Reader<'a, T>, ::std::result::Result<T, NotInSchema>>{
+    pub fn iter(self) -> ListIter<Reader<'a, T>, core::result::Result<T, NotInSchema>>{
         let l = self.len();
         ListIter::new(self, l)
     }
@@ -65,14 +65,14 @@ impl <'a, T : FromU16> FromPointerReader<'a> for Reader<'a, T> {
     }
 }
 
-impl <'a, T: FromU16>  IndexMove<u32, ::std::result::Result<T, NotInSchema>> for Reader<'a, T>{
-    fn index_move(&self, index: u32) -> ::std::result::Result<T, NotInSchema> {
+impl <'a, T: FromU16>  IndexMove<u32, core::result::Result<T, NotInSchema>> for Reader<'a, T>{
+    fn index_move(&self, index: u32) -> core::result::Result<T, NotInSchema> {
         self.get(index)
     }
 }
 
 impl <'a, T : FromU16> Reader<'a, T> {
-    pub fn get(&self, index: u32) -> ::std::result::Result<T, NotInSchema> {
+    pub fn get(&self, index: u32) -> core::result::Result<T, NotInSchema> {
         assert!(index < self.len());
         let result: u16 = PrimitiveElement::get(&self.reader, index);
         FromU16::from_u16(result)
@@ -119,7 +119,7 @@ impl <'a, T : FromU16> FromPointerBuilder<'a> for Builder<'a, T> {
 }
 
 impl <'a, T : ToU16 + FromU16>  Builder<'a, T> {
-    pub fn get(&self, index: u32) -> ::std::result::Result<T, NotInSchema> {
+    pub fn get(&self, index: u32) -> core::result::Result<T, NotInSchema> {
         assert!(index < self.len());
         let result: u16 = PrimitiveElement::get_from_builder(&self.builder, index);
         FromU16::from_u16(result)
@@ -138,8 +138,8 @@ impl <'a, T> crate::traits::SetPointerBuilder<Builder<'a, T>> for Reader<'a, T>
     }
 }
 
-impl <'a, T: FromU16> ::std::iter::IntoIterator for Reader<'a, T> {
-    type Item = ::std::result::Result<T, NotInSchema>;
+impl <'a, T: FromU16> core::iter::IntoIterator for Reader<'a, T> {
+    type Item = core::result::Result<T, NotInSchema>;
     type IntoIter = ListIter<Reader<'a, T>, Self::Item>;
 
     fn into_iter(self) -> Self::IntoIter {
diff --git a/capnp/src/lib.rs b/capnp/src/lib.rs
index e842d8000..4adc3c190 100644
--- a/capnp/src/lib.rs
+++ b/capnp/src/lib.rs
@@ -27,12 +27,71 @@
 //! [capnpc-rust](https://github.com/capnproto/capnproto-rust/capnpc) crate.
 #![cfg_attr(feature = "rpc_try", feature(try_trait))]
 
+#![cfg_attr(feature = "no_std", no_std)]
+
 #[cfg(any(feature="quickcheck", test))]
 extern crate quickcheck;
 
 #[cfg(feature = "rpc")]
 extern crate futures;
 
+#[cfg(feature = "no_std")]
+#[macro_use]
+extern crate alloc;
+
+#[cfg(feature = "no_std")]
+extern crate core_io;
+
+#[cfg(not(feature = "no_std"))]
+use std as core;
+
+#[cfg(feature = "no_std")]
+use core_io as io;
+#[cfg(not(feature = "no_std"))]
+use std::io as io;
+
+#[cfg(feature = "no_std")]
+use alloc::string as string;
+#[cfg(not(feature = "no_std"))]
+use std::string as string;
+
+#[cfg(feature = "no_std")]
+use alloc::str as str;
+#[cfg(not(feature = "no_std"))]
+use std::str as str;
+
+/// Constructs a [`Word`](struct.Word.html) from its constituent bytes, accounting
+/// for endianness. This macro can be used to construct constants. In the future, once
+/// Rust supports [constant functions](https://github.com/rust-lang/rust/issues/24111),
+/// this macro will be replaced by such a function.
+#[cfg(target_endian = "little")]
+#[macro_export]
+macro_rules! capnp_word {
+  ($b0:expr, $b1:expr, $b2:expr, $b3:expr,
+   $b4:expr, $b5:expr, $b6:expr, $b7:expr) => (
+    $crate::Word {
+        raw_content: (($b0 as u64) << 0) + (($b1 as u64) << 8) +
+                     (($b2 as u64) << 16) + (($b3 as u64) << 24) +
+                     (($b4 as u64) << 32) + (($b5 as u64) << 40) +
+                     (($b6 as u64) << 48) + (($b7 as u64) << 56)
+    }
+  )
+}
+
+#[cfg(target_endian = "big")]
+#[macro_export]
+macro_rules! capnp_word {
+  ($b0:expr, $b1:expr, $b2:expr, $b3:expr,
+   $b4:expr, $b5:expr, $b6:expr, $b7:expr) => (
+     $crate::Word {
+         raw_content: (($b7 as u64) << 0) + (($b6 as u64) << 8) +
+                      (($b5 as u64) << 16) + (($b4 as u64) << 24) +
+                      (($b3 as u64) << 32) + (($b2 as u64) << 40) +
+                      (($b1 as u64) << 48) + (($b0 as u64) << 56)
+     }
+  )
+}
+
 pub mod any_pointer;
 pub mod any_pointer_list;
 pub mod capability;
@@ -53,7 +112,13 @@ pub mod text;
 pub mod text_list;
 pub mod traits;
 
-/// Eight bytes of memory with opaque interior.
+#[cfg(feature = "no_std")]
+use alloc::string::String;
+#[cfg(feature = "no_std")]
+use io::prelude::*;
+
+/// Eight bytes of memory with opaque interior. Use [`capnp_word!()`](macro.capnp_word!.html)
+/// to construct one of these.
 ///
 /// This type is used to ensure that the data of a message is properly aligned.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -77,7 +142,7 @@ impl Word {
         unsafe {
             result.set_len(length);
             let p : *mut u8 = result.as_mut_ptr() as *mut u8;
-            ::std::ptr::write_bytes(p, 0u8, length * ::std::mem::size_of::<Word>());
+            core::ptr::write_bytes(p, 0u8, length * core::mem::size_of::<Word>());
         }
         result
     }
@@ -87,7 +152,7 @@ impl Word {
     ///    1. `bytes.to_ptr()` falls on an eight-byte boundary, or
     ///    2. your processor is okay with unaligned reads.
     pub unsafe fn bytes_to_words<'a>(bytes: &'a [u8]) -> &'a [Word] {
-        ::std::slice::from_raw_parts(bytes.as_ptr() as *const Word, bytes.len() / 8)
+        core::slice::from_raw_parts(bytes.as_ptr() as *const Word, bytes.len() / 8)
     }
 
     /// Converts a mutable byte slice into a mutable `Word` slice. Unsafe due to possible
@@ -95,18 +160,18 @@ impl Word {
     ///    1. `bytes.to_ptr()` falls on an eight-byte boundary, or
     ///    2. your processor is okay with unaligned reads and writes
     pub unsafe fn bytes_to_words_mut<'a>(bytes: &'a mut [u8]) -> &'a mut [Word] {
-        ::std::slice::from_raw_parts_mut(bytes.as_ptr() as *mut Word, bytes.len() / 8)
+        core::slice::from_raw_parts_mut(bytes.as_ptr() as *mut Word, bytes.len() / 8)
     }
 
     pub fn words_to_bytes<'a>(words: &'a [Word]) -> &'a [u8] {
         unsafe {
-            ::std::slice::from_raw_parts(words.as_ptr() as *const u8, words.len() * 8)
+            core::slice::from_raw_parts(words.as_ptr() as *const u8, words.len() * 8)
         }
     }
 
     pub fn words_to_bytes_mut<'a>(words: &'a mut [Word]) -> &'a mut [u8] {
         unsafe {
-            ::std::slice::from_raw_parts_mut(words.as_mut_ptr() as *mut u8, words.len() * 8)
+            core::slice::from_raw_parts_mut(words.as_mut_ptr() as *mut u8, words.len() * 8)
         }
     }
 }
@@ -145,12 +210,13 @@ impl MessageSize {
 #[derive(PartialEq, Clone, Copy, Debug)]
 pub struct NotInSchema(pub u16);
 
-impl ::std::fmt::Display for NotInSchema {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> {
+impl core::fmt::Display for NotInSchema {
+    fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::result::Result<(), core::fmt::Error> {
         write!(fmt, "Enum value or union discriminant {} was not present in the schema.", self.0)
     }
 }
 
+#[cfg(feature = "std")]
 impl ::std::error::Error for NotInSchema {
     fn description<'a>(&'a self) -> &'a str {
         "Enum value or union disriminant was not present in schema."
@@ -159,7 +225,7 @@ impl ::std::error::Error for NotInSchema {
 
 /// Because messages are lazily validated, the return type of any method that reads a pointer field
 /// must be wrapped in a Result.
-pub type Result<T> = ::std::result::Result<T, Error>;
+pub type Result<T> = core::result::Result<T, Error>;
 
 /// Describes an arbitrary error that prevented an operation from completing.
 #[derive(Debug, Clone)]
@@ -211,9 +277,8 @@ impl Error {
     }
 }
 
-impl ::std::convert::From<::std::io::Error> for Error {
-    fn from(err: ::std::io::Error) -> Error {
-        use std::io;
+impl core::convert::From<io::Error> for Error {
+    fn from(err: io::Error) -> Error {
         let kind = match err.kind() {
             io::ErrorKind::TimedOut => ErrorKind::Overloaded,
             io::ErrorKind::BrokenPipe |
@@ -227,38 +292,50 @@ impl ::std::convert::From<::std::io::Error> for Error {
     }
 }
 
-impl ::std::convert::From<::std::string::FromUtf8Error> for Error {
-    fn from(err: ::std::string::FromUtf8Error) -> Error {
+impl core::convert::From<string::FromUtf8Error> for Error {
+    fn from(err: string::FromUtf8Error) -> Error {
         Error::failed(format!("{}", err))
     }
 }
 
-impl ::std::convert::From<::std::str::Utf8Error> for Error {
-    fn from(err: ::std::str::Utf8Error) -> Error {
+//impl core::convert::From<::alloc::string::FromUtf8Error> for Error {
+//    fn from(err: ::alloc::string::FromUtf8Error) -> Error {
+//        Error::failed(format!("{}", err))
+//    }
+//}
+
+impl core::convert::From<str::Utf8Error> for Error {
+    fn from(err: str::Utf8Error) -> Error {
         Error::failed(format!("{}", err))
     }
 }
 
-
 #[cfg(feature = "rpc")]
-impl ::std::convert::From<futures::sync::oneshot::Canceled> for Error {
+impl core::convert::From<futures::sync::oneshot::Canceled> for Error {
     fn from(_e: futures::sync::oneshot::Canceled) -> Error {
         Error::failed(format!("oneshot was canceled"))
     }
 }
 
-impl ::std::convert::From<NotInSchema> for Error {
+impl core::convert::From<NotInSchema> for Error {
     fn from(e: NotInSchema) -> Error {
         Error::failed(format!("Enum value or union discriminant {} was not present in schema.", e.0))
     }
 }
 
-impl ::std::fmt::Display for Error {
-    fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::result::Result<(), ::std::fmt::Error> {
+//impl core::convert::From<NotInSchema> for Error {
+//    fn from(e: NotInSchema) -> Error {
+//        Error::failed(format!("Enum value or union discriminant {} was not present in schema.", e.0))
+//    }
+//}
+
+impl core::fmt::Display for Error {
+    fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::result::Result<(), core::fmt::Error> {
         write!(fmt, "{:?}: {}", self.kind, self.description)
     }
 }
 
+#[cfg(feature = "std")]
 impl ::std::error::Error for Error {
     fn description(&self) -> &str {
         &self.description
@@ -275,7 +352,7 @@ pub enum OutputSegments<'a> {
     MultiSegment(Vec<&'a [Word]>),
 }
 
-impl <'a> ::std::ops::Deref for OutputSegments<'a> {
+impl <'a> core::ops::Deref for OutputSegments<'a> {
     type Target = [&'a [Word]];
     fn deref<'b>(&'b self) -> &'b [&'a [Word]] {
         match *self {
diff --git a/capnp/src/list_list.rs b/capnp/src/list_list.rs
index ff2e435c3..5f3be4d73 100644
--- a/capnp/src/list_list.rs
+++ b/capnp/src/list_list.rs
@@ -21,13 +21,14 @@
 
 //! List of lists.
 
+use core;
 use crate::traits::{FromPointerReader, FromPointerBuilder, ListIter, IndexMove};
 use crate::private::layout::{ListReader, ListBuilder, PointerReader, PointerBuilder, Pointer};
 use crate::Result;
 
 #[derive(Clone, Copy)]
 pub struct Owned<T> where T: for<'a> crate::traits::Owned<'a> {
-    marker: ::std::marker::PhantomData<T>,
+    marker: core::marker::PhantomData<T>,
 }
 
 impl<'a, T> crate::traits::Owned<'a> for Owned<T> where T: for<'b> crate::traits::Owned<'b> {
@@ -36,13 +37,13 @@ impl<'a, T> crate::traits::Owned<'a> for Owned<T> where T: for<'b> crate::traits
 }
 
 pub struct Reader<'a, T> where T: for<'b> crate::traits::Owned<'b> {
-    marker: ::std::marker::PhantomData<<T as crate::traits::Owned<'a>>::Reader>,
+    marker: core::marker::PhantomData<<T as crate::traits::Owned<'a>>::Reader>,
     reader: ListReader<'a>
 }
 
 impl <'a, T> Reader<'a, T> where T: for<'b> crate::traits::Owned<'b> {
     pub fn new<'b>(reader: ListReader<'b>) -> Reader<'b, T> {
-        Reader::<'b, T> { reader: reader, marker: ::std::marker::PhantomData }
+        Reader::<'b, T> { reader: reader, marker: core::marker::PhantomData }
     }
 
     pub fn len(&self) -> u32 { self.reader.len() }
@@ -69,7 +70,7 @@ where T: for<'b> crate::traits::Owned<'b> {
 impl <'a, T> FromPointerReader<'a> for Reader<'a, T> where T: for<'b> crate::traits::Owned<'b> {
     fn get_from_pointer(reader: &PointerReader<'a>, default: Option<&'a [crate::Word]>) -> Result<Reader<'a, T>> {
         Ok(Reader { reader: reader.get_list(Pointer, default)?,
-                    marker: ::std::marker::PhantomData })
+                    marker: core::marker::PhantomData })
     }
 }
 
@@ -81,19 +82,19 @@ impl <'a, T> Reader<'a, T> where T: for<'b> crate::traits::Owned<'b> {
 }
 
 pub struct Builder<'a, T> where T: for<'b> crate::traits::Owned<'b> {
-    marker: ::std::marker::PhantomData<T>,
+    marker: core::marker::PhantomData<T>,
     builder: ListBuilder<'a>
 }
 
 impl <'a, T> Builder<'a, T> where T: for<'b> crate::traits::Owned<'b> {
     pub fn new(builder: ListBuilder<'a>) -> Builder<'a, T> {
-        Builder { builder: builder, marker: ::std::marker::PhantomData }
+        Builder { builder: builder, marker: core::marker::PhantomData }
     }
 
     pub fn len(&self) -> u32 { self.builder.len() }
 
     pub fn into_reader(self) -> Reader<'a, T> {
-        Reader { reader: self.builder.into_reader(), marker: ::std::marker::PhantomData }
+        Reader { reader: self.builder.into_reader(), marker: core::marker::PhantomData }
     }
 }
 
@@ -105,20 +106,20 @@ impl <'a, T> Builder<'a, T> where T: for<'b> crate::traits::Owned<'b> {
 
 impl <'a, T> Builder<'a, T> where T: for<'b> crate::traits::Owned<'b> {
     pub fn reborrow<'b>(&'b mut self) -> Builder<'b, T> {
-        Builder {builder: self.builder.borrow(), marker: ::std::marker::PhantomData}
+        Builder {builder: self.builder.borrow(), marker: core::marker::PhantomData}
     }
 }
 
 impl <'a, T> FromPointerBuilder<'a> for Builder<'a, T> where T: for<'b> crate::traits::Owned<'b> {
     fn init_pointer(builder: PointerBuilder<'a>, size : u32) -> Builder<'a, T> {
         Builder {
-            marker: ::std::marker::PhantomData,
+            marker: core::marker::PhantomData,
             builder: builder.init_list(Pointer, size)
         }
     }
     fn get_from_pointer(builder: PointerBuilder<'a>, default: Option<&'a [crate::Word]>) -> Result<Builder<'a, T>> {
         Ok(Builder {
-            marker: ::std::marker::PhantomData,
+            marker: core::marker::PhantomData,
             builder: builder.get_list(Pointer, default)?
         })
     }
@@ -141,7 +142,7 @@ impl <'a, T> crate::traits::SetPointerBuilder<Builder<'a, T>> for Reader<'a, T>
     }
 }
 
-impl <'a, T> ::std::iter::IntoIterator for Reader<'a, T>
+impl <'a, T> core::iter::IntoIterator for Reader<'a, T>
     where T: for<'b> crate::traits::Owned<'b>
 {
     type Item = Result<<T as crate::traits::Owned<'a>>::Reader>;
diff --git a/capnp/src/message.rs b/capnp/src/message.rs
index 779b3d950..83dc31dca 100644
--- a/capnp/src/message.rs
+++ b/capnp/src/message.rs
@@ -21,7 +21,9 @@
 
 //! Untyped root container for a Cap'n Proto value.
 
-use std::convert::From;
+#[cfg(feature = "no_std")]
+use crate::io::prelude::*;
+use core::{self, convert::From};
 
 use crate::any_pointer;
 use crate::private::arena::{BuilderArenaImpl, ReaderArenaImpl, BuilderArena, ReaderArena};
@@ -177,7 +179,7 @@ impl <S> Reader<S> where S: ReaderSegments {
 
         let pointer_reader = layout::PointerReader::get_root(
             &self.arena, 0, segment_start, self.nesting_limit)?;
-        let read_head = ::std::cell::Cell::new(unsafe {segment_start.offset(1)});
+        let read_head = core::cell::Cell::new(unsafe {segment_start.offset(1)});
         let root_is_canonical = pointer_reader.is_canonical(&read_head)?;
         let all_words_consumed =
             (read_head.get() as usize - segment_start as usize) / BYTES_PER_WORD == seg_len as usize;
@@ -210,7 +212,7 @@ impl <S> Reader<S> where S: ReaderSegments {
 pub struct TypedReader<S, T>
     where S: ReaderSegments,
           T: for<'a> Owned<'a> {
-    marker: ::std::marker::PhantomData<T>,
+    marker: core::marker::PhantomData<T>,
     message: Reader<S>,
 }
 
@@ -220,7 +222,7 @@ impl <S, T> TypedReader<S, T>
 
     pub fn new(message: Reader<S>) -> Self {
         TypedReader {
-            marker: ::std::marker::PhantomData,
+            marker: core::marker::PhantomData,
             message: message,
         }
     }
@@ -419,7 +421,7 @@ impl HeapAllocator {
 
 unsafe impl Allocator for HeapAllocator {
     fn allocate_segment(&mut self, minimum_size: u32) -> (*mut Word, u32) {
-        let size = ::std::cmp::max(minimum_size, self.next_size);
+        let size = core::cmp::max(minimum_size, self.next_size);
         let mut new_words = Word::allocate_zeroed_vec(size as usize);
         let ptr = new_words.as_mut_ptr();
         self.owned_memory.push(new_words);
@@ -487,7 +489,7 @@ unsafe impl <'a, 'b: 'a> Allocator for ScratchSpaceHeapAllocator<'a, 'b> {
     fn pre_drop(&mut self, segment0_currently_allocated: u32) {
         let ptr = self.scratch_space.slice.as_mut_ptr();
         unsafe {
-            ::std::ptr::write_bytes(ptr, 0u8, segment0_currently_allocated as usize);
+            core::ptr::write_bytes(ptr, 0u8, segment0_currently_allocated as usize);
         }
         self.scratch_space.in_use = false;
     }
diff --git a/capnp/src/primitive_list.rs b/capnp/src/primitive_list.rs
index 57777d92d..77b58c3b6 100644
--- a/capnp/src/primitive_list.rs
+++ b/capnp/src/primitive_list.rs
@@ -21,7 +21,7 @@
 
 //! List of primitives.
 
-use std::{marker};
+use core::{self, marker};
 
 use crate::traits::{FromPointerReader, FromPointerBuilder, IndexMove, ListIter};
 use crate::private::layout::{ListReader, ListBuilder, PointerReader, PointerBuilder,
@@ -139,7 +139,7 @@ impl <'a, T> crate::traits::SetPointerBuilder<Builder<'a, T>> for Reader<'a, T>
     }
 }
 
-impl <'a, T> ::std::iter::IntoIterator for Reader<'a, T>
+impl <'a, T> core::iter::IntoIterator for Reader<'a, T>
     where T: PrimitiveElement
 {
     type Item = T;
diff --git a/capnp/src/private/arena.rs b/capnp/src/private/arena.rs
index 5c9ca5394..a5463eb25 100644
--- a/capnp/src/private/arena.rs
+++ b/capnp/src/private/arena.rs
@@ -18,9 +18,11 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-use std::cell::{Cell, RefCell};
-use std::slice;
-use std::u64;
+#[cfg(feature = "no_std")]
+use crate::io::prelude::*;
+
+use core::cell::{Cell, RefCell};
+use core::{self, u64, slice};
 
 use crate::private::units::*;
 use crate::message;
@@ -309,7 +311,7 @@ impl BuilderArena for NullArena {
     }
 
     fn get_segment_mut(&self, _id: u32) -> (*mut Word, u32) {
-        (::std::ptr::null_mut(), 0)
+        (core::ptr::null_mut(), 0)
     }
 
     fn as_reader<'a>(&'a self) -> &'a dyn ReaderArena {
diff --git a/capnp/src/private/capability.rs b/capnp/src/private/capability.rs
index 62cc0bec2..549c60a38 100644
--- a/capnp/src/private/capability.rs
+++ b/capnp/src/private/capability.rs
@@ -19,6 +19,10 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+#[cfg(feature = "no_std")]
+use crate::io::prelude::*;
+use core;
+
 use crate::any_pointer;
 use crate::MessageSize;
 use crate::capability::{Params, Promise, Request, RemotePromise, Results};
@@ -105,15 +109,15 @@ pub trait ParamsHook {
 
 // Where should this live?
 pub fn internal_get_typed_params<T>(typeless: Params<any_pointer::Owned>) -> Params<T> {
-    Params { hook: typeless.hook, marker: ::std::marker::PhantomData }
+    Params { hook: typeless.hook, marker: core::marker::PhantomData }
 }
 
 pub fn internal_get_typed_results<T>(typeless: Results<any_pointer::Owned>) -> Results<T> {
-    Results { hook: typeless.hook, marker: ::std::marker::PhantomData }
+    Results { hook: typeless.hook, marker: core::marker::PhantomData }
 }
 
 pub fn internal_get_untyped_results<T>(typeful: Results<T>) -> Results<any_pointer::Owned> {
-    Results { hook: typeful.hook, marker: ::std::marker::PhantomData }
+    Results { hook: typeful.hook, marker: core::marker::PhantomData }
 }
 
 pub trait PipelineHook {
diff --git a/capnp/src/private/layout.rs b/capnp/src/private/layout.rs
index 658a88cbc..3adfbd627 100644
--- a/capnp/src/private/layout.rs
+++ b/capnp/src/private/layout.rs
@@ -19,9 +19,10 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
-use std::mem;
-use std::ptr;
-use std::cell::Cell;
+#[cfg(feature = "no_std")]
+use crate::io::prelude::*;
+
+use core::{self, mem, ptr, cell::Cell};
 
 use crate::data;
 use crate::text;
@@ -310,7 +311,11 @@ impl WirePointer {
 }
 
 mod wire_helpers {
-    use std::{mem, ptr, slice};
+    #[cfg(feature = "no_std")]
+    use crate::io::prelude::*;
+
+    use core::{self, mem, ptr, slice};
+    use crate::string::ToString;
 
     use crate::private::capability::ClientHook;
     use crate::private::arena::*;
@@ -1022,8 +1027,8 @@ mod wire_helpers {
             //# handle writes? Instead, we have to copy the struct to a
             //# new space now.
 
-            let new_data_size = ::std::cmp::max(old_data_size, size.data);
-            let new_pointer_count = ::std::cmp::max(old_pointer_count, size.pointers);
+            let new_data_size = core::cmp::max(old_data_size, size.data);
+            let new_pointer_count = core::cmp::max(old_pointer_count, size.pointers);
             let total_size = new_data_size as u32 + new_pointer_count as u32 * WORDS_PER_POINTER as u32;
 
             //# Don't let allocate() zero out the object just yet.
@@ -1330,8 +1335,8 @@ mod wire_helpers {
             // The structs in this list are smaller than expected, probably written using an older
             // version of the protocol. We need to make a copy and expand them.
 
-            let new_data_size = ::std::cmp::max(old_data_size, element_size.data);
-            let new_pointer_count = ::std::cmp::max(old_pointer_count, element_size.pointers);
+            let new_data_size = core::cmp::max(old_data_size, element_size.data);
+            let new_pointer_count = core::cmp::max(old_pointer_count, element_size.pointers);
             let new_step = new_data_size as u32 + new_pointer_count as u32 * WORDS_PER_POINTER as u32;
             let total_size = new_step * element_count;
 
@@ -1406,10 +1411,10 @@ mod wire_helpers {
                 let mut new_pointer_count = element_size.pointers;
 
                 if old_size == ElementSize::Pointer {
-                    new_pointer_count = ::std::cmp::max(new_pointer_count, 1);
+                    new_pointer_count = core::cmp::max(new_pointer_count, 1);
                 } else {
                     // Old list contains data elements, so we need at least one word of data.
-                    new_data_size = ::std::cmp::max(new_data_size, 1);
+                    new_data_size = core::cmp::max(new_data_size, 1);
                 }
 
                 let new_step = new_data_size as u32 + new_pointer_count as u32 * WORDS_PER_POINTER as u32;
@@ -1516,7 +1521,7 @@ mod wire_helpers {
                 None => return text::Builder::new(&mut [], 0),
                 Some(d) => {
                     let (new_ref_target, new_reff, new_segment_id) =
-                        copy_message(arena, segment_id, CapTableBuilder::Plain(::std::ptr::null_mut()), reff, d.as_ptr() as *const _);
+                        copy_message(arena, segment_id, CapTableBuilder::Plain(core::ptr::null_mut()), reff, d.as_ptr() as *const _);
                     reff = new_reff;
                     segment_id = new_segment_id;
                     new_ref_target
@@ -1590,7 +1595,7 @@ mod wire_helpers {
                 None => return Ok(&mut []),
                 Some(d) => {
                     let (new_ref_target, new_reff, new_segment_id) =
-                        copy_message(arena, segment_id, CapTableBuilder::Plain(::std::ptr::null_mut()), reff, d.as_ptr() as *const _);
+                        copy_message(arena, segment_id, CapTableBuilder::Plain(core::ptr::null_mut()), reff, d.as_ptr() as *const _);
                     reff = new_reff;
                     segment_id = new_segment_id;
                     new_ref_target
@@ -2481,7 +2486,7 @@ impl <'a> PointerReader<'a> {
 
     pub fn get_list(self, expected_element_size: ElementSize,
                     default: Option<&'a [Word]>) -> Result<ListReader<'a>> {
-        let default_value: *const Word = match default { None => std::ptr::null(), Some(d) => d.as_ptr() };
+        let default_value: *const Word = match default { None => core::ptr::null(), Some(d) => d.as_ptr() };
         let reff = if self.pointer.is_null() { zero_pointer() } else { self.pointer };
         unsafe {
             wire_helpers::read_list_pointer(
@@ -2630,7 +2635,7 @@ impl <'a> PointerBuilder<'a> {
     pub fn get_list(self, element_size: ElementSize, default: Option<&'a [Word]>)
                     -> Result<ListBuilder<'a>>
     {
-        let default_value: *const Word = match default { None => std::ptr::null(), Some(d) => d.as_ptr() };
+        let default_value: *const Word = match default { None => core::ptr::null(), Some(d) => d.as_ptr() };
         unsafe {
             wire_helpers::get_writable_list_pointer(
                 self.arena, self.pointer, self.segment_id, self.cap_table, element_size, default_value)
@@ -2640,7 +2645,7 @@ impl <'a> PointerBuilder<'a> {
     pub fn get_struct_list(self, element_size: StructSize,
                            default: Option<&'a [Word]>) -> Result<ListBuilder<'a>>
     {
-        let default_value: *const Word = match default { None => std::ptr::null(), Some(d) => d.as_ptr() };
+        let default_value: *const Word = match default { None => core::ptr::null(), Some(d) => d.as_ptr() };
         unsafe {
             wire_helpers::get_writable_struct_list_pointer(
                 self.arena, self.pointer, self.segment_id, self.cap_table, element_size, default_value)
@@ -2669,7 +2674,7 @@ impl <'a> PointerBuilder<'a> {
         unsafe {
             wire_helpers::read_capability_pointer(
                 self.arena.as_reader(),
-                self.segment_id, self.cap_table.into_reader(), self.pointer, ::std::i32::MAX)
+                self.segment_id, self.cap_table.into_reader(), self.pointer, core::i32::MAX)
         }
     }
 
@@ -2834,7 +2839,7 @@ impl <'a> StructReader<'a> {
             &[]
         } else {
             unsafe {
-                ::std::slice::from_raw_parts(self.data, self.data_size as usize / BITS_PER_BYTE)
+                core::slice::from_raw_parts(self.data, self.data_size as usize / BITS_PER_BYTE)
             }
         }
     }
@@ -3070,7 +3075,7 @@ impl <'a> StructBuilder<'a> {
     }
 
     pub fn copy_content_from(&mut self, other: &StructReader) -> Result<()> {
-        use std::cmp::min;
+        use core::cmp::min;
         // Determine the amount of data the builders have in common.
         let shared_data_size = min(self.data_size, other.data_size);
         let shared_pointer_count = min(self.pointer_count, other.pointer_count);
@@ -3185,7 +3190,7 @@ impl <'a> ListReader<'a> {
             let num_bytes = wire_helpers::round_bits_up_to_bytes(
                 self.step as u64 * self.element_count as u64) as usize;
             unsafe {
-                ::std::slice::from_raw_parts(self.ptr, num_bytes)
+                core::slice::from_raw_parts(self.ptr, num_bytes)
             }
         }
     }
diff --git a/capnp/src/private/units.rs b/capnp/src/private/units.rs
index 14fe33708..460e7031b 100644
--- a/capnp/src/private/units.rs
+++ b/capnp/src/private/units.rs
@@ -19,6 +19,8 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+use core;
+
 pub type BitCount0 = usize; // `BitCount` clashes with a standard trait
 pub type BitCount8 = u8;
 pub type BitCount16 = u16;
@@ -60,9 +62,9 @@ pub const WORDS_PER_POINTER : WordCount = 1;
 pub const POINTER_SIZE_IN_WORDS : WordCount = 1;
 
 pub fn _bytes_per_element<T>() -> ByteCount {
-    ::std::mem::size_of::<T>()
+    core::mem::size_of::<T>()
 }
 
 pub fn bits_per_element<T>() -> BitCount0 {
-    8 * ::std::mem::size_of::<T>()
+    8 * core::mem::size_of::<T>()
 }
diff --git a/capnp/src/serialize.rs b/capnp/src/serialize.rs
index b6f836b57..54007d8a5 100644
--- a/capnp/src/serialize.rs
+++ b/capnp/src/serialize.rs
@@ -22,8 +22,8 @@
 //! Reading and writing of messages using the
 //! [standard stream framing](https://capnproto.org/encoding.html#serialization-over-a-stream).
 
-use std::convert::TryInto;
-use std::io::{Read, Write};
+use core::convert::TryInto;
+use crate::io::{self, prelude::*};
 
 use crate::message;
 use crate::{Error, Result, Word};
@@ -90,7 +90,7 @@ impl crate::message::ReaderSegments for OwnedSegments {
 ///
 /// For optimal performance, `read` should be a buffered reader type.
 pub fn read_message<R>(read: &mut R, options: message::ReaderOptions) -> Result<message::Reader<OwnedSegments>>
-where R: Read {
+where R: io::Read {
     let (total_words, segment_slices) = read_segment_table(read, options)?;
     read_segments(read, total_words, segment_slices, options)
 }
@@ -103,7 +103,7 @@ where R: Read {
 fn read_segment_table<R>(read: &mut R,
                          options: message::ReaderOptions)
                          -> Result<(usize, Vec<(usize, usize)>)>
-    where R: Read
+    where R: io::Read
 {
     let mut buf: [u8; 8] = [0; 8];
 
@@ -207,20 +207,20 @@ fn flatten_segments<R: message::ReaderSegments + ?Sized>(segments: &R) -> Vec<Wo
 ///
 /// For optimal performance, `write` should be a buffered writer. `flush` will not be called on
 /// the writer.
-pub fn write_message<W, A>(write: &mut W, message: &message::Builder<A>) -> ::std::io::Result<()>
+pub fn write_message<W, A>(write: &mut W, message: &message::Builder<A>) -> io::Result<()>
  where W: Write, A: message::Allocator {
     let segments = message.get_segments_for_output();
     write_segment_table(write, &segments)?;
     write_segments(write, &segments)
 }
 
-pub fn write_message_segments<W, R>(write: &mut W, segments: &R) -> ::std::io::Result<()>
+pub fn write_message_segments<W, R>(write: &mut W, segments: &R) -> io::Result<()>
  where W: Write, R: message::ReaderSegments {
     write_segment_table_internal(write, segments)?;
     write_segments(write, segments)
 }
 
-fn write_segment_table<W>(write: &mut W, segments: &[&[Word]]) -> ::std::io::Result<()>
+fn write_segment_table<W>(write: &mut W, segments: &[&[Word]]) -> io::Result<()>
 where W: Write {
     write_segment_table_internal(write, segments)
 }
@@ -228,7 +228,7 @@ where W: Write {
 /// Writes a segment table to `write`.
 ///
 /// `segments` must contain at least one segment.
-fn write_segment_table_internal<W, R>(write: &mut W, segments: &R) -> ::std::io::Result<()>
+fn write_segment_table_internal<W, R>(write: &mut W, segments: &R) -> io::Result<()>
 where W: Write, R: message::ReaderSegments + ?Sized {
     let mut buf: [u8; 8] = [0; 8];
     let segment_count = segments.len();
@@ -264,7 +264,7 @@ where W: Write, R: message::ReaderSegments + ?Sized {
 }
 
 /// Writes segments to `write`.
-fn write_segments<W, R: message::ReaderSegments + ?Sized>(write: &mut W, segments: &R) -> ::std::io::Result<()>
+fn write_segments<W, R: message::ReaderSegments + ?Sized>(write: &mut W, segments: &R) -> io::Result<()>
 where W: Write {
     for i in 0.. {
         if let Some(segment) = segments.get_segment(i) {
@@ -296,8 +296,7 @@ pub fn compute_serialized_size_in_words<A>(message: &crate::message::Builder<A>)
 
 #[cfg(test)]
 pub mod test {
-
-    use std::io::{Cursor, Write};
+    use crate::io::{self, prelude::*};
 
     use quickcheck::{quickcheck, TestResult};
 
@@ -324,7 +323,7 @@ pub mod test {
         buf.extend([0,0,0,0, // 1 segments
                     0,0,0,0] // 0 length
                     .iter().cloned());
-        let (words, segment_slices) = read_segment_table(&mut Cursor::new(&buf[..]),
+        let (words, segment_slices) = read_segment_table(&mut io::Cursor::new(&buf[..]),
                                                          message::ReaderOptions::new()).unwrap();
         assert_eq!(0, words);
         assert_eq!(vec![(0,0)], segment_slices);
@@ -333,7 +332,7 @@ pub mod test {
         buf.extend([0,0,0,0, // 1 segments
                     1,0,0,0] // 1 length
                     .iter().cloned());
-        let (words, segment_slices) = read_segment_table(&mut Cursor::new(&buf[..]),
+        let (words, segment_slices) = read_segment_table(&mut io::Cursor::new(&buf[..]),
                                                          message::ReaderOptions::new()).unwrap();
         assert_eq!(1, words);
         assert_eq!(vec![(0,1)], segment_slices);
@@ -344,7 +343,7 @@ pub mod test {
                     1,0,0,0, // 1 length
                     0,0,0,0] // padding
                     .iter().cloned());
-        let (words, segment_slices) = read_segment_table(&mut Cursor::new(&buf[..]),
+        let (words, segment_slices) = read_segment_table(&mut io::Cursor::new(&buf[..]),
                                                          message::ReaderOptions::new()).unwrap();
         assert_eq!(2, words);
         assert_eq!(vec![(0,1), (1, 2)], segment_slices);
@@ -355,7 +354,7 @@ pub mod test {
                     1,0,0,0, // 1 length
                     0,1,0,0] // 256 length
                     .iter().cloned());
-        let (words, segment_slices) = read_segment_table(&mut Cursor::new(&buf[..]),
+        let (words, segment_slices) = read_segment_table(&mut io::Cursor::new(&buf[..]),
                                                          message::ReaderOptions::new()).unwrap();
         assert_eq!(258, words);
         assert_eq!(vec![(0,1), (1, 2), (2, 258)], segment_slices);
@@ -368,7 +367,7 @@ pub mod test {
                     99,0,0,0, // 99 length
                     0,0,0,0]  // padding
                     .iter().cloned());
-        let (words, segment_slices) = read_segment_table(&mut Cursor::new(&buf[..]),
+        let (words, segment_slices) = read_segment_table(&mut io::Cursor::new(&buf[..]),
                                                          message::ReaderOptions::new()).unwrap();
         assert_eq!(200, words);
         assert_eq!(vec![(0,77), (77, 100), (100, 101), (101, 200)], segment_slices);
@@ -382,23 +381,23 @@ pub mod test {
 
         buf.extend([0,2,0,0].iter().cloned()); // 513 segments
         buf.extend([0; 513 * 4].iter().cloned());
-        assert!(read_segment_table(&mut Cursor::new(&buf[..]),
+        assert!(read_segment_table(&mut io::Cursor::new(&buf[..]),
                                    message::ReaderOptions::new()).is_err());
         buf.clear();
 
         buf.extend([0,0,0,0].iter().cloned()); // 1 segments
-        assert!(read_segment_table(&mut Cursor::new(&buf[..]),
+        assert!(read_segment_table(&mut io::Cursor::new(&buf[..]),
                                    message::ReaderOptions::new()).is_err());
         buf.clear();
 
         buf.extend([0,0,0,0].iter().cloned()); // 1 segments
         buf.extend([0; 3].iter().cloned());
-        assert!(read_segment_table(&mut Cursor::new(&buf[..]),
+        assert!(read_segment_table(&mut io::Cursor::new(&buf[..]),
                                    message::ReaderOptions::new()).is_err());
         buf.clear();
 
         buf.extend([255,255,255,255].iter().cloned()); // 0 segments
-        assert!(read_segment_table(&mut Cursor::new(&buf[..]),
+        assert!(read_segment_table(&mut io::Cursor::new(&buf[..]),
                                    message::ReaderOptions::new()).is_err());
         buf.clear();
     }
@@ -465,7 +464,7 @@ pub mod test {
     fn check_round_trip() {
         fn round_trip(segments: Vec<Vec<Word>>) -> TestResult {
             if segments.len() == 0 { return TestResult::discard(); }
-            let mut cursor = Cursor::new(Vec::new());
+            let mut cursor = io::Cursor::new(Vec::new());
 
             write_message_segments(&mut cursor, &segments);
             cursor.set_position(0);
diff --git a/capnp/src/serialize_packed.rs b/capnp/src/serialize_packed.rs
index 6614176bb..abb08f198 100644
--- a/capnp/src/serialize_packed.rs
+++ b/capnp/src/serialize_packed.rs
@@ -22,8 +22,8 @@
 //! Reading and writing of messages using the
 //! [packed stream encoding](https://capnproto.org/encoding.html#packing).
 
-use std::{io, mem, ptr, slice};
-use std::io::{Read, BufRead, Write};
+use core::{mem, ptr, slice};
+use crate::io::{self, prelude::*};
 
 use crate::serialize;
 use crate::Result;
@@ -370,9 +370,8 @@ pub fn write_message<W, A>(write: &mut W, message: &crate::message::Builder<A>)
 
 #[cfg(test)]
 mod tests {
-    use std::io::{Write, Read};
+    use crate::io::{Write, Read, Cursor};
 
-    use std::io::Cursor;
     use quickcheck::{quickcheck, TestResult};
 
     use crate::{Word};
diff --git a/capnp/src/struct_list.rs b/capnp/src/struct_list.rs
index 1e9b7f47a..d30cd1703 100644
--- a/capnp/src/struct_list.rs
+++ b/capnp/src/struct_list.rs
@@ -21,7 +21,7 @@
 
 //! List of structs.
 
-use std::marker::PhantomData;
+use core::{self, marker::PhantomData};
 
 use crate::private::layout::{ListReader, ListBuilder, PointerReader, PointerBuilder, InlineComposite};
 use crate::traits::{FromPointerReader, FromPointerBuilder,
@@ -171,7 +171,7 @@ impl <'a, T> crate::traits::SetPointerBuilder<Builder<'a, T>> for Reader<'a, T>
     }
 }
 
-impl <'a, T> ::std::iter::IntoIterator for Reader<'a, T>
+impl <'a, T> core::iter::IntoIterator for Reader<'a, T>
     where T: for<'b> crate::traits::OwnedStruct<'b>
 {
     type Item = <T as crate::traits::OwnedStruct<'a>>::Reader;
diff --git a/capnp/src/text.rs b/capnp/src/text.rs
index bca3daf62..d6e230a98 100644
--- a/capnp/src/text.rs
+++ b/capnp/src/text.rs
@@ -21,8 +21,7 @@
 
 //! UTF-8 encoded text.
 
-use std::{convert, str, ops};
-
+use core::{convert, str, ops};
 use crate::{Error, Result};
 
 #[derive(Copy, Clone)]
diff --git a/capnp/src/text_list.rs b/capnp/src/text_list.rs
index bddf3079f..ca99c7a94 100644
--- a/capnp/src/text_list.rs
+++ b/capnp/src/text_list.rs
@@ -21,6 +21,7 @@
 
 //! List of strings containing UTF-8 encoded text.
 
+use core;
 use crate::traits::{FromPointerReader, FromPointerBuilder, IndexMove, ListIter};
 use crate::private::layout::{ListBuilder, ListReader, Pointer, PointerBuilder, PointerReader};
 use crate::Result;
@@ -129,7 +130,7 @@ impl <'a> crate::traits::SetPointerBuilder<Builder<'a>> for Reader<'a> {
     }
 }
 
-impl <'a> ::std::iter::IntoIterator for Reader<'a> {
+impl <'a> core::iter::IntoIterator for Reader<'a> {
     type Item = Result<crate::text::Reader<'a>>;
     type IntoIter = ListIter<Reader<'a>, Self::Item>;
 
diff --git a/capnp/src/traits.rs b/capnp/src/traits.rs
index 75851dde1..fd3977316 100644
--- a/capnp/src/traits.rs
+++ b/capnp/src/traits.rs
@@ -19,12 +19,12 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
 
+use core::{self, marker::PhantomData};
+
 use crate::{Word, Result};
 use crate::private::layout::{CapTable, ListReader, StructReader, StructBuilder, StructSize,
                              PointerBuilder, PointerReader};
 
-use std::marker::PhantomData;
-
 pub trait FromStructReader<'a> {
     fn new(reader: StructReader<'a>) -> Self;
 }
@@ -100,7 +100,7 @@ pub trait ToU16 {
 }
 
 pub trait FromU16 : Sized {
-    fn from_u16(value: u16) -> ::std::result::Result<Self, crate::NotInSchema>;
+    fn from_u16(value: u16) -> core::result::Result<Self, crate::NotInSchema>;
 }
 
 pub trait IndexMove<I, T> {
@@ -120,9 +120,9 @@ impl <T, U> ListIter<T, U>{
     }
 }
 
-impl <U, T : IndexMove<u32, U>> ::std::iter::Iterator for ListIter<T, U> {
+impl <U, T : IndexMove<u32, U>> core::iter::Iterator for ListIter<T, U> {
     type Item = U;
-    fn next(&mut self) -> ::std::option::Option<U> {
+    fn next(&mut self) -> core::option::Option<U> {
         if self.index < self.size {
             let result = self.list.index_move(self.index);
             self.index += 1;
@@ -147,14 +147,14 @@ impl <U, T : IndexMove<u32, U>> ::std::iter::Iterator for ListIter<T, U> {
     }
 }
 
-impl <U, T: IndexMove<u32, U>> ::std::iter::ExactSizeIterator for ListIter<T, U>{
+impl <U, T: IndexMove<u32, U>> core::iter::ExactSizeIterator for ListIter<T, U>{
     fn len(&self) -> usize{
         self.size as usize
     }
 }
 
-impl <U, T: IndexMove<u32, U>> ::std::iter::DoubleEndedIterator for ListIter<T, U>{
-    fn next_back(&mut self) -> ::std::option::Option<U> {
+impl <U, T: IndexMove<u32, U>> core::iter::DoubleEndedIterator for ListIter<T, U>{
+    fn next_back(&mut self) -> core::option::Option<U> {
         if self.size > self.index {
             self.size -= 1;
             Some(self.list.index_move(self.size))
diff --git a/capnpc/Cargo.toml b/capnpc/Cargo.toml
index 43c1f7422..8c5a464b2 100644
--- a/capnpc/Cargo.toml
+++ b/capnpc/Cargo.toml
@@ -24,5 +24,5 @@ name = "capnpc-rust"
 path = "src/capnpc-rust.rs"
 
 [dependencies]
-capnp = { version = "0.10", path = "../capnp" }
+capnp = { version = "0.10", path = "../capnp", default-features = false }
 
diff --git a/capnpc/src/codegen.rs b/capnpc/src/codegen.rs
index 8c0d7ae0d..91a484d93 100644
--- a/capnpc/src/codegen.rs
+++ b/capnpc/src/codegen.rs
@@ -1859,7 +1859,8 @@ pub fn generate_code<T>(mut inp: T, out_dir: &::std::path::Path) -> ::capnp::Res
         let requested = ::std::path::PathBuf::from(requested_file.get_filename()?);
         filepath.push(requested);
         if let Some(parent) = filepath.parent() {
-            ::std::fs::create_dir_all(parent)?;
+            ::std::fs::create_dir_all(parent)
+                .map_err(|err| ::capnp::Error::failed(err.to_string()))?;
         }
 
         let root_name = path_to_stem_string(&filepath)?.replace("-", "_");
@@ -1878,12 +1879,13 @@ pub fn generate_code<T>(mut inp: T, out_dir: &::std::path::Path) -> ::capnp::Res
         // would not include `filepath`.
         match ::std::fs::File::create(&filepath) {
             Ok(ref mut writer) => {
-                writer.write_all(text.as_bytes())?;
+                writer.write_all(text.as_bytes())
+                    .map_err(|err| ::capnp::Error::failed(err.to_string()))?;
             }
             Err(e) => {
                 let _ = writeln!(&mut ::std::io::stderr(),
                                  "could not open file {:?} for writing: {}", filepath, e);
-                return Err(e.into());
+                return Err(::capnp::Error::failed(e.to_string()));
             }
         }
     }
diff --git a/capnpc/src/lib.rs b/capnpc/src/lib.rs
index fbec37779..6a418e87e 100644
--- a/capnpc/src/lib.rs
+++ b/capnpc/src/lib.rs
@@ -78,9 +78,9 @@ pub enum RustEdition {
 }
 
 fn run_command(mut command: ::std::process::Command, path: &PathBuf) -> ::capnp::Result<()> {
-    let mut p = command.spawn()?;
+    let mut p = command.spawn().map_err(|err| capnp::Error::failed(err.to_string()))?;
     crate::codegen::generate_code(p.stdout.take().unwrap(), path.as_path())?;
-    let exit_status = p.wait()?;
+    let exit_status = p.wait().map_err(|err| ::capnp::Error::failed(err.to_string()))?;
     if !exit_status.success() {
         Err(::capnp::Error::failed(format!(
             "Non-success exit status: {}",