diff --git a/.gitignore b/.gitignore
index eb4206933..d85043979 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,3 @@
-doc/
 target/
 Cargo.lock
 
diff --git a/Cargo.toml b/Cargo.toml
index 3a7f2b8c2..aa57a694a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,33 +1,8 @@
-[package]
-name = "objc"
-version = "0.2.7"
-authors = ["Steven Sheldon"]
-edition = "2018"
-
-description = "Objective-C Runtime bindings and wrapper for Rust."
-keywords = ["objective-c", "osx", "ios", "cocoa", "uikit"]
-readme = "README.md"
-repository = "http://github.com/SSheldon/rust-objc"
-documentation = "http://ssheldon.github.io/rust-objc/objc/"
-license = "MIT"
-
-exclude = [
-  ".gitignore",
-  ".travis.yml",
-  "doc.sh",
-  "travis_install.sh",
-  "travis_test.sh",
-  "tests-ios/**",
- ]
-
-[features]
-exception = ["objc_exception"]
-verify_message = []
-
-[dependencies]
-malloc_buf = "1.0"
-objc-encode = "1.0"
-
-[dependencies.objc_exception]
-version = "0.1"
-optional = true
+[workspace]
+members = [
+    "objc",
+    "objc_encode",
+    "objc_exception",
+    "objc_foundation",
+    "objc_id",
+]
diff --git a/.travis.yml b/objc/.travis.yml
similarity index 100%
rename from .travis.yml
rename to objc/.travis.yml
diff --git a/CHANGELOG.md b/objc/CHANGELOG.md
similarity index 100%
rename from CHANGELOG.md
rename to objc/CHANGELOG.md
diff --git a/objc/Cargo.toml b/objc/Cargo.toml
new file mode 100644
index 000000000..a6e18860f
--- /dev/null
+++ b/objc/Cargo.toml
@@ -0,0 +1,30 @@
+[package]
+name = "objc"
+version = "0.2.7"
+authors = ["Steven Sheldon"]
+edition = "2018"
+
+description = "Objective-C Runtime bindings and wrapper for Rust."
+keywords = ["objective-c", "osx", "ios", "cocoa", "uikit"]
+readme = "README.md"
+repository = "http://github.com/SSheldon/rust-objc"
+documentation = "http://ssheldon.github.io/rust-objc/objc/"
+license = "MIT"
+
+exclude = [
+  ".gitignore",
+  ".travis.yml",
+  "doc.sh",
+  "travis_install.sh",
+  "travis_test.sh",
+  "tests-ios/**",
+ ]
+
+[features]
+exception = ["objc_exception"]
+verify_message = []
+
+[dependencies]
+malloc_buf = "1.0"
+objc-encode = { path = "../objc_encode", version = "1.0" }
+objc_exception = { path = "../objc_exception", version = "0.1", optional = true }
diff --git a/README.md b/objc/README.md
similarity index 100%
rename from README.md
rename to objc/README.md
diff --git a/doc.sh b/objc/doc.sh
similarity index 100%
rename from doc.sh
rename to objc/doc.sh
diff --git a/examples/example.rs b/objc/examples/example.rs
similarity index 100%
rename from examples/example.rs
rename to objc/examples/example.rs
diff --git a/src/cache.rs b/objc/src/cache.rs
similarity index 100%
rename from src/cache.rs
rename to objc/src/cache.rs
diff --git a/src/declare.rs b/objc/src/declare.rs
similarity index 100%
rename from src/declare.rs
rename to objc/src/declare.rs
diff --git a/src/encode.rs b/objc/src/encode.rs
similarity index 100%
rename from src/encode.rs
rename to objc/src/encode.rs
diff --git a/src/exception.rs b/objc/src/exception.rs
similarity index 100%
rename from src/exception.rs
rename to objc/src/exception.rs
diff --git a/src/lib.rs b/objc/src/lib.rs
similarity index 100%
rename from src/lib.rs
rename to objc/src/lib.rs
diff --git a/src/macros.rs b/objc/src/macros.rs
similarity index 100%
rename from src/macros.rs
rename to objc/src/macros.rs
diff --git a/src/message/apple/arm.rs b/objc/src/message/apple/arm.rs
similarity index 100%
rename from src/message/apple/arm.rs
rename to objc/src/message/apple/arm.rs
diff --git a/src/message/apple/arm64.rs b/objc/src/message/apple/arm64.rs
similarity index 100%
rename from src/message/apple/arm64.rs
rename to objc/src/message/apple/arm64.rs
diff --git a/src/message/apple/mod.rs b/objc/src/message/apple/mod.rs
similarity index 100%
rename from src/message/apple/mod.rs
rename to objc/src/message/apple/mod.rs
diff --git a/src/message/apple/x86.rs b/objc/src/message/apple/x86.rs
similarity index 100%
rename from src/message/apple/x86.rs
rename to objc/src/message/apple/x86.rs
diff --git a/src/message/apple/x86_64.rs b/objc/src/message/apple/x86_64.rs
similarity index 100%
rename from src/message/apple/x86_64.rs
rename to objc/src/message/apple/x86_64.rs
diff --git a/src/message/gnustep.rs b/objc/src/message/gnustep.rs
similarity index 100%
rename from src/message/gnustep.rs
rename to objc/src/message/gnustep.rs
diff --git a/src/message/mod.rs b/objc/src/message/mod.rs
similarity index 100%
rename from src/message/mod.rs
rename to objc/src/message/mod.rs
diff --git a/src/message/verify.rs b/objc/src/message/verify.rs
similarity index 100%
rename from src/message/verify.rs
rename to objc/src/message/verify.rs
diff --git a/src/rc/autorelease.rs b/objc/src/rc/autorelease.rs
similarity index 100%
rename from src/rc/autorelease.rs
rename to objc/src/rc/autorelease.rs
diff --git a/src/rc/mod.rs b/objc/src/rc/mod.rs
similarity index 100%
rename from src/rc/mod.rs
rename to objc/src/rc/mod.rs
diff --git a/src/rc/strong.rs b/objc/src/rc/strong.rs
similarity index 100%
rename from src/rc/strong.rs
rename to objc/src/rc/strong.rs
diff --git a/src/rc/weak.rs b/objc/src/rc/weak.rs
similarity index 100%
rename from src/rc/weak.rs
rename to objc/src/rc/weak.rs
diff --git a/src/runtime.rs b/objc/src/runtime.rs
similarity index 100%
rename from src/runtime.rs
rename to objc/src/runtime.rs
diff --git a/src/test_utils.rs b/objc/src/test_utils.rs
similarity index 100%
rename from src/test_utils.rs
rename to objc/src/test_utils.rs
diff --git a/tests-ios/prelude.rs b/objc/tests-ios/prelude.rs
similarity index 100%
rename from tests-ios/prelude.rs
rename to objc/tests-ios/prelude.rs
diff --git a/tests/use_macros.rs b/objc/tests/use_macros.rs
similarity index 100%
rename from tests/use_macros.rs
rename to objc/tests/use_macros.rs
diff --git a/travis_install.sh b/objc/travis_install.sh
similarity index 100%
rename from travis_install.sh
rename to objc/travis_install.sh
diff --git a/travis_test.sh b/objc/travis_test.sh
similarity index 100%
rename from travis_test.sh
rename to objc/travis_test.sh
diff --git a/objc_encode/Cargo.toml b/objc_encode/Cargo.toml
new file mode 100644
index 000000000..99013c41e
--- /dev/null
+++ b/objc_encode/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "objc-encode"
+version = "1.1.0"
+authors = ["Steven Sheldon"]
+edition = "2018"
+
+description = "Objective-C type encoding creation and parsing in Rust."
+keywords = ["objective-c", "osx", "ios", "cocoa", "uikit"]
+categories = ["development-tools::ffi", "no-std"]
+readme = "README.md"
+repository = "http://github.com/SSheldon/rust-objc-encode"
+documentation = "http://ssheldon.github.io/rust-objc/objc_encode/"
+license = "MIT"
+
+exclude = [
+  ".gitignore",
+]
diff --git a/objc_encode/README.md b/objc_encode/README.md
new file mode 100644
index 000000000..38ecd2b55
--- /dev/null
+++ b/objc_encode/README.md
@@ -0,0 +1,38 @@
+Objective-C type encoding creation and parsing in Rust.
+
+The Objective-C compiler encodes types as strings for usage in the runtime.
+This crate aims to provide a strongly-typed (rather than stringly-typed) way
+to create and describe these type encodings without memory allocation in Rust.
+
+# Implementing Encode
+
+This crate declares an `Encode` trait that can be implemented for types that
+the Objective-C compiler can encode. Implementing this trait looks like:
+
+``` rust
+unsafe impl Encode for CGPoint {
+    const ENCODING: Encoding<'static> =
+        Encoding::Struct("CGPoint", &[CGFloat::ENCODING, CGFLOAT::ENCODING]);
+}
+```
+
+For an example of how this works with more complex types, like structs
+containing structs, see the `core_graphics` example.
+
+# Comparing with encoding strings
+
+An `Encoding` can be compared with an encoding string from the Objective-C
+runtime:
+
+``` rust
+assert!(&i32::ENCODING == "i");
+```
+
+# Generating encoding strings
+
+Every `Encoding` implements `Display` as its string representation.
+This can be generated conveniently through the `to_string` method:
+
+``` rust
+assert_eq!(i32::ENCODING.to_string(), "i");
+```
diff --git a/objc_encode/examples/core_graphics.rs b/objc_encode/examples/core_graphics.rs
new file mode 100644
index 000000000..4c0b7f75b
--- /dev/null
+++ b/objc_encode/examples/core_graphics.rs
@@ -0,0 +1,46 @@
+extern crate objc_encode;
+
+use objc_encode::{Encode, Encoding};
+
+#[cfg(target_pointer_width = "32")]
+type CGFloat = f32;
+
+#[cfg(target_pointer_width = "64")]
+type CGFloat = f64;
+
+#[repr(C)]
+struct CGPoint {
+    x: CGFloat,
+    y: CGFloat,
+}
+
+unsafe impl Encode for CGPoint {
+    const ENCODING: Encoding<'static> =
+        Encoding::Struct("CGPoint", &[CGFloat::ENCODING, CGFloat::ENCODING]);
+}
+
+#[repr(C)]
+struct CGSize {
+    width: CGFloat,
+    height: CGFloat,
+}
+
+unsafe impl Encode for CGSize {
+    const ENCODING: Encoding<'static> =
+        Encoding::Struct("CGSize", &[CGFloat::ENCODING, CGFloat::ENCODING]);
+}
+
+#[repr(C)]
+struct CGRect {
+    origin: CGPoint,
+    size: CGSize,
+}
+
+unsafe impl Encode for CGRect {
+    const ENCODING: Encoding<'static> =
+        Encoding::Struct("CGRect", &[CGPoint::ENCODING, CGSize::ENCODING]);
+}
+
+fn main() {
+    println!("{}", CGRect::ENCODING);
+}
diff --git a/objc_encode/src/encode.rs b/objc_encode/src/encode.rs
new file mode 100644
index 000000000..cd592103f
--- /dev/null
+++ b/objc_encode/src/encode.rs
@@ -0,0 +1,103 @@
+use core::ffi::c_void;
+
+use crate::Encoding;
+
+/// Types that have an Objective-C type encoding.
+///
+/// Unsafe because Objective-C will make assumptions about the type (like its
+/// size and alignment) from its encoding, so the implementer must verify that
+/// the encoding is accurate.
+pub unsafe trait Encode {
+    /// Returns the Objective-C type encoding for Self.
+    const ENCODING: Encoding<'static>;
+}
+
+macro_rules! encode_impls {
+    ($($t:ty : $e:ident,)*) => ($(
+        unsafe impl Encode for $t {
+            const ENCODING: Encoding<'static> = Encoding::$e;
+        }
+    )*);
+}
+
+encode_impls!(
+    i8: Char,
+    i16: Short,
+    i32: Int,
+    i64: LongLong,
+    u8: UChar,
+    u16: UShort,
+    u32: UInt,
+    u64: ULongLong,
+    f32: Float,
+    f64: Double,
+    bool: Bool,
+    (): Void,
+    *mut i8: String,
+    *const i8: String,
+    *mut u8: String,
+    *const u8: String,
+);
+
+unsafe impl Encode for isize {
+    #[cfg(target_pointer_width = "32")]
+    const ENCODING: Encoding<'static> = i32::ENCODING;
+
+    #[cfg(target_pointer_width = "64")]
+    const ENCODING: Encoding<'static> = i64::ENCODING;
+}
+
+unsafe impl Encode for usize {
+    #[cfg(target_pointer_width = "32")]
+    const ENCODING: Encoding<'static> = u32::ENCODING;
+
+    #[cfg(target_pointer_width = "64")]
+    const ENCODING: Encoding<'static> = u64::ENCODING;
+}
+
+unsafe impl Encode for *mut c_void {
+    const ENCODING: Encoding<'static> = Encoding::Pointer(&Encoding::Void);
+}
+
+unsafe impl Encode for *const c_void {
+    const ENCODING: Encoding<'static> = Encoding::Pointer(&Encoding::Void);
+}
+
+// TODO: Replace this with a const generics implementation when they stabilise (#44580)
+macro_rules! slice_encode_impl {
+    ($($n:literal),* $(,)?) => {
+        $(
+            unsafe impl<T: Encode> Encode for [T; $n] {
+                const ENCODING: Encoding<'static> = Encoding::Array($n, &<T as Encode>::ENCODING);
+            }
+        )*
+    };
+}
+
+slice_encode_impl!(
+    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
+    27, 28, 29, 30, 31, 32
+);
+
+/*
+External crates cannot implement Encode for pointers or Optionals, but they
+*can* implement it for references. rust-lang/rust#25126
+
+As a workaround, we provide implementations for these types that return the
+same encoding as references.
+*/
+unsafe impl<T> Encode for *const T where for<'b> &'b T: Encode {
+    const ENCODING: Encoding<'static> = <&T>::ENCODING;
+}
+
+unsafe impl<T> Encode for *mut T where for<'b> &'b mut T: Encode {
+    const ENCODING: Encoding<'static> = <&mut T>::ENCODING;
+}
+
+unsafe impl<'a, T> Encode for Option<&'a T> where for<'b> &'b T: Encode {
+    const ENCODING: Encoding<'static> = <&T>::ENCODING;
+}
+
+unsafe impl<'a, T> Encode for Option<&'a mut T> where for<'b> &'b mut T: Encode {
+    const ENCODING: Encoding<'static> = <&mut T>::ENCODING;
+}
diff --git a/objc_encode/src/encoding.rs b/objc_encode/src/encoding.rs
new file mode 100644
index 000000000..099ee8da8
--- /dev/null
+++ b/objc_encode/src/encoding.rs
@@ -0,0 +1,172 @@
+use core::fmt;
+
+use crate::parse;
+
+/// An Objective-C type encoding.
+///
+/// For more information, see Apple's documentation:
+/// <https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtTypeEncodings.html>
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Encoding<'a> {
+    Char,
+    Short,
+    Int,
+    Long,
+    LongLong,
+    UChar,
+    UShort,
+    UInt,
+    ULong,
+    ULongLong,
+    Float,
+    Double,
+    Bool,
+    Void,
+    String,
+    Object,
+    Block,
+    Class,
+    Sel,
+    Unknown,
+    BitField(u32),
+    Pointer(&'a Encoding<'a>),
+    Array(u32, &'a Encoding<'a>),
+    Struct(&'a str, &'a [Encoding<'a>]),
+    Union(&'a str, &'a [Encoding<'a>]),
+}
+
+impl fmt::Display for Encoding<'_> {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        use Encoding::*;
+        let code = match *self {
+            Char      => "c",
+            Short     => "s",
+            Int       => "i",
+            Long      => "l",
+            LongLong  => "q",
+            UChar     => "C",
+            UShort    => "S",
+            UInt      => "I",
+            ULong     => "L",
+            ULongLong => "Q",
+            Float     => "f",
+            Double    => "d",
+            Bool      => "B",
+            Void      => "v",
+            String    => "*",
+            Object    => "@",
+            Block     => "@?",
+            Class     => "#",
+            Sel       => ":",
+            Unknown   => "?",
+            BitField(b) => {
+                return write!(formatter, "b{}", b);
+            }
+            Pointer(t) => {
+                return write!(formatter, "^{}", t);
+            }
+            Array(len, item) => {
+                return write!(formatter, "[{}{}]", len, item);
+            }
+            Struct(name, fields) => {
+                write!(formatter, "{{{}=", name)?;
+                for field in fields {
+                    fmt::Display::fmt(field, formatter)?;
+                }
+                return formatter.write_str("}");
+            }
+            Union(name, members) => {
+                write!(formatter, "({}=", name)?;
+                for member in members {
+                    fmt::Display::fmt(member, formatter)?;
+                }
+                return formatter.write_str(")");
+            }
+        };
+        formatter.write_str(code)
+    }
+}
+
+impl PartialEq<str> for Encoding<'_> {
+    fn eq(&self, other: &str) -> bool {
+        parse::eq_enc(other, self)
+    }
+}
+
+impl PartialEq<Encoding<'_>> for str {
+    fn eq(&self, other: &Encoding) -> bool {
+        parse::eq_enc(self, other)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::string::ToString;
+    use super::Encoding;
+
+    #[test]
+    fn test_array_display() {
+        let e = Encoding::Array(12, &Encoding::Int);
+        assert_eq!(e.to_string(), "[12i]");
+        assert_eq!(&e, "[12i]");
+    }
+
+    #[test]
+    fn test_pointer_display() {
+        let e = Encoding::Pointer(&Encoding::Int);
+        assert_eq!(e.to_string(), "^i");
+        assert_eq!(&e, "^i");
+    }
+
+    #[test]
+    fn test_pointer_eq() {
+        let i = Encoding::Int;
+        let p = Encoding::Pointer(&Encoding::Int);
+
+        assert!(p == p);
+        assert!(p != i);
+    }
+
+    #[test]
+    fn test_int_display() {
+        assert_eq!(Encoding::Int.to_string(), "i");
+        assert_eq!(&Encoding::Int, "i");
+    }
+
+    #[test]
+    fn test_eq() {
+        let i = Encoding::Int;
+        let c = Encoding::Char;
+
+        assert!(i == i);
+        assert!(i != c);
+    }
+
+    #[test]
+    fn test_struct_display() {
+        let s = Encoding::Struct("CGPoint", &[Encoding::Char, Encoding::Int]);
+        assert_eq!(s.to_string(), "{CGPoint=ci}");
+        assert_eq!(&s, "{CGPoint=ci}");
+    }
+
+    #[test]
+    fn test_struct_eq() {
+        let s = Encoding::Struct("CGPoint", &[Encoding::Char, Encoding::Int]);
+        assert!(s == s);
+        assert!(s != Encoding::Int);
+    }
+
+    #[test]
+    fn test_union_display() {
+        let u = Encoding::Union("Onion", &[Encoding::Char, Encoding::Int]);
+        assert_eq!(u.to_string(), "(Onion=ci)");
+        assert_eq!(&u, "(Onion=ci)");
+    }
+
+    #[test]
+    fn test_union_eq() {
+        let u = Encoding::Union("Onion", &[Encoding::Char, Encoding::Int]);
+        assert!(u == u);
+        assert!(u != Encoding::Int);
+    }
+}
diff --git a/objc_encode/src/lib.rs b/objc_encode/src/lib.rs
new file mode 100644
index 000000000..12052da8b
--- /dev/null
+++ b/objc_encode/src/lib.rs
@@ -0,0 +1,54 @@
+/*!
+Objective-C type encoding creation and parsing in Rust.
+
+The Objective-C compiler encodes types as strings for usage in the runtime.
+This crate aims to provide a strongly-typed (rather than stringly-typed) way
+to create and describe these type encodings without memory allocation in Rust.
+
+# Implementing Encode
+
+This crate declares an `Encode` trait that can be implemented for types that
+the Objective-C compiler can encode. Implementing this trait looks like:
+
+``` ignore
+unsafe impl Encode for CGPoint {
+    const ENCODING: Encoding<'static> =
+        Encoding::Struct("CGPoint", &[CGFloat::ENCODING, CGFLOAT::ENCODING]);
+}
+```
+
+For an example of how this works with more complex types, like structs
+containing structs, see the `core_graphics` example.
+
+# Comparing with encoding strings
+
+An `Encoding` can be compared with an encoding string from the Objective-C
+runtime:
+
+```
+# use objc_encode::Encode;
+assert!(&i32::ENCODING == "i");
+```
+
+# Generating encoding strings
+
+Every `Encoding` implements `Display` as its string representation.
+This can be generated conveniently through the `to_string` method:
+
+```
+# use objc_encode::Encode;
+assert_eq!(i32::ENCODING.to_string(), "i");
+```
+*/
+
+#![no_std]
+
+#[cfg(test)]
+extern crate std;
+
+mod encoding;
+mod encode;
+mod parse;
+
+pub use crate::encoding::Encoding;
+pub use crate::encode::Encode;
diff --git a/objc_encode/src/parse.rs b/objc_encode/src/parse.rs
new file mode 100644
index 000000000..645776fce
--- /dev/null
+++ b/objc_encode/src/parse.rs
@@ -0,0 +1,146 @@
+//! Parsing encodings from their string representation.
+
+use crate::Encoding;
+
+const QUALIFIERS: &'static [char] = &[
+    'r', // const
+    'n', // in
+    'N', // inout
+    'o', // out
+    'O', // bycopy
+    'R', // byref
+    'V', // oneway
+];
+
+fn rm_enc_prefix<'a>(s: &'a str, enc: &Encoding) -> Option<&'a str> {
+    use Encoding::*;
+    let code = match *enc {
+        Char      => "c",
+        Short     => "s",
+        Int       => "i",
+        Long      => "l",
+        LongLong  => "q",
+        UChar     => "C",
+        UShort    => "S",
+        UInt      => "I",
+        ULong     => "L",
+        ULongLong => "Q",
+        Float     => "f",
+        Double    => "d",
+        Bool      => "B",
+        Void      => "v",
+        String    => "*",
+        Object    => "@",
+        Block     => "@?",
+        Class     => "#",
+        Sel       => ":",
+        Unknown   => "?",
+        BitField(b) => {
+            let s = rm_prefix(s, "b")?;
+            return rm_int_prefix(s, b);
+        }
+        Pointer(t) => {
+            let s = rm_prefix(s, "^")?;
+            return rm_enc_prefix(s, t);
+        }
+        Array(len, item) => {
+            let mut s = s;
+            s = rm_prefix(s, "[")?;
+            s = rm_int_prefix(s, len)?;
+            s = rm_enc_prefix(s, item)?;
+            return rm_prefix(s, "]");
+        }
+        Struct(name, fields) => {
+            let mut s = s;
+            s = rm_prefix(s, "{")?;
+            s = rm_prefix(s, name)?;
+            s = rm_prefix(s, "=")?;
+            for field in fields {
+                s = rm_enc_prefix(s, field)?;
+            }
+            return rm_prefix(s, "}");
+        }
+        Union(name, members) => {
+            let mut s = s;
+            s = rm_prefix(s, "(")?;
+            s = rm_prefix(s, name)?;
+            s = rm_prefix(s, "=")?;
+            for member in members {
+                s = rm_enc_prefix(s, member)?;
+            }
+            return rm_prefix(s, ")");
+        }
+    };
+
+    rm_prefix(s, code)
+}
+
+fn chomp_int(s: &str) -> Option<(u32, &str)> {
+    // Chomp until we hit a non-digit
+    let (num, t) = match s.find(|c: char| !c.is_digit(10)) {
+        Some(i) => s.split_at(i),
+        None => (s, ""),
+    };
+    num.parse().map(|n| (n, t)).ok()
+}
+
+fn rm_int_prefix(s: &str, other: u32) -> Option<&str> {
+    chomp_int(s)
+        .and_then(|(n, t)| if other == n { Some(t) } else { None })
+}
+
+fn rm_prefix<'a>(s: &'a str, other: &str) -> Option<&'a str> {
+    if s.starts_with(other) {
+        Some(&s[other.len()..])
+    } else {
+        None
+    }
+}
+
+pub fn eq_enc(s: &str, enc: &Encoding) -> bool {
+    // strip qualifiers
+    let s = s.trim_start_matches(QUALIFIERS);
+
+    // if the given encoding can be successfully removed from the start
+    // and an empty string remains, they were equal!
+    rm_enc_prefix(s, enc).map_or(false, str::is_empty)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_nested() {
+        let enc = Encoding::Struct("A", &[
+            Encoding::Struct("B", &[
+                Encoding::Char,
+                Encoding::Int,
+            ]),
+            Encoding::Char,
+            Encoding::Int,
+        ]);
+        assert!(eq_enc("{A={B=ci}ci}", &enc));
+        assert!(!eq_enc("{A={B=ci}ci", &enc));
+
+    }
+
+    #[test]
+    fn test_bitfield() {
+        assert!(eq_enc("b32", &Encoding::BitField(32)));
+        assert!(!eq_enc("b", &Encoding::BitField(32)));
+        assert!(!eq_enc("b-32", &Encoding::BitField(32)));
+    }
+
+    #[test]
+    fn test_qualifiers() {
+        assert!(eq_enc("Vv", &Encoding::Void));
+        assert!(eq_enc("r*", &Encoding::String));
+    }
+
+    #[test]
+    fn test_unicode() {
+        let fields = &[Encoding::Char, Encoding::Int];
+        assert!(eq_enc("{☃=ci}", &Encoding::Struct("☃", fields)));
+    }
+}
diff --git a/objc_exception/Cargo.toml b/objc_exception/Cargo.toml
new file mode 100644
index 000000000..7bb99c7cf
--- /dev/null
+++ b/objc_exception/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "objc_exception"
+version = "0.1.2"
+authors = ["Steven Sheldon"]
+
+description = "Rust interface for Objective-C's throw and try/catch statements."
+keywords = ["objective-c", "osx", "ios"]
+repository = "http://github.com/SSheldon/rust-objc-exception"
+documentation = "http://ssheldon.github.io/rust-objc/objc_exception/"
+license = "MIT"
+
+exclude = [".gitignore"]
+
+build = "build.rs"
+
+[build-dependencies]
+cc = "1"
diff --git a/objc_exception/build.rs b/objc_exception/build.rs
new file mode 100644
index 000000000..ba728b6e1
--- /dev/null
+++ b/objc_exception/build.rs
@@ -0,0 +1,7 @@
+extern crate cc;
+
+fn main() {
+    cc::Build::new()
+        .file("extern/exception.m")
+        .compile("libexception.a");
+}
diff --git a/objc_exception/extern/exception.m b/objc_exception/extern/exception.m
new file mode 100644
index 000000000..700439ecf
--- /dev/null
+++ b/objc_exception/extern/exception.m
@@ -0,0 +1,21 @@
+#include <objc/objc.h>
+#include <objc/NSObject.h>
+
+void RustObjCExceptionThrow(id exception) {
+    @throw exception;
+}
+
+int RustObjCExceptionTryCatch(void (*try)(void *), void *context, id *error) {
+    @try {
+        try(context);
+        if (error) {
+            *error = nil;
+        }
+        return 0;
+    } @catch (id exception) {
+        if (error) {
+            *error = [exception retain];
+        }
+        return 1;
+    }
+}
diff --git a/objc_exception/src/lib.rs b/objc_exception/src/lib.rs
new file mode 100644
index 000000000..d381f60c7
--- /dev/null
+++ b/objc_exception/src/lib.rs
@@ -0,0 +1,100 @@
+//! Rust interface for Objective-C's `@throw` and `@try`/`@catch` statements.
+
+use std::mem;
+use std::os::raw::{c_int, c_void};
+use std::ptr;
+
+#[link(name = "objc", kind = "dylib")]
+extern { }
+
+extern {
+    fn RustObjCExceptionThrow(exception: *mut c_void);
+    fn RustObjCExceptionTryCatch(try: extern fn(*mut c_void),
+            context: *mut c_void, error: *mut *mut c_void) -> c_int;
+}
+
+/// An opaque type representing any Objective-C object thrown as an exception.
+pub enum Exception { }
+
+/// Throws an Objective-C exception.
+/// The argument must be a pointer to an Objective-C object.
+///
+/// Unsafe because this unwinds from Objective-C.
+pub unsafe fn throw(exception: *mut Exception) -> ! {
+    RustObjCExceptionThrow(exception as *mut _);
+    unreachable!();
+}
+
+unsafe fn try_no_ret<F>(closure: F) -> Result<(), *mut Exception>
+        where F: FnOnce() {
+    extern fn try_objc_execute_closure<F>(closure: &mut Option<F>)
+            where F: FnOnce() {
+        // This is always passed Some, so it's safe to unwrap
+        let closure = closure.take().unwrap();
+        closure();
+    }
+
+    let f: extern fn(&mut Option<F>) = try_objc_execute_closure;
+    let f: extern fn(*mut c_void) = mem::transmute(f);
+    // Wrap the closure in an Option so it can be taken
+    let mut closure = Some(closure);
+    let context = &mut closure as *mut _ as *mut c_void;
+
+    let mut exception = ptr::null_mut();
+    let success = RustObjCExceptionTryCatch(f, context, &mut exception);
+
+    if success == 0 {
+        Ok(())
+    } else {
+        Err(exception as *mut _)
+    }
+}
+
+/// Tries to execute the given closure and catches an Objective-C exception
+/// if one is thrown.
+///
+/// Returns a `Result` that is either `Ok` if the closure succeeded without an
+/// exception being thrown, or an `Err` with a pointer to an exception if one
+/// was thrown. The exception is retained and so must be released.
+///
+/// Unsafe because this encourages unwinding through the closure from
+/// Objective-C, which is not safe.
+pub unsafe fn try<F, R>(closure: F) -> Result<R, *mut Exception>
+        where F: FnOnce() -> R {
+    let mut value = None;
+    let result = {
+        let value_ref = &mut value;
+        try_no_ret(move || {
+            *value_ref = Some(closure());
+        })
+    };
+    // If the try succeeded, this was set so it's safe to unwrap
+    result.map(|_| value.unwrap())
+}
+
+#[cfg(test)]
+mod tests {
+    use std::ptr;
+    use super::{throw, try};
+
+    #[test]
+    fn test_try() {
+        unsafe {
+            let s = "Hello".to_string();
+            let result = try(move || {
+                if s.len() > 0 {
+                    throw(ptr::null_mut());
+                }
+                s.len()
+            });
+            assert!(result.unwrap_err() == ptr::null_mut());
+
+            let mut s = "Hello".to_string();
+            let result = try(move || {
+                s.push_str(", World!");
+                s
+            });
+            assert!(result.unwrap() == "Hello, World!");
+        }
+    }
+}
diff --git a/objc_foundation/Cargo.toml b/objc_foundation/Cargo.toml
new file mode 100644
index 000000000..17c4a0ed4
--- /dev/null
+++ b/objc_foundation/Cargo.toml
@@ -0,0 +1,18 @@
+[package]
+name = "objc-foundation"
+version = "0.1.1"
+authors = ["Steven Sheldon"]
+
+description = "Rust wrapper for Objective-C's Foundation framework."
+keywords = ["objective-c", "osx", "ios", "cocoa", "uikit"]
+repository = "http://github.com/SSheldon/rust-objc-foundation"
+documentation = "http://ssheldon.github.io/rust-objc/objc_foundation/"
+license = "MIT"
+
+exclude = [".gitignore"]
+
+[dependencies]
+block = "0.1"
+# TODO: Refer to the crates in this repo with `path = "XYZ"`
+objc = "0.2.2"
+objc_id = "0.1"
diff --git a/objc_foundation/derive/Cargo.toml b/objc_foundation/derive/Cargo.toml
new file mode 100644
index 000000000..6b9b8cbe1
--- /dev/null
+++ b/objc_foundation/derive/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "objc-foundation-derive"
+version = "0.0.1"
+authors = ["Steven Sheldon"]
+
+description = "Procedural macros for deriving traits from objc-foundation."
+keywords = ["objective-c", "osx", "ios", "cocoa", "uikit"]
+repository = "http://github.com/SSheldon/rust-objc-foundation"
+documentation = "http://ssheldon.github.io/rust-objc/objc_foundation/"
+license = "MIT"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = "0.10"
+quote = "0.3.8"
diff --git a/objc_foundation/derive/src/lib.rs b/objc_foundation/derive/src/lib.rs
new file mode 100644
index 000000000..8e381121f
--- /dev/null
+++ b/objc_foundation/derive/src/lib.rs
@@ -0,0 +1,68 @@
+extern crate proc_macro;
+#[macro_use]
+extern crate quote;
+extern crate syn;
+
+use proc_macro::TokenStream;
+use quote::{Tokens, ToTokens};
+
+#[proc_macro_derive(INSObject)]
+pub fn impl_object(input: TokenStream) -> TokenStream {
+    // Construct a string representation of the type definition
+    let s = input.to_string();
+
+    // Parse the string representation
+    let ast = syn::parse_macro_input(&s).unwrap();
+
+    // Build the impl
+    let name = &ast.ident;
+    let link_name = format!("OBJC_CLASS_$_{}", name);
+    let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
+
+    let mut gen = Tokens::new();
+    quote!(
+        unsafe impl #impl_generics ::objc::Message for #name #ty_generics #where_clause { }
+    ).to_tokens(&mut gen);
+
+    quote!(
+        impl #impl_generics INSObject for #name #ty_generics #where_clause {
+            fn class() -> &'static ::objc::runtime::Class {
+                extern {
+                    #[link_name = #link_name]
+                    static OBJC_CLASS: ::objc::runtime::Class;
+                }
+                unsafe {
+                    &OBJC_CLASS
+                }
+            }
+        }
+    ).to_tokens(&mut gen);
+
+    quote!(
+        impl #impl_generics ::std::cmp::PartialEq for #name #ty_generics #where_clause {
+            fn eq(&self, other: &Self) -> bool {
+                INSObject::is_equal(self, other)
+            }
+        }
+    ).to_tokens(&mut gen);
+
+    quote!(
+        impl #impl_generics ::std::hash::Hash for #name #ty_generics #where_clause {
+            fn hash<H>(&self, state: &mut H) where H: ::std::hash::Hasher {
+                INSObject::hash_code(self).hash(state);
+            }
+        }
+    ).to_tokens(&mut gen);
+
+    quote!(
+        impl #impl_generics ::std::fmt::Debug for #name #ty_generics #where_clause {
+            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                let s = INSObject::description(self);
+                ::std::fmt::Display::fmt(&*s, f)
+            }
+        }
+    ).to_tokens(&mut gen);
+
+    // Return the generated impl
+    gen.parse().unwrap()
+}
diff --git a/objc_foundation/examples/custom_class.rs b/objc_foundation/examples/custom_class.rs
new file mode 100644
index 000000000..793e0bf5a
--- /dev/null
+++ b/objc_foundation/examples/custom_class.rs
@@ -0,0 +1,77 @@
+#[macro_use]
+extern crate objc;
+extern crate objc_foundation;
+
+use std::sync::{Once, ONCE_INIT};
+
+use objc::Message;
+use objc::declare::ClassDecl;
+use objc::runtime::{Class, Object, Sel};
+use objc_foundation::{INSObject, NSObject};
+
+pub enum MYObject { }
+
+impl MYObject {
+    fn number(&self) -> u32 {
+        unsafe {
+            let obj = &*(self as *const _ as *const Object);
+            *obj.get_ivar("_number")
+        }
+    }
+
+    fn set_number(&mut self, number: u32) {
+        unsafe {
+            let obj =  &mut *(self as *mut _ as *mut Object);
+            obj.set_ivar("_number", number);
+        }
+    }
+}
+
+unsafe impl Message for MYObject { }
+
+static MYOBJECT_REGISTER_CLASS: Once = ONCE_INIT;
+
+impl INSObject for MYObject {
+    fn class() -> &'static Class {
+        MYOBJECT_REGISTER_CLASS.call_once(|| {
+            let superclass = NSObject::class();
+            let mut decl = ClassDecl::new("MYObject", superclass).unwrap();
+            decl.add_ivar::<u32>("_number");
+
+            // Add ObjC methods for getting and setting the number
+            extern fn my_object_set_number(this: &mut Object, _cmd: Sel, number: u32) {
+                unsafe { this.set_ivar("_number", number); }
+            }
+
+            extern fn my_object_get_number(this: &Object, _cmd: Sel) -> u32 {
+                unsafe { *this.get_ivar("_number") }
+            }
+
+            unsafe {
+                let set_number: extern fn(&mut Object, Sel, u32) = my_object_set_number;
+                decl.add_method(sel!(setNumber:), set_number);
+                let get_number: extern fn(&Object, Sel) -> u32 = my_object_get_number;
+                decl.add_method(sel!(number), get_number);
+            }
+
+            decl.register();
+        });
+
+        Class::get("MYObject").unwrap()
+    }
+}
+
+fn main() {
+    let mut obj = MYObject::new();
+
+    obj.set_number(7);
+    println!("Number: {}", unsafe {
+        let number: u32 = msg_send![obj, number];
+        number
+    });
+
+    unsafe {
+        let _: () = msg_send![obj, setNumber:12u32];
+    }
+    println!("Number: {}", obj.number());
+}
diff --git a/objc_foundation/examples/example.rs b/objc_foundation/examples/example.rs
new file mode 100644
index 000000000..533848717
--- /dev/null
+++ b/objc_foundation/examples/example.rs
@@ -0,0 +1,38 @@
+extern crate objc_foundation;
+
+use objc_foundation::{NSArray, NSDictionary, NSObject, NSString,
+    INSArray, INSCopying, INSDictionary, INSObject, INSString};
+
+fn main() {
+    // Create and compare NSObjects
+    let obj = NSObject::new();
+    println!("{:?} == {:?}? {:?}", obj, obj, obj == obj);
+
+    let obj2 = NSObject::new();
+    println!("{:?} == {:?}? {:?}", obj, obj2, obj == obj2);
+
+    // Create an NSArray from a Vec
+    let objs = vec![obj, obj2];
+    let array = NSArray::from_vec(objs);
+    for obj in array.object_enumerator() {
+        println!("{:?}", obj);
+    }
+    println!("{}", array.count());
+
+    // Turn the NSArray back into a Vec
+    let mut objs = NSArray::into_vec(array);
+    let obj = objs.pop().unwrap();
+
+    // Create an NSString from a str slice
+    let string = NSString::from_str("Hello, world!");
+    println!("{}", string.as_str());
+    let string2 = string.copy();
+    println!("{}", string2.as_str());
+
+    // Create a dictionary mapping strings to objects
+    let keys = &[&*string];
+    let vals = vec![obj];
+    let dict = NSDictionary::from_keys_and_objects(keys, vals);
+    println!("{:?}", dict.object_for(&string));
+    println!("{}", dict.count());
+}
diff --git a/objc_foundation/src/array.rs b/objc_foundation/src/array.rs
new file mode 100644
index 000000000..7eda34413
--- /dev/null
+++ b/objc_foundation/src/array.rs
@@ -0,0 +1,444 @@
+use std::cmp::Ordering;
+use std::marker::PhantomData;
+use std::ops::{Index, Range};
+use std::os::raw::c_void;
+
+use objc::runtime::{Class, Object};
+use objc_id::{Id, Owned, Ownership, Shared, ShareId};
+
+use {INSCopying, INSFastEnumeration, INSMutableCopying, INSObject, NSEnumerator};
+
+#[repr(isize)]
+#[derive(Clone, Copy)]
+pub enum NSComparisonResult {
+    Ascending  = -1,
+    Same       = 0,
+    Descending = 1,
+}
+
+impl NSComparisonResult {
+    pub fn from_ordering(order: Ordering) -> NSComparisonResult {
+        match order {
+            Ordering::Less => NSComparisonResult::Ascending,
+            Ordering::Equal => NSComparisonResult::Same,
+            Ordering::Greater => NSComparisonResult::Descending,
+        }
+    }
+
+    pub fn as_ordering(&self) -> Ordering {
+        match *self {
+            NSComparisonResult::Ascending => Ordering::Less,
+            NSComparisonResult::Same => Ordering::Equal,
+            NSComparisonResult::Descending => Ordering::Greater,
+        }
+    }
+}
+
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct NSRange {
+    pub location: usize,
+    pub length: usize,
+}
+
+impl NSRange {
+    pub fn from_range(range: Range<usize>) -> NSRange {
+        assert!(range.end >= range.start);
+        NSRange { location: range.start, length: range.end - range.start }
+    }
+
+    pub fn as_range(&self) -> Range<usize> {
+        Range { start: self.location, end: self.location + self.length }
+    }
+}
+
+unsafe fn from_refs<A>(refs: &[&A::Item]) -> Id<A> where A: INSArray {
+    let cls = A::class();
+    let obj: *mut A = msg_send![cls, alloc];
+    let obj: *mut A = msg_send![obj, initWithObjects:refs.as_ptr()
+                                               count:refs.len()];
+    Id::from_retained_ptr(obj)
+}
+
+pub trait INSArray : INSObject {
+    type Item: INSObject;
+    type Own: Ownership;
+
+    fn count(&self) -> usize {
+        unsafe {
+            msg_send![self, count]
+        }
+    }
+
+    fn object_at(&self, index: usize) -> &Self::Item {
+        unsafe {
+            let obj: *const Self::Item = msg_send![self, objectAtIndex:index];
+            &*obj
+        }
+    }
+
+    fn first_object(&self) -> Option<&Self::Item> {
+        unsafe {
+            let obj: *const Self::Item = msg_send![self, firstObject];
+            if obj.is_null() { None } else { Some(&*obj) }
+        }
+    }
+
+    fn last_object(&self) -> Option<&Self::Item> {
+        unsafe {
+            let obj: *const Self::Item = msg_send![self, lastObject];
+            if obj.is_null() { None } else { Some(&*obj) }
+        }
+    }
+
+    fn object_enumerator(&self) -> NSEnumerator<Self::Item> {
+        unsafe {
+            let result: *mut Object = msg_send![self, objectEnumerator];
+            NSEnumerator::from_ptr(result)
+        }
+    }
+
+    fn from_vec(vec: Vec<Id<Self::Item, Self::Own>>) -> Id<Self> {
+        let refs: Vec<&Self::Item> = vec.iter().map(|obj| &**obj).collect();
+        unsafe {
+            from_refs(&refs)
+        }
+    }
+
+    fn objects_in_range(&self, range: Range<usize>) -> Vec<&Self::Item> {
+        let range = NSRange::from_range(range);
+        let mut vec = Vec::with_capacity(range.length);
+        unsafe {
+            let _: () = msg_send![self, getObjects:vec.as_ptr() range:range];
+            vec.set_len(range.length);
+        }
+        vec
+    }
+
+    fn to_vec(&self) -> Vec<&Self::Item> {
+        self.objects_in_range(0..self.count())
+    }
+
+    fn into_vec(array: Id<Self>) -> Vec<Id<Self::Item, Self::Own>> {
+        array.to_vec().into_iter().map(|obj| unsafe {
+            let obj_ptr: *const Self::Item = obj;
+            Id::from_ptr(obj_ptr as *mut Self::Item)
+        }).collect()
+    }
+
+    fn mut_object_at(&mut self, index: usize) -> &mut Self::Item
+            where Self: INSArray<Own=Owned> {
+        unsafe {
+            let result: *mut Self::Item = msg_send![self, objectAtIndex:index];
+            &mut *result
+        }
+    }
+
+    fn shared_object_at(&self, index: usize) -> ShareId<Self::Item>
+            where Self: INSArray<Own=Shared> {
+        let obj = self.object_at(index);
+        unsafe {
+            Id::from_ptr(obj as *const _ as *mut Self::Item)
+        }
+    }
+
+    fn from_slice(slice: &[ShareId<Self::Item>]) -> Id<Self>
+            where Self: INSArray<Own=Shared> {
+        let refs: Vec<&Self::Item> = slice.iter().map(|obj| &**obj).collect();
+        unsafe {
+            from_refs(&refs)
+        }
+    }
+
+    fn to_shared_vec(&self) -> Vec<ShareId<Self::Item>>
+            where Self: INSArray<Own=Shared> {
+        self.to_vec().into_iter().map(|obj| unsafe {
+            let obj_ptr: *const Self::Item = obj;
+            Id::from_ptr(obj_ptr as *mut Self::Item)
+        }).collect()
+    }
+}
+
+pub struct NSArray<T, O = Owned> {
+    item: PhantomData<Id<T, O>>,
+}
+
+object_impl!(NSArray<T, O>);
+
+impl<T, O> INSObject for NSArray<T, O> where T: INSObject, O: Ownership {
+    fn class() -> &'static Class {
+        class!(NSArray)
+    }
+}
+
+impl<T, O> INSArray for NSArray<T, O> where T: INSObject, O: Ownership {
+    type Item = T;
+    type Own = O;
+}
+
+impl<T> INSCopying for NSArray<T, Shared> where T: INSObject {
+    type Output = NSSharedArray<T>;
+}
+
+impl<T> INSMutableCopying for NSArray<T, Shared> where T: INSObject {
+    type Output = NSMutableSharedArray<T>;
+}
+
+impl<T, O> INSFastEnumeration for NSArray<T, O>
+        where T: INSObject, O: Ownership {
+    type Item = T;
+}
+
+impl<T, O> Index<usize> for NSArray<T, O> where T: INSObject, O: Ownership {
+    type Output = T;
+
+    fn index(&self, index: usize) -> &T {
+        self.object_at(index)
+    }
+}
+
+pub type NSSharedArray<T> = NSArray<T, Shared>;
+
+pub trait INSMutableArray : INSArray {
+    fn add_object(&mut self, obj: Id<Self::Item, Self::Own>) {
+        unsafe {
+            let _: () = msg_send![self, addObject:&*obj];
+        }
+    }
+
+    fn insert_object_at(&mut self, index: usize, obj: Id<Self::Item, Self::Own>) {
+        unsafe {
+            let _: () = msg_send![self, insertObject:&*obj atIndex:index];
+        }
+    }
+
+    fn replace_object_at(&mut self, index: usize, obj: Id<Self::Item, Self::Own>) ->
+            Id<Self::Item, Self::Own> {
+        let old_obj = unsafe {
+            let obj = self.object_at(index);
+            Id::from_ptr(obj as *const _ as *mut Self::Item)
+        };
+        unsafe {
+            let _: () = msg_send![self, replaceObjectAtIndex:index
+                                                  withObject:&*obj];
+        }
+        old_obj
+    }
+
+    fn remove_object_at(&mut self, index: usize) -> Id<Self::Item, Self::Own> {
+        let obj = unsafe {
+            let obj = self.object_at(index);
+            Id::from_ptr(obj as *const _ as *mut Self::Item)
+        };
+        unsafe {
+            let _: () = msg_send![self, removeObjectAtIndex:index];
+        }
+        obj
+    }
+
+    fn remove_last_object(&mut self) -> Id<Self::Item, Self::Own> {
+        let obj = self.last_object().map(|obj| unsafe {
+            Id::from_ptr(obj as *const _ as *mut Self::Item)
+        });
+        unsafe {
+            let _: () = msg_send![self, removeLastObject];
+        }
+        // removeLastObject would have failed if the array is empty,
+        // so we know this won't be None
+        obj.unwrap()
+    }
+
+    fn remove_all_objects(&mut self) {
+        unsafe {
+            let _: () = msg_send![self, removeAllObjects];
+        }
+    }
+
+    fn sort_by<F>(&mut self, compare: F)
+            where F: FnMut(&Self::Item, &Self::Item) -> Ordering {
+        extern fn compare_with_closure<T, F>(obj1: &T, obj2: &T,
+                compare: &mut F) -> NSComparisonResult
+                where F: FnMut(&T, &T) -> Ordering {
+            NSComparisonResult::from_ordering((*compare)(obj1, obj2))
+        }
+
+        let f: extern fn(&Self::Item, &Self::Item, &mut F) -> NSComparisonResult =
+            compare_with_closure;
+        let mut closure = compare;
+        let closure_ptr: *mut F = &mut closure;
+        let context = closure_ptr as *mut c_void;
+        unsafe {
+            let _: () = msg_send![self, sortUsingFunction:f
+                                                  context:context];
+        }
+    }
+}
+
+pub struct NSMutableArray<T, O = Owned> {
+    item: PhantomData<Id<T, O>>,
+}
+
+object_impl!(NSMutableArray<T, O>);
+
+impl<T, O> INSObject for NSMutableArray<T, O> where T: INSObject, O: Ownership {
+    fn class() -> &'static Class {
+        class!(NSMutableArray)
+    }
+}
+
+impl<T, O> INSArray for NSMutableArray<T, O> where T: INSObject, O: Ownership {
+    type Item = T;
+    type Own = O;
+}
+
+impl<T, O> INSMutableArray for NSMutableArray<T, O>
+        where T: INSObject, O: Ownership { }
+
+impl<T> INSCopying for NSMutableArray<T, Shared> where T: INSObject {
+    type Output = NSSharedArray<T>;
+}
+
+impl<T> INSMutableCopying for NSMutableArray<T, Shared> where T: INSObject {
+    type Output = NSMutableSharedArray<T>;
+}
+
+impl<T, O> INSFastEnumeration for NSMutableArray<T, O>
+        where T: INSObject, O: Ownership {
+    type Item = T;
+}
+
+impl<T, O> Index<usize> for NSMutableArray<T, O>
+        where T: INSObject, O: Ownership {
+    type Output = T;
+
+    fn index(&self, index: usize) -> &T {
+        self.object_at(index)
+    }
+}
+
+pub type NSMutableSharedArray<T> = NSMutableArray<T, Shared>;
+
+#[cfg(test)]
+mod tests {
+    use objc_id::Id;
+    use {INSObject, INSString, NSObject, NSString};
+    use super::{INSArray, INSMutableArray, NSArray, NSMutableArray};
+
+    fn sample_array(len: usize) -> Id<NSArray<NSObject>> {
+        let mut vec = Vec::with_capacity(len);
+        for _ in 0..len {
+            vec.push(NSObject::new());
+        }
+        NSArray::from_vec(vec)
+    }
+
+    #[test]
+    fn test_count() {
+        let empty_array = NSArray::<NSObject>::new();
+        assert!(empty_array.count() == 0);
+
+        let array = sample_array(4);
+        assert!(array.count() == 4);
+    }
+
+    #[test]
+    fn test_object_at() {
+        let array = sample_array(4);
+        assert!(array.object_at(0) != array.object_at(3));
+        assert!(array.first_object().unwrap() == array.object_at(0));
+        assert!(array.last_object().unwrap() == array.object_at(3));
+
+        let empty_array: Id<NSArray<NSObject>> = INSObject::new();
+        assert!(empty_array.first_object().is_none());
+        assert!(empty_array.last_object().is_none());
+    }
+
+    #[test]
+    fn test_object_enumerator() {
+        let array = sample_array(4);
+
+        assert!(array.object_enumerator().count() == 4);
+        assert!(array.object_enumerator()
+                     .enumerate()
+                     .all(|(i, obj)| obj == array.object_at(i)));
+    }
+
+    #[test]
+    fn test_objects_in_range() {
+        let array = sample_array(4);
+
+        let middle_objs = array.objects_in_range(1..3);
+        assert!(middle_objs.len() == 2);
+        assert!(middle_objs[0] == array.object_at(1));
+        assert!(middle_objs[1] == array.object_at(2));
+
+        let empty_objs = array.objects_in_range(1..1);
+        assert!(empty_objs.len() == 0);
+
+        let all_objs = array.objects_in_range(0..4);
+        assert!(all_objs.len() == 4);
+    }
+
+    #[test]
+    fn test_into_vec() {
+        let array = sample_array(4);
+
+        let vec = INSArray::into_vec(array);
+        assert!(vec.len() == 4);
+    }
+
+    #[test]
+    fn test_add_object() {
+        let mut array = NSMutableArray::new();
+        let obj = NSObject::new();
+        array.add_object(obj);
+
+        assert!(array.count() == 1);
+        assert!(array.object_at(0) == array.object_at(0));
+
+        let obj = NSObject::new();
+        array.insert_object_at(0, obj);
+        assert!(array.count() == 2);
+    }
+
+    #[test]
+    fn test_replace_object() {
+        let mut array = NSMutableArray::new();
+        let obj = NSObject::new();
+        array.add_object(obj);
+
+        let obj = NSObject::new();
+        let old_obj = array.replace_object_at(0, obj);
+        assert!(&*old_obj != array.object_at(0));
+    }
+
+    #[test]
+    fn test_remove_object() {
+        let mut array = NSMutableArray::new();
+        for _ in 0..4 {
+            array.add_object(NSObject::new());
+        }
+
+        array.remove_object_at(1);
+        assert!(array.count() == 3);
+
+        array.remove_last_object();
+        assert!(array.count() == 2);
+
+        array.remove_all_objects();
+        assert!(array.count() == 0);
+    }
+
+    #[test]
+    fn test_sort() {
+        let strings = vec![
+            NSString::from_str("hello"),
+            NSString::from_str("hi"),
+        ];
+        let mut strings = NSMutableArray::from_vec(strings);
+
+        strings.sort_by(|s1, s2| s1.as_str().len().cmp(&s2.as_str().len()));
+        assert!(strings[0].as_str() == "hi");
+        assert!(strings[1].as_str() == "hello");
+    }
+}
diff --git a/objc_foundation/src/data.rs b/objc_foundation/src/data.rs
new file mode 100644
index 000000000..53b1c022b
--- /dev/null
+++ b/objc_foundation/src/data.rs
@@ -0,0 +1,204 @@
+use std::mem;
+use std::ops::Range;
+use std::os::raw::c_void;
+use std::slice;
+
+use objc_id::Id;
+use block::{Block, ConcreteBlock};
+use {INSObject, INSCopying, INSMutableCopying, NSRange};
+
+pub trait INSData : INSObject {
+    fn len(&self) -> usize {
+        unsafe {
+            msg_send![self, length]
+        }
+    }
+
+    fn bytes(&self) -> &[u8] {
+        let ptr: *const c_void = unsafe { msg_send![self, bytes] };
+        // The bytes pointer may be null for length zero
+        let (ptr, len) = if ptr.is_null() {
+            (0x1 as *const u8, 0)
+        } else {
+            (ptr as *const u8, self.len())
+        };
+        unsafe {
+            slice::from_raw_parts(ptr, len)
+        }
+    }
+
+    fn with_bytes(bytes: &[u8]) -> Id<Self> {
+        let cls = Self::class();
+        let bytes_ptr = bytes.as_ptr() as *const c_void;
+        unsafe {
+            let obj: *mut Self = msg_send![cls, alloc];
+            let obj: *mut Self = msg_send![obj, initWithBytes:bytes_ptr
+                                                       length:bytes.len()];
+            Id::from_retained_ptr(obj)
+        }
+    }
+
+    fn from_vec(bytes: Vec<u8>) -> Id<Self> {
+        let capacity = bytes.capacity();
+        let dealloc = ConcreteBlock::new(move |bytes: *mut c_void, len: usize| unsafe {
+            // Recreate the Vec and let it drop
+            let _ = Vec::from_raw_parts(bytes as *mut u8, len, capacity);
+        });
+        let dealloc = dealloc.copy();
+        let dealloc: &Block<(*mut c_void, usize), ()> = &dealloc;
+
+        let mut bytes = bytes;
+        let bytes_ptr = bytes.as_mut_ptr() as *mut c_void;
+        let cls = Self::class();
+        unsafe {
+            let obj: *mut Self = msg_send![cls, alloc];
+            let obj: *mut Self = msg_send![obj, initWithBytesNoCopy:bytes_ptr
+                                                             length:bytes.len()
+                                                        deallocator:dealloc];
+            mem::forget(bytes);
+            Id::from_retained_ptr(obj)
+        }
+    }
+}
+
+object_struct!(NSData);
+
+impl INSData for NSData { }
+
+impl INSCopying for NSData {
+    type Output = NSData;
+}
+
+impl INSMutableCopying for NSData {
+    type Output = NSMutableData;
+}
+
+pub trait INSMutableData : INSData {
+    fn bytes_mut(&mut self) -> &mut [u8] {
+        let ptr: *mut c_void = unsafe { msg_send![self, mutableBytes] };
+        // The bytes pointer may be null for length zero
+        let (ptr, len) = if ptr.is_null() {
+            (0x1 as *mut u8, 0)
+        } else {
+            (ptr as *mut u8, self.len())
+        };
+        unsafe {
+            slice::from_raw_parts_mut(ptr, len)
+        }
+    }
+
+    fn set_len(&mut self, len: usize) {
+        unsafe {
+            let _: () = msg_send![self, setLength:len];
+        }
+    }
+
+    fn append(&mut self, bytes: &[u8]) {
+        let bytes_ptr = bytes.as_ptr() as *const c_void;
+        unsafe {
+            let _: () = msg_send![self, appendBytes:bytes_ptr
+                                             length:bytes.len()];
+        }
+    }
+
+    fn replace_range(&mut self, range: Range<usize>, bytes: &[u8]) {
+        let range = NSRange::from_range(range);
+        let bytes_ptr = bytes.as_ptr() as *const c_void;
+        unsafe {
+            let _: () = msg_send![self, replaceBytesInRange:range
+                                                  withBytes:bytes_ptr
+                                                     length:bytes.len()];
+        }
+    }
+
+    fn set_bytes(&mut self, bytes: &[u8]) {
+        let len = self.len();
+        self.replace_range(0..len, bytes);
+    }
+}
+
+object_struct!(NSMutableData);
+
+impl INSData for NSMutableData { }
+
+impl INSMutableData for NSMutableData { }
+
+impl INSCopying for NSMutableData {
+    type Output = NSData;
+}
+
+impl INSMutableCopying for NSMutableData {
+    type Output = NSMutableData;
+}
+
+#[cfg(test)]
+mod tests {
+    use INSObject;
+    use super::{INSData, INSMutableData, NSData, NSMutableData};
+
+    #[test]
+    fn test_bytes() {
+        let bytes = [3, 7, 16, 52, 112, 19];
+        let data = NSData::with_bytes(&bytes);
+        assert!(data.len() == bytes.len());
+        assert!(data.bytes() == bytes);
+    }
+
+    #[test]
+    fn test_no_bytes() {
+        let data = NSData::new();
+        assert!(Some(data.bytes()).is_some());
+    }
+
+    #[test]
+    fn test_bytes_mut() {
+        let mut data = NSMutableData::with_bytes(&[7, 16]);
+        data.bytes_mut()[0] = 3;
+        assert!(data.bytes() == [3, 16]);
+    }
+
+    #[test]
+    fn test_set_len() {
+        let mut data = NSMutableData::with_bytes(&[7, 16]);
+        data.set_len(4);
+        assert!(data.len() == 4);
+        assert!(data.bytes() == [7, 16, 0, 0]);
+
+        data.set_len(1);
+        assert!(data.len() == 1);
+        assert!(data.bytes() == [7]);
+    }
+
+    #[test]
+    fn test_append() {
+        let mut data = NSMutableData::with_bytes(&[7, 16]);
+        data.append(&[3, 52]);
+        assert!(data.len() == 4);
+        assert!(data.bytes() == [7, 16, 3, 52]);
+    }
+
+    #[test]
+    fn test_replace() {
+        let mut data = NSMutableData::with_bytes(&[7, 16]);
+        data.replace_range(0..0, &[3]);
+        assert!(data.bytes() == [3, 7, 16]);
+
+        data.replace_range(1..2, &[52, 13]);
+        assert!(data.bytes() == [3, 52, 13, 16]);
+
+        data.replace_range(2..4, &[6]);
+        assert!(data.bytes() == [3, 52, 6]);
+
+        data.set_bytes(&[8, 17]);
+        assert!(data.bytes() == [8, 17]);
+    }
+
+    #[test]
+    fn test_from_vec() {
+        let bytes = vec![3, 7, 16];
+        let bytes_ptr = bytes.as_ptr();
+
+        let data = NSData::from_vec(bytes);
+        assert!(data.bytes().as_ptr() == bytes_ptr);
+    }
+}
diff --git a/objc_foundation/src/dictionary.rs b/objc_foundation/src/dictionary.rs
new file mode 100644
index 000000000..44b96efe0
--- /dev/null
+++ b/objc_foundation/src/dictionary.rs
@@ -0,0 +1,230 @@
+use std::cmp::min;
+use std::marker::PhantomData;
+use std::ops::Index;
+use std::ptr;
+
+use objc::runtime::Class;
+use objc_id::{Id, Owned, Ownership, ShareId};
+
+use {
+    INSFastEnumeration, INSCopying, INSObject,
+    NSArray, NSSharedArray, NSEnumerator,
+};
+
+unsafe fn from_refs<D, T>(keys: &[&T], vals: &[&D::Value]) -> Id<D>
+        where D: INSDictionary, T: INSCopying<Output=D::Key> {
+    let cls = D::class();
+    let count = min(keys.len(), vals.len());
+    let obj: *mut D = msg_send![cls, alloc];
+    let obj: *mut D = msg_send![obj, initWithObjects:vals.as_ptr()
+                                             forKeys:keys.as_ptr()
+                                               count:count];
+    Id::from_retained_ptr(obj)
+}
+
+pub trait INSDictionary : INSObject {
+    type Key: INSObject;
+    type Value: INSObject;
+    type Own: Ownership;
+
+    fn count(&self) -> usize {
+        unsafe {
+            msg_send![self, count]
+        }
+    }
+
+    fn object_for(&self, key: &Self::Key) -> Option<&Self::Value> {
+        unsafe {
+            let obj: *mut Self::Value = msg_send![self, objectForKey:key];
+            if obj.is_null() { None } else { Some(&*obj) }
+        }
+    }
+
+    fn keys(&self) -> Vec<&Self::Key> {
+        let len = self.count();
+        let mut keys = Vec::with_capacity(len);
+        unsafe {
+            let _: () = msg_send![self, getObjects:ptr::null_mut::<&Self::Value>()
+                                           andKeys:keys.as_mut_ptr()];
+            keys.set_len(len);
+        }
+        keys
+    }
+
+    fn values(&self) -> Vec<&Self::Value> {
+        let len = self.count();
+        let mut vals = Vec::with_capacity(len);
+        unsafe {
+            let _: () = msg_send![self, getObjects:vals.as_mut_ptr()
+                                           andKeys:ptr::null_mut::<&Self::Key>()];
+            vals.set_len(len);
+        }
+        vals
+    }
+
+    fn keys_and_objects(&self) -> (Vec<&Self::Key>, Vec<&Self::Value>) {
+        let len = self.count();
+        let mut keys = Vec::with_capacity(len);
+        let mut objs = Vec::with_capacity(len);
+        unsafe {
+            let _: () = msg_send![self, getObjects:objs.as_mut_ptr()
+                                           andKeys:keys.as_mut_ptr()];
+            keys.set_len(len);
+            objs.set_len(len);
+        }
+        (keys, objs)
+    }
+
+    fn key_enumerator(&self) -> NSEnumerator<Self::Key> {
+        unsafe {
+            let result = msg_send![self, keyEnumerator];
+            NSEnumerator::from_ptr(result)
+        }
+    }
+
+    fn object_enumerator(&self) -> NSEnumerator<Self::Value> {
+        unsafe {
+            let result = msg_send![self, objectEnumerator];
+            NSEnumerator::from_ptr(result)
+        }
+    }
+
+    fn keys_array(&self) -> Id<NSSharedArray<Self::Key>> {
+        unsafe {
+            let keys: *mut NSSharedArray<Self::Key> = msg_send![self, allKeys];
+            Id::from_ptr(keys)
+        }
+    }
+
+    fn from_keys_and_objects<T>(keys: &[&T],
+            vals: Vec<Id<Self::Value, Self::Own>>) -> Id<Self>
+            where T: INSCopying<Output=Self::Key> {
+        let vals_refs: Vec<&Self::Value> = vals.iter().map(|obj| &**obj).collect();
+        unsafe {
+            from_refs(keys, &vals_refs)
+        }
+    }
+
+    fn into_values_array(dict: Id<Self>) -> Id<NSArray<Self::Value, Self::Own>> {
+        unsafe {
+            let vals = msg_send![dict, allValues];
+            Id::from_ptr(vals)
+        }
+    }
+}
+
+pub struct NSDictionary<K, V> {
+    key: PhantomData<ShareId<K>>,
+    obj: PhantomData<Id<V>>,
+}
+
+object_impl!(NSDictionary<K, V>);
+
+impl<K, V> INSObject for NSDictionary<K, V> where K: INSObject, V: INSObject {
+    fn class() -> &'static Class {
+        class!(NSDictionary)
+    }
+}
+
+impl<K, V> INSDictionary for NSDictionary<K, V>
+        where K: INSObject, V: INSObject {
+    type Key = K;
+    type Value = V;
+    type Own = Owned;
+}
+
+impl<K, V> INSFastEnumeration for NSDictionary<K, V>
+        where K: INSObject, V: INSObject {
+    type Item = K;
+}
+
+impl<'a, K, V> Index<&'a K> for NSDictionary<K, V> where K: INSObject, V: INSObject {
+    type Output = V;
+
+    fn index(&self, index: &K) -> &V {
+        self.object_for(index).unwrap()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use objc_id::Id;
+    use {INSArray, INSObject, INSString, NSObject, NSString};
+    use super::{INSDictionary, NSDictionary};
+
+    fn sample_dict(key: &str) -> Id<NSDictionary<NSString, NSObject>> {
+        let string = NSString::from_str(key);
+        let obj = NSObject::new();
+        NSDictionary::from_keys_and_objects(&[&*string], vec![obj])
+    }
+
+    #[test]
+    fn test_count() {
+        let dict = sample_dict("abcd");
+        assert!(dict.count() == 1);
+    }
+
+    #[test]
+    fn test_object_for() {
+        let dict = sample_dict("abcd");
+
+        let string = NSString::from_str("abcd");
+        assert!(dict.object_for(&string).is_some());
+
+        let string = NSString::from_str("abcde");
+        assert!(dict.object_for(&string).is_none());
+    }
+
+    #[test]
+    fn test_keys() {
+        let dict = sample_dict("abcd");
+        let keys = dict.keys();
+
+        assert!(keys.len() == 1);
+        assert!(keys[0].as_str() == "abcd");
+    }
+
+    #[test]
+    fn test_values() {
+        let dict = sample_dict("abcd");
+        let vals = dict.values();
+
+        assert!(vals.len() == 1);
+    }
+
+    #[test]
+    fn test_keys_and_objects() {
+        let dict = sample_dict("abcd");
+        let (keys, objs) = dict.keys_and_objects();
+
+        assert!(keys.len() == 1);
+        assert!(objs.len() == 1);
+        assert!(keys[0].as_str() == "abcd");
+        assert!(objs[0] == dict.object_for(keys[0]).unwrap());
+    }
+
+    #[test]
+    fn test_key_enumerator() {
+        let dict = sample_dict("abcd");
+        assert!(dict.key_enumerator().count() == 1);
+        assert!(dict.key_enumerator().next().unwrap().as_str() == "abcd");
+    }
+
+    #[test]
+    fn test_object_enumerator() {
+        let dict = sample_dict("abcd");
+        assert!(dict.object_enumerator().count() == 1);
+    }
+
+    #[test]
+    fn test_arrays() {
+        let dict = sample_dict("abcd");
+
+        let keys = dict.keys_array();
+        assert!(keys.count() == 1);
+        assert!(keys.object_at(0).as_str() == "abcd");
+
+        let objs = INSDictionary::into_values_array(dict);
+        assert!(objs.count() == 1);
+    }
+}
diff --git a/objc_foundation/src/enumerator.rs b/objc_foundation/src/enumerator.rs
new file mode 100644
index 000000000..9f2c081ce
--- /dev/null
+++ b/objc_foundation/src/enumerator.rs
@@ -0,0 +1,166 @@
+use std::marker::PhantomData;
+use std::mem;
+use std::os::raw::c_ulong;
+use std::ptr;
+use std::slice;
+
+use objc::runtime::Object;
+use objc_id::Id;
+
+use INSObject;
+
+pub struct NSEnumerator<'a, T> where T: INSObject {
+    id: Id<Object>,
+    item: PhantomData<&'a T>,
+}
+
+impl<'a, T> NSEnumerator<'a, T> where T: INSObject {
+    pub unsafe fn from_ptr(ptr: *mut Object) -> NSEnumerator<'a, T> {
+        NSEnumerator { id: Id::from_ptr(ptr), item: PhantomData }
+    }
+}
+
+impl<'a, T> Iterator for NSEnumerator<'a, T> where T: INSObject {
+    type Item = &'a T;
+
+    fn next(&mut self) -> Option<&'a T> {
+        unsafe {
+            let obj: *mut T = msg_send![self.id, nextObject];
+            if obj.is_null() { None } else { Some(&*obj) }
+        }
+    }
+}
+
+pub trait INSFastEnumeration: INSObject {
+    type Item: INSObject;
+
+    fn enumerator(&self) -> NSFastEnumerator<Self> {
+        NSFastEnumerator::new(self)
+    }
+}
+
+#[repr(C)]
+struct NSFastEnumerationState<T> {
+    state: c_ulong,
+    items_ptr: *const *const T,
+    mutations_ptr: *mut c_ulong,
+    extra: [c_ulong; 5],
+}
+
+fn enumerate<'a, 'b: 'a, C: INSFastEnumeration>(object: &'b C,
+        state: &mut NSFastEnumerationState<C::Item>,
+        buf: &'a mut [*const C::Item]) -> Option<&'a [*const C::Item]> {
+    let count: usize = unsafe {
+        // Reborrow state so that we don't move it
+        let state = &mut *state;
+        msg_send![object, countByEnumeratingWithState:state
+                                              objects:buf.as_mut_ptr()
+                                                count:buf.len()]
+    };
+
+    if count > 0 {
+        unsafe { Some(slice::from_raw_parts(state.items_ptr, count)) }
+    } else {
+        None
+    }
+}
+
+const FAST_ENUM_BUF_SIZE: usize = 16;
+
+pub struct NSFastEnumerator<'a, C: 'a + INSFastEnumeration> {
+    object: &'a C,
+
+    ptr: *const *const C::Item,
+    end: *const *const C::Item,
+
+    state: NSFastEnumerationState<C::Item>,
+    buf: [*const C::Item; FAST_ENUM_BUF_SIZE],
+}
+
+impl<'a, C: INSFastEnumeration> NSFastEnumerator<'a, C> {
+    fn new(object: &C) -> NSFastEnumerator<C> {
+        NSFastEnumerator {
+            object: object,
+
+            ptr: ptr::null(),
+            end: ptr::null(),
+
+            state: unsafe { mem::zeroed() },
+            buf: [ptr::null(); FAST_ENUM_BUF_SIZE],
+        }
+    }
+
+    fn update_buf(&mut self) -> bool {
+        // If this isn't our first time enumerating, record the previous value
+        // from the mutations pointer.
+        let mutations = if !self.ptr.is_null() {
+            Some(unsafe { *self.state.mutations_ptr })
+        } else {
+            None
+        };
+
+        let next_buf = enumerate(self.object, &mut self.state, &mut self.buf);
+        if let Some(buf) = next_buf {
+            // Check if the collection was mutated
+            if let Some(mutations) = mutations {
+                assert!(mutations == unsafe { *self.state.mutations_ptr },
+                    "Mutation detected during enumeration of object {:p}",
+                    self.object);
+            }
+
+            self.ptr = buf.as_ptr();
+            self.end = unsafe { self.ptr.offset(buf.len() as isize) };
+            true
+        } else {
+            self.ptr = ptr::null();
+            self.end = ptr::null();
+            false
+        }
+    }
+}
+
+impl<'a, C: INSFastEnumeration> Iterator for NSFastEnumerator<'a, C> {
+    type Item = &'a C::Item;
+
+    fn next(&mut self) -> Option<&'a C::Item> {
+        if self.ptr == self.end && !self.update_buf() {
+            None
+        } else {
+            unsafe {
+                let obj = *self.ptr;
+                self.ptr = self.ptr.offset(1);
+                Some(&*obj)
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use {INSArray, INSValue, NSArray, NSValue};
+    use super::INSFastEnumeration;
+
+    #[test]
+    fn test_enumerator() {
+        let vec = (0u32..4).map(NSValue::from_value).collect();
+        let array = NSArray::from_vec(vec);
+
+        let enumerator = array.object_enumerator();
+        assert!(enumerator.count() == 4);
+
+        let enumerator = array.object_enumerator();
+        assert!(enumerator.enumerate().all(|(i, obj)| obj.value() == i as u32));
+    }
+
+    #[test]
+    fn test_fast_enumerator() {
+        let vec = (0u32..4).map(NSValue::from_value).collect();
+        let array = NSArray::from_vec(vec);
+
+        let enumerator = array.enumerator();
+        assert!(enumerator.count() == 4);
+
+        let enumerator = array.enumerator();
+        assert!(enumerator.enumerate().all(|(i, obj)| obj.value() == i as u32));
+    }
+}
diff --git a/objc_foundation/src/lib.rs b/objc_foundation/src/lib.rs
new file mode 100644
index 000000000..65bbd01e8
--- /dev/null
+++ b/objc_foundation/src/lib.rs
@@ -0,0 +1,33 @@
+#![crate_name = "objc_foundation"]
+#![crate_type = "lib"]
+
+#[macro_use]
+extern crate objc;
+extern crate objc_id;
+extern crate block;
+
+pub use self::array::{
+    INSArray, INSMutableArray,
+    NSArray, NSComparisonResult, NSMutableArray, NSRange,
+    NSMutableSharedArray, NSSharedArray,
+};
+pub use self::data::{INSData, INSMutableData, NSData, NSMutableData};
+pub use self::dictionary::{INSDictionary, NSDictionary};
+pub use self::enumerator::{INSFastEnumeration, NSEnumerator, NSFastEnumerator};
+pub use self::object::{INSObject, NSObject};
+pub use self::string::{INSCopying, INSMutableCopying, INSString, NSString};
+pub use self::value::{INSValue, NSValue};
+
+#[link(name = "Foundation", kind = "framework")]
+extern { }
+
+#[macro_use]
+mod macros;
+
+mod array;
+mod data;
+mod dictionary;
+mod enumerator;
+mod object;
+mod string;
+mod value;
diff --git a/objc_foundation/src/macros.rs b/objc_foundation/src/macros.rs
new file mode 100644
index 000000000..c2ef00166
--- /dev/null
+++ b/objc_foundation/src/macros.rs
@@ -0,0 +1,51 @@
+#[macro_export]
+macro_rules! object_struct {
+    ($name:ident) => (
+        pub struct $name {
+            _private: (),
+        }
+
+        unsafe impl ::objc::Message for $name { }
+
+        impl $crate::INSObject for $name {
+            fn class() -> &'static ::objc::runtime::Class {
+                class!($name)
+            }
+        }
+
+        impl ::std::cmp::PartialEq for $name {
+            fn eq(&self, other: &Self) -> bool {
+                use $crate::INSObject;
+                self.is_equal(other)
+            }
+        }
+
+        impl ::std::cmp::Eq for $name { }
+
+        impl ::std::hash::Hash for $name {
+            fn hash<H>(&self, state: &mut H) where H: ::std::hash::Hasher {
+                use $crate::INSObject;
+                self.hash_code().hash(state);
+            }
+        }
+
+        impl ::std::fmt::Debug for $name {
+            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                use $crate::{INSObject, INSString};
+                ::std::fmt::Debug::fmt(self.description().as_str(), f)
+            }
+        }
+    );
+}
+
+macro_rules! object_impl {
+    ($name:ident) => (
+        object_impl!($name,);
+    );
+    ($name:ident<$($t:ident),+>) => (
+        object_impl!($name, $($t),+);
+    );
+    ($name:ident, $($t:ident),*) => (
+        unsafe impl<$($t),*> ::objc::Message for $name<$($t),*> { }
+    );
+}
diff --git a/objc_foundation/src/object.rs b/objc_foundation/src/object.rs
new file mode 100644
index 000000000..2f11626b0
--- /dev/null
+++ b/objc_foundation/src/object.rs
@@ -0,0 +1,91 @@
+use std::any::Any;
+
+use objc::Message;
+use objc::runtime::{BOOL, Class, NO};
+use objc_id::{Id, ShareId};
+
+use NSString;
+
+/*
+ The Sized bound is unfortunate; ideally, objc objects would not be
+ treated as Sized. However, rust won't allow casting a dynamically-sized type
+ pointer to an Object pointer, because dynamically-sized types can have fat
+ pointers (two words) instead of real pointers.
+ */
+pub trait INSObject : Any + Sized + Message {
+    fn class() -> &'static Class;
+
+    fn hash_code(&self) -> usize {
+        unsafe {
+            msg_send![self, hash]
+        }
+    }
+
+    fn is_equal<T>(&self, other: &T) -> bool where T: INSObject {
+        let result: BOOL = unsafe {
+            msg_send![self, isEqual:other]
+        };
+        result != NO
+    }
+
+    fn description(&self) -> ShareId<NSString> {
+        unsafe {
+            let result: *mut NSString = msg_send![self, description];
+            Id::from_ptr(result)
+        }
+    }
+
+    fn is_kind_of(&self, cls: &Class) -> bool {
+        let result: BOOL = unsafe {
+            msg_send![self, isKindOfClass:cls]
+        };
+        result != NO
+    }
+
+    fn new() -> Id<Self> {
+        let cls = Self::class();
+        unsafe {
+            let obj: *mut Self = msg_send![cls, alloc];
+            let obj: *mut Self = msg_send![obj, init];
+            Id::from_retained_ptr(obj)
+        }
+    }
+}
+
+object_struct!(NSObject);
+
+#[cfg(test)]
+mod tests {
+    use {INSString, NSString};
+    use super::{INSObject, NSObject};
+
+    #[test]
+    fn test_is_equal() {
+        let obj1 = NSObject::new();
+        assert!(obj1.is_equal(&*obj1));
+
+        let obj2 = NSObject::new();
+        assert!(!obj1.is_equal(&*obj2));
+    }
+
+    #[test]
+    fn test_hash_code() {
+        let obj = NSObject::new();
+        assert!(obj.hash_code() == obj.hash_code());
+    }
+
+    #[test]
+    fn test_description() {
+        let obj = NSObject::new();
+        let description = obj.description();
+        let expected = format!("<NSObject: {:p}>", &*obj);
+        assert!(description.as_str() == &*expected);
+    }
+
+    #[test]
+    fn test_is_kind_of() {
+        let obj = NSObject::new();
+        assert!(obj.is_kind_of(NSObject::class()));
+        assert!(!obj.is_kind_of(NSString::class()));
+    }
+}
diff --git a/objc_foundation/src/string.rs b/objc_foundation/src/string.rs
new file mode 100644
index 000000000..74b14a4a1
--- /dev/null
+++ b/objc_foundation/src/string.rs
@@ -0,0 +1,106 @@
+use std::fmt;
+use std::os::raw::{c_char, c_void};
+use std::slice;
+use std::str;
+
+use objc_id::{Id, ShareId};
+
+use INSObject;
+
+pub trait INSCopying : INSObject {
+    type Output: INSObject;
+
+    fn copy(&self) -> ShareId<Self::Output> {
+        unsafe {
+            let obj: *mut Self::Output = msg_send![self, copy];
+            Id::from_retained_ptr(obj)
+        }
+    }
+}
+
+pub trait INSMutableCopying : INSObject {
+    type Output: INSObject;
+
+    fn mutable_copy(&self) -> Id<Self::Output> {
+        unsafe {
+            let obj: *mut Self::Output = msg_send![self, mutableCopy];
+            Id::from_retained_ptr(obj)
+        }
+    }
+}
+
+const UTF8_ENCODING: usize = 4;
+
+pub trait INSString : INSObject {
+    fn len(&self) -> usize {
+        unsafe {
+            msg_send![self, lengthOfBytesUsingEncoding:UTF8_ENCODING]
+        }
+    }
+
+    fn as_str(&self) -> &str {
+        let bytes = unsafe {
+            let bytes: *const c_char = msg_send![self, UTF8String];
+            bytes as *const u8
+        };
+        let len = self.len();
+        unsafe {
+            let bytes = slice::from_raw_parts(bytes, len);
+            str::from_utf8(bytes).unwrap()
+        }
+    }
+
+    fn from_str(string: &str) -> Id<Self> {
+        let cls = Self::class();
+        let bytes = string.as_ptr() as *const c_void;
+        unsafe {
+            let obj: *mut Self = msg_send![cls, alloc];
+            let obj: *mut Self = msg_send![obj, initWithBytes:bytes
+                                                       length:string.len()
+                                                     encoding:UTF8_ENCODING];
+            Id::from_retained_ptr(obj)
+        }
+    }
+}
+
+object_struct!(NSString);
+
+impl INSString for NSString { }
+
+impl INSCopying for NSString {
+    type Output = NSString;
+}
+
+impl fmt::Display for NSString {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(self.as_str(), f)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{INSCopying, INSString, NSString};
+
+    #[test]
+    fn test_utf8() {
+        let expected = "ประเทศไทย中华Việt Nam";
+        let s = NSString::from_str(expected);
+        assert!(s.len() == expected.len());
+        assert!(s.as_str() == expected);
+    }
+
+    #[test]
+    fn test_interior_nul() {
+        let expected = "Hello\0World";
+        let s = NSString::from_str(expected);
+        assert!(s.len() == expected.len());
+        assert!(s.as_str() == expected);
+    }
+
+    #[test]
+    fn test_copy() {
+        let s = NSString::from_str("Hello!");
+        let copied = s.copy();
+        assert!(copied.as_str() == s.as_str());
+    }
+}
diff --git a/objc_foundation/src/value.rs b/objc_foundation/src/value.rs
new file mode 100644
index 000000000..dbf727b32
--- /dev/null
+++ b/objc_foundation/src/value.rs
@@ -0,0 +1,82 @@
+use std::any::Any;
+use std::ffi::{CStr, CString};
+use std::marker::PhantomData;
+use std::mem;
+use std::os::raw::{c_char, c_void};
+use std::str;
+
+use objc::{Encode, Encoding};
+use objc::runtime::Class;
+use objc_id::Id;
+
+use {INSCopying, INSObject};
+
+pub trait INSValue : INSObject {
+    type Value: 'static + Copy + Encode;
+
+    fn value(&self) -> Self::Value {
+        assert!(Self::Value::encode() == self.encoding());
+        unsafe {
+            let mut value = mem::uninitialized::<Self::Value>();
+            let value_ptr: *mut Self::Value = &mut value;
+            let bytes = value_ptr as *mut c_void;
+            let _: () = msg_send![self, getValue:bytes];
+            value
+        }
+    }
+
+    fn encoding(&self) -> Encoding {
+        unsafe {
+            let result: *const c_char = msg_send![self, objCType];
+            let s = CStr::from_ptr(result);
+            let s = str::from_utf8(s.to_bytes()).unwrap();
+            Encoding::from_str(s)
+        }
+    }
+
+    fn from_value(value: Self::Value) -> Id<Self> {
+        let cls = Self::class();
+        let value_ptr: *const Self::Value = &value;
+        let bytes = value_ptr as *const c_void;
+        let encoding = CString::new(Self::Value::encode().as_str()).unwrap();
+        unsafe {
+            let obj: *mut Self = msg_send![cls, alloc];
+            let obj: *mut Self = msg_send![obj, initWithBytes:bytes
+                                                     objCType:encoding.as_ptr()];
+            Id::from_retained_ptr(obj)
+        }
+    }
+}
+
+pub struct NSValue<T> {
+    value: PhantomData<T>,
+}
+
+object_impl!(NSValue<T>);
+
+impl<T> INSObject for NSValue<T> where T: Any {
+    fn class() -> &'static Class {
+        class!(NSValue)
+    }
+}
+
+impl<T> INSValue for NSValue<T> where T: Any + Copy + Encode {
+    type Value = T;
+}
+
+impl<T> INSCopying for NSValue<T> where T: Any {
+    type Output = NSValue<T>;
+}
+
+#[cfg(test)]
+mod tests {
+    use objc::Encode;
+    use {INSValue, NSValue};
+
+    #[test]
+    fn test_value() {
+        let val = NSValue::from_value(13u32);
+        assert!(val.value() == 13);
+        assert!(u32::encode() == val.encoding());
+    }
+}
diff --git a/objc_id/Cargo.toml b/objc_id/Cargo.toml
new file mode 100644
index 000000000..99598b913
--- /dev/null
+++ b/objc_id/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "objc_id"
+version = "0.1.1"
+authors = ["Steven Sheldon"]
+
+description = "Rust smart pointers for Objective-C reference counting."
+keywords = ["objective-c", "osx", "ios"]
+readme = "README.md"
+repository = "http://github.com/SSheldon/rust-objc-id"
+documentation = "http://ssheldon.github.io/rust-objc/objc_id/"
+license = "MIT"
+
+exclude = [".gitignore"]
+
+[dependencies]
+objc = { path = "../objc", version = "0.2.4" }
diff --git a/objc_id/README.md b/objc_id/README.md
new file mode 100644
index 000000000..f1f362b84
--- /dev/null
+++ b/objc_id/README.md
@@ -0,0 +1,34 @@
+Rust smart pointers for Objective-C reference counting.
+
+To ensure that Objective-C objects are retained and released
+at the proper times, we can use the Id struct.
+
+To enforce aliasing rules, an `Id` can be either owned or shared; if it is
+owned, meaning the `Id` is the only reference to the object, it can be mutably
+dereferenced. An owned `Id` can be downgraded to a ShareId
+which can be cloned to allow multiple references.
+
+Weak references may be created using the WeakId struct.
+
+``` rust
+use objc::runtime::{Class, Object};
+use objc_id::{Id, WeakId};
+
+let cls = Class::get("NSObject").unwrap();
+let obj: Id<Object> = unsafe {
+    Id::from_retained_ptr(msg_send![cls, new])
+};
+// obj will be released when it goes out of scope
+
+// share the object so we can clone it
+let obj = obj.share();
+let another_ref = obj.clone();
+// dropping our other reference will decrement the retain count
+drop(another_ref);
+
+let weak = WeakId::new(&obj);
+assert!(weak.load().is_some());
+// After the object is deallocated, our weak pointer returns none
+drop(obj);
+assert!(weak.load().is_none());
+```
diff --git a/objc_id/src/id.rs b/objc_id/src/id.rs
new file mode 100644
index 000000000..b679f3b43
--- /dev/null
+++ b/objc_id/src/id.rs
@@ -0,0 +1,217 @@
+use std::any::Any;
+use std::fmt;
+use std::hash;
+use std::marker::PhantomData;
+use std::ops::{Deref, DerefMut};
+
+use objc::Message;
+use objc::rc::{StrongPtr, WeakPtr};
+use objc::runtime::Object;
+
+/// A type used to mark that a struct owns the object(s) it contains,
+/// so it has the sole references to them.
+pub enum Owned { }
+/// A type used to mark that the object(s) a struct contains are shared,
+/// so there may be other references to them.
+pub enum Shared { }
+
+/// A type that marks what type of ownership a struct has over the object(s)
+/// it contains; specifically, either `Owned` or `Shared`.
+pub trait Ownership: Any { }
+impl Ownership for Owned { }
+impl Ownership for Shared { }
+
+/// A pointer type for Objective-C's reference counted objects.
+///
+/// The object of an `Id` is retained and sent a `release` message when
+/// the `Id` is dropped.
+///
+/// An `Id` may be either `Owned` or `Shared`, represented by the types `Id`
+/// and `ShareId`, respectively. If owned, there are no other references to the
+/// object and the `Id` can be mutably dereferenced. `ShareId`, however, can
+/// only be immutably dereferenced because there may be other references to the
+/// object, but a `ShareId` can be cloned to provide more references to the
+/// object. An owned `Id` can be "downgraded" freely to a `ShareId`, but there
+/// is no way to safely upgrade back.
+pub struct Id<T, O = Owned> {
+    ptr: StrongPtr,
+    item: PhantomData<T>,
+    own: PhantomData<O>,
+}
+
+impl<T, O> Id<T, O> where T: Message, O: Ownership {
+    unsafe fn new(ptr: StrongPtr) -> Id<T, O> {
+        Id { ptr: ptr, item: PhantomData, own: PhantomData }
+    }
+
+    /// Constructs an `Id` from a pointer to an unretained object and
+    /// retains it. Panics if the pointer is null.
+    /// Unsafe because the pointer must be to a valid object and
+    /// the caller must ensure the ownership is correct.
+    pub unsafe fn from_ptr(ptr: *mut T) -> Id<T, O> {
+        assert!(!ptr.is_null(), "Attempted to construct an Id from a null pointer");
+        Id::new(StrongPtr::retain(ptr as *mut Object))
+    }
+
+    /// Constructs an `Id` from a pointer to a retained object; this won't
+    /// retain the pointer, so the caller must ensure the object has a +1
+    /// retain count. Panics if the pointer is null.
+    /// Unsafe because the pointer must be to a valid object and
+    /// the caller must ensure the ownership is correct.
+    pub unsafe fn from_retained_ptr(ptr: *mut T) -> Id<T, O> {
+        assert!(!ptr.is_null(), "Attempted to construct an Id from a null pointer");
+        Id::new(StrongPtr::new(ptr as *mut Object))
+    }
+}
+
+impl<T> Id<T, Owned> where T: Message {
+    /// "Downgrade" an owned `Id` to a `ShareId`, allowing it to be cloned.
+    pub fn share(self) -> ShareId<T> {
+        let Id { ptr, .. } = self;
+        unsafe { Id::new(ptr) }
+    }
+}
+
+impl<T> Clone for Id<T, Shared> where T: Message {
+    fn clone(&self) -> ShareId<T> {
+        unsafe {
+            Id::new(self.ptr.clone())
+        }
+    }
+}
+
+unsafe impl<T, O> Sync for Id<T, O> where T: Sync { }
+
+unsafe impl<T> Send for Id<T, Owned> where T: Send { }
+
+unsafe impl<T> Send for Id<T, Shared> where T: Sync { }
+
+impl<T, O> Deref for Id<T, O> {
+    type Target = T;
+
+    fn deref(&self) -> &T {
+        unsafe { &*(*self.ptr as *mut T) }
+    }
+}
+
+impl<T> DerefMut for Id<T, Owned> {
+    fn deref_mut(&mut self) -> &mut T {
+        unsafe { &mut *(*self.ptr as *mut T) }
+    }
+}
+
+impl<T, O> PartialEq for Id<T, O> where T: PartialEq {
+    fn eq(&self, other: &Id<T, O>) -> bool {
+        self.deref() == other.deref()
+    }
+
+    fn ne(&self, other: &Id<T, O>) -> bool {
+        self.deref() != other.deref()
+    }
+}
+
+impl<T, O> Eq for Id<T, O> where T: Eq { }
+
+impl<T, O> hash::Hash for Id<T, O> where T: hash::Hash {
+    fn hash<H>(&self, state: &mut H) where H: hash::Hasher {
+        self.deref().hash(state)
+    }
+}
+
+impl<T, O> fmt::Debug for Id<T, O> where T: fmt::Debug {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.deref().fmt(f)
+    }
+}
+
+impl<T, O> fmt::Pointer for Id<T, O> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Pointer::fmt(&self.ptr, f)
+    }
+}
+
+/// A convenient alias for a shared `Id`.
+pub type ShareId<T> = Id<T, Shared>;
+
+/// A pointer type for a weak reference to an Objective-C reference counted
+/// object.
+pub struct WeakId<T> {
+    ptr: WeakPtr,
+    item: PhantomData<T>,
+}
+
+impl<T> WeakId<T> where T: Message {
+    /// Construct a new `WeakId` referencing the given `ShareId`.
+    pub fn new(obj: &ShareId<T>) -> WeakId<T> {
+        WeakId {
+            ptr: obj.ptr.weak(),
+            item: PhantomData,
+        }
+    }
+
+    /// Load a `ShareId` from the `WeakId` if the object still exists.
+    /// Returns `None` if the object has been deallocated.
+    pub fn load(&self) -> Option<ShareId<T>> {
+        let obj = self.ptr.load();
+        if obj.is_null() {
+            None
+        } else {
+            Some(unsafe { Id::new(obj) })
+        }
+    }
+}
+
+unsafe impl<T> Sync for WeakId<T> where T: Sync { }
+
+unsafe impl<T> Send for WeakId<T> where T: Sync { }
+
+#[cfg(test)]
+mod tests {
+    use objc::runtime::Object;
+    use super::{Id, ShareId, WeakId};
+
+    fn retain_count(obj: &Object) -> usize {
+        unsafe { msg_send![obj, retainCount] }
+    }
+
+    #[test]
+    fn test_clone() {
+        let cls = class!(NSObject);
+        let obj: Id<Object> = unsafe {
+            let obj: *mut Object = msg_send![cls, alloc];
+            let obj: *mut Object = msg_send![obj, init];
+            Id::from_retained_ptr(obj)
+        };
+        assert!(retain_count(&obj) == 1);
+
+        let obj = obj.share();
+        assert!(retain_count(&obj) == 1);
+
+        let cloned = obj.clone();
+        assert!(retain_count(&cloned) == 2);
+        assert!(retain_count(&obj) == 2);
+
+        drop(obj);
+        assert!(retain_count(&cloned) == 1);
+    }
+
+    #[test]
+    fn test_weak() {
+        let cls = class!(NSObject);
+        let obj: ShareId<Object> = unsafe {
+            let obj: *mut Object = msg_send![cls, alloc];
+            let obj: *mut Object = msg_send![obj, init];
+            Id::from_retained_ptr(obj)
+        };
+
+        let weak = WeakId::new(&obj);
+        let strong = weak.load().unwrap();
+        let strong_ptr: *const Object = &*strong;
+        let obj_ptr: *const Object = &*obj;
+        assert!(strong_ptr == obj_ptr);
+        drop(strong);
+
+        drop(obj);
+        assert!(weak.load().is_none());
+    }
+}
diff --git a/objc_id/src/lib.rs b/objc_id/src/lib.rs
new file mode 100644
index 000000000..d03b354b7
--- /dev/null
+++ b/objc_id/src/lib.rs
@@ -0,0 +1,47 @@
+/*!
+Rust smart pointers for Objective-C reference counting.
+
+To ensure that Objective-C objects are retained and released
+at the proper times, we can use the [`Id`](struct.Id.html) struct.
+
+To enforce aliasing rules, an `Id` can be either owned or shared; if it is
+owned, meaning the `Id` is the only reference to the object, it can be mutably
+dereferenced. An owned `Id` can be downgraded to a [`ShareId`](type.ShareId.html)
+which can be cloned to allow multiple references.
+
+Weak references may be created using the [`WeakId`](struct.WeakId.html) struct.
+
+```
+# #[macro_use] extern crate objc;
+# extern crate objc_id;
+use objc::runtime::{Class, Object};
+use objc_id::{Id, WeakId};
+
+# fn main() {
+let cls = Class::get("NSObject").unwrap();
+let obj: Id<Object> = unsafe {
+    Id::from_retained_ptr(msg_send![cls, new])
+};
+// obj will be released when it goes out of scope
+
+// share the object so we can clone it
+let obj = obj.share();
+let another_ref = obj.clone();
+// dropping our other reference will decrement the retain count
+drop(another_ref);
+
+let weak = WeakId::new(&obj);
+assert!(weak.load().is_some());
+// After the object is deallocated, our weak pointer returns none
+drop(obj);
+assert!(weak.load().is_none());
+# }
+```
+*/
+
+#[macro_use]
+extern crate objc;
+
+pub use id::{Id, Owned, Ownership, Shared, ShareId, WeakId};
+
+mod id;