From 680619413ef64ee1b1c0fdd480851e953abbd1e7 Mon Sep 17 00:00:00 2001
From: Mads Marquart <mads@marquart.dk>
Date: Sun, 10 Jul 2022 19:58:05 +0200
Subject: [PATCH] Use msg_send_id! and rc::Id

---
 ARCHITECTURE.md                         | 12 ++---
 src/appkit/alert.rs                     | 16 +++---
 src/appkit/app/class.rs                 |  8 +--
 src/appkit/app/delegate.rs              |  8 +--
 src/appkit/app/mod.rs                   | 21 ++++----
 src/appkit/event/mod.rs                 | 15 +++---
 src/appkit/menu/item.rs                 | 45 ++++++++++-------
 src/appkit/menu/menu.rs                 | 14 +++---
 src/appkit/printing/settings.rs         |  6 +--
 src/appkit/toolbar/class.rs             |  2 +-
 src/appkit/toolbar/item.rs              | 13 +++--
 src/appkit/toolbar/mod.rs               | 24 ++++-----
 src/appkit/window/class.rs              |  2 +-
 src/appkit/window/controller/class.rs   |  8 +--
 src/appkit/window/controller/mod.rs     | 14 +++---
 src/appkit/window/mod.rs                | 66 +++++++++++++------------
 src/button/mod.rs                       | 14 +++---
 src/cloudkit/share.rs                   |  6 +--
 src/color/appkit_dynamic_color.rs       |  8 +--
 src/color/mod.rs                        | 37 ++++++++------
 src/defaults/mod.rs                     | 12 ++---
 src/dragdrop.rs                         |  4 +-
 src/filesystem/manager.rs               | 14 +++---
 src/filesystem/save.rs                  | 13 +++--
 src/filesystem/select.rs                | 13 +++--
 src/foundation/array.rs                 | 40 ++++++++-------
 src/foundation/autoreleasepool.rs       |  8 +--
 src/foundation/class.rs                 |  8 +--
 src/foundation/data.rs                  | 31 +++++++-----
 src/foundation/dictionary.rs            |  8 +--
 src/foundation/number.rs                | 19 +++----
 src/foundation/string.rs                | 37 ++++++++------
 src/foundation/urls/mod.rs              | 12 ++---
 src/image/appkit.rs                     | 10 ++--
 src/image/handle.rs                     |  6 +--
 src/image/image.rs                      | 50 ++++++++++---------
 src/image/mod.rs                        |  4 +-
 src/image/uikit.rs                      | 16 +++---
 src/input/appkit.rs                     | 12 ++---
 src/input/mod.rs                        |  2 +-
 src/invoker.rs                          | 30 ++++++-----
 src/layout/animator.rs                  |  9 ++--
 src/layout/constraint.rs                |  8 +--
 src/layout/dimension.rs                 | 16 +++---
 src/layout/horizontal.rs                | 26 +++++-----
 src/layout/traits.rs                    |  2 +-
 src/layout/vertical.rs                  | 18 +++----
 src/lib.rs                              | 57 ---------------------
 src/listview/actions.rs                 | 13 ++---
 src/listview/appkit.rs                  | 22 ++++-----
 src/listview/mod.rs                     | 41 ++++++++-------
 src/listview/row/appkit.rs              | 28 +++++------
 src/listview/row/mod.rs                 |  4 +-
 src/listview/row/uikit.rs               | 20 ++++----
 src/networking/mod.rs                   |  8 +--
 src/notification_center/mod.rs          | 10 ++--
 src/pasteboard/mod.rs                   | 14 +++---
 src/progress/mod.rs                     |  2 +-
 src/quicklook/config.rs                 |  2 +-
 src/quicklook/mod.rs                    |  8 +--
 src/scrollview/appkit.rs                | 28 +++++------
 src/scrollview/mod.rs                   |  4 +-
 src/select/mod.rs                       | 14 +++---
 src/switch.rs                           | 14 +++---
 src/text/attributed_string.rs           | 12 ++---
 src/text/font.rs                        | 12 ++---
 src/text/label/appkit.rs                | 18 +++----
 src/text/label/mod.rs                   |  4 +-
 src/uikit/app/class.rs                  |  8 +--
 src/uikit/app/delegate.rs               |  8 +--
 src/uikit/scene/config.rs               | 14 +++---
 src/uikit/scene/delegate.rs             |  8 +--
 src/uikit/scene/mod.rs                  |  6 +--
 src/uikit/scene/options.rs              |  6 +--
 src/uikit/scene/session.rs              |  6 +--
 src/uikit/window/mod.rs                 | 10 ++--
 src/user_activity.rs                    |  6 +--
 src/user_notifications/notifications.rs | 14 +++---
 src/utils/mod.rs                        |  4 +-
 src/utils/properties.rs                 |  8 +--
 src/view/animator.rs                    |  8 +--
 src/view/appkit.rs                      | 22 ++++-----
 src/view/controller/appkit.rs           |  2 +-
 src/view/controller/mod.rs              | 16 +++---
 src/view/controller/uikit.rs            |  2 +-
 src/view/splitviewcontroller/ios.rs     |  8 +--
 src/view/splitviewcontroller/macos.rs   |  2 +-
 src/view/splitviewcontroller/mod.rs     | 30 +++++------
 src/view/uikit.rs                       | 12 ++---
 src/webview/class.rs                    | 16 +++---
 src/webview/config.rs                   | 11 ++---
 src/webview/mod.rs                      | 12 ++---
 92 files changed, 657 insertions(+), 684 deletions(-)

diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 522399f6..927f4f9f 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -352,8 +352,8 @@ We'll step through an example (abridged) `View` bridge below, for macOS. You sho
 For our basic `View` type, we want to just map to the corresponding class on the Objective-C side (in this case, `NSView`), and maybe do a bit of tweaking for sanity reasons.
 
 ``` rust
-pub(crate) fn register_view_class() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_view_class() -> &'static Class {
+    static mut VIEW_CLASS: Option<'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
@@ -364,10 +364,10 @@ pub(crate) fn register_view_class() -> *const Class {
 
         decl.add_ivar::<id>(BACKGROUND_COLOR);
 
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
 ```
 
@@ -377,7 +377,7 @@ Objective-C method signatures, as well as provision space for variable storage (
 For our _delegate_ types, we need a different class creation method - one that creates a subclass per-unique-type:
 
 ``` rust
-pub(crate) fn register_view_class_with_delegate<T: ViewDelegate>(instance: &T) -> *const Class {
+pub(crate) fn register_view_class_with_delegate<T: ViewDelegate>(instance: &T) -> &'static Class {
     load_or_register_class("NSView", instance.subclass_name(), |decl| unsafe {
         decl.add_ivar::<usize>(VIEW_DELEGATE_PTR);
         decl.add_ivar::<id>(BACKGROUND_COLOR);
@@ -412,7 +412,7 @@ Here, we just want to tell `NSView` to use top,left as the origin point, so we n
 extern "C" fn dragging_entered<T: ViewDelegate>(this: &mut Object, _: Sel, info: id) -> NSUInteger {
     let view = utils::load::<T>(this, VIEW_DELEGATE_PTR);
     view.dragging_entered(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     }).into()
 }
 ```
diff --git a/src/appkit/alert.rs b/src/appkit/alert.rs
index bffc38ec..b9420253 100644
--- a/src/appkit/alert.rs
+++ b/src/appkit/alert.rs
@@ -24,16 +24,16 @@
 //! }
 //! ```
 
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::{id, NSString};
 
 /// Represents an `NSAlert`. Has no information other than the retained pointer to the Objective C
 /// side, so... don't bother inspecting this.
 #[derive(Debug)]
-pub struct Alert(Id<Object>);
+pub struct Alert(Id<Object, Owned>);
 
 impl Alert {
     /// Creates a basic `NSAlert`, storing a pointer to it in the Objective C runtime.
@@ -44,11 +44,11 @@ impl Alert {
         let ok = NSString::new("OK");
 
         Alert(unsafe {
-            let alert: id = msg_send![class!(NSAlert), new];
-            let _: () = msg_send![alert, setMessageText: &*title];
-            let _: () = msg_send![alert, setInformativeText: &*message];
-            let _: () = msg_send![alert, addButtonWithTitle: &*ok];
-            Id::from_ptr(alert)
+            let mut alert = msg_send_id![class!(NSAlert), new].unwrap();
+            let _: () = msg_send![&mut alert, setMessageText: &*title];
+            let _: () = msg_send![&mut alert, setInformativeText: &*message];
+            let _: () = msg_send![&mut alert, addButtonWithTitle: &*ok];
+            alert
         })
     }
 
diff --git a/src/appkit/app/class.rs b/src/appkit/app/class.rs
index e53885f4..fa034ba1 100644
--- a/src/appkit/app/class.rs
+++ b/src/appkit/app/class.rs
@@ -9,15 +9,15 @@ use objc::declare::ClassDecl;
 use objc::runtime::Class;
 
 /// Used for injecting a custom NSApplication. Currently does nothing.
-pub(crate) fn register_app_class() -> *const Class {
-    static mut APP_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_app_class() -> &'static Class {
+    static mut APP_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
         let superclass = class!(NSApplication);
         let decl = ClassDecl::new("RSTApplication", superclass).unwrap();
-        APP_CLASS = decl.register();
+        APP_CLASS = Some(decl.register());
     });
 
-    unsafe { APP_CLASS }
+    unsafe { APP_CLASS.unwrap() }
 }
diff --git a/src/appkit/app/delegate.rs b/src/appkit/app/delegate.rs
index 0b904ee2..cf5a7438 100644
--- a/src/appkit/app/delegate.rs
+++ b/src/appkit/app/delegate.rs
@@ -294,8 +294,8 @@ extern "C" fn delegate_handles_key<T: AppDelegate>(this: &Object, _: Sel, _: id,
 
 /// Registers an `NSObject` application delegate, and configures it for the various callbacks and
 /// pointers we need to have.
-pub(crate) fn register_app_delegate_class<T: AppDelegate + AppDelegate>() -> *const Class {
-    static mut DELEGATE_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_app_delegate_class<T: AppDelegate + AppDelegate>() -> &'static Class {
+    static mut DELEGATE_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
@@ -453,8 +453,8 @@ pub(crate) fn register_app_delegate_class<T: AppDelegate + AppDelegate>() -> *co
             delegate_handles_key::<T> as extern "C" fn(_, _, _, _) -> _
         );
 
-        DELEGATE_CLASS = decl.register();
+        DELEGATE_CLASS = Some(decl.register());
     });
 
-    unsafe { DELEGATE_CLASS }
+    unsafe { DELEGATE_CLASS.unwrap() }
 }
diff --git a/src/appkit/app/mod.rs b/src/appkit/app/mod.rs
index ae0ee2c3..99554580 100644
--- a/src/appkit/app/mod.rs
+++ b/src/appkit/app/mod.rs
@@ -39,9 +39,9 @@ use std::sync::{Arc, Mutex};
 
 use lazy_static::lazy_static;
 
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::appkit::menu::Menu;
 use crate::foundation::{id, nil, AutoReleasePool, NSUInteger, NO, YES};
@@ -86,11 +86,11 @@ fn shared_application<F: Fn(id)>(handler: F) {
 /// application.
 pub struct App<T = (), M = ()> {
     /// The underlying Objective-C Object.
-    pub objc: Id<Object>,
+    pub objc: Id<Object, Owned>,
 
     /// The underlying Objective-C Object, which in this case is a delegate that forwards to the
     /// app delegate.
-    pub objc_delegate: Id<Object>,
+    pub objc_delegate: Id<Object, Owned>,
 
     /// The stored `AppDelegate`.
     pub delegate: Box<T>,
@@ -142,20 +142,17 @@ where
 
         let pool = AutoReleasePool::new();
 
-        let objc = unsafe {
-            let app: id = msg_send![register_app_class(), sharedApplication];
-            Id::from_ptr(app)
-        };
+        let objc = unsafe { msg_send_id![register_app_class(), sharedApplication].unwrap() };
 
         let app_delegate = Box::new(delegate);
 
         let objc_delegate = unsafe {
             let delegate_class = register_app_delegate_class::<T>();
-            let delegate: id = msg_send![delegate_class, new];
+            let mut delegate: Id<Object, Owned> = msg_send_id![delegate_class, new].unwrap();
             let delegate_ptr: *const T = &*app_delegate;
-            (&mut *delegate).set_ivar(APP_PTR, delegate_ptr as usize);
-            let _: () = msg_send![&*objc, setDelegate: delegate];
-            Id::from_ptr(delegate)
+            delegate.set_ivar(APP_PTR, delegate_ptr as usize);
+            let _: () = msg_send![&*objc, setDelegate: &*delegate];
+            delegate
         };
 
         App {
diff --git a/src/appkit/event/mod.rs b/src/appkit/event/mod.rs
index 8db0239f..fc6bcda6 100644
--- a/src/appkit/event/mod.rs
+++ b/src/appkit/event/mod.rs
@@ -1,8 +1,8 @@
 use block::ConcreteBlock;
 
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::{id, nil, NSString};
 
@@ -14,15 +14,15 @@ pub enum EventMask {
 
 /// A wrapper over an `NSEvent`.
 #[derive(Debug)]
-pub struct EventMonitor(pub Id<Object>);
+pub struct EventMonitor(pub Id<Object, Owned>);
 
 /// A wrapper over an `NSEvent`.
 #[derive(Debug)]
-pub struct Event(pub Id<Object>);
+pub struct Event(pub Id<Object, Owned>);
 
 impl Event {
     pub(crate) fn new(objc: id) -> Self {
-        Event(unsafe { Id::from_ptr(objc) })
+        Event(unsafe { Id::retain(objc).unwrap() })
     }
 
     pub fn characters(&self) -> String {
@@ -68,11 +68,12 @@ impl Event {
         let block = block.copy();
 
         EventMonitor(unsafe {
-            Id::from_ptr(msg_send![
+            msg_send_id![
                 class!(NSEvent),
                 addLocalMonitorForEventsMatchingMask: 1024,
                 handler: &*block,
-            ])
+            ]
+            .unwrap()
         })
     }
 }
diff --git a/src/appkit/menu/item.rs b/src/appkit/menu/item.rs
index a39eaa48..6712c606 100644
--- a/src/appkit/menu/item.rs
+++ b/src/appkit/menu/item.rs
@@ -5,11 +5,11 @@
 use std::fmt;
 use std::sync::Once;
 
-use crate::id_shim::Id;
 use block::ConcreteBlock;
 use objc::declare::ClassDecl;
+use objc::rc::{Id, Owned};
 use objc::runtime::{Class, Object, Sel};
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::events::EventModifierFlag;
 use crate::foundation::{id, nil, NSString, NSUInteger};
@@ -40,7 +40,7 @@ fn make_menu_item<S: AsRef<str>>(
     key: Option<&str>,
     action: Option<Sel>,
     modifiers: Option<&[EventModifierFlag]>
-) -> Id<Object> {
+) -> Id<Object, Owned> {
     unsafe {
         let title = NSString::new(title.as_ref());
 
@@ -53,14 +53,22 @@ fn make_menu_item<S: AsRef<str>>(
         // Stock menu items that use selectors targeted at system pieces are just standard
         // `NSMenuItem`s. If there's no custom ones, we use our subclass that has a slot to store a
         // handler pointer.
-        let alloc: id = msg_send![register_menu_item_class(), alloc];
-        let item = Id::from_retained_ptr(match action {
-            Some(a) => msg_send![alloc, initWithTitle:&*title action:a keyEquivalent:&*key],
-
-            None => msg_send![alloc, initWithTitle:&*title
-                action:sel!(fireBlockAction:)
-                keyEquivalent:&*key]
-        });
+        let alloc = msg_send_id![register_menu_item_class(), alloc];
+        let item = match action {
+            Some(a) => msg_send_id![
+                alloc,
+                initWithTitle: &*title,
+                action: a,
+                keyEquivalent: &*key,
+            ],
+            None => msg_send_id![
+                alloc,
+                initWithTitle: &*title,
+                action: sel!(fireBlockAction:),
+                keyEquivalent: &*key,
+            ]
+        }
+        .unwrap();
 
         if let Some(modifiers) = modifiers {
             let mut key_mask: NSUInteger = 0;
@@ -86,7 +94,7 @@ pub enum MenuItem {
     /// You can (and should) create this variant via the `new(title)` method, but if you need to do
     /// something crazier, then wrap it in this and you can hook into the Cacao menu system
     /// accordingly.
-    Custom(Id<Object>),
+    Custom(Id<Object, Owned>),
 
     /// Shows a standard "About" item,  which will bring up the necessary window when clicked
     /// (include a `credits.html` in your App to make use of here). The argument baked in here
@@ -153,7 +161,7 @@ pub enum MenuItem {
 impl MenuItem {
     /// Consumes and returns a handle for the underlying MenuItem. This is internal as we make a few assumptions
     /// for how it interacts with our `Menu` setup, but this could be made public in the future.
-    pub(crate) unsafe fn to_objc(self) -> Id<Object> {
+    pub(crate) unsafe fn to_objc(self) -> Id<Object, Owned> {
         match self {
             Self::Custom(objc) => objc,
 
@@ -210,8 +218,7 @@ impl MenuItem {
 
             Self::Separator => {
                 let cls = class!(NSMenuItem);
-                let separator: id = msg_send![cls, separatorItem];
-                Id::from_ptr(separator)
+                msg_send_id![cls, separatorItem].unwrap()
             }
         }
     }
@@ -313,8 +320,8 @@ extern "C" fn fire_block_action(this: &Object, _: Sel, _item: id) {
 ///
 /// In general, we do not want to do more than we need to here - menus are one of the last areas
 /// where Carbon still lurks, and subclassing things can get weird.
-pub(crate) fn register_menu_item_class() -> *const Class {
-    static mut APP_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_menu_item_class() -> &'static Class {
+    static mut APP_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
@@ -325,8 +332,8 @@ pub(crate) fn register_menu_item_class() -> *const Class {
         decl.add_method(sel!(dealloc), dealloc_cacao_menuitem as extern "C" fn(_, _));
         decl.add_method(sel!(fireBlockAction:), fire_block_action as extern "C" fn(_, _, _));
 
-        APP_CLASS = decl.register();
+        APP_CLASS = Some(decl.register());
     });
 
-    unsafe { APP_CLASS }
+    unsafe { APP_CLASS.unwrap() }
 }
diff --git a/src/appkit/menu/menu.rs b/src/appkit/menu/menu.rs
index 184e8c03..2044c8ae 100644
--- a/src/appkit/menu/menu.rs
+++ b/src/appkit/menu/menu.rs
@@ -2,9 +2,9 @@
 
 use std::sync::{Arc, Mutex};
 
-use crate::id_shim::{Id, ShareId};
+use objc::rc::{Id, Owned, Shared};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::appkit::menu::item::MenuItem;
 use crate::foundation::{id, NSInteger, NSString};
@@ -12,7 +12,7 @@ use crate::foundation::{id, NSInteger, NSString};
 /// A struct that represents an `NSMenu`. It takes ownership of items, and handles instrumenting
 /// them throughout the application lifecycle.
 #[derive(Debug)]
-pub struct Menu(pub Id<Object>);
+pub struct Menu(pub Id<Object, Owned>);
 
 impl Menu {
     /// Creates a new `Menu` with the given title, and uses the passed items as submenu items.
@@ -27,16 +27,16 @@ impl Menu {
     pub fn new(title: &str, items: Vec<MenuItem>) -> Self {
         Menu(unsafe {
             let cls = class!(NSMenu);
-            let alloc: id = msg_send![cls, alloc];
+            let alloc = msg_send_id![cls, alloc];
             let title = NSString::new(title);
-            let menu: id = msg_send![alloc, initWithTitle:&*title];
+            let mut menu = msg_send_id![alloc, initWithTitle: &*title].unwrap();
 
             for item in items.into_iter() {
                 let objc = item.to_objc();
-                let _: () = msg_send![menu, addItem:&*objc];
+                let _: () = msg_send![&mut menu, addItem:&*objc];
             }
 
-            Id::from_retained_ptr(menu)
+            menu
         })
     }
 
diff --git a/src/appkit/printing/settings.rs b/src/appkit/printing/settings.rs
index 40df0841..b13281bb 100644
--- a/src/appkit/printing/settings.rs
+++ b/src/appkit/printing/settings.rs
@@ -1,7 +1,7 @@
 //! Represents settings for printing items. Backed by an `NSDictionary` in Objective-C, this struct
 //! aims to make it easier to query/process printing operations.
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::Object;
 
 use crate::foundation::id;
@@ -10,14 +10,14 @@ use crate::foundation::id;
 /// application/user.
 #[derive(Clone, Debug)]
 pub struct PrintSettings {
-    pub inner: ShareId<Object>
+    pub inner: Id<Object, Shared>
 }
 
 impl PrintSettings {
     /// Internal method, constructs a wrapper around the backing `NSDictionary` print settings.
     pub(crate) fn with_inner(inner: id) -> Self {
         PrintSettings {
-            inner: unsafe { ShareId::from_ptr(inner) }
+            inner: unsafe { Id::retain(inner).unwrap() }
         }
     }
 }
diff --git a/src/appkit/toolbar/class.rs b/src/appkit/toolbar/class.rs
index 29139fcb..feecfda0 100644
--- a/src/appkit/toolbar/class.rs
+++ b/src/appkit/toolbar/class.rs
@@ -65,7 +65,7 @@ extern "C" fn item_for_identifier<T: ToolbarDelegate>(this: &Object, _: Sel, _:
 
 /// Registers a `NSToolbar` subclass, and configures it to hold some ivars for various things we need
 /// to store. We use it as our delegate as well, just to cut down on moving pieces.
-pub(crate) fn register_toolbar_class<T: ToolbarDelegate>(instance: &T) -> *const Class {
+pub(crate) fn register_toolbar_class<T: ToolbarDelegate>(instance: &T) -> &'static Class {
     load_or_register_class("NSObject", instance.subclass_name(), |decl| unsafe {
         // For callbacks
         decl.add_ivar::<usize>(TOOLBAR_PTR);
diff --git a/src/appkit/toolbar/item.rs b/src/appkit/toolbar/item.rs
index c3908ab4..b8a36b80 100644
--- a/src/appkit/toolbar/item.rs
+++ b/src/appkit/toolbar/item.rs
@@ -6,9 +6,9 @@
 use core_graphics::geometry::CGSize;
 use std::fmt;
 
-use crate::id_shim::{Id, ShareId};
+use objc::rc::{Id, Owned, Shared};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::button::{BezelStyle, Button};
 use crate::foundation::{id, NSString, NO, YES};
@@ -19,7 +19,7 @@ use crate::invoker::TargetActionHandler;
 #[derive(Debug)]
 pub struct ToolbarItem {
     pub identifier: String,
-    pub objc: Id<Object>,
+    pub objc: Id<Object, Owned>,
     pub button: Option<Button>,
     pub image: Option<Image>,
     handler: Option<TargetActionHandler>
@@ -33,9 +33,8 @@ impl ToolbarItem {
 
         let objc = unsafe {
             let identifer = NSString::new(&identifier);
-            let alloc: id = msg_send![class!(NSToolbarItem), alloc];
-            let item: id = msg_send![alloc, initWithItemIdentifier: &*identifer];
-            Id::from_ptr(item)
+            let alloc = msg_send_id![class!(NSToolbarItem), alloc];
+            msg_send_id![alloc, initWithItemIdentifier: &*identifer].unwrap()
         };
 
         ToolbarItem {
@@ -50,7 +49,7 @@ impl ToolbarItem {
     pub(crate) fn wrap(item: id) -> Self {
         ToolbarItem {
             identifier: "".to_string(),
-            objc: unsafe { Id::from_retained_ptr(item) },
+            objc: unsafe { Id::new(item).unwrap() },
             button: None,
             image: None,
             handler: None
diff --git a/src/appkit/toolbar/mod.rs b/src/appkit/toolbar/mod.rs
index da0652c7..6f94eb98 100644
--- a/src/appkit/toolbar/mod.rs
+++ b/src/appkit/toolbar/mod.rs
@@ -5,9 +5,9 @@
 
 use std::fmt;
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Owned, Shared};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::{id, nil, NSString, NSUInteger, NO, YES};
 
@@ -32,10 +32,10 @@ pub struct Toolbar<T = ()> {
     pub identifier: String,
 
     /// The Objective-C runtime toolbar.
-    pub objc: ShareId<Object>,
+    pub objc: Id<Object, Shared>,
 
     /// A pointer to the underlying delegate.
-    pub objc_delegate: ShareId<Object>,
+    pub objc_delegate: Id<Object, Shared>,
 
     /// The user supplied delegate.
     pub delegate: Option<Box<T>>
@@ -52,17 +52,19 @@ where
         let cls = register_toolbar_class::<T>(&delegate);
         let mut delegate = Box::new(delegate);
 
-        let (objc, objc_delegate) = unsafe {
-            let alloc: id = msg_send![class!(NSToolbar), alloc];
+        let (objc, objc_delegate): (Id<Object, Shared>, Id<Object, Shared>) = unsafe {
+            let alloc = msg_send_id![class!(NSToolbar), alloc];
             let identifier = NSString::new(&identifier);
-            let toolbar: id = msg_send![alloc, initWithIdentifier: &*identifier];
-            let objc_delegate: id = msg_send![cls, new]; //WithIdentifier:identifier];
+            let mut toolbar: Id<Object, Owned> = msg_send_id![alloc, initWithIdentifier: &*identifier].unwrap();
+            let mut objc_delegate: Id<Object, Owned> = msg_send_id![cls, new].unwrap(); //WithIdentifier:identifier];
 
             let ptr: *const T = &*delegate;
-            (&mut *objc_delegate).set_ivar(TOOLBAR_PTR, ptr as usize);
-            let _: () = msg_send![toolbar, setDelegate: objc_delegate];
+            objc_delegate.set_ivar(TOOLBAR_PTR, ptr as usize);
 
-            (ShareId::from_ptr(toolbar), ShareId::from_ptr(objc_delegate))
+            let objc_delegate: Id<Object, Shared> = objc_delegate.into();
+            let _: () = msg_send![&mut toolbar, setDelegate: &*objc_delegate];
+
+            (toolbar.into(), objc_delegate)
         };
 
         let _ret = &mut delegate.did_load(Toolbar {
diff --git a/src/appkit/window/class.rs b/src/appkit/window/class.rs
index 19dca2a6..09c6c02c 100644
--- a/src/appkit/window/class.rs
+++ b/src/appkit/window/class.rs
@@ -227,7 +227,7 @@ extern "C" fn cancel<T: WindowDelegate>(this: &Object, _: Sel, _: id) {
 
 /// Injects an `NSWindowDelegate` subclass, with some callback and pointer ivars for what we
 /// need to do.
-pub(crate) fn register_window_class_with_delegate<T: WindowDelegate>(instance: &T) -> *const Class {
+pub(crate) fn register_window_class_with_delegate<T: WindowDelegate>(instance: &T) -> &'static Class {
     load_or_register_class("NSWindow", instance.subclass_name(), |decl| unsafe {
         decl.add_ivar::<usize>(WINDOW_DELEGATE_PTR);
 
diff --git a/src/appkit/window/controller/class.rs b/src/appkit/window/controller/class.rs
index 2f9c914c..ac2802ba 100644
--- a/src/appkit/window/controller/class.rs
+++ b/src/appkit/window/controller/class.rs
@@ -11,16 +11,16 @@ use crate::appkit::window::{WindowDelegate, WINDOW_DELEGATE_PTR};
 
 /// Injects an `NSWindowController` subclass, with some callback and pointer ivars for what we
 /// need to do.
-pub(crate) fn register_window_controller_class<T: WindowDelegate>() -> *const Class {
-    static mut DELEGATE_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_window_controller_class<T: WindowDelegate>() -> &'static Class {
+    static mut DELEGATE_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
         let superclass = class!(NSWindowController);
         let mut decl = ClassDecl::new("RSTWindowController", superclass).unwrap();
         decl.add_ivar::<usize>(WINDOW_DELEGATE_PTR);
-        DELEGATE_CLASS = decl.register();
+        DELEGATE_CLASS = Some(decl.register());
     });
 
-    unsafe { DELEGATE_CLASS }
+    unsafe { DELEGATE_CLASS.unwrap() }
 }
diff --git a/src/appkit/window/controller/mod.rs b/src/appkit/window/controller/mod.rs
index dbcd2e20..b8291424 100644
--- a/src/appkit/window/controller/mod.rs
+++ b/src/appkit/window/controller/mod.rs
@@ -29,9 +29,9 @@
 
 use std::fmt;
 
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
-use objc::{msg_send, sel};
+use objc::{msg_send, msg_send_id, sel};
 
 use crate::appkit::window::{Window, WindowConfig, WindowDelegate, WINDOW_DELEGATE_PTR};
 use crate::foundation::{id, nil};
@@ -44,7 +44,7 @@ use class::register_window_controller_class;
 /// provides some extra lifecycle methods.
 pub struct WindowController<T> {
     /// A handler to the underlying `NSWindowController`.
-    pub objc: Id<Object>,
+    pub objc: Id<Object, Owned>,
 
     /// The underlying `Window` that this controller wraps.
     pub window: Window<T>
@@ -61,15 +61,15 @@ where
 
         let objc = unsafe {
             let window_controller_class = register_window_controller_class::<T>();
-            let controller_alloc: id = msg_send![window_controller_class, alloc];
-            let controller: id = msg_send![controller_alloc, initWithWindow:&*window.objc];
+            let controller_alloc = msg_send_id![window_controller_class, alloc];
+            let mut controller: Id<Object, Owned> = msg_send_id![controller_alloc, initWithWindow: &*window.objc].unwrap();
 
             if let Some(delegate) = &window.delegate {
                 let ptr: *const T = &**delegate;
-                (&mut *controller).set_ivar(WINDOW_DELEGATE_PTR, ptr as usize);
+                controller.set_ivar(WINDOW_DELEGATE_PTR, ptr as usize);
             }
 
-            Id::from_ptr(controller)
+            controller
         };
 
         WindowController { objc, window }
diff --git a/src/appkit/window/mod.rs b/src/appkit/window/mod.rs
index dead2132..3383c91b 100644
--- a/src/appkit/window/mod.rs
+++ b/src/appkit/window/mod.rs
@@ -13,9 +13,9 @@ use block::ConcreteBlock;
 use core_graphics::base::CGFloat;
 use core_graphics::geometry::{CGRect, CGSize};
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Owned, Shared};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::appkit::toolbar::{Toolbar, ToolbarDelegate};
 use crate::color::Color;
@@ -46,7 +46,7 @@ pub(crate) static WINDOW_DELEGATE_PTR: &str = "rstWindowDelegate";
 #[derive(Debug)]
 pub struct Window<T = ()> {
     /// Represents an `NS/UIWindow` in the Objective-C runtime.
-    pub objc: ShareId<Object>,
+    pub objc: Id<Object, Shared>,
 
     /// A delegate for this window.
     pub delegate: Option<Box<T>>
@@ -71,40 +71,41 @@ impl Window {
             // apps that would use this toolkit wouldn't be tab-oriented...
             let _: () = msg_send![class!(NSWindow), setAllowsAutomaticWindowTabbing: NO];
 
-            let alloc: id = msg_send![class!(NSWindow), alloc];
-
             // Other types of backing (Retained/NonRetained) are archaic, dating back to the
             // NeXTSTEP era, and are outright deprecated... so we don't allow setting them.
             let buffered: NSUInteger = 2;
             let dimensions: CGRect = config.initial_dimensions.into();
-            let window: id = msg_send![alloc, initWithContentRect:dimensions
-                styleMask:config.style
-                backing:buffered
-                defer:match config.defer {
+            let window = msg_send_id![
+                msg_send_id![class!(NSWindow), alloc],
+                initWithContentRect: dimensions,
+                styleMask: config.style,
+                backing: buffered,
+                defer: match config.defer {
                     true => YES,
                     false => NO
-                }
-            ];
+                },
+            ]
+            .unwrap();
 
-            let _: () = msg_send![window, autorelease];
+            let _: () = msg_send![&*window, autorelease];
 
             // This is very important! NSWindow is an old class and has some behavior that we need
             // to disable, like... this. If we don't set this, we'll segfault entirely because the
             // Objective-C runtime gets out of sync by releasing the window out from underneath of
             // us.
-            let _: () = msg_send![window, setReleasedWhenClosed: NO];
+            let _: () = msg_send![&*window, setReleasedWhenClosed: NO];
 
-            let _: () = msg_send![window, setRestorable: NO];
+            let _: () = msg_send![&*window, setRestorable: NO];
 
             // This doesn't exist prior to Big Sur, but is important to support for Big Sur.
             //
             // Why this isn't a setting on the Toolbar itself I'll never know.
             if os::is_minimum_version(11) {
                 let toolbar_style: NSUInteger = config.toolbar_style.into();
-                let _: () = msg_send![window, setToolbarStyle: toolbar_style];
+                let _: () = msg_send![&*window, setToolbarStyle: toolbar_style];
             }
 
-            ShareId::from_ptr(window)
+            window
         };
 
         Window {
@@ -126,51 +127,52 @@ where
         let class = register_window_class_with_delegate::<T>(&delegate);
         let mut delegate = Box::new(delegate);
 
-        let objc = unsafe {
+        let objc: Id<Object, Shared> = unsafe {
             // This behavior might make sense to keep as default (YES), but I think the majority of
             // apps that would use this toolkit wouldn't be tab-oriented...
             let _: () = msg_send![class!(NSWindow), setAllowsAutomaticWindowTabbing: NO];
 
-            let alloc: id = msg_send![class, alloc];
-
             // Other types of backing (Retained/NonRetained) are archaic, dating back to the
             // NeXTSTEP era, and are outright deprecated... so we don't allow setting them.
             let buffered: NSUInteger = 2;
             let dimensions: CGRect = config.initial_dimensions.into();
-            let window: id = msg_send![alloc, initWithContentRect:dimensions
-                styleMask:config.style
-                backing:buffered
-                defer:match config.defer {
+            let mut window: Id<Object, Owned> = msg_send_id![
+                msg_send_id![class, alloc],
+                initWithContentRect: dimensions,
+                styleMask: config.style,
+                backing: buffered,
+                defer: match config.defer {
                     true => YES,
                     false => NO
-                }
-            ];
+                },
+            ]
+            .unwrap();
 
             let delegate_ptr: *const T = &*delegate;
-            (&mut *window).set_ivar(WINDOW_DELEGATE_PTR, delegate_ptr as usize);
+            window.set_ivar(WINDOW_DELEGATE_PTR, delegate_ptr as usize);
 
-            let _: () = msg_send![window, autorelease];
+            let _: () = msg_send![&*window, autorelease];
 
             // This is very important! NSWindow is an old class and has some behavior that we need
             // to disable, like... this. If we don't set this, we'll segfault entirely because the
             // Objective-C runtime gets out of sync by releasing the window out from underneath of
             // us.
-            let _: () = msg_send![window, setReleasedWhenClosed: NO];
+            let _: () = msg_send![&*window, setReleasedWhenClosed: NO];
 
             // We set the window to be its own delegate - this is cleaned up inside `Drop`.
-            let _: () = msg_send![window, setDelegate: window];
+            let _: () = msg_send![&*window, setDelegate: &*window];
 
-            let _: () = msg_send![window, setRestorable: NO];
+            let _: () = msg_send![&*window, setRestorable: NO];
 
             // This doesn't exist prior to Big Sur, but is important to support for Big Sur.
             //
             // Why this isn't a setting on the Toolbar itself I'll never know.
             if os::is_minimum_version(11) {
                 let toolbar_style: NSUInteger = config.toolbar_style.into();
-                let _: () = msg_send![window, setToolbarStyle: toolbar_style];
+                let _: () = msg_send![&*window, setToolbarStyle: toolbar_style];
             }
 
-            ShareId::from_ptr(window)
+            window.into()
         };
 
         {
diff --git a/src/button/mod.rs b/src/button/mod.rs
index 27e7bec5..f6198b71 100644
--- a/src/button/mod.rs
+++ b/src/button/mod.rs
@@ -23,10 +23,10 @@ use std::sync::Once;
 use std::cell::RefCell;
 use std::rc::Rc;
 
-use crate::id_shim::ShareId;
 use objc::declare::ClassDecl;
+use objc::rc::{Id, Shared};
 use objc::runtime::{Class, Object, Sel};
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::color::Color;
 use crate::control::Control;
@@ -198,7 +198,7 @@ impl Button {
     /// best just to message pass or something.
     pub fn set_action<F: Fn() + Send + Sync + 'static>(&mut self, action: F) {
         // @TODO: This probably isn't ideal but gets the job done for now; needs revisiting.
-        let this = self.objc.get(|obj| unsafe { ShareId::from_ptr(msg_send![obj, self]) });
+        let this: Id<Object, Shared> = self.objc.get(|obj| unsafe { msg_send_id![obj, self].unwrap() });
         let handler = TargetActionHandler::new(&*this, action);
         self.handler = Some(handler);
     }
@@ -334,15 +334,15 @@ impl Drop for Button {
 
 /// Registers an `NSButton` subclass, and configures it to hold some ivars
 /// for various things we need to store.
-fn register_class() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+fn register_class() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
         let superclass = class!(NSButton);
         let decl = ClassDecl::new("RSTButton", superclass).unwrap();
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
diff --git a/src/cloudkit/share.rs b/src/cloudkit/share.rs
index d36d9648..15016ce9 100644
--- a/src/cloudkit/share.rs
+++ b/src/cloudkit/share.rs
@@ -1,6 +1,6 @@
 //! This module includes wrappers for `CKShare` and `CKShareMetaData`.
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::Object;
 
 use crate::foundation::id;
@@ -9,14 +9,14 @@ use crate::foundation::id;
 /// to, say, handle accepting an invite for a share.
 #[derive(Clone, Debug)]
 pub struct CKShareMetaData {
-    pub inner: ShareId<Object>
+    pub inner: Id<Object, Shared>
 }
 
 impl CKShareMetaData {
     /// Internal method for wrapping a system-provided `CKShareMetaData` object.
     pub(crate) fn with_inner(object: id) -> Self {
         CKShareMetaData {
-            inner: unsafe { ShareId::from_ptr(object) }
+            inner: unsafe { Id::retain(object).unwrap() }
         }
     }
 }
diff --git a/src/color/appkit_dynamic_color.rs b/src/color/appkit_dynamic_color.rs
index 3c3ceb9f..3e12c3df 100644
--- a/src/color/appkit_dynamic_color.rs
+++ b/src/color/appkit_dynamic_color.rs
@@ -258,8 +258,8 @@ extern "C" fn color_with_system_effect(this: &Object, _: Sel, effect: NSInteger)
     unsafe { msg_send![color, colorWithSystemEffect: effect] }
 }
 
-pub(crate) fn register_class() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_class() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
@@ -333,8 +333,8 @@ pub(crate) fn register_class() -> *const Class {
         decl.add_ivar::<id>(AQUA_DARK_COLOR_NORMAL_CONTRAST);
         decl.add_ivar::<id>(AQUA_DARK_COLOR_HIGH_CONTRAST);
 
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
diff --git a/src/color/mod.rs b/src/color/mod.rs
index 370b6ffd..9dd25532 100644
--- a/src/color/mod.rs
+++ b/src/color/mod.rs
@@ -19,9 +19,9 @@ use core_foundation::base::TCFType;
 use core_graphics::base::CGFloat;
 use core_graphics::color::CGColor;
 
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::id;
 use crate::utils::os;
@@ -86,7 +86,7 @@ pub enum Color {
     ///
     /// If you need to do custom work not covered by this enum, you can drop to
     /// the Objective-C level yourself and wrap your color in this.
-    Custom(Arc<RwLock<Id<Object>>>),
+    Custom(Arc<RwLock<Id<Object, Owned>>>),
 
     /// The system-provided black. Harsh - you probably don't want to use this.
     SystemBlack,
@@ -251,12 +251,12 @@ impl Color {
         Color::Custom(Arc::new(RwLock::new(unsafe {
             #[cfg(feature = "appkit")]
             {
-                Id::from_ptr(msg_send![class!(NSColor), colorWithCalibratedRed: r, green: g, blue: b, alpha: a])
+                msg_send_id![class!(NSColor), colorWithCalibratedRed: r, green: g, blue: b, alpha: a].unwrap()
             }
 
             #[cfg(feature = "uikit")]
             {
-                Id::from_ptr(msg_send![class!(UIColor), colorWithRed: r, green: g, blue: b, alpha: a])
+                msg_send_id![class!(UIColor), colorWithRed: r, green: g, blue: b, alpha: a].unwrap()
             }
         })))
     }
@@ -278,12 +278,19 @@ impl Color {
         Color::Custom(Arc::new(RwLock::new(unsafe {
             #[cfg(feature = "appkit")]
             {
-                Id::from_ptr(msg_send![class!(NSColor), colorWithCalibratedHue:h saturation:s brightness:b alpha:a])
+                msg_send_id![
+                    class!(NSColor),
+                    colorWithCalibratedHue: h,
+                    saturation: s,
+                    brightness: b,
+                    alpha: a
+                ]
+                .unwrap()
             }
 
             #[cfg(feature = "uikit")]
             {
-                Id::from_ptr(msg_send![class!(UIColor), colorWithHue:h saturation:s brightness:b alpha:a])
+                msg_send_id![class!(UIColor), colorWithHue: h, saturation: s, brightness: b, alpha: a].unwrap()
             }
         })))
     }
@@ -300,12 +307,12 @@ impl Color {
         Color::Custom(Arc::new(RwLock::new(unsafe {
             #[cfg(feature = "appkit")]
             {
-                Id::from_ptr(msg_send![class!(NSColor), colorWithCalibratedWhite:level alpha:alpha])
+                msg_send_id![class!(NSColor), colorWithCalibratedWhite: level, alpha: alpha].unwrap()
             }
 
             #[cfg(feature = "uikit")]
             {
-                Id::from_ptr(msg_send![class!(UIColor), colorWithWhite:level alpha:alpha])
+                msg_send_id![class!(UIColor), colorWithWhite: level, alpha: alpha].unwrap()
             }
         })))
     }
@@ -352,9 +359,9 @@ impl Color {
         // am happy to do this for now and let someone who needs true dynamic allocation look into
         // it and PR it.
         Color::Custom(Arc::new(RwLock::new(unsafe {
-            let color: id = msg_send![appkit_dynamic_color::register_class(), new];
+            let mut color: Id<Object, Owned> = msg_send_id![appkit_dynamic_color::register_class(), new].unwrap();
 
-            (&mut *color).set_ivar(AQUA_LIGHT_COLOR_NORMAL_CONTRAST, {
+            color.set_ivar(AQUA_LIGHT_COLOR_NORMAL_CONTRAST, {
                 let color: id = handler(Style {
                     theme: Theme::Light,
                     contrast: Contrast::Normal
@@ -364,7 +371,7 @@ impl Color {
                 color
             });
 
-            (&mut *color).set_ivar(AQUA_LIGHT_COLOR_HIGH_CONTRAST, {
+            color.set_ivar(AQUA_LIGHT_COLOR_HIGH_CONTRAST, {
                 let color: id = handler(Style {
                     theme: Theme::Light,
                     contrast: Contrast::High
@@ -374,7 +381,7 @@ impl Color {
                 color
             });
 
-            (&mut *color).set_ivar(AQUA_DARK_COLOR_NORMAL_CONTRAST, {
+            color.set_ivar(AQUA_DARK_COLOR_NORMAL_CONTRAST, {
                 let color: id = handler(Style {
                     theme: Theme::Dark,
                     contrast: Contrast::Normal
@@ -384,7 +391,7 @@ impl Color {
                 color
             });
 
-            (&mut *color).set_ivar(AQUA_DARK_COLOR_HIGH_CONTRAST, {
+            color.set_ivar(AQUA_DARK_COLOR_HIGH_CONTRAST, {
                 let color: id = handler(Style {
                     theme: Theme::Light,
                     contrast: Contrast::Normal
@@ -394,7 +401,7 @@ impl Color {
                 color
             });
 
-            Id::from_ptr(color)
+            color
         })))
     }
 
diff --git a/src/defaults/mod.rs b/src/defaults/mod.rs
index b62f4449..d5f8aad7 100644
--- a/src/defaults/mod.rs
+++ b/src/defaults/mod.rs
@@ -33,9 +33,9 @@
 
 use std::collections::HashMap;
 
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::{id, nil, to_bool, NSData, NSMutableDictionary, NSNumber, NSString, BOOL, NO, YES};
 
@@ -47,7 +47,7 @@ pub use value::Value;
 ///
 /// This should not be used for sensitive data - use the Keychain for that.
 #[derive(Debug)]
-pub struct UserDefaults(pub Id<Object>);
+pub struct UserDefaults(pub Id<Object, Owned>);
 
 impl Default for UserDefaults {
     /// Equivalent to calling `UserDefaults::standard()`.
@@ -70,7 +70,7 @@ impl UserDefaults {
     /// let _ = defaults.get("test");
     /// ```
     pub fn standard() -> Self {
-        UserDefaults(unsafe { Id::from_ptr(msg_send![class!(NSUserDefaults), standardUserDefaults]) })
+        UserDefaults(unsafe { msg_send_id![class!(NSUserDefaults), standardUserDefaults].unwrap() })
     }
 
     /// Returns a user defaults instance for the given suite name. You typically use this to share
@@ -88,8 +88,8 @@ impl UserDefaults {
         let name = NSString::new(named);
 
         UserDefaults(unsafe {
-            let alloc: id = msg_send![class!(NSUserDefaults), alloc];
-            Id::from_ptr(msg_send![alloc, initWithSuiteName:&*name])
+            let alloc = msg_send_id![class!(NSUserDefaults), alloc];
+            msg_send_id![alloc, initWithSuiteName:&*name].unwrap()
         })
     }
 
diff --git a/src/dragdrop.rs b/src/dragdrop.rs
index 4b2477a0..b1995c23 100644
--- a/src/dragdrop.rs
+++ b/src/dragdrop.rs
@@ -2,7 +2,7 @@
 //! across the codebase, hence why they're here - they're not currently exhaustive, so feel free to
 //! tinker and pull request.
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::Object;
 use objc::{msg_send, sel};
 
@@ -54,7 +54,7 @@ impl From<DragOperation> for NSUInteger {
 /// this only provides getters - merely a Rust-y way to grab what you need.
 #[derive(Clone, Debug)]
 pub struct DragInfo {
-    pub info: ShareId<Object>
+    pub info: Id<Object, Shared>
 }
 
 impl DragInfo {
diff --git a/src/filesystem/manager.rs b/src/filesystem/manager.rs
index 57ad8aa9..a659eaaa 100644
--- a/src/filesystem/manager.rs
+++ b/src/filesystem/manager.rs
@@ -4,9 +4,9 @@
 use std::error::Error;
 use std::sync::{Arc, RwLock};
 
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::{Object, BOOL};
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 use url::Url;
 
 use crate::error::Error as AppKitError;
@@ -18,17 +18,16 @@ use crate::foundation::{id, nil, NSString, NSUInteger, NO};
 /// If your app is not sandboxed, you can use your favorite Rust library -
 /// but if you _are_ operating in the sandbox, there's a good chance you'll want to use this.
 ///
-/// @TODO: Couldn't this just be a ShareId?
+/// @TODO: Couldn't this just be a Id<Object, Shared>?
 #[derive(Clone, Debug)]
-pub struct FileManager(pub Arc<RwLock<Id<Object>>>);
+pub struct FileManager(pub Arc<RwLock<Id<Object, Owned>>>);
 
 impl Default for FileManager {
     /// Returns a default file manager, which maps to the default system file manager. For common
     /// and simple tasks, with no callbacks, you might want this.
     fn default() -> Self {
         FileManager(Arc::new(RwLock::new(unsafe {
-            let manager: id = msg_send![class!(NSFileManager), defaultManager];
-            Id::from_ptr(manager)
+            msg_send_id![class!(NSFileManager), defaultManager].unwrap()
         })))
     }
 }
@@ -37,8 +36,7 @@ impl FileManager {
     /// Returns a new FileManager that opts in to delegate methods.
     pub fn new() -> Self {
         FileManager(Arc::new(RwLock::new(unsafe {
-            let manager: id = msg_send![class!(NSFileManager), new];
-            Id::from_ptr(manager)
+            msg_send_id![class!(NSFileManager), new].unwrap()
         })))
     }
 
diff --git a/src/filesystem/save.rs b/src/filesystem/save.rs
index fdec114c..65dfa42f 100644
--- a/src/filesystem/save.rs
+++ b/src/filesystem/save.rs
@@ -4,19 +4,19 @@
 
 use block::ConcreteBlock;
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::{id, nil, NSInteger, NSString, NO, YES};
 
 #[derive(Debug)]
 pub struct FileSavePanel {
     /// The internal Objective C `NSOpenPanel` instance.
-    pub panel: ShareId<Object>,
+    pub panel: Id<Object, Shared>,
 
     /// The internal `NSObject` that routes delegate callbacks around.
-    pub delegate: ShareId<Object>,
+    pub delegate: Id<Object, Shared>,
 
     /// Whether the user can choose files. Defaults to `true`.
     pub can_create_directories: bool
@@ -35,11 +35,10 @@ impl FileSavePanel {
         FileSavePanel {
             panel: unsafe {
                 let cls = class!(NSSavePanel);
-                let x: id = msg_send![cls, savePanel];
-                ShareId::from_ptr(x)
+                msg_send_id![cls, savePanel].unwrap()
             },
 
-            delegate: unsafe { ShareId::from_ptr(msg_send![class!(NSObject), new]) },
+            delegate: unsafe { msg_send_id![class!(NSObject), new].unwrap() },
 
             can_create_directories: true
         }
diff --git a/src/filesystem/select.rs b/src/filesystem/select.rs
index 40807995..a021b844 100644
--- a/src/filesystem/select.rs
+++ b/src/filesystem/select.rs
@@ -6,9 +6,9 @@ use std::path::PathBuf;
 
 use block::ConcreteBlock;
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::filesystem::enums::ModalResponse;
 use crate::foundation::{id, nil, NSInteger, NSString, NO, NSURL, YES};
@@ -19,10 +19,10 @@ use crate::appkit::window::{Window, WindowDelegate};
 #[derive(Debug)]
 pub struct FileSelectPanel {
     /// The internal Objective C `NSOpenPanel` instance.
-    pub panel: ShareId<Object>,
+    pub panel: Id<Object, Shared>,
 
     /// The internal `NSObject` that routes delegate callbacks around.
-    pub delegate: ShareId<Object>,
+    pub delegate: Id<Object, Shared>,
 
     /// Whether the user can choose files. Defaults to `true`.
     pub can_choose_files: bool,
@@ -54,11 +54,10 @@ impl FileSelectPanel {
         FileSelectPanel {
             panel: unsafe {
                 let cls = class!(NSOpenPanel);
-                let x: id = msg_send![cls, openPanel];
-                ShareId::from_ptr(x)
+                msg_send_id![cls, openPanel].unwrap()
             },
 
-            delegate: unsafe { ShareId::from_ptr(msg_send![class!(NSObject), new]) },
+            delegate: unsafe { msg_send_id![class!(NSObject), new].unwrap() },
 
             can_choose_files: true,
             can_choose_directories: false,
diff --git a/src/foundation/array.rs b/src/foundation/array.rs
index 231baa46..86edb6f0 100644
--- a/src/foundation/array.rs
+++ b/src/foundation/array.rs
@@ -1,8 +1,8 @@
 use std::ops::{Deref, DerefMut};
 
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::id;
 
@@ -11,29 +11,31 @@ use crate::foundation::id;
 /// ever deemed necessary (unlikely, given how much Apple has optimized the Foundation classes, but
 /// still...).
 #[derive(Debug)]
-pub struct NSArray(pub Id<Object>);
+pub struct NSArray(pub Id<Object, Owned>);
 
 impl NSArray {
     /// Given a set of `Object`s, creates and retains an `NSArray` that holds them.
     pub fn new(objects: &[id]) -> Self {
         NSArray(unsafe {
-            Id::from_ptr(msg_send![class!(NSArray),
-                arrayWithObjects:objects.as_ptr()
-                count:objects.len()
-            ])
+            msg_send_id![
+                class!(NSArray),
+                arrayWithObjects: objects.as_ptr(),
+                count: objects.len()
+            ]
+            .unwrap()
         })
     }
 
     /// In some cases, we're vended an `NSArray` by the system that we need to call retain on.
     /// This handles that case.
     pub fn retain(array: id) -> Self {
-        NSArray(unsafe { Id::from_ptr(array) })
+        NSArray(unsafe { Id::retain(array).unwrap() })
     }
 
     /// In some cases, we're vended an `NSArray` by the system, and it's ideal to not retain that.
     /// This handles that edge case.
     pub fn from_retained(array: id) -> Self {
-        NSArray(unsafe { Id::from_retained_ptr(array) })
+        NSArray(unsafe { Id::new(array).unwrap() })
     }
 
     /// Returns the `count` (`len()` equivalent) for the backing `NSArray`.
@@ -63,10 +65,12 @@ impl From<Vec<&Object>> for NSArray {
     /// Given a set of `Object`s, creates an `NSArray` that holds them.
     fn from(objects: Vec<&Object>) -> Self {
         NSArray(unsafe {
-            Id::from_ptr(msg_send![class!(NSArray),
-                arrayWithObjects:objects.as_ptr()
-                count:objects.len()
-            ])
+            msg_send_id![
+                class!(NSArray),
+                arrayWithObjects: objects.as_ptr(),
+                count: objects.len(),
+            ]
+            .unwrap()
         })
     }
 }
@@ -75,10 +79,12 @@ impl From<Vec<id>> for NSArray {
     /// Given a set of `*mut Object`s, creates an `NSArray` that holds them.
     fn from(objects: Vec<id>) -> Self {
         NSArray(unsafe {
-            Id::from_ptr(msg_send![class!(NSArray),
-                arrayWithObjects:objects.as_ptr()
-                count:objects.len()
-            ])
+            msg_send_id![
+                class!(NSArray),
+                arrayWithObjects: objects.as_ptr(),
+                count: objects.len()
+            ]
+            .unwrap()
         })
     }
 }
diff --git a/src/foundation/autoreleasepool.rs b/src/foundation/autoreleasepool.rs
index 80119025..76c0bf1f 100644
--- a/src/foundation/autoreleasepool.rs
+++ b/src/foundation/autoreleasepool.rs
@@ -1,6 +1,6 @@
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 /// A wrapper around `NSAutoReleasePool`. The core `App` structures create and manage one of these,
 /// but it's conceivable that users might need to create their own.
@@ -8,13 +8,13 @@ use objc::{class, msg_send, sel};
 /// When this is dropped, we automatically send a `drain` message to the underlying pool. You can
 /// also call `drain()` yourself if you need to drain for whatever reason.
 #[derive(Debug)]
-pub struct AutoReleasePool(pub Id<Object>);
+pub struct AutoReleasePool(pub Id<Object, Owned>);
 
 impl AutoReleasePool {
     /// Creates and returns a new `AutoReleasePool`. You need to take care to keep this alive for
     /// as long as you need it.
     pub fn new() -> Self {
-        AutoReleasePool(unsafe { Id::from_retained_ptr(msg_send![class!(NSAutoreleasePool), new]) })
+        AutoReleasePool(unsafe { msg_send_id![class!(NSAutoreleasePool), new].unwrap() })
     }
 
     /// Drains the underlying AutoreleasePool.
diff --git a/src/foundation/class.rs b/src/foundation/class.rs
index dd2f5db5..bab3b3fb 100644
--- a/src/foundation/class.rs
+++ b/src/foundation/class.rs
@@ -49,12 +49,12 @@ impl ClassMap {
     }
 
     /// Attempts to load a previously registered subclass.
-    pub fn load_subclass(&self, subclass_name: &'static str, superclass_name: &'static str) -> Option<*const Class> {
+    pub fn load_subclass(&self, subclass_name: &'static str, superclass_name: &'static str) -> Option<&'static Class> {
         let reader = self.0.read().unwrap();
 
         if let Some(inner) = (*reader).get(subclass_name) {
             if let Some(class) = inner.get(superclass_name) {
-                return Some(*class as *const Class);
+                return Some(unsafe { (*class as *const Class).as_ref() }.unwrap());
             }
         }
 
@@ -103,7 +103,7 @@ impl ClassMap {
             }
         }
 
-        Some(superclass.cast())
+        Some(unsafe { superclass.cast::<Class>().as_ref() }.unwrap())
     }
 }
 
@@ -121,7 +121,7 @@ impl ClassMap {
 ///
 /// There's definitely room to optimize here, but it works for now.
 #[inline(always)]
-pub fn load_or_register_class<F>(superclass_name: &'static str, subclass_name: &'static str, config: F) -> *const Class
+pub fn load_or_register_class<F>(superclass_name: &'static str, subclass_name: &'static str, config: F) -> &'static Class
 where
     F: Fn(&mut ClassDecl) + 'static
 {
diff --git a/src/foundation/data.rs b/src/foundation/data.rs
index 473bcead..e67cdf4a 100644
--- a/src/foundation/data.rs
+++ b/src/foundation/data.rs
@@ -5,9 +5,9 @@ use std::slice;
 
 use block::{Block, ConcreteBlock};
 
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::{id, to_bool, NSUInteger, BOOL, NO, YES};
 
@@ -18,7 +18,7 @@ use crate::foundation::{id, to_bool, NSUInteger, BOOL, NO, YES};
 ///
 /// This is an intentionally limited API.
 #[derive(Debug)]
-pub struct NSData(pub Id<Object>);
+pub struct NSData(pub Id<Object, Owned>);
 
 impl NSData {
     /// Given a vector of bytes, creates, retains, and returns a wrapped `NSData`.
@@ -41,12 +41,15 @@ impl NSData {
         let bytes_ptr = bytes.as_mut_ptr() as *mut c_void;
 
         unsafe {
-            let obj: id = msg_send![class!(NSData), alloc];
-            let obj: id = msg_send![obj, initWithBytesNoCopy:bytes_ptr
-                                                             length:bytes.len()
-                                                        deallocator:dealloc];
+            let obj = msg_send_id![class!(NSData), alloc];
+            let obj = msg_send_id![
+                obj,
+                initWithBytesNoCopy: bytes_ptr,
+                length: bytes.len(),
+                deallocator: dealloc,
+            ];
             mem::forget(bytes);
-            NSData(Id::from_ptr(obj))
+            NSData(obj.unwrap())
         }
     }
 
@@ -60,20 +63,24 @@ impl NSData {
         let bytes_ptr = bytes.as_ptr() as *mut c_void;
 
         unsafe {
-            let obj: id = msg_send![class!(NSData), dataWithBytes:bytes_ptr length:bytes.len()];
-            NSData(Id::from_ptr(obj))
+            let obj = msg_send_id![
+                class!(NSData),
+                dataWithBytes: bytes_ptr,
+                length: bytes.len(),
+            ];
+            NSData(obj.unwrap())
         }
     }
 
     /// Given a (presumably) `NSData`, wraps and retains it.
     pub fn retain(data: id) -> Self {
-        NSData(unsafe { Id::from_ptr(data) })
+        NSData(unsafe { Id::retain(data).unwrap() })
     }
 
     /// If we're vended an NSData from a method (e.g, a push notification token) we might want to
     /// wrap it while we figure out what to do with it. This does that.
     pub fn from_retained(data: id) -> Self {
-        NSData(unsafe { Id::from_retained_ptr(data) })
+        NSData(unsafe { Id::new(data).unwrap() })
     }
 
     /// A helper method for determining if a given `NSObject` is an `NSData`.
diff --git a/src/foundation/dictionary.rs b/src/foundation/dictionary.rs
index 8be03366..5afcadfe 100644
--- a/src/foundation/dictionary.rs
+++ b/src/foundation/dictionary.rs
@@ -1,15 +1,15 @@
 use std::collections::HashMap;
 use std::ops::{Deref, DerefMut};
 
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::{id, NSString};
 
 /// A wrapper for `NSMutableDictionary`.
 #[derive(Debug)]
-pub struct NSMutableDictionary(pub Id<Object>);
+pub struct NSMutableDictionary(pub Id<Object, Owned>);
 
 impl Default for NSMutableDictionary {
     /// Returns a blank NSMutableDictionary.
@@ -26,7 +26,7 @@ impl NSMutableDictionary {
     /// object model. You can, of course, bypass it and `msg_send![]` yourself, but it'd require an
     /// `unsafe {}` block... so you'll know you're in special territory then.
     pub fn new() -> Self {
-        NSMutableDictionary(unsafe { Id::from_ptr(msg_send![class!(NSMutableDictionary), new]) })
+        NSMutableDictionary(unsafe { msg_send_id![class!(NSMutableDictionary), new].unwrap() })
     }
 
     /// Inserts an object into the backing NSMutablyDictionary.
diff --git a/src/foundation/number.rs b/src/foundation/number.rs
index 42b5d965..8c31f838 100644
--- a/src/foundation/number.rs
+++ b/src/foundation/number.rs
@@ -1,9 +1,9 @@
 use std::ffi::CStr;
 use std::os::raw::c_char;
 
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::{id, to_bool, NSInteger, BOOL, NO, YES};
 
@@ -12,39 +12,40 @@ use crate::foundation::{id, to_bool, NSInteger, BOOL, NO, YES};
 /// In general we strive to avoid using this in the codebase, but it's a requirement for moving
 /// objects in and out of certain situations (e.g, `UserDefaults`).
 #[derive(Debug)]
-pub struct NSNumber(pub Id<Object>);
+pub struct NSNumber(pub Id<Object, Owned>);
 
 impl NSNumber {
     /// If we're vended an NSNumber from a method (e.g, `NSUserDefaults` querying) we might want to
     /// wrap (and retain) it while we figure out what to do with it. This does that.
     pub fn retain(data: id) -> Self {
-        NSNumber(unsafe { Id::from_ptr(data) })
+        NSNumber(unsafe { Id::retain(data).unwrap() })
     }
 
     /// If we're vended an NSNumber from a method (e.g, `NSUserDefaults` querying) we might want to
     /// wrap it while we figure out what to do with it. This does that.
     pub fn wrap(data: id) -> Self {
-        NSNumber(unsafe { Id::from_retained_ptr(data) })
+        NSNumber(unsafe { Id::new(data).unwrap() })
     }
 
     /// Constructs a `numberWithBool` instance of `NSNumber` and retains it.
     pub fn bool(value: bool) -> Self {
         NSNumber(unsafe {
-            Id::from_retained_ptr(msg_send![class!(NSNumber), numberWithBool:match value {
+            msg_send_id![class!(NSNumber), numberWithBool:match value {
                 true => YES,
                 false => NO
-            }])
+            }]
+            .unwrap()
         })
     }
 
     /// Constructs a `numberWithInteger` instance of `NSNumber` and retains it.
     pub fn integer(value: i64) -> Self {
-        NSNumber(unsafe { Id::from_retained_ptr(msg_send![class!(NSNumber), numberWithInteger: value as NSInteger]) })
+        NSNumber(unsafe { msg_send_id![class!(NSNumber), numberWithInteger: value as NSInteger].unwrap() })
     }
 
     /// Constructs a `numberWithDouble` instance of `NSNumber` and retains it.
     pub fn float(value: f64) -> Self {
-        NSNumber(unsafe { Id::from_retained_ptr(msg_send![class!(NSNumber), numberWithDouble: value]) })
+        NSNumber(unsafe { msg_send_id![class!(NSNumber), numberWithDouble: value].unwrap() })
     }
 
     /// Returns the `objCType` of the underlying `NSNumber` as a Rust `&str`. This flag can be used
diff --git a/src/foundation/string.rs b/src/foundation/string.rs
index 70fc646f..467de0f4 100644
--- a/src/foundation/string.rs
+++ b/src/foundation/string.rs
@@ -3,9 +3,9 @@ use std::ops::{Deref, DerefMut};
 use std::os::raw::c_char;
 use std::{fmt, slice, str};
 
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::{id, to_bool, BOOL, NO, YES};
 
@@ -18,7 +18,7 @@ const UTF8_ENCODING: usize = 4;
 #[derive(Debug)]
 pub struct NSString<'a> {
     /// A reference to the backing `NSString`.
-    pub objc: Id<Object>,
+    pub objc: Id<Object, Owned>,
     phantom: PhantomData<&'a ()>
 }
 
@@ -27,11 +27,13 @@ impl<'a> NSString<'a> {
     pub fn new(s: &str) -> Self {
         NSString {
             objc: unsafe {
-                let nsstring: *mut Object = msg_send![class!(NSString), alloc];
-                Id::from_ptr(msg_send![nsstring, initWithBytes:s.as_ptr()
-                    length:s.len()
-                    encoding:UTF8_ENCODING
-                ])
+                msg_send_id![
+                    msg_send_id![class!(NSString), alloc],
+                    initWithBytes: s.as_ptr(),
+                    length: s.len(),
+                    encoding: UTF8_ENCODING,
+                ]
+                .unwrap()
             },
 
             phantom: PhantomData
@@ -42,12 +44,15 @@ impl<'a> NSString<'a> {
     pub fn no_copy(s: &'a str) -> Self {
         NSString {
             objc: unsafe {
-                let nsstring: id = msg_send![class!(NSString), alloc];
-                Id::from_ptr(msg_send![nsstring, initWithBytesNoCopy:s.as_ptr()
-                    length:s.len()
-                    encoding:UTF8_ENCODING
-                    freeWhenDone:NO
-                ])
+                let nsstring = msg_send_id![class!(NSString), alloc];
+                msg_send_id![
+                    nsstring,
+                    initWithBytesNoCopy: s.as_ptr(),
+                    length: s.len(),
+                    encoding: UTF8_ENCODING,
+                    freeWhenDone: NO,
+                ]
+                .unwrap()
             },
 
             phantom: PhantomData
@@ -58,7 +63,7 @@ impl<'a> NSString<'a> {
     /// retain it.
     pub fn retain(object: id) -> Self {
         NSString {
-            objc: unsafe { Id::from_ptr(object) },
+            objc: unsafe { Id::retain(object).unwrap() },
             phantom: PhantomData
         }
     }
@@ -66,7 +71,7 @@ impl<'a> NSString<'a> {
     /// In some cases, we want to wrap a system-provided NSString without retaining it.
     pub fn from_retained(object: id) -> Self {
         NSString {
-            objc: unsafe { Id::from_retained_ptr(object) },
+            objc: unsafe { Id::new(object).unwrap() },
             phantom: PhantomData
         }
     }
diff --git a/src/foundation/urls/mod.rs b/src/foundation/urls/mod.rs
index e4099bec..ca2474ee 100644
--- a/src/foundation/urls/mod.rs
+++ b/src/foundation/urls/mod.rs
@@ -3,9 +3,9 @@ use std::marker::PhantomData;
 use std::ops::{Deref, DerefMut};
 use std::path::PathBuf;
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::{id, nil, NSData, NSString, NSUInteger};
 
@@ -31,7 +31,7 @@ pub use resource_keys::{NSURLFileResource, NSURLResourceKey, NSUbiquitousItemDow
 #[derive(Clone, Debug)]
 pub struct NSURL<'a> {
     /// A reference to the backing `NSURL`.
-    pub objc: ShareId<Object>,
+    pub objc: Id<Object, Shared>,
     phantom: PhantomData<&'a ()>
 }
 
@@ -40,7 +40,7 @@ impl<'a> NSURL<'a> {
     /// retain it.
     pub fn retain(object: id) -> Self {
         NSURL {
-            objc: unsafe { ShareId::from_ptr(object) },
+            objc: unsafe { Id::retain(object).unwrap() },
             phantom: PhantomData
         }
     }
@@ -48,7 +48,7 @@ impl<'a> NSURL<'a> {
     /// In some cases, we want to wrap a system-provided NSURL without retaining it.
     pub fn from_retained(object: id) -> Self {
         NSURL {
-            objc: unsafe { ShareId::from_retained_ptr(object) },
+            objc: unsafe { Id::new(object).unwrap() },
             phantom: PhantomData
         }
     }
@@ -58,7 +58,7 @@ impl<'a> NSURL<'a> {
         let url = NSString::new(url);
 
         Self {
-            objc: unsafe { ShareId::from_ptr(msg_send![class!(NSURL), URLWithString:&*url]) },
+            objc: unsafe { msg_send_id![class!(NSURL), URLWithString:&*url].unwrap() },
 
             phantom: PhantomData
         }
diff --git a/src/image/appkit.rs b/src/image/appkit.rs
index a269041b..7d3f616d 100644
--- a/src/image/appkit.rs
+++ b/src/image/appkit.rs
@@ -9,8 +9,8 @@
 
 use std::sync::Once;
 
-use crate::id_shim::Id;
 use objc::declare::ClassDecl;
+use objc::rc::{Id, Owned};
 use objc::runtime::{Class, Object, Sel, BOOL};
 use objc::{class, sel};
 
@@ -22,8 +22,8 @@ use crate::view::{ViewDelegate, VIEW_DELEGATE_PTR};
 /// Injects an `NSView` subclass. This is used for the default views that don't use delegates - we
 /// have separate classes here since we don't want to waste cycles on methods that will never be
 /// used if there's no delegates.
-pub(crate) fn register_image_view_class() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_image_view_class() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
@@ -32,8 +32,8 @@ pub(crate) fn register_image_view_class() -> *const Class {
 
         //decl.add_method(sel!(isFlipped), enforce_normalcy as extern "C" fn(_, _) -> _);
 
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
diff --git a/src/image/handle.rs b/src/image/handle.rs
index 2bc0d216..061af678 100644
--- a/src/image/handle.rs
+++ b/src/image/handle.rs
@@ -1,12 +1,12 @@
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::Object;
 
 /// Views get passed these, and can
 #[derive(Debug)]
 pub struct ViewHandle<T> {
     /// A pointer to the Objective-C runtime view controller.
-    pub objc: ShareId<Object>,
+    pub objc: Id<Object, Shared>,
 
     _t: std::marker::PhantomData<T>
 
@@ -40,7 +40,7 @@ where
     T:
 
 impl<T> Layout for ViewHandle<T> {
-    fn get_backing_node(&self) -> ShareId<Object> {
+    fn get_backing_node(&self) -> Id<Object, Shared> {
         self.objc.clone()
     }
 
diff --git a/src/image/image.rs b/src/image/image.rs
index 0ed41e01..54a73d85 100644
--- a/src/image/image.rs
+++ b/src/image/image.rs
@@ -1,7 +1,7 @@
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::Object;
 
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use block::ConcreteBlock;
 
@@ -119,12 +119,12 @@ pub struct DrawConfig {
 /// Wraps `NSImage` under AppKit, and `UIImage` on under UIKit (iOS and tvOS). Can be used to display images, icons,
 /// and so on.
 #[derive(Clone, Debug)]
-pub struct Image(pub ShareId<Object>);
+pub struct Image(pub Id<Object, Shared>);
 
 impl Image {
     /// Wraps a system-returned image, e.g from QuickLook previews.
     pub fn with(image: id) -> Self {
-        Image(unsafe { ShareId::from_ptr(image) })
+        Image(unsafe { Id::retain(image).unwrap() })
     }
 
     /// Loads an image from the specified path.
@@ -132,8 +132,8 @@ impl Image {
         let file_path = NSString::new(path);
 
         Image(unsafe {
-            let alloc: id = msg_send![class!(NSImage), alloc];
-            ShareId::from_ptr(msg_send![alloc, initWithContentsOfFile: &*file_path])
+            let alloc = msg_send_id![class!(NSImage), alloc];
+            msg_send_id![alloc, initWithContentsOfFile: &*file_path].unwrap()
         })
     }
 
@@ -143,8 +143,8 @@ impl Image {
         let data = NSData::with_slice(data);
 
         Image(unsafe {
-            let alloc: id = msg_send![class!(NSImage), alloc];
-            ShareId::from_ptr(msg_send![alloc, initWithData: &*data])
+            let alloc = msg_send_id![class!(NSImage), alloc];
+            msg_send_id![alloc, initWithData: &*data].unwrap()
         })
     }
 
@@ -155,10 +155,8 @@ impl Image {
     #[cfg(target_os = "macos")]
     pub fn system_icon(icon: MacSystemIcon) -> Self {
         Image(unsafe {
-            ShareId::from_ptr({
-                let icon = icon.to_id();
-                msg_send![class!(NSImage), imageNamed: icon]
-            })
+            let icon = icon.to_id();
+            msg_send_id![class!(NSImage), imageNamed: icon].unwrap()
         })
     }
 
@@ -175,22 +173,23 @@ impl Image {
     #[cfg(target_os = "macos")]
     pub fn toolbar_icon(icon: MacSystemIcon, accessibility_description: &str) -> Self {
         Image(unsafe {
-            ShareId::from_ptr(match os::is_minimum_version(11) {
+            match os::is_minimum_version(11) {
                 true => {
                     let icon = NSString::new(icon.to_sfsymbol_str());
                     let desc = NSString::new(accessibility_description);
-                    msg_send![
+                    msg_send_id![
                         class!(NSImage),
                         imageWithSystemSymbolName:&*icon,
                         accessibilityDescription:&*desc,
                     ]
+                    .unwrap()
                 },
 
                 false => {
                     let icon = icon.to_id();
-                    msg_send![class!(NSImage), imageNamed: icon]
+                    msg_send_id![class!(NSImage), imageNamed: icon].unwrap()
                 }
-            })
+            }
         })
     }
 
@@ -199,19 +198,23 @@ impl Image {
     /// provide a fallback image or user experience if you need to support an older OS.
     pub fn symbol(symbol: SFSymbol, accessibility_description: &str) -> Self {
         Image(unsafe {
-            ShareId::from_ptr(match os::is_minimum_version(11) {
+            match os::is_minimum_version(11) {
                 true => {
                     let icon = NSString::new(symbol.to_str());
                     let desc = NSString::new(accessibility_description);
-                    msg_send![class!(NSImage), imageWithSystemSymbolName:&*icon
-                        accessibilityDescription:&*desc]
+                    msg_send_id![
+                        class!(NSImage),
+                        imageWithSystemSymbolName:&*icon,
+                        accessibilityDescription:&*desc,
+                    ]
+                    .unwrap()
                 },
 
                 false => {
                     #[cfg(target_os = "macos")]
                     panic!("SFSymbols are only supported on macOS 11.0 and up.");
                 }
-            })
+            }
         })
     }
 
@@ -250,14 +253,13 @@ impl Image {
         let block = block.copy();
 
         Image(unsafe {
-            let img: id = msg_send![
+            msg_send_id![
                 class!(NSImage),
                 imageWithSize: target_frame.size,
                 flipped: YES,
                 drawingHandler: &*block,
-            ];
-
-            ShareId::from_ptr(img)
+            ]
+            .unwrap()
         })
     }
 }
diff --git a/src/image/mod.rs b/src/image/mod.rs
index cf57dd73..8c625b75 100644
--- a/src/image/mod.rs
+++ b/src/image/mod.rs
@@ -1,6 +1,6 @@
 use core_foundation::base::TCFType;
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::{Class, Object};
 use objc::{msg_send, sel};
 
@@ -32,7 +32,7 @@ mod icons;
 pub use icons::*;
 
 /// A helper method for instantiating view classes and applying default settings to them.
-fn allocate_view(registration_fn: fn() -> *const Class) -> id {
+fn allocate_view(registration_fn: fn() -> &'static Class) -> id {
     unsafe {
         let view: id = msg_send![registration_fn(), new];
 
diff --git a/src/image/uikit.rs b/src/image/uikit.rs
index 70a36563..fc61c407 100644
--- a/src/image/uikit.rs
+++ b/src/image/uikit.rs
@@ -3,7 +3,7 @@ use std::sync::Once;
 use objc::declare::ClassDecl;
 use objc::runtime::{Class, Object, Sel, BOOL};
 use objc::{class, sel};
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 
 use crate::foundation::{id, YES, NO, NSUInteger};
 use crate::dragdrop::DragInfo;
@@ -13,30 +13,30 @@ use crate::utils::load;
 /// Injects an `NSView` subclass. This is used for the default views that don't use delegates - we
 /// have separate classes here since we don't want to waste cycles on methods that will never be
 /// used if there's no delegates.
-pub(crate) fn register_view_class() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_view_class() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
         let superclass = class!(UIView);
         let mut decl = ClassDecl::new("RSTView", superclass).unwrap();
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
 
 /// Injects an `NSView` subclass, with some callback and pointer ivars for what we
 /// need to do.
-pub(crate) fn register_view_class_with_delegate<T: ViewDelegate>() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_view_class_with_delegate<T: ViewDelegate>() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
         let superclass = class!(UIView);
         let mut decl = ClassDecl::new("RSTViewWithDelegate", superclass).unwrap();
         decl.add_ivar::<usize>(VIEW_DELEGATE_PTR);
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
     unsafe {
diff --git a/src/input/appkit.rs b/src/input/appkit.rs
index 11417cda..539890fb 100644
--- a/src/input/appkit.rs
+++ b/src/input/appkit.rs
@@ -1,7 +1,7 @@
 use std::sync::Once;
 
-use crate::id_shim::Id;
 use objc::declare::ClassDecl;
+use objc::rc::{Id, Owned};
 use objc::runtime::{Class, Object, Sel, BOOL};
 use objc::{class, msg_send, sel};
 
@@ -51,22 +51,22 @@ extern "C" fn text_should_end_editing<T: TextFieldDelegate>(this: &mut Object, _
 /// Injects an `NSTextField` subclass. This is used for the default views that don't use delegates - we
 /// have separate classes here since we don't want to waste cycles on methods that will never be
 /// used if there's no delegates.
-pub(crate) fn register_view_class() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_view_class() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
         let superclass = class!(NSTextField);
         let decl = ClassDecl::new("RSTTextInputField", superclass).unwrap();
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
 
 /// Injects an `NSTextField` subclass, with some callback and pointer ivars for what we
 /// need to do.
-pub(crate) fn register_view_class_with_delegate<T: TextFieldDelegate>(instance: &T) -> *const Class {
+pub(crate) fn register_view_class_with_delegate<T: TextFieldDelegate>(instance: &T) -> &'static Class {
     load_or_register_class("NSTextField", instance.subclass_name(), |decl| unsafe {
         // A pointer to the "view controller" on the Rust side. It's expected that this doesn't
         // move.
diff --git a/src/input/mod.rs b/src/input/mod.rs
index a4d34a28..6743a0cb 100644
--- a/src/input/mod.rs
+++ b/src/input/mod.rs
@@ -42,7 +42,7 @@
 
 use core_foundation::base::TCFType;
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::{Class, Object};
 use objc::{msg_send, sel};
 
diff --git a/src/invoker.rs b/src/invoker.rs
index 173fa08a..4e6ae1e3 100644
--- a/src/invoker.rs
+++ b/src/invoker.rs
@@ -11,11 +11,11 @@
 use std::fmt;
 use std::sync::{Arc, Mutex, Once};
 
-use crate::id_shim::ShareId;
 use block::{Block, ConcreteBlock, RcBlock};
 use objc::declare::ClassDecl;
+use objc::rc::{Id, Owned, Shared};
 use objc::runtime::{Class, Object, Sel};
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::{id, nil, NSString};
 use crate::utils::load;
@@ -49,7 +49,7 @@ impl fmt::Debug for Action {
 #[derive(Debug)]
 pub struct TargetActionHandler {
     action: Box<Action>,
-    invoker: ShareId<Object>
+    invoker: Id<Object, Shared>
 }
 
 impl TargetActionHandler {
@@ -59,18 +59,16 @@ impl TargetActionHandler {
         let ptr = Box::into_raw(block);
 
         let invoker = unsafe {
-            ShareId::from_ptr({
-                let invoker: id = msg_send![register_invoker_class::<F>(), alloc];
-                let invoker: id = msg_send![invoker, init];
-                (&mut *invoker).set_ivar(ACTION_CALLBACK_PTR, ptr as usize);
-                let _: () = msg_send![control, setAction: sel!(perform:)];
-                let _: () = msg_send![control, setTarget: invoker];
-                invoker
-            })
+            let invoker = msg_send_id![register_invoker_class::<F>(), alloc];
+            let mut invoker: Id<Object, Owned> = msg_send_id![invoker, init].unwrap();
+            invoker.set_ivar(ACTION_CALLBACK_PTR, ptr as usize);
+            let _: () = msg_send![control, setAction: sel!(perform:)];
+            let _: () = msg_send![control, setTarget: &*invoker];
+            invoker.into()
         };
 
         TargetActionHandler {
-            invoker: invoker,
+            invoker,
             action: unsafe { Box::from_raw(ptr) }
         }
     }
@@ -94,8 +92,8 @@ extern "C" fn perform<F: Fn() + 'static>(this: &mut Object, _: Sel, _sender: id)
 /// The `NSButton` owns this object on instantiation, and will release it
 /// on drop. We handle the heap copy on the Rust side, so setting the block
 /// is just an ivar.
-pub(crate) fn register_invoker_class<F: Fn() + 'static>() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_invoker_class<F: Fn() + 'static>() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
@@ -105,8 +103,8 @@ pub(crate) fn register_invoker_class<F: Fn() + 'static>() -> *const Class {
         decl.add_ivar::<usize>(ACTION_CALLBACK_PTR);
         decl.add_method(sel!(perform:), perform::<F> as extern "C" fn(_, _, _));
 
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
diff --git a/src/layout/animator.rs b/src/layout/animator.rs
index 740e1b79..8780285e 100644
--- a/src/layout/animator.rs
+++ b/src/layout/animator.rs
@@ -1,19 +1,19 @@
 use core_graphics::base::CGFloat;
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::{Class, Object};
-use objc::{msg_send, sel};
+use objc::{msg_send, msg_send_id, sel};
 
 use crate::foundation::id;
 
 /// A wrapper for an animation proxy object in Cocoa that supports basic animations.
 #[derive(Clone, Debug)]
-pub struct LayoutConstraintAnimatorProxy(pub ShareId<Object>);
+pub struct LayoutConstraintAnimatorProxy(pub Id<Object, Shared>);
 
 impl LayoutConstraintAnimatorProxy {
     /// Wraps and returns a proxy for animation of layout constraint values.
     pub fn new(proxy: id) -> Self {
-        Self(unsafe { ShareId::from_ptr(msg_send![proxy, animator]) })
+        Self(unsafe { msg_send_id![proxy, animator].unwrap() })
     }
 
     /// Sets the constant (usually referred to as `offset` in Cacao) value for the constraint being animated.
@@ -27,4 +27,3 @@ impl LayoutConstraintAnimatorProxy {
 // TODO: Safety
 unsafe impl Send for LayoutConstraintAnimatorProxy {}
 unsafe impl Sync for LayoutConstraintAnimatorProxy {}
-
diff --git a/src/layout/constraint.rs b/src/layout/constraint.rs
index 71386fc3..e60efd33 100644
--- a/src/layout/constraint.rs
+++ b/src/layout/constraint.rs
@@ -4,7 +4,7 @@
 
 use core_graphics::base::CGFloat;
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::Object;
 use objc::{class, msg_send, sel};
 
@@ -19,7 +19,7 @@ use super::LayoutConstraintAnimatorProxy;
 pub struct LayoutConstraint {
     /// A shared pointer to the underlying view. Provided your view isn't dropped, this will always
     /// be valid.
-    pub constraint: ShareId<Object>,
+    pub constraint: Id<Object, Shared>,
 
     /// The offset used in computing this constraint.
     pub offset: f64,
@@ -39,7 +39,7 @@ impl LayoutConstraint {
     pub(crate) fn new(object: id) -> Self {
         LayoutConstraint {
             animator: LayoutConstraintAnimatorProxy::new(object),
-            constraint: unsafe { ShareId::from_ptr(object) },
+            constraint: unsafe { Id::retain(object).unwrap() },
             offset: 0.0,
             multiplier: 0.0,
             priority: 0.0
@@ -87,7 +87,7 @@ impl LayoutConstraint {
 
     /// Call this with your batch of constraints to activate them.
     // If you're astute, you'll note that, yes... this is kind of hacking around some
-    // borrowing rules with how crate::id_shim::Id/crate::id_shim::ShareId works. In this case, to
+    // borrowing rules with how objc::rc::{Id, Owned}/objc::rc::{Id, Shared} works. In this case, to
     // support the way autolayout constraints work over in the cocoa runtime, we need to be
     // able to clone these and pass them around... while also getting certain references to
     // them.
diff --git a/src/layout/dimension.rs b/src/layout/dimension.rs
index 74759e94..09fdb0aa 100644
--- a/src/layout/dimension.rs
+++ b/src/layout/dimension.rs
@@ -1,8 +1,8 @@
 use core_graphics::base::CGFloat;
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::{id, nil, NSInteger};
 use crate::layout::constraint::LayoutConstraint;
@@ -12,7 +12,7 @@ use super::attributes::{LayoutAttribute, LayoutRelation};
 /// A wrapper for `NSLayoutAnchor`. You should never be creating this yourself - it's more of a
 /// factory/helper for creating `LayoutConstraint` objects based on your views.
 #[derive(Clone, Debug, Default)]
-pub struct LayoutAnchorDimension2(pub Option<ShareId<Object>>);
+pub struct LayoutAnchorDimension2(pub Option<Id<Object, Shared>>);
 
 /// A wrapper for `NSLayoutAnchorDimension`, which is typically used to handle `width` and `height`
 /// values for how a given view should layout.
@@ -22,10 +22,10 @@ pub enum LayoutAnchorDimension {
     Uninitialized,
 
     /// Represents a Width anchor.
-    Width(ShareId<Object>),
+    Width(Id<Object, Shared>),
 
     /// Represents a Height anchor.
-    Height(ShareId<Object>)
+    Height(Id<Object, Shared>)
 }
 
 impl Default for LayoutAnchorDimension {
@@ -38,12 +38,12 @@ impl Default for LayoutAnchorDimension {
 impl LayoutAnchorDimension {
     /// Given a view, returns an anchor for the width anchor.
     pub(crate) fn width(view: id) -> Self {
-        Self::Width(unsafe { ShareId::from_ptr(msg_send![view, widthAnchor]) })
+        Self::Width(unsafe { msg_send_id![view, widthAnchor].unwrap() })
     }
 
     /// Given a view, returns an anchor for the height anchor.
     pub(crate) fn height(view: id) -> Self {
-        Self::Height(unsafe { ShareId::from_ptr(msg_send![view, heightAnchor]) })
+        Self::Height(unsafe { msg_send_id![view, heightAnchor].unwrap() })
     }
 
     /// Return a constraint equal to a constant value.
@@ -87,7 +87,7 @@ impl LayoutAnchorDimension {
     /// wrong.
     fn constraint_with<F>(&self, anchor_to: &LayoutAnchorDimension, handler: F) -> LayoutConstraint
     where
-        F: Fn(&ShareId<Object>, &ShareId<Object>) -> id
+        F: Fn(&Id<Object, Shared>, &Id<Object, Shared>) -> id
     {
         match (self, anchor_to) {
             (Self::Width(from), Self::Width(to))
diff --git a/src/layout/horizontal.rs b/src/layout/horizontal.rs
index bb828633..c3ba6010 100644
--- a/src/layout/horizontal.rs
+++ b/src/layout/horizontal.rs
@@ -1,6 +1,6 @@
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::Object;
-use objc::{msg_send, sel};
+use objc::{msg_send, msg_send_id, sel};
 
 use crate::foundation::id;
 use crate::layout::constraint::LayoutConstraint;
@@ -16,19 +16,19 @@ pub enum LayoutAnchorX {
     Uninitialized,
 
     /// Represents a leading anchor; side depends on system orientation.
-    Leading(ShareId<Object>),
+    Leading(Id<Object, Shared>),
 
     /// Represents a left anchor.
-    Left(ShareId<Object>),
+    Left(Id<Object, Shared>),
 
     /// Represents a trailing anchor; side depends on system orientation.
-    Trailing(ShareId<Object>),
+    Trailing(Id<Object, Shared>),
 
     /// Represents a right anchor.
-    Right(ShareId<Object>),
+    Right(Id<Object, Shared>),
 
     /// Represents a center anchor on the X axis.
-    Center(ShareId<Object>)
+    Center(Id<Object, Shared>)
 }
 
 impl Default for LayoutAnchorX {
@@ -41,27 +41,27 @@ impl Default for LayoutAnchorX {
 impl LayoutAnchorX {
     /// Given a view, returns an anchor for the leading anchor.
     pub(crate) fn leading(view: id) -> Self {
-        Self::Leading(unsafe { ShareId::from_ptr(msg_send![view, leadingAnchor]) })
+        Self::Leading(unsafe { msg_send_id![view, leadingAnchor].unwrap() })
     }
 
     /// Given a view, returns an anchor for the left anchor.
     pub(crate) fn left(view: id) -> Self {
-        Self::Left(unsafe { ShareId::from_ptr(msg_send![view, leftAnchor]) })
+        Self::Left(unsafe { msg_send_id![view, leftAnchor].unwrap() })
     }
 
     /// Given a view, returns an anchor for the trailing anchor.
     pub(crate) fn trailing(view: id) -> Self {
-        Self::Trailing(unsafe { ShareId::from_ptr(msg_send![view, trailingAnchor]) })
+        Self::Trailing(unsafe { msg_send_id![view, trailingAnchor].unwrap() })
     }
 
     /// Given a view, returns an anchor for the right anchor.
     pub(crate) fn right(view: id) -> Self {
-        Self::Right(unsafe { ShareId::from_ptr(msg_send![view, rightAnchor]) })
+        Self::Right(unsafe { msg_send_id![view, rightAnchor].unwrap() })
     }
 
     /// Given a view, returns an anchor for the right anchor.
     pub(crate) fn center(view: id) -> Self {
-        Self::Center(unsafe { ShareId::from_ptr(msg_send![view, centerXAnchor]) })
+        Self::Center(unsafe { msg_send_id![view, centerXAnchor].unwrap() })
     }
 
     /// Boilerplate for handling constraint construction and panic'ing with some more helpful
@@ -69,7 +69,7 @@ impl LayoutAnchorX {
     /// wrong.
     fn constraint_with<F>(&self, anchor_to: &LayoutAnchorX, handler: F) -> LayoutConstraint
     where
-        F: Fn(&ShareId<Object>, &ShareId<Object>) -> id
+        F: Fn(&Id<Object, Shared>, &Id<Object, Shared>) -> id
     {
         match (self, anchor_to) {
             // The anchors that can connect to each other. These blocks could be condensed, but are
diff --git a/src/layout/traits.rs b/src/layout/traits.rs
index 56c1298f..8fc5de92 100644
--- a/src/layout/traits.rs
+++ b/src/layout/traits.rs
@@ -4,7 +4,7 @@
 use core_graphics::base::CGFloat;
 use core_graphics::geometry::{CGPoint, CGRect, CGSize};
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::Object;
 use objc::{msg_send, sel};
 
diff --git a/src/layout/vertical.rs b/src/layout/vertical.rs
index 232945a7..fe106e9f 100644
--- a/src/layout/vertical.rs
+++ b/src/layout/vertical.rs
@@ -1,6 +1,6 @@
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::Object;
-use objc::{msg_send, sel};
+use objc::{msg_send, msg_send_id, sel};
 
 use crate::foundation::id;
 use crate::layout::constraint::LayoutConstraint;
@@ -13,13 +13,13 @@ pub enum LayoutAnchorY {
     Uninitialized,
 
     /// Represents a top anchor.
-    Top(ShareId<Object>),
+    Top(Id<Object, Shared>),
 
     /// Represents a bottom anchor.
-    Bottom(ShareId<Object>),
+    Bottom(Id<Object, Shared>),
 
     /// Represents a center anchor for the Y axis.
-    Center(ShareId<Object>)
+    Center(Id<Object, Shared>)
 }
 
 impl Default for LayoutAnchorY {
@@ -31,17 +31,17 @@ impl Default for LayoutAnchorY {
 impl LayoutAnchorY {
     /// Given a view, returns an anchor for the top anchor.
     pub(crate) fn top(view: id) -> Self {
-        Self::Top(unsafe { ShareId::from_ptr(msg_send![view, topAnchor]) })
+        Self::Top(unsafe { msg_send_id![view, topAnchor].unwrap() })
     }
 
     /// Given a view, returns an anchor for the bottom anchor.
     pub(crate) fn bottom(view: id) -> Self {
-        Self::Bottom(unsafe { ShareId::from_ptr(msg_send![view, bottomAnchor]) })
+        Self::Bottom(unsafe { msg_send_id![view, bottomAnchor].unwrap() })
     }
 
     /// Given a view, returns an anchor for the center Y anchor.
     pub(crate) fn center(view: id) -> Self {
-        Self::Center(unsafe { ShareId::from_ptr(msg_send![view, centerYAnchor]) })
+        Self::Center(unsafe { msg_send_id![view, centerYAnchor].unwrap() })
     }
 
     /// Boilerplate for handling constraint construction and panic'ing with some more helpful
@@ -49,7 +49,7 @@ impl LayoutAnchorY {
     /// wrong.
     fn constraint_with<F>(&self, anchor_to: &LayoutAnchorY, handler: F) -> LayoutConstraint
     where
-        F: Fn(&ShareId<Object>, &ShareId<Object>) -> id
+        F: Fn(&Id<Object, Shared>, &Id<Object, Shared>) -> id
     {
         match (self, anchor_to) {
             (Self::Top(from), Self::Top(to))
diff --git a/src/lib.rs b/src/lib.rs
index be3c55d0..cfc96edc 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -96,63 +96,6 @@ pub use lazy_static;
 pub use objc;
 pub use url;
 
-// Temporary!
-mod id_shim {
-    use core::ops::{Deref, DerefMut};
-    use objc::rc::{self, Owned, Ownership, Shared};
-    use objc::runtime::Object;
-    use objc::{Message, MessageReceiver};
-
-    #[repr(transparent)]
-    #[derive(Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
-    pub struct Id<T, O: Ownership = Owned>(rc::Id<T, O>);
-
-    unsafe impl<'a, T: Message, O: Ownership> MessageReceiver for &'a Id<T, O> {
-        fn __as_raw_receiver(self) -> *mut Object {
-            self.0.__as_raw_receiver()
-        }
-    }
-
-    unsafe impl<'a, T: Message> MessageReceiver for &'a mut Id<T, Owned> {
-        fn __as_raw_receiver(self) -> *mut Object {
-            self.0.__as_raw_receiver()
-        }
-    }
-
-    impl<T: Message, O: Ownership> Id<T, O> {
-        pub unsafe fn from_ptr(ptr: *mut T) -> Id<T, O> {
-            Self(rc::Id::retain(ptr).unwrap())
-        }
-
-        pub unsafe fn from_retained_ptr(ptr: *mut T) -> Id<T, O> {
-            Self(rc::Id::new(ptr).unwrap())
-        }
-    }
-
-    impl<T: Message> Clone for Id<T, Shared> {
-        fn clone(&self) -> Id<T, Shared> {
-            Self(self.0.clone())
-        }
-    }
-
-    impl<T: Message, O: Ownership> Deref for Id<T, O> {
-        type Target = T;
-
-        fn deref(&self) -> &T {
-            &*self.0
-        }
-    }
-
-    impl<T: Message> DerefMut for Id<T, Owned> {
-        fn deref_mut(&mut self) -> &mut T {
-            &mut *self.0
-        }
-    }
-
-    pub type ShareId<T> = Id<T, Shared>;
-}
-pub use id_shim::*;
-
 //#[cfg(all(feature = "appkit", feature = "uikit", not(feature = "doc_cfg")))]
 //compile_error!("The \"appkit\" and \"uikit\" features cannot be enabled together. Pick one. :)");
 
diff --git a/src/listview/actions.rs b/src/listview/actions.rs
index 6059d005..e6660f11 100644
--- a/src/listview/actions.rs
+++ b/src/listview/actions.rs
@@ -1,6 +1,6 @@
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use block::ConcreteBlock;
 
@@ -39,7 +39,7 @@ impl From<RowActionStyle> for NSUInteger {
 /// on a ListViewRow. You return this from the appropriate delegate method,
 /// and the system will handle displaying the necessary pieces for you.
 #[derive(Debug)]
-pub struct RowAction(pub Id<Object>);
+pub struct RowAction(pub Id<Object, Owned>);
 
 impl RowAction {
     /// Creates and returns a new `RowAction`. You'd use this handler to
@@ -56,7 +56,7 @@ impl RowAction {
     {
         let title = NSString::new(title);
         let block = ConcreteBlock::new(move |action: id, row: NSUInteger| {
-            let action = RowAction(unsafe { Id::from_ptr(action) });
+            let action = RowAction(unsafe { Id::retain(action).unwrap() });
 
             handler(action, row as usize);
         });
@@ -65,12 +65,13 @@ impl RowAction {
 
         RowAction(unsafe {
             let cls = class!(NSTableViewRowAction);
-            Id::from_ptr(msg_send![
+            msg_send_id![
                 cls,
                 rowActionWithStyle: style,
                 title: &*title,
                 handler: &*block,
-            ])
+            ]
+            .unwrap()
         })
     }
 
diff --git a/src/listview/appkit.rs b/src/listview/appkit.rs
index 45c3cf83..6e703303 100644
--- a/src/listview/appkit.rs
+++ b/src/listview/appkit.rs
@@ -9,8 +9,8 @@
 
 use std::sync::Once;
 
-use crate::id_shim::Id;
 use objc::declare::ClassDecl;
+use objc::rc::{Id, Owned};
 use objc::runtime::{Class, Object, Sel, BOOL};
 use objc::{class, msg_send, sel};
 
@@ -133,7 +133,7 @@ extern "C" fn enforce_normalcy(_: &Object, _: Sel) -> BOOL {
 extern "C" fn dragging_entered<T: ListViewDelegate>(this: &mut Object, _: Sel, info: id) -> NSUInteger {
     let view = load::<T>(this, LISTVIEW_DELEGATE_PTR);
     view.dragging_entered(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     })
     .into()
 }
@@ -143,7 +143,7 @@ extern "C" fn prepare_for_drag_operation<T: ListViewDelegate>(this: &mut Object,
     let view = load::<T>(this, LISTVIEW_DELEGATE_PTR);
 
     match view.prepare_for_drag_operation(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     }) {
         true => YES,
         false => NO
@@ -155,7 +155,7 @@ extern "C" fn perform_drag_operation<T: ListViewDelegate>(this: &mut Object, _:
     let view = load::<T>(this, LISTVIEW_DELEGATE_PTR);
 
     match view.perform_drag_operation(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     }) {
         true => YES,
         false => NO
@@ -167,7 +167,7 @@ extern "C" fn conclude_drag_operation<T: ListViewDelegate>(this: &mut Object, _:
     let view = load::<T>(this, LISTVIEW_DELEGATE_PTR);
 
     view.conclude_drag_operation(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     });
 }
 
@@ -176,7 +176,7 @@ extern "C" fn dragging_exited<T: ListViewDelegate>(this: &mut Object, _: Sel, in
     let view = load::<T>(this, LISTVIEW_DELEGATE_PTR);
 
     view.dragging_exited(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     });
 }
 
@@ -184,24 +184,24 @@ extern "C" fn dragging_exited<T: ListViewDelegate>(this: &mut Object, _: Sel, in
 /// need to do. Note that we treat and constrain this as a one-column "list" view to match
 /// `UITableView` semantics; if `NSTableView`'s multi column behavior is needed, then it can
 /// be added in.
-pub(crate) fn register_listview_class() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_listview_class() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
         let superclass = class!(NSTableView);
         let decl = ClassDecl::new("RSTListView", superclass).unwrap();
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
 
 /// Injects an `NSTableView` subclass, with some callback and pointer ivars for what we
 /// need to do. Note that we treat and constrain this as a one-column "list" view to match
 /// `UITableView` semantics; if `NSTableView`'s multi column behavior is needed, then it can
 /// be added in.
-pub(crate) fn register_listview_class_with_delegate<T: ListViewDelegate>(instance: &T) -> *const Class {
+pub(crate) fn register_listview_class_with_delegate<T: ListViewDelegate>(instance: &T) -> &'static Class {
     load_or_register_class("NSTableView", instance.subclass_name(), |decl| unsafe {
         decl.add_ivar::<usize>(LISTVIEW_DELEGATE_PTR);
 
diff --git a/src/listview/mod.rs b/src/listview/mod.rs
index 5d1007de..c8ac5f62 100644
--- a/src/listview/mod.rs
+++ b/src/listview/mod.rs
@@ -45,10 +45,10 @@ use std::collections::HashMap;
 
 use core_foundation::base::TCFType;
 
-use crate::id_shim::ShareId;
 use core_graphics::base::CGFloat;
+use objc::rc::{Id, Owned, Shared};
 use objc::runtime::{Class, Object};
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::color::Color;
 use crate::foundation::{id, nil, NSArray, NSInteger, NSString, NSUInteger, NO, YES};
@@ -485,14 +485,14 @@ impl<T> ListView<T> {
     /// Select the rows at the specified indexes, optionally adding to any existing selections.
     pub fn select_row_indexes(&self, indexes: &[usize], extends_existing: bool) {
         unsafe {
-            let index_set: id = msg_send![class!(NSMutableIndexSet), new];
+            let mut index_set: Id<Object, Owned> = msg_send_id![class!(NSMutableIndexSet), new].unwrap();
 
             for index in indexes {
-                let _: () = msg_send![index_set, addIndex: index];
+                let _: () = msg_send![&mut index_set, addIndex: index];
             }
 
             self.objc.with_mut(|obj| {
-                let _: () = msg_send![obj, selectRowIndexes:index_set byExtendingSelection:match extends_existing {
+                let _: () = msg_send![obj, selectRowIndexes: &*index_set, byExtendingSelection: match extends_existing {
                     true => YES,
                     false => NO
                 }];
@@ -565,23 +565,24 @@ impl<T> ListView<T> {
     pub fn insert_rows(&self, indexes: &[usize], animation: RowAnimation) {
         #[cfg(feature = "appkit")]
         unsafe {
-            let index_set: id = msg_send![class!(NSMutableIndexSet), new];
+            let mut index_set: Id<Object, Owned> = msg_send_id![class!(NSMutableIndexSet), new].unwrap();
 
             for index in indexes {
                 let x: NSUInteger = *index as NSUInteger;
-                let _: () = msg_send![index_set, addIndex: x];
+                let _: () = msg_send![&mut index_set, addIndex: x];
             }
 
             let animation_options: NSUInteger = animation.into();
 
             // We need to temporarily retain this; it can drop after the underlying NSTableView
             // has also retained it.
-            let x = ShareId::from_ptr(index_set);
+            let index_set: Id<Object, Shared> = index_set.into();
+            let x = index_set.clone();
 
             // This is done for a very explicit reason; see the comments on the method itself for
             // an explanation.
             self.hack_avoid_dequeue_loop(|obj| {
-                let _: () = msg_send![obj, insertRowsAtIndexes:&*x withAnimation:animation_options];
+                let _: () = msg_send![obj, insertRowsAtIndexes: &*x, withAnimation: animation_options];
             });
         }
     }
@@ -590,21 +591,21 @@ impl<T> ListView<T> {
     pub fn reload_rows(&self, indexes: &[usize]) {
         #[cfg(feature = "appkit")]
         unsafe {
-            let index_set: id = msg_send![class!(NSMutableIndexSet), new];
+            let mut index_set: Id<Object, Owned> = msg_send_id![class!(NSMutableIndexSet), new].unwrap();
 
             for index in indexes {
                 let x: NSUInteger = *index as NSUInteger;
-                let _: () = msg_send![index_set, addIndex: x];
+                let _: () = msg_send![&mut index_set, addIndex: x];
             }
 
-            let x = ShareId::from_ptr(index_set);
+            let index_set: Id<Object, Shared> = index_set.into();
+            let x = index_set.clone();
 
-            let ye: id = msg_send![class!(NSIndexSet), indexSetWithIndex:0];
-            let y = ShareId::from_ptr(ye);
+            let y: Id<Object, Shared> = msg_send_id![class!(NSIndexSet), indexSetWithIndex:0].unwrap();
 
             // Must use `get` to avoid a double lock.
             self.objc.get(|obj| {
-                let _: () = msg_send![obj, reloadDataForRowIndexes:&*x columnIndexes:&*y];
+                let _: () = msg_send![obj, reloadDataForRowIndexes: &*x, columnIndexes: &*y];
             });
         }
     }
@@ -617,20 +618,22 @@ impl<T> ListView<T> {
     pub fn remove_rows(&self, indexes: &[usize], animations: RowAnimation) {
         #[cfg(feature = "appkit")]
         unsafe {
-            let index_set: id = msg_send![class!(NSMutableIndexSet), new];
+            let mut index_set: Id<Object, Owned> = msg_send_id![class!(NSMutableIndexSet), new].unwrap();
 
             for index in indexes {
                 let x: NSUInteger = *index as NSUInteger;
-                let _: () = msg_send![index_set, addIndex: x];
+                let _: () = msg_send![&mut index_set, addIndex: x];
             }
 
             let animation_options: NSUInteger = animations.into();
 
             // We need to temporarily retain this; it can drop after the underlying NSTableView
             // has also retained it.
-            let x = ShareId::from_ptr(index_set);
+            let index_set: Id<Object, Shared> = index_set.into();
+            let x = index_set.clone();
+
             self.objc.with_mut(|obj| {
-                let _: () = msg_send![obj, removeRowsAtIndexes:&*x withAnimation:animation_options];
+                let _: () = msg_send![obj, removeRowsAtIndexes: &*x, withAnimation: animation_options];
             });
         }
     }
diff --git a/src/listview/row/appkit.rs b/src/listview/row/appkit.rs
index a3487baf..c4e9ec6b 100644
--- a/src/listview/row/appkit.rs
+++ b/src/listview/row/appkit.rs
@@ -9,8 +9,8 @@
 
 use std::sync::Once;
 
-use crate::id_shim::Id;
 use objc::declare::ClassDecl;
+use objc::rc::{Id, Owned};
 use objc::runtime::{Class, Object, Sel, BOOL};
 use objc::{class, msg_send, sel};
 
@@ -28,7 +28,7 @@ extern "C" fn enforce_normalcy(_: &Object, _: Sel) -> BOOL {
 extern "C" fn dragging_entered<T: ViewDelegate>(this: &mut Object, _: Sel, info: id) -> NSUInteger {
     let view = load::<T>(this, LISTVIEW_ROW_DELEGATE_PTR);
     view.dragging_entered(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     })
     .into()
 }
@@ -38,7 +38,7 @@ extern "C" fn prepare_for_drag_operation<T: ViewDelegate>(this: &mut Object, _:
     let view = load::<T>(this, LISTVIEW_ROW_DELEGATE_PTR);
 
     match view.prepare_for_drag_operation(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     }) {
         true => YES,
         false => NO
@@ -50,7 +50,7 @@ extern "C" fn perform_drag_operation<T: ViewDelegate>(this: &mut Object, _: Sel,
     let view = load::<T>(this, LISTVIEW_ROW_DELEGATE_PTR);
 
     match view.perform_drag_operation(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     }) {
         true => YES,
         false => NO
@@ -62,7 +62,7 @@ extern "C" fn conclude_drag_operation<T: ViewDelegate>(this: &mut Object, _: Sel
     let view = load::<T>(this, LISTVIEW_ROW_DELEGATE_PTR);
 
     view.conclude_drag_operation(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     });
 }
 
@@ -71,7 +71,7 @@ extern "C" fn dragging_exited<T: ViewDelegate>(this: &mut Object, _: Sel, info:
     let view = load::<T>(this, LISTVIEW_ROW_DELEGATE_PTR);
 
     view.dragging_exited(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     });
 }
 
@@ -106,8 +106,8 @@ extern "C" fn dealloc<T: ViewDelegate>(this: &Object, _: Sel) {
 /// Injects an `NSView` subclass. This is used for the default views that don't use delegates - we
 /// have separate classes here since we don't want to waste cycles on methods that will never be
 /// used if there's no delegates.
-pub(crate) fn register_listview_row_class() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_listview_row_class() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
@@ -116,16 +116,16 @@ pub(crate) fn register_listview_row_class() -> *const Class {
 
         decl.add_method(sel!(isFlipped), enforce_normalcy as extern "C" fn(_, _) -> _);
 
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
 
 /// Injects an `NSView` subclass, with some callback and pointer ivars for what we
 /// need to do.
-pub(crate) fn register_listview_row_class_with_delegate<T: ViewDelegate>() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_listview_row_class_with_delegate<T: ViewDelegate>() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
@@ -159,8 +159,8 @@ pub(crate) fn register_listview_row_class_with_delegate<T: ViewDelegate>() -> *c
         // Cleanup
         decl.add_method(sel!(dealloc), dealloc::<T> as extern "C" fn(_, _));
 
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
diff --git a/src/listview/row/mod.rs b/src/listview/row/mod.rs
index 06948f19..b1bb19f1 100644
--- a/src/listview/row/mod.rs
+++ b/src/listview/row/mod.rs
@@ -44,7 +44,7 @@
 use std::cell::RefCell;
 use std::rc::Rc;
 
-use crate::id_shim::{Id, ShareId};
+use objc::rc::{Id, Owned, Shared};
 use objc::runtime::{Class, Object};
 use objc::{class, msg_send, sel};
 
@@ -75,7 +75,7 @@ pub(crate) static BACKGROUND_COLOR: &str = "cacaoBackgroundColor";
 pub(crate) static LISTVIEW_ROW_DELEGATE_PTR: &str = "cacaoListViewRowDelegatePtr";
 
 /// A helper method for instantiating view classes and applying default settings to them.
-fn allocate_view(registration_fn: fn() -> *const Class) -> id {
+fn allocate_view(registration_fn: fn() -> &'static Class) -> id {
     unsafe {
         let view: id = msg_send![registration_fn(), new];
 
diff --git a/src/listview/row/uikit.rs b/src/listview/row/uikit.rs
index 70a36563..25b5c0ce 100644
--- a/src/listview/row/uikit.rs
+++ b/src/listview/row/uikit.rs
@@ -3,7 +3,7 @@ use std::sync::Once;
 use objc::declare::ClassDecl;
 use objc::runtime::{Class, Object, Sel, BOOL};
 use objc::{class, sel};
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 
 use crate::foundation::{id, YES, NO, NSUInteger};
 use crate::dragdrop::DragInfo;
@@ -13,33 +13,31 @@ use crate::utils::load;
 /// Injects an `NSView` subclass. This is used for the default views that don't use delegates - we
 /// have separate classes here since we don't want to waste cycles on methods that will never be
 /// used if there's no delegates.
-pub(crate) fn register_view_class() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_view_class() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
         let superclass = class!(UIView);
         let mut decl = ClassDecl::new("RSTView", superclass).unwrap();
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
 
 /// Injects an `NSView` subclass, with some callback and pointer ivars for what we
 /// need to do.
-pub(crate) fn register_view_class_with_delegate<T: ViewDelegate>() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_view_class_with_delegate<T: ViewDelegate>() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
         let superclass = class!(UIView);
         let mut decl = ClassDecl::new("RSTViewWithDelegate", superclass).unwrap();
         decl.add_ivar::<usize>(VIEW_DELEGATE_PTR);
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe {
-        VIEW_CLASS
-    }
+    unsafe { VIEW_CLASS.unwrap() }
 }
diff --git a/src/networking/mod.rs b/src/networking/mod.rs
index 037b16a7..7f7d149e 100644
--- a/src/networking/mod.rs
+++ b/src/networking/mod.rs
@@ -1,6 +1,6 @@
 //! A lightweight wrapper over some networking components, like `NSURLRequest` and co.
 //!
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::Object;
 /// At the moment, this is mostly used for inspection of objects returned from system
 /// calls, as `NSURL` is pervasive in some filesystem references. Over time this may grow to
@@ -12,17 +12,17 @@ use crate::foundation::{id, NSString};
 
 /// A wrapper around `NSURLRequest`.
 #[derive(Debug)]
-pub struct URLRequest(ShareId<Object>);
+pub struct URLRequest(Id<Object, Shared>);
 
 impl URLRequest {
     /// Wraps and retains an `NSURLRequest`.
     pub fn with(request: id) -> Self {
-        URLRequest(unsafe { ShareId::from_ptr(request) })
+        URLRequest(unsafe { Id::retain(request).unwrap() })
     }
 
     /// Returns the underlying request URL as an owned `String`.
     pub fn absolute_url(&self) -> String {
-        NSString::from_retained(unsafe {
+        NSString::retain(unsafe {
             let url: id = msg_send![&*self.0, URL];
             msg_send![url, absoluteString]
         })
diff --git a/src/notification_center/mod.rs b/src/notification_center/mod.rs
index ddc260e7..a2a12caf 100644
--- a/src/notification_center/mod.rs
+++ b/src/notification_center/mod.rs
@@ -16,9 +16,9 @@
 //use std::collections::HashMap;
 
 //use lazy_static::lazy_static;
-//use objc::{class, msg_send, sel};
+//use objc::{class, msg_send, msg_send_id, sel};
 //use objc::runtime::Object;
-//use crate::id_shim::ShareId;
+//use objc::rc::{Id, Shared};
 
 mod name;
 pub use name::NotificationName;
@@ -30,7 +30,7 @@ pub use traits::Dispatcher;
     pub static ref DefaultNotificationCenter: NotificationCenter = {
         NotificationCenter {
             objc: unsafe {
-                ShareId::from_ptr(msg_send![class!(NSNotificationCenter), defaultCenter])
+                msg_send_id![class!(NSNotificationCenter), defaultCenter].unwrap()
             },
 
             subscribers: Mutex::new(HashMap::new())
@@ -42,7 +42,7 @@ pub use traits::Dispatcher;
 // default center; in the future it should aim to support custom variants.
 //#[derive(Debug)]
 //pub struct NotificationCenter {
-//    pub objc: ShareId<Object>,
+//    pub objc: Id<Object, Shared>,
 //pub subscribers: Mutex<HashMap<String, Vec<Dispatcher>>>
 //}
 
@@ -52,7 +52,7 @@ pub use traits::Dispatcher;
     fn default() -> Self {
         NotificationCenter {
             objc: unsafe {
-                ShareId::from_ptr(msg_send![class!(NSNotificationCenter), defaultCenter])
+                msg_send_id![class!(NSNotificationCenter), defaultCenter].unwrap()
             }
         }
     }
diff --git a/src/pasteboard/mod.rs b/src/pasteboard/mod.rs
index b9e42a5a..5c1696bf 100644
--- a/src/pasteboard/mod.rs
+++ b/src/pasteboard/mod.rs
@@ -15,9 +15,9 @@
 
 use std::path::PathBuf;
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 use url::Url;
 
 use crate::error::Error;
@@ -28,33 +28,33 @@ pub use types::{PasteboardName, PasteboardType};
 
 /// Represents an `NSPasteboard`, enabling you to handle copy/paste/drag and drop.
 #[derive(Debug)]
-pub struct Pasteboard(pub ShareId<Object>);
+pub struct Pasteboard(pub Id<Object, Shared>);
 
 impl Default for Pasteboard {
     /// Returns the default system pasteboard (the "general" pasteboard).
     fn default() -> Self {
-        Pasteboard(unsafe { ShareId::from_ptr(msg_send![class!(NSPasteboard), generalPasteboard]) })
+        Pasteboard(unsafe { msg_send_id![class!(NSPasteboard), generalPasteboard].unwrap() })
     }
 }
 
 impl Pasteboard {
     /// Used internally for wrapping a Pasteboard returned from operations (say, drag and drop).
     pub(crate) fn with(existing: id) -> Self {
-        Pasteboard(unsafe { ShareId::from_ptr(existing) })
+        Pasteboard(unsafe { Id::retain(existing).unwrap() })
     }
 
     /// Retrieves the system Pasteboard for the given name/type.
     pub fn named(name: PasteboardName) -> Self {
         Pasteboard(unsafe {
             let name: NSString = name.into();
-            ShareId::from_ptr(msg_send![class!(NSPasteboard), pasteboardWithName:&*name])
+            msg_send_id![class!(NSPasteboard), pasteboardWithName:&*name].unwrap()
         })
     }
 
     /// Creates and returns a new pasteboard with a name that is guaranteed to be unique with
     /// respect to other pasteboards in the system.
     pub fn unique() -> Self {
-        Pasteboard(unsafe { ShareId::from_ptr(msg_send![class!(NSPasteboard), pasteboardWithUniqueName]) })
+        Pasteboard(unsafe { msg_send_id![class!(NSPasteboard), pasteboardWithUniqueName].unwrap() })
     }
 
     /// A shorthand helper method for copying some text to the clipboard.
diff --git a/src/progress/mod.rs b/src/progress/mod.rs
index bc90eb63..368f1b7f 100644
--- a/src/progress/mod.rs
+++ b/src/progress/mod.rs
@@ -13,7 +13,7 @@
 
 use core_graphics::base::CGFloat;
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::{Class, Object};
 use objc::{class, msg_send, sel};
 
diff --git a/src/quicklook/config.rs b/src/quicklook/config.rs
index 369970b0..773b5af3 100644
--- a/src/quicklook/config.rs
+++ b/src/quicklook/config.rs
@@ -1,7 +1,7 @@
 use std::path::Path;
 
-use crate::id_shim::ShareId;
 use core_graphics::base::CGFloat;
+use objc::rc::{Id, Shared};
 use objc::runtime::Object;
 use objc::{class, msg_send, sel};
 
diff --git a/src/quicklook/mod.rs b/src/quicklook/mod.rs
index bca530d0..7702711d 100644
--- a/src/quicklook/mod.rs
+++ b/src/quicklook/mod.rs
@@ -1,8 +1,8 @@
 use std::path::Path;
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use block::ConcreteBlock;
 
@@ -14,12 +14,12 @@ mod config;
 pub use config::{ThumbnailConfig, ThumbnailQuality};
 
 #[derive(Debug)]
-pub struct ThumbnailGenerator(pub ShareId<Object>);
+pub struct ThumbnailGenerator(pub Id<Object, Shared>);
 
 impl ThumbnailGenerator {
     /// Returns the global shared, wrapped, QLThumbnailGenerator.
     pub fn shared() -> Self {
-        ThumbnailGenerator(unsafe { ShareId::from_ptr(msg_send![class!(QLThumbnailGenerator), sharedGenerator]) })
+        ThumbnailGenerator(unsafe { msg_send_id![class!(QLThumbnailGenerator), sharedGenerator].unwrap() })
     }
 
     /// Given a path and config, will generate a preview image, calling back on the provided
diff --git a/src/scrollview/appkit.rs b/src/scrollview/appkit.rs
index 012e5675..b26163f7 100644
--- a/src/scrollview/appkit.rs
+++ b/src/scrollview/appkit.rs
@@ -9,8 +9,8 @@
 
 use std::sync::Once;
 
-use crate::id_shim::Id;
 use objc::declare::ClassDecl;
+use objc::rc::{Id, Owned};
 use objc::runtime::{Class, Object, Sel, BOOL};
 use objc::{class, sel};
 
@@ -28,7 +28,7 @@ extern "C" fn enforce_normalcy(_: &Object, _: Sel) -> BOOL {
 extern "C" fn dragging_entered<T: ScrollViewDelegate>(this: &mut Object, _: Sel, info: id) -> NSUInteger {
     let view = load::<T>(this, SCROLLVIEW_DELEGATE_PTR);
     view.dragging_entered(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     })
     .into()
 }
@@ -38,7 +38,7 @@ extern "C" fn prepare_for_drag_operation<T: ScrollViewDelegate>(this: &mut Objec
     let view = load::<T>(this, SCROLLVIEW_DELEGATE_PTR);
 
     match view.prepare_for_drag_operation(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     }) {
         true => YES,
         false => NO
@@ -50,7 +50,7 @@ extern "C" fn perform_drag_operation<T: ScrollViewDelegate>(this: &mut Object, _
     let view = load::<T>(this, SCROLLVIEW_DELEGATE_PTR);
 
     match view.perform_drag_operation(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     }) {
         true => YES,
         false => NO
@@ -62,7 +62,7 @@ extern "C" fn conclude_drag_operation<T: ScrollViewDelegate>(this: &mut Object,
     let view = load::<T>(this, SCROLLVIEW_DELEGATE_PTR);
 
     view.conclude_drag_operation(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     });
 }
 
@@ -71,28 +71,28 @@ extern "C" fn dragging_exited<T: ScrollViewDelegate>(this: &mut Object, _: Sel,
     let view = load::<T>(this, SCROLLVIEW_DELEGATE_PTR);
 
     view.dragging_exited(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     });
 }
 
 /// Injects an `NSScrollView` subclass.
-pub(crate) fn register_scrollview_class() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_scrollview_class() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
         let superclass = class!(NSScrollView);
         let decl = ClassDecl::new("RSTScrollView", superclass).unwrap();
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
 
 /// Injects an `NSView` subclass, with some callback and pointer ivars for what we
 /// need to do.
-pub(crate) fn register_scrollview_class_with_delegate<T: ScrollViewDelegate>() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_scrollview_class_with_delegate<T: ScrollViewDelegate>() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
@@ -121,8 +121,8 @@ pub(crate) fn register_scrollview_class_with_delegate<T: ScrollViewDelegate>() -
         );
         decl.add_method(sel!(draggingExited:), dragging_exited::<T> as extern "C" fn(_, _, _));
 
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
diff --git a/src/scrollview/mod.rs b/src/scrollview/mod.rs
index fbcc083b..5158a5c4 100644
--- a/src/scrollview/mod.rs
+++ b/src/scrollview/mod.rs
@@ -43,7 +43,7 @@
 
 use core_foundation::base::TCFType;
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::{Class, Object};
 use objc::{msg_send, sel};
 
@@ -75,7 +75,7 @@ pub use traits::ScrollViewDelegate;
 pub(crate) static SCROLLVIEW_DELEGATE_PTR: &str = "rstScrollViewDelegatePtr";
 
 /// A helper method for instantiating view classes and applying default settings to them.
-fn allocate_view(registration_fn: fn() -> *const Class) -> id {
+fn allocate_view(registration_fn: fn() -> &'static Class) -> id {
     unsafe {
         let view: id = msg_send![registration_fn(), new];
 
diff --git a/src/select/mod.rs b/src/select/mod.rs
index d11837c0..0f7077d6 100644
--- a/src/select/mod.rs
+++ b/src/select/mod.rs
@@ -4,10 +4,10 @@ use std::sync::Once;
 
 use core_graphics::geometry::CGRect;
 
-use crate::id_shim::ShareId;
 use objc::declare::ClassDecl;
+use objc::rc::{Id, Shared};
 use objc::runtime::{Class, Object, Sel};
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::control::Control;
 use crate::foundation::{id, nil, NSInteger, NSString, NO, YES};
@@ -142,7 +142,7 @@ impl Select {
     /// I cannot stress this enough.
     pub fn set_action<F: Fn() + Send + Sync + 'static>(&mut self, action: F) {
         // @TODO: This probably isn't ideal but gets the job done for now; needs revisiting.
-        let this = self.objc.get(|obj| unsafe { ShareId::from_ptr(msg_send![obj, self]) });
+        let this: Id<Object, Shared> = self.objc.get(|obj| unsafe { msg_send_id![obj, self].unwrap() });
         let handler = TargetActionHandler::new(&*this, action);
         self.handler = Some(handler);
     }
@@ -262,15 +262,15 @@ impl Drop for Select {
 
 /// Registers an `NSSelect` subclass, and configures it to hold some ivars
 /// for various things we need to store.
-fn register_class() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+fn register_class() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
         let superclass = class!(NSPopUpButton);
         let decl = ClassDecl::new("CacaoSelect", superclass).unwrap();
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
diff --git a/src/switch.rs b/src/switch.rs
index 97e4d32f..c23252ee 100644
--- a/src/switch.rs
+++ b/src/switch.rs
@@ -4,10 +4,10 @@
 use std::fmt;
 use std::sync::Once;
 
-use crate::id_shim::ShareId;
 use objc::declare::ClassDecl;
+use objc::rc::{Id, Shared};
 use objc::runtime::{Class, Object, Sel};
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::{id, nil, NSString, BOOL, NO, YES};
 use crate::invoker::TargetActionHandler;
@@ -137,7 +137,7 @@ impl Switch {
     /// best just to message pass or something.
     pub fn set_action<F: Fn() + Send + Sync + 'static>(&mut self, action: F) {
         // @TODO: This probably isn't ideal but gets the job done for now; needs revisiting.
-        let this = self.objc.get(|obj| unsafe { ShareId::from_ptr(msg_send![obj, self]) });
+        let this: Id<Object, Shared> = self.objc.get(|obj| unsafe { msg_send_id![obj, self].unwrap() });
         let handler = TargetActionHandler::new(&*this, action);
         self.handler = Some(handler);
     }
@@ -177,15 +177,15 @@ impl Drop for Switch {
 
 /// Registers an `NSButton` subclass, and configures it to hold some ivars
 /// for various things we need to store.
-fn register_class() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+fn register_class() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
         let superclass = class!(NSButton);
         let decl = ClassDecl::new("RSTSwitch", superclass).unwrap();
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
diff --git a/src/text/attributed_string.rs b/src/text/attributed_string.rs
index f07cacfd..a3624d56 100644
--- a/src/text/attributed_string.rs
+++ b/src/text/attributed_string.rs
@@ -3,9 +3,9 @@ use std::ops::{Deref, DerefMut, Range};
 use std::os::raw::c_char;
 use std::{fmt, slice, str};
 
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::color::Color;
 use crate::foundation::{id, to_bool, NSString, BOOL, NO, YES};
@@ -21,7 +21,7 @@ extern "C" {
 /// A wrapper around `NSMutableAttributedString`, which can be used for more complex text
 /// rendering.
 ///
-pub struct AttributedString(pub Id<Object>);
+pub struct AttributedString(pub Id<Object, Owned>);
 
 impl AttributedString {
     /// Creates a blank AttributedString. Internally, this allocates an
@@ -30,8 +30,8 @@ impl AttributedString {
         let text = NSString::no_copy(value);
 
         Self(unsafe {
-            let alloc: id = msg_send![class!(NSMutableAttributedString), alloc];
-            Id::from_ptr(msg_send![alloc, initWithString:&*text])
+            let alloc = msg_send_id![class!(NSMutableAttributedString), alloc];
+            msg_send_id![alloc, initWithString:&*text].unwrap()
         })
     }
 
@@ -39,7 +39,7 @@ impl AttributedString {
     /// internal use, but kept available as part of the public API for the more adventurous types
     /// who might need it.
     pub fn wrap(value: id) -> Self {
-        Self(unsafe { Id::from_ptr(msg_send![value, mutableCopy]) })
+        Self(unsafe { msg_send_id![value, mutableCopy].unwrap() })
     }
 
     /// Sets the text (foreground) color for the specified range.
diff --git a/src/text/font.rs b/src/text/font.rs
index c9e72530..8e6f7349 100644
--- a/src/text/font.rs
+++ b/src/text/font.rs
@@ -4,16 +4,16 @@ use std::ops::Deref;
 
 use core_graphics::base::CGFloat;
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::{Class, Object};
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::{id, nil, NSArray, NSString, NO, YES};
 
 /// A `Font` can be constructed and applied to supported controls to control things like text
 /// appearance and size.
 #[derive(Clone, Debug)]
-pub struct Font(pub ShareId<Object>);
+pub struct Font(pub Id<Object, Shared>);
 
 impl Default for Font {
     /// Returns the default `labelFont` on macOS.
@@ -21,7 +21,7 @@ impl Default for Font {
         Font(unsafe {
             let cls = class!(NSFont);
             let default_size: id = msg_send![cls, labelFontSize];
-            ShareId::from_ptr(msg_send![cls, labelFontOfSize: default_size])
+            msg_send_id![cls, labelFontOfSize: default_size].unwrap()
         })
     }
 }
@@ -31,14 +31,14 @@ impl Font {
     pub fn system(size: f64) -> Self {
         let size = size as CGFloat;
 
-        Font(unsafe { ShareId::from_ptr(msg_send![class!(NSFont), systemFontOfSize: size]) })
+        Font(unsafe { msg_send_id![class!(NSFont), systemFontOfSize: size].unwrap() })
     }
 
     /// Creates and returns a default bold system font at the specified size.
     pub fn bold_system(size: f64) -> Self {
         let size = size as CGFloat;
 
-        Font(unsafe { ShareId::from_ptr(msg_send![class!(NSFont), boldSystemFontOfSize: size]) })
+        Font(unsafe { msg_send_id![class!(NSFont), boldSystemFontOfSize: size].unwrap() })
     }
 }
 
diff --git a/src/text/label/appkit.rs b/src/text/label/appkit.rs
index c84d8c47..3112ed0a 100644
--- a/src/text/label/appkit.rs
+++ b/src/text/label/appkit.rs
@@ -9,8 +9,8 @@
 
 use std::sync::Once;
 
-use crate::id_shim::Id;
 use objc::declare::ClassDecl;
+use objc::rc::{Id, Owned};
 use objc::runtime::{Class, Object, Sel, BOOL};
 use objc::{class, sel};
 
@@ -22,23 +22,23 @@ use crate::utils::load;
 /// Injects an `NSTextField` subclass. This is used for the default views that don't use delegates - we
 /// have separate classes here since we don't want to waste cycles on methods that will never be
 /// used if there's no delegates.
-pub(crate) fn register_view_class() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_view_class() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
         let superclass = class!(NSTextField);
         let decl = ClassDecl::new("RSTTextField", superclass).unwrap();
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
 
 /// Injects an `NSTextField` subclass, with some callback and pointer ivars for what we
 /// need to do.
-pub(crate) fn register_view_class_with_delegate<T: LabelDelegate>() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_view_class_with_delegate<T: LabelDelegate>() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
@@ -49,8 +49,8 @@ pub(crate) fn register_view_class_with_delegate<T: LabelDelegate>() -> *const Cl
         // move.
         decl.add_ivar::<usize>(LABEL_DELEGATE_PTR);
 
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
diff --git a/src/text/label/mod.rs b/src/text/label/mod.rs
index 8b24c1c2..97c53d1b 100644
--- a/src/text/label/mod.rs
+++ b/src/text/label/mod.rs
@@ -42,7 +42,7 @@
 
 use core_foundation::base::TCFType;
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::{Class, Object};
 use objc::{msg_send, sel};
 
@@ -74,7 +74,7 @@ pub use traits::LabelDelegate;
 pub(crate) static LABEL_DELEGATE_PTR: &str = "rstLabelDelegatePtr";
 
 /// A helper method for instantiating view classes and applying default settings to them.
-fn allocate_view(registration_fn: fn() -> *const Class) -> id {
+fn allocate_view(registration_fn: fn() -> &'static Class) -> id {
     unsafe {
         #[cfg(feature = "appkit")]
         let view: id = {
diff --git a/src/uikit/app/class.rs b/src/uikit/app/class.rs
index 3baf3502..5c590986 100644
--- a/src/uikit/app/class.rs
+++ b/src/uikit/app/class.rs
@@ -9,15 +9,15 @@ use objc::declare::ClassDecl;
 use objc::runtime::Class;
 
 /// Used for injecting a custom UIApplication. Currently does nothing.
-pub(crate) fn register_app_class() -> *const Class {
-    static mut APP_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_app_class() -> &'static Class {
+    static mut APP_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
         let superclass = class!(UIApplication);
         let decl = ClassDecl::new("RSTApplication", superclass).unwrap();
-        APP_CLASS = decl.register();
+        APP_CLASS = Some(decl.register());
     });
 
-    unsafe { APP_CLASS }
+    unsafe { APP_CLASS.unwrap() }
 }
diff --git a/src/uikit/app/delegate.rs b/src/uikit/app/delegate.rs
index fc636f3c..0040cbd4 100644
--- a/src/uikit/app/delegate.rs
+++ b/src/uikit/app/delegate.rs
@@ -48,8 +48,8 @@ extern "C" fn configuration_for_scene_session<T: AppDelegate>(this: &Object, _:
 
 /// Registers an `NSObject` application delegate, and configures it for the various callbacks and
 /// pointers we need to have.
-pub(crate) fn register_app_delegate_class<T: AppDelegate>() -> *const Class {
-    static mut DELEGATE_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_app_delegate_class<T: AppDelegate>() -> &'static Class {
+    static mut DELEGATE_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
@@ -72,8 +72,8 @@ pub(crate) fn register_app_delegate_class<T: AppDelegate>() -> *const Class {
             did_discard_scene_sessions::<T> as extern "C" fn(_, _, _, _)
         );*/
 
-        DELEGATE_CLASS = decl.register();
+        DELEGATE_CLASS = Some(decl.register());
     });
 
-    unsafe { DELEGATE_CLASS }
+    unsafe { DELEGATE_CLASS.unwrap() }
 }
diff --git a/src/uikit/scene/config.rs b/src/uikit/scene/config.rs
index 70ac36cb..bc7c8768 100644
--- a/src/uikit/scene/config.rs
+++ b/src/uikit/scene/config.rs
@@ -1,6 +1,6 @@
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::{id, NSString};
 use crate::uikit::scene::SessionRole;
@@ -9,7 +9,7 @@ use crate::uikit::scene::SessionRole;
 ///
 /// Due to the way we have to implement this, you likely never need to touch this.
 #[derive(Debug)]
-pub struct SceneConfig(Id<Object>);
+pub struct SceneConfig(Id<Object, Owned>);
 
 impl SceneConfig {
     /// Creates a new `UISceneConfiguration` with the specified name and session role, retains it,
@@ -20,12 +20,12 @@ impl SceneConfig {
             let role = NSString::from(role);
 
             let cls = class!(UISceneConfiguration);
-            let config: id = msg_send![cls, configurationWithName: &*name, sessionRole: &*role];
+            let mut config = msg_send_id![cls, configurationWithName: &*name, sessionRole: &*role].unwrap();
 
-            let _: () = msg_send![config, setSceneClass: class!(UIWindowScene)];
-            let _: () = msg_send![config, setDelegateClass: class!(RSTWindowSceneDelegate)];
+            let _: () = msg_send![&mut config, setSceneClass: class!(UIWindowScene)];
+            let _: () = msg_send![&mut config, setDelegateClass: class!(RSTWindowSceneDelegate)];
 
-            Id::from_ptr(config)
+            config
         })
     }
 
diff --git a/src/uikit/scene/delegate.rs b/src/uikit/scene/delegate.rs
index 9db97aa6..824e2485 100644
--- a/src/uikit/scene/delegate.rs
+++ b/src/uikit/scene/delegate.rs
@@ -59,8 +59,8 @@ extern "C" fn scene_will_connect_to_session_with_options<T: WindowSceneDelegate>
 
 /// Registers an `NSObject` application delegate, and configures it for the various callbacks and
 /// pointers we need to have.
-pub(crate) fn register_window_scene_delegate_class<T: WindowSceneDelegate, F: Fn() -> Box<T>>() -> *const Class {
-    static mut DELEGATE_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_window_scene_delegate_class<T: WindowSceneDelegate, F: Fn() -> Box<T>>() -> &'static Class {
+    static mut DELEGATE_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
@@ -83,8 +83,8 @@ pub(crate) fn register_window_scene_delegate_class<T: WindowSceneDelegate, F: Fn
         );
 
         // Launching Applications
-        DELEGATE_CLASS = decl.register();
+        DELEGATE_CLASS = Some(decl.register());
     });
 
-    unsafe { DELEGATE_CLASS }
+    unsafe { DELEGATE_CLASS.unwrap() }
 }
diff --git a/src/uikit/scene/mod.rs b/src/uikit/scene/mod.rs
index 7ca7e559..f78a9ef5 100644
--- a/src/uikit/scene/mod.rs
+++ b/src/uikit/scene/mod.rs
@@ -5,7 +5,7 @@
 
 use core_graphics::geometry::CGRect;
 
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
 use objc::{class, msg_send, sel};
 
@@ -31,11 +31,11 @@ mod session;
 pub use session::*;
 
 #[derive(Debug)]
-pub struct Scene(pub Id<Object>);
+pub struct Scene(pub Id<Object, Owned>);
 
 impl Scene {
     pub fn with(scene: id) -> Self {
-        Scene(unsafe { Id::from_ptr(scene) })
+        Scene(unsafe { Id::retain(scene).unwrap() })
     }
 
     // This is temporary - I'm not wrapping `coordinateSpace` until I'm happy with the ergonomics
diff --git a/src/uikit/scene/options.rs b/src/uikit/scene/options.rs
index a254a7f0..149ac6a8 100644
--- a/src/uikit/scene/options.rs
+++ b/src/uikit/scene/options.rs
@@ -1,4 +1,4 @@
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
 use objc::{class, msg_send, sel};
 
@@ -8,11 +8,11 @@ use crate::foundation::{id, NSString};
 ///
 /// Due to the way we have to implement this, you likely never need to touch this.
 #[derive(Debug)]
-pub struct SceneConnectionOptions(Id<Object>);
+pub struct SceneConnectionOptions(Id<Object, Owned>);
 
 impl SceneConnectionOptions {
     pub fn with(opts: id) -> Self {
-        SceneConnectionOptions(unsafe { Id::from_ptr(opts) })
+        SceneConnectionOptions(unsafe { Id::retain(opts).unwrap() })
     }
 
     /// Consumes and returns the underlying `UISceneConfiguration`.
diff --git a/src/uikit/scene/session.rs b/src/uikit/scene/session.rs
index 01842dae..bb0aec1d 100644
--- a/src/uikit/scene/session.rs
+++ b/src/uikit/scene/session.rs
@@ -1,4 +1,4 @@
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
 use objc::{msg_send, sel};
 
@@ -6,11 +6,11 @@ use crate::foundation::{id, NSString};
 use crate::uikit::scene::enums::SessionRole;
 
 #[derive(Debug)]
-pub struct SceneSession(pub Id<Object>);
+pub struct SceneSession(pub Id<Object, Owned>);
 
 impl SceneSession {
     pub fn with(session: id) -> Self {
-        SceneSession(unsafe { Id::from_ptr(session) })
+        SceneSession(unsafe { Id::retain(session).unwrap() })
     }
 
     pub fn role(&self) -> SessionRole {
diff --git a/src/uikit/window/mod.rs b/src/uikit/window/mod.rs
index 6ba1f48a..b9c228bc 100644
--- a/src/uikit/window/mod.rs
+++ b/src/uikit/window/mod.rs
@@ -1,8 +1,8 @@
 use core_graphics::geometry::CGRect;
 
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::id;
 use crate::geometry::Rect;
@@ -10,14 +10,14 @@ use crate::uikit::Scene;
 use crate::utils::Controller;
 
 #[derive(Debug)]
-pub struct Window(pub Id<Object>);
+pub struct Window(pub Id<Object, Owned>);
 
 impl Window {
     pub fn new(frame: Rect) -> Self {
         Window(unsafe {
             let rect: CGRect = frame.into();
-            let alloc: id = msg_send![class!(UIWindow), alloc];
-            Id::from_ptr(msg_send![alloc, initWithFrame: rect])
+            let alloc = msg_send_id![class!(UIWindow), alloc];
+            msg_send_id![alloc, initWithFrame: rect].unwrap()
         })
     }
 
diff --git a/src/user_activity.rs b/src/user_activity.rs
index d0f5d881..7b5d825c 100644
--- a/src/user_activity.rs
+++ b/src/user_activity.rs
@@ -2,7 +2,7 @@
 //!
 //! This is primarily used in handling app handoff between devices.
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::Object;
 
 use crate::foundation::id;
@@ -10,11 +10,11 @@ use crate::foundation::id;
 /// Represents an `NSUserActivity`, which acts as a lightweight method to capture
 /// the state of your app.
 #[derive(Debug)]
-pub struct UserActivity(pub ShareId<Object>);
+pub struct UserActivity(pub Id<Object, Shared>);
 
 impl UserActivity {
     /// An internal method for wrapping a system-provided activity.
     pub(crate) fn with_inner(object: id) -> Self {
-        UserActivity(unsafe { ShareId::from_ptr(object) })
+        UserActivity(unsafe { Id::retain(object).unwrap() })
     }
 }
diff --git a/src/user_notifications/notifications.rs b/src/user_notifications/notifications.rs
index 770e2e01..8b40af6f 100644
--- a/src/user_notifications/notifications.rs
+++ b/src/user_notifications/notifications.rs
@@ -1,16 +1,16 @@
 //! Acts as a (currently dumb) wrapper for `UNMutableNotificationContent`, which is what you mostly
 //! need to pass to the notification center for things to work.
 
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::{id, NSString};
 
 /// A wrapper for `UNMutableNotificationContent`. Retains the pointer from the Objective C side,
 /// and is ultimately dropped upon sending.
 #[derive(Debug)]
-pub struct Notification(pub Id<Object>);
+pub struct Notification(pub Id<Object, Owned>);
 
 impl Notification {
     /// Constructs a new `Notification`. This allocates `NSString`'s, as it has to do so for the
@@ -20,10 +20,10 @@ impl Notification {
         let body = NSString::new(body);
 
         Notification(unsafe {
-            let content: id = msg_send![class!(UNMutableNotificationContent), new];
-            let _: () = msg_send![content, setTitle: &*title];
-            let _: () = msg_send![content, setBody: &*body];
-            Id::from_ptr(content)
+            let mut content = msg_send_id![class!(UNMutableNotificationContent), new].unwrap();
+            let _: () = msg_send![&mut content, setTitle: &*title];
+            let _: () = msg_send![&mut content, setBody: &*body];
+            content
         })
     }
 }
diff --git a/src/utils/mod.rs b/src/utils/mod.rs
index 830c9661..1b2d5284 100644
--- a/src/utils/mod.rs
+++ b/src/utils/mod.rs
@@ -7,7 +7,7 @@ use core_graphics::base::CGFloat;
 
 use objc::{class, msg_send, sel};
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::Object;
 use objc::{Encode, Encoding};
 
@@ -23,7 +23,7 @@ pub mod properties;
 /// a guard for whether something is a (View|Window|etc)Controller.
 pub trait Controller {
     /// Returns the underlying Objective-C object.
-    fn get_backing_node(&self) -> ShareId<Object>;
+    fn get_backing_node(&self) -> Id<Object, Shared>;
 }
 
 /// Utility method for taking a pointer and grabbing the corresponding delegate in Rust. This is
diff --git a/src/utils/properties.rs b/src/utils/properties.rs
index ef4cef3d..0671578c 100644
--- a/src/utils/properties.rs
+++ b/src/utils/properties.rs
@@ -1,7 +1,7 @@
 use std::cell::RefCell;
 use std::rc::Rc;
 
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
 
 use crate::foundation::id;
@@ -15,17 +15,17 @@ use crate::foundation::id;
 /// It is possible we could remove the `Id` wrapper in here if we're just doing this ourselves, and
 /// is probably worth investigating at some point.
 #[derive(Clone, Debug)]
-pub struct ObjcProperty(Rc<RefCell<Id<Object>>>);
+pub struct ObjcProperty(Rc<RefCell<Id<Object, Owned>>>);
 
 impl ObjcProperty {
     /// Given an Objective-C object, retains it and wraps it as a `Property`.
     pub fn retain(obj: id) -> Self {
-        ObjcProperty(Rc::new(RefCell::new(unsafe { Id::from_ptr(obj) })))
+        ObjcProperty(Rc::new(RefCell::new(unsafe { Id::retain(obj).unwrap() })))
     }
 
     /// Given an Objective-C object, retains it and wraps it as a `Property`.
     pub fn from_retained(obj: id) -> Self {
-        ObjcProperty(Rc::new(RefCell::new(unsafe { Id::from_retained_ptr(obj) })))
+        ObjcProperty(Rc::new(RefCell::new(unsafe { Id::new(obj).unwrap() })))
     }
 
     /// Runs a handler with mutable access for the underlying Objective-C object.
diff --git a/src/view/animator.rs b/src/view/animator.rs
index 92b8a3ea..837a4388 100644
--- a/src/view/animator.rs
+++ b/src/view/animator.rs
@@ -1,18 +1,18 @@
 use core_graphics::base::CGFloat;
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::{Class, Object};
-use objc::{msg_send, sel};
+use objc::{msg_send, msg_send_id, sel};
 
 use crate::foundation::id;
 
 /// A wrapper for an animation proxy object in Cocoa that supports basic animations.
 #[derive(Clone, Debug)]
-pub struct ViewAnimatorProxy(pub ShareId<Object>);
+pub struct ViewAnimatorProxy(pub Id<Object, Shared>);
 
 impl ViewAnimatorProxy {
     pub fn new(proxy: id) -> Self {
-        Self(unsafe { ShareId::from_ptr(msg_send![proxy, animator]) })
+        Self(unsafe { msg_send_id![proxy, animator].unwrap() })
     }
 
     /// Sets the alpha value for the view being animated.
diff --git a/src/view/appkit.rs b/src/view/appkit.rs
index 7684293d..bf046ae3 100644
--- a/src/view/appkit.rs
+++ b/src/view/appkit.rs
@@ -9,8 +9,8 @@
 
 use std::sync::Once;
 
-use crate::id_shim::Id;
 use objc::declare::ClassDecl;
+use objc::rc::{Id, Owned};
 use objc::runtime::{Class, Object, Sel, BOOL};
 use objc::{class, msg_send, sel};
 
@@ -28,7 +28,7 @@ extern "C" fn enforce_normalcy(_: &Object, _: Sel) -> BOOL {
 extern "C" fn dragging_entered<T: ViewDelegate>(this: &mut Object, _: Sel, info: id) -> NSUInteger {
     let view = load::<T>(this, VIEW_DELEGATE_PTR);
     view.dragging_entered(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     })
     .into()
 }
@@ -38,7 +38,7 @@ extern "C" fn prepare_for_drag_operation<T: ViewDelegate>(this: &mut Object, _:
     let view = load::<T>(this, VIEW_DELEGATE_PTR);
 
     match view.prepare_for_drag_operation(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     }) {
         true => YES,
         false => NO
@@ -50,7 +50,7 @@ extern "C" fn perform_drag_operation<T: ViewDelegate>(this: &mut Object, _: Sel,
     let view = load::<T>(this, VIEW_DELEGATE_PTR);
 
     match view.perform_drag_operation(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     }) {
         true => YES,
         false => NO
@@ -62,7 +62,7 @@ extern "C" fn conclude_drag_operation<T: ViewDelegate>(this: &mut Object, _: Sel
     let view = load::<T>(this, VIEW_DELEGATE_PTR);
 
     view.conclude_drag_operation(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     });
 }
 
@@ -71,7 +71,7 @@ extern "C" fn dragging_exited<T: ViewDelegate>(this: &mut Object, _: Sel, info:
     let view = load::<T>(this, VIEW_DELEGATE_PTR);
 
     view.dragging_exited(DragInfo {
-        info: unsafe { Id::from_ptr(info) }
+        info: unsafe { Id::retain(info).unwrap() }
     });
 }
 
@@ -91,8 +91,8 @@ extern "C" fn update_layer(this: &Object, _: Sel) {
 /// Injects an `NSView` subclass. This is used for the default views that don't use delegates - we
 /// have separate classes here since we don't want to waste cycles on methods that will never be
 /// used if there's no delegates.
-pub(crate) fn register_view_class() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_view_class() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
@@ -105,15 +105,15 @@ pub(crate) fn register_view_class() -> *const Class {
 
         decl.add_ivar::<id>(BACKGROUND_COLOR);
 
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
 
 /// Injects an `NSView` subclass, with some callback and pointer ivars for what we
 /// need to do.
-pub(crate) fn register_view_class_with_delegate<T: ViewDelegate>(instance: &T) -> *const Class {
+pub(crate) fn register_view_class_with_delegate<T: ViewDelegate>(instance: &T) -> &'static Class {
     load_or_register_class("NSView", instance.subclass_name(), |decl| unsafe {
         // A pointer to the ViewDelegate instance on the Rust side.
         // It's expected that this doesn't move.
diff --git a/src/view/controller/appkit.rs b/src/view/controller/appkit.rs
index 9aec40c7..4e7840b4 100644
--- a/src/view/controller/appkit.rs
+++ b/src/view/controller/appkit.rs
@@ -51,7 +51,7 @@ extern "C" fn did_disappear<T: ViewDelegate>(this: &mut Object, _: Sel) {
 }
 
 /// Registers an `NSViewDelegate`.
-pub(crate) fn register_view_controller_class<T: ViewDelegate + 'static>(instance: &T) -> *const Class {
+pub(crate) fn register_view_controller_class<T: ViewDelegate + 'static>(instance: &T) -> &'static Class {
     load_or_register_class("NSViewController", instance.subclass_name(), |decl| unsafe {
         decl.add_ivar::<usize>(VIEW_DELEGATE_PTR);
 
diff --git a/src/view/controller/mod.rs b/src/view/controller/mod.rs
index e9dfba01..e572f3fd 100644
--- a/src/view/controller/mod.rs
+++ b/src/view/controller/mod.rs
@@ -1,6 +1,6 @@
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Owned, Shared};
 use objc::runtime::Object;
-use objc::{msg_send, sel};
+use objc::{msg_send, msg_send_id, sel};
 
 use crate::foundation::id;
 use crate::layout::Layout;
@@ -33,7 +33,7 @@ mod native_interface;
 #[derive(Debug)]
 pub struct ViewController<T> {
     /// The underlying Objective-C pointer.
-    pub objc: ShareId<Object>,
+    pub objc: Id<Object, Shared>,
 
     /// The underlying View that we manage.
     pub view: View<T>
@@ -49,18 +49,18 @@ where
         let view = View::with(delegate);
 
         let objc = unsafe {
-            let vc: id = msg_send![class, new];
+            let mut vc: Id<Object, Owned> = msg_send_id![class, new].unwrap();
 
             if let Some(delegate) = &view.delegate {
                 let ptr: *const T = &**delegate;
-                (&mut *vc).set_ivar(VIEW_DELEGATE_PTR, ptr as usize);
+                vc.set_ivar(VIEW_DELEGATE_PTR, ptr as usize);
             }
 
             view.with_backing_obj_mut(|backing_node| {
-                let _: () = msg_send![vc, setView: backing_node];
+                let _: () = msg_send![&vc, setView: backing_node];
             });
 
-            ShareId::from_ptr(vc)
+            vc.into()
         };
 
         ViewController { objc, view }
@@ -68,7 +68,7 @@ where
 }
 
 impl<T> Controller for ViewController<T> {
-    fn get_backing_node(&self) -> ShareId<Object> {
+    fn get_backing_node(&self) -> Id<Object, Shared> {
         self.objc.clone()
     }
 }
diff --git a/src/view/controller/uikit.rs b/src/view/controller/uikit.rs
index a95f71b3..542a6adc 100644
--- a/src/view/controller/uikit.rs
+++ b/src/view/controller/uikit.rs
@@ -51,7 +51,7 @@ extern "C" fn did_disappear<T: ViewDelegate>(this: &mut Object, _: Sel, animated
 }
 
 /// Registers an `NSViewDelegate`.
-pub(crate) fn register_view_controller_class<T: ViewDelegate + 'static>(instance: &T) -> *const Class {
+pub(crate) fn register_view_controller_class<T: ViewDelegate + 'static>(instance: &T) -> &'static Class {
     load_or_register_class("UIViewController", instance.subclass_name(), |decl| unsafe {
         decl.add_ivar::<usize>(VIEW_DELEGATE_PTR);
 
diff --git a/src/view/splitviewcontroller/ios.rs b/src/view/splitviewcontroller/ios.rs
index ff11dcf4..43ff36bd 100644
--- a/src/view/splitviewcontroller/ios.rs
+++ b/src/view/splitviewcontroller/ios.rs
@@ -50,8 +50,8 @@ extern "C" fn did_disappear<T: ViewDelegate>(this: &mut Object, _: Sel, animated
 }
 
 /// Registers an `NSViewDelegate`.
-pub(crate) fn register_view_controller_class<T: ViewDelegate + 'static>() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_view_controller_class<T: ViewDelegate + 'static>() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
@@ -65,8 +65,8 @@ pub(crate) fn register_view_controller_class<T: ViewDelegate + 'static>() -> *co
         decl.add_method(sel!(viewWillDisappear:), will_disappear::<T> as extern "C" fn(_, _, _));
         decl.add_method(sel!(viewDidDisappear:), did_disappear::<T> as extern "C" fn(_, _, _));
 
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
diff --git a/src/view/splitviewcontroller/macos.rs b/src/view/splitviewcontroller/macos.rs
index a31d966b..e5005170 100644
--- a/src/view/splitviewcontroller/macos.rs
+++ b/src/view/splitviewcontroller/macos.rs
@@ -51,7 +51,7 @@ extern "C" fn did_disappear<T: ViewDelegate>(this: &mut Object, _: Sel) {
 }
 
 /// Registers an `NSViewDelegate`.
-pub(crate) fn register_view_controller_class<T: ViewDelegate + 'static>(instance: &T) -> *const Class {
+pub(crate) fn register_view_controller_class<T: ViewDelegate + 'static>(instance: &T) -> &'static Class {
     load_or_register_class("NSViewController", instance.subclass_name(), |decl| unsafe {
         decl.add_ivar::<usize>(VIEW_DELEGATE_PTR);
 
diff --git a/src/view/splitviewcontroller/mod.rs b/src/view/splitviewcontroller/mod.rs
index 1dd2be29..dc4eaa51 100644
--- a/src/view/splitviewcontroller/mod.rs
+++ b/src/view/splitviewcontroller/mod.rs
@@ -1,6 +1,6 @@
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Shared};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::appkit::toolbar::ToolbarItem;
 use crate::foundation::{id, nil, NSString};
@@ -16,7 +16,7 @@ use crate::view::{View, ViewController, ViewDelegate};
 #[derive(Debug)]
 pub struct SplitViewItem<T> {
     /// The underlying Objective-C Object.
-    pub objc: ShareId<Object>,
+    pub objc: Id<Object, Shared>,
 
     /// The wrapped ViewController.
     pub view_controller: ViewController<T>
@@ -33,9 +33,10 @@ where
 
         SplitViewItem {
             objc: unsafe {
-                ShareId::from_ptr(msg_send![class!(NSSplitViewItem),
+                msg_send_id![class!(NSSplitViewItem),
                     splitViewItemWithViewController:&*view_controller.objc
-                ])
+                ]
+                .unwrap()
             },
 
             view_controller
@@ -59,9 +60,10 @@ where
 
             SplitViewItem {
                 objc: unsafe {
-                    ShareId::from_ptr(msg_send![class!(NSSplitViewItem),
+                    msg_send_id![class!(NSSplitViewItem),
                         sidebarWithViewController:&*view_controller.objc
-                    ])
+                    ]
+                    .unwrap()
                 },
 
                 view_controller
@@ -112,7 +114,7 @@ where
 #[derive(Debug)]
 pub struct SplitViewController<Sidebar, Content, Details> {
     /// A reference to the underlying Objective-C split view controller.
-    pub objc: ShareId<Object>,
+    pub objc: Id<Object, Shared>,
 
     /// A reference to the sidebar `SplitViewItem`.
     pub sidebar: SplitViewItem<Sidebar>,
@@ -141,15 +143,15 @@ where
         };
 
         let objc = unsafe {
-            let vc: id = msg_send![class!(NSSplitViewController), new];
-            let _: () = msg_send![vc, addSplitViewItem:&*sidebar.objc];
-            let _: () = msg_send![vc, addSplitViewItem:&*content.objc];
+            let vc = msg_send_id![class!(NSSplitViewController), new].unwrap();
+            let _: () = msg_send![&vc, addSplitViewItem:&*sidebar.objc];
+            let _: () = msg_send![&vc, addSplitViewItem:&*content.objc];
 
             if let Some(details) = &details {
-                let _: () = msg_send![vc, addSplitViewItem:&*details.objc];
+                let _: () = msg_send![&vc, addSplitViewItem:&*details.objc];
             }
 
-            ShareId::from_ptr(vc)
+            vc
         };
 
         SplitViewController {
@@ -186,7 +188,7 @@ impl<Sidebar, Content, Details> SplitViewController<Sidebar, Content, Details> {
 }
 
 impl<Sidebar, Content, Details> Controller for SplitViewController<Sidebar, Content, Details> {
-    fn get_backing_node(&self) -> ShareId<Object> {
+    fn get_backing_node(&self) -> Id<Object, Shared> {
         self.objc.clone()
     }
 }
diff --git a/src/view/uikit.rs b/src/view/uikit.rs
index e0d7b189..b4322ddd 100644
--- a/src/view/uikit.rs
+++ b/src/view/uikit.rs
@@ -1,7 +1,7 @@
 use std::sync::Once;
 
-use crate::id_shim::Id;
 use objc::declare::ClassDecl;
+use objc::rc::{Id, Owned};
 use objc::runtime::{Class, Object, Sel, BOOL};
 use objc::{class, sel};
 
@@ -13,22 +13,22 @@ use crate::view::{ViewDelegate, VIEW_DELEGATE_PTR};
 /// Injects an `NSView` subclass. This is used for the default views that don't use delegates - we
 /// have separate classes here since we don't want to waste cycles on methods that will never be
 /// used if there's no delegates.
-pub(crate) fn register_view_class() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub(crate) fn register_view_class() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
         let superclass = class!(UIView);
         let mut decl = ClassDecl::new("RSTView", superclass).unwrap();
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
 
 /// Injects a `UIView` subclass, with some callback and pointer ivars for what we
 /// need to do.
-pub(crate) fn register_view_class_with_delegate<T: ViewDelegate>(instance: &T) -> *const Class {
+pub(crate) fn register_view_class_with_delegate<T: ViewDelegate>(instance: &T) -> &'static Class {
     load_or_register_class("UIView", instance.subclass_name(), |decl| unsafe {
         decl.add_ivar::<usize>(VIEW_DELEGATE_PTR);
     })
diff --git a/src/webview/class.rs b/src/webview/class.rs
index a4cfc7ae..868bbe59 100644
--- a/src/webview/class.rs
+++ b/src/webview/class.rs
@@ -174,24 +174,24 @@ extern "C" fn handle_download<T: WebViewDelegate>(this: &Object, _: Sel, downloa
 /// Registers an `NSViewController` that we effectively turn into a `WebViewController`. Acts as
 /// both a subclass of `NSViewController` and a delegate of the held `WKWebView` (for the various
 /// varieties of delegates needed there).
-pub fn register_webview_class() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub fn register_webview_class() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
         let superclass = class!(WKWebView);
         let decl = ClassDecl::new("RSTWebView", superclass).unwrap();
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
 
 /// Registers an `NSViewController` that we effectively turn into a `WebViewController`. Acts as
 /// both a subclass of `NSViewController` and a delegate of the held `WKWebView` (for the various
 /// varieties of delegates needed there).
-pub fn register_webview_delegate_class<T: WebViewDelegate>() -> *const Class {
-    static mut VIEW_CLASS: *const Class = 0 as *const Class;
+pub fn register_webview_delegate_class<T: WebViewDelegate>() -> &'static Class {
+    static mut VIEW_CLASS: Option<&'static Class> = None;
     static INIT: Once = Once::new();
 
     INIT.call_once(|| unsafe {
@@ -245,8 +245,8 @@ pub fn register_webview_delegate_class<T: WebViewDelegate>() -> *const Class {
             handle_download::<T> as extern "C" fn(_, _, _, _, _)
         );
 
-        VIEW_CLASS = decl.register();
+        VIEW_CLASS = Some(decl.register());
     });
 
-    unsafe { VIEW_CLASS }
+    unsafe { VIEW_CLASS.unwrap() }
 }
diff --git a/src/webview/config.rs b/src/webview/config.rs
index 6c3fe6b0..70903c9b 100644
--- a/src/webview/config.rs
+++ b/src/webview/config.rs
@@ -1,9 +1,9 @@
 //! A wrapper for `WKWebViewConfiguration`. It aims to (mostly) cover
 //! the important pieces of configuring and updating a WebView configuration.
 
-use crate::id_shim::Id;
+use objc::rc::{Id, Owned};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::{id, NSInteger, NSString, NO, YES};
 use crate::webview::enums::InjectAt;
@@ -12,7 +12,7 @@ use crate::webview::enums::InjectAt;
 /// where everything lives.
 #[derive(Debug)]
 pub struct WebViewConfig {
-    pub objc: Id<Object>,
+    pub objc: Id<Object, Owned>,
     pub handlers: Vec<String>,
     pub protocols: Vec<String>
 }
@@ -20,10 +20,7 @@ pub struct WebViewConfig {
 impl Default for WebViewConfig {
     /// Initializes a default `WebViewConfig`.
     fn default() -> Self {
-        let config = unsafe {
-            let config: id = msg_send![class!(WKWebViewConfiguration), new];
-            Id::from_ptr(config)
-        };
+        let config = unsafe { msg_send_id![class!(WKWebViewConfiguration), new].unwrap() };
 
         WebViewConfig {
             objc: config,
diff --git a/src/webview/mod.rs b/src/webview/mod.rs
index 25af352d..abe50f81 100644
--- a/src/webview/mod.rs
+++ b/src/webview/mod.rs
@@ -15,9 +15,9 @@
 
 use core_graphics::geometry::CGRect;
 
-use crate::id_shim::ShareId;
+use objc::rc::{Id, Owned, Shared};
 use objc::runtime::Object;
-use objc::{class, msg_send, sel};
+use objc::{class, msg_send, msg_send_id, sel};
 
 use crate::foundation::{id, nil, NSString, NO, YES};
 use crate::geometry::Rect;
@@ -109,7 +109,7 @@ pub struct WebView<T = ()> {
 
     /// We need to store the underlying delegate separately from the `WKWebView` - this is a where
     /// we do so.
-    pub objc_delegate: Option<ShareId<Object>>,
+    pub objc_delegate: Option<Id<Object, Shared>>,
 
     /// A pointer to the delegate for this view.
     pub delegate: Option<Box<T>>,
@@ -233,10 +233,10 @@ where
         let mut delegate = Box::new(delegate);
 
         let objc_delegate = unsafe {
-            let objc_delegate: id = msg_send![register_webview_delegate_class::<T>(), new];
+            let mut objc_delegate: Id<Object, Owned> = msg_send_id![register_webview_delegate_class::<T>(), new].unwrap();
             let ptr: *const T = &*delegate;
-            (&mut *objc_delegate).set_ivar(WEBVIEW_DELEGATE_PTR, ptr as usize);
-            ShareId::from_ptr(objc_delegate)
+            objc_delegate.set_ivar(WEBVIEW_DELEGATE_PTR, ptr as usize);
+            objc_delegate
         };
 
         let view = allocate_webview(config, Some(&objc_delegate));