diff --git a/crates/icrate/src/additions/Foundation/array.rs b/crates/icrate/src/additions/Foundation/array.rs
index 6866222a6..f9cf94136 100644
--- a/crates/icrate/src/additions/Foundation/array.rs
+++ b/crates/icrate/src/additions/Foundation/array.rs
@@ -391,7 +391,7 @@ __impl_iter! {
 pub struct IterMut<'a, T: Message>(iter::IterMut<'a, NSArray<T>>);
 
 __impl_iter! {
-    impl<'a, T: IsMutable> Iterator<Item = &'a mut T> for IterMut<'a, T> { ... }
+    impl<'a, T: Message + IsMutable> Iterator<Item = &'a mut T> for IterMut<'a, T> { ... }
 }
 
 /// An iterator that retains the items of a `NSArray`.
@@ -399,7 +399,7 @@ __impl_iter! {
 pub struct IterRetained<'a, T: Message>(iter::IterRetained<'a, NSArray<T>>);
 
 __impl_iter! {
-    impl<'a, T: IsIdCloneable> Iterator<Item = Id<T>> for IterRetained<'a, T> { ... }
+    impl<'a, T: Message + IsIdCloneable> Iterator<Item = Id<T>> for IterRetained<'a, T> { ... }
 }
 
 /// A consuming iterator over the items of a `NSArray`.
@@ -420,16 +420,16 @@ __impl_into_iter! {
         type IntoIter = Iter<'_, T>;
     }
 
-    impl<T: IsMutable> IntoIterator for &mut NSArray<T> {
+    impl<T: Message + IsMutable> IntoIterator for &mut NSArray<T> {
         type IntoIter = IterMut<'_, T>;
     }
 
     #[cfg(feature = "Foundation_NSMutableArray")]
-    impl<T: IsMutable> IntoIterator for &mut NSMutableArray<T> {
+    impl<T: Message + IsMutable> IntoIterator for &mut NSMutableArray<T> {
         type IntoIter = IterMut<'_, T>;
     }
 
-    impl<T: IsIdCloneable> IntoIterator for Id<NSArray<T>> {
+    impl<T: Message + IsIdCloneable> IntoIterator for Id<NSArray<T>> {
         type IntoIter = IntoIter<T>;
     }
 
@@ -456,14 +456,14 @@ impl<T: Message> Index<usize> for NSMutableArray<T> {
     }
 }
 
-impl<T: IsMutable> IndexMut<usize> for NSArray<T> {
+impl<T: Message + IsMutable> IndexMut<usize> for NSArray<T> {
     fn index_mut(&mut self, index: usize) -> &mut T {
         self.get_mut(index).unwrap()
     }
 }
 
 #[cfg(feature = "Foundation_NSMutableArray")]
-impl<T: IsMutable> IndexMut<usize> for NSMutableArray<T> {
+impl<T: Message + IsMutable> IndexMut<usize> for NSMutableArray<T> {
     fn index_mut(&mut self, index: usize) -> &mut T {
         self.get_mut(index).unwrap()
     }
@@ -484,7 +484,7 @@ impl<T: Message> Extend<Id<T>> for NSMutableArray<T> {
 }
 
 #[cfg(feature = "Foundation_NSMutableArray")]
-impl<'a, T: IsRetainable> Extend<&'a T> for NSMutableArray<T> {
+impl<'a, T: Message + IsRetainable> Extend<&'a T> for NSMutableArray<T> {
     fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
         // SAFETY: Because of the `T: IsRetainable` bound, it is safe for the
         // array to retain the object here.
@@ -493,7 +493,7 @@ impl<'a, T: IsRetainable> Extend<&'a T> for NSMutableArray<T> {
     }
 }
 
-impl<'a, T: IsRetainable + 'a> IdFromIterator<&'a T> for NSArray<T> {
+impl<'a, T: Message + IsRetainable + 'a> IdFromIterator<&'a T> for NSArray<T> {
     fn id_from_iter<I: IntoIterator<Item = &'a T>>(iter: I) -> Id<Self> {
         let vec = Vec::from_iter(iter);
         Self::from_slice(&vec)
@@ -508,7 +508,7 @@ impl<T: Message> IdFromIterator<Id<T>> for NSArray<T> {
 }
 
 #[cfg(feature = "Foundation_NSMutableArray")]
-impl<'a, T: IsRetainable + 'a> IdFromIterator<&'a T> for NSMutableArray<T> {
+impl<'a, T: Message + IsRetainable + 'a> IdFromIterator<&'a T> for NSMutableArray<T> {
     fn id_from_iter<I: IntoIterator<Item = &'a T>>(iter: I) -> Id<Self> {
         let vec = Vec::from_iter(iter);
         Self::from_slice(&vec)
diff --git a/crates/icrate/src/additions/Foundation/dictionary.rs b/crates/icrate/src/additions/Foundation/dictionary.rs
index f2fef8d08..2feac65af 100644
--- a/crates/icrate/src/additions/Foundation/dictionary.rs
+++ b/crates/icrate/src/additions/Foundation/dictionary.rs
@@ -516,7 +516,7 @@ mod iter_helpers {
     );
 
     __impl_iter! {
-        impl<'a, K: IsIdCloneable, V: Message> Iterator<Item = Id<K>> for KeysRetained<'a, K, V> { ... }
+        impl<'a, K: Message + IsIdCloneable, V: Message> Iterator<Item = Id<K>> for KeysRetained<'a, K, V> { ... }
     }
 
     /// An iterator over the values of a `NSDictionary`.
@@ -536,7 +536,7 @@ mod iter_helpers {
     );
 
     __impl_iter! {
-        impl<'a, K: Message, V: IsMutable> Iterator<Item = &'a mut V> for ValuesMut<'a, K, V> { ... }
+        impl<'a, K: Message, V: Message + IsMutable> Iterator<Item = &'a mut V> for ValuesMut<'a, K, V> { ... }
     }
 
     /// A iterator that retains the values of a `NSDictionary`.
@@ -546,7 +546,7 @@ mod iter_helpers {
     );
 
     __impl_iter! {
-        impl<'a, K: Message, V: IsIdCloneable> Iterator<Item = Id<V>> for ValuesRetained<'a, K, V> { ... }
+        impl<'a, K: Message, V: Message + IsIdCloneable> Iterator<Item = Id<V>> for ValuesRetained<'a, K, V> { ... }
     }
 
     /// A consuming iterator over the values of a `NSDictionary`.
@@ -580,14 +580,16 @@ impl<'a, K: Message + Eq + Hash, V: Message> Index<&'a K> for NSMutableDictionar
     }
 }
 
-impl<'a, K: Message + Eq + Hash, V: IsMutable> IndexMut<&'a K> for NSDictionary<K, V> {
+impl<'a, K: Message + Eq + Hash, V: Message + IsMutable> IndexMut<&'a K> for NSDictionary<K, V> {
     fn index_mut<'s>(&'s mut self, index: &'a K) -> &'s mut V {
         self.get_mut(index).unwrap()
     }
 }
 
 #[cfg(feature = "Foundation_NSMutableDictionary")]
-impl<'a, K: Message + Eq + Hash, V: IsMutable> IndexMut<&'a K> for NSMutableDictionary<K, V> {
+impl<'a, K: Message + Eq + Hash, V: Message + IsMutable> IndexMut<&'a K>
+    for NSMutableDictionary<K, V>
+{
     fn index_mut<'s>(&'s mut self, index: &'a K) -> &'s mut V {
         self.get_mut(index).unwrap()
     }
diff --git a/crates/icrate/src/additions/Foundation/enumerator.rs b/crates/icrate/src/additions/Foundation/enumerator.rs
index cec199dd9..6a3f09399 100644
--- a/crates/icrate/src/additions/Foundation/enumerator.rs
+++ b/crates/icrate/src/additions/Foundation/enumerator.rs
@@ -1,7 +1,5 @@
 //! Utilities for the `NSEnumerator` class.
 #![cfg(feature = "Foundation_NSEnumerator")]
-use objc2::mutability::{IsIdCloneable, IsMutable};
-
 use super::iter;
 use crate::common::*;
 use crate::Foundation::NSEnumerator;
diff --git a/crates/icrate/src/additions/Foundation/iter.rs b/crates/icrate/src/additions/Foundation/iter.rs
index 51fa429e1..59b317be0 100644
--- a/crates/icrate/src/additions/Foundation/iter.rs
+++ b/crates/icrate/src/additions/Foundation/iter.rs
@@ -428,7 +428,7 @@ impl<C: FastEnumerationHelper> IntoIter<C> {
         }
     }
 
-    pub(crate) fn new_mutable<T: IsMutable + ClassType<Super = C>>(collection: Id<T>) -> Self
+    pub(crate) fn new_mutable<T: ClassType<Super = C> + IsMutable>(collection: Id<T>) -> Self
     where
         C: IsIdCloneable,
     {
@@ -648,7 +648,7 @@ where
         }
     }
 
-    pub(crate) unsafe fn new_mutable<T: IsMutable + ClassType<Super = C>>(
+    pub(crate) unsafe fn new_mutable<T: ClassType<Super = C> + IsMutable>(
         collection: Id<T>,
         enumerator: Id<E>,
     ) -> Self
@@ -696,9 +696,9 @@ where
 #[doc(hidden)]
 macro_rules! __impl_iter {
     (
-        impl<$($lifetime:lifetime, )? $t1:ident: $bound1:ident $(, $t2:ident: $bound2:ident)?> Iterator<Item = $item:ty> for $for:ty { ... }
+        impl<$($lifetime:lifetime, )? $t1:ident: $bound1:ident $(+ $bound1_b:ident)? $(, $t2:ident: $bound2:ident $(+ $bound2_b:ident)?)?> Iterator<Item = $item:ty> for $for:ty { ... }
     ) => {
-        impl<$($lifetime, )? $t1: $bound1 $(, $t2: $bound2)?> Iterator for $for {
+        impl<$($lifetime, )? $t1: $bound1 $(+ $bound1_b)? $(, $t2: $bound2 $(+ $bound2_b)?)?> Iterator for $for {
             type Item = $item;
 
             #[inline]
@@ -743,14 +743,14 @@ macro_rules! __impl_into_iter {
     };
     (
         $(#[$m:meta])*
-        impl<T: IsMutable> IntoIterator for &mut $ty:ident<T> {
+        impl<T: Message + IsMutable> IntoIterator for &mut $ty:ident<T> {
             type IntoIter = $iter_mut:ident<'_, T>;
         }
 
         $($rest:tt)*
     ) => {
         $(#[$m])*
-        impl<'a, T: IsMutable> IntoIterator for &'a mut $ty<T> {
+        impl<'a, T: Message + IsMutable> IntoIterator for &'a mut $ty<T> {
             type Item = &'a mut T;
             type IntoIter = $iter_mut<'a, T>;
 
@@ -766,14 +766,14 @@ macro_rules! __impl_into_iter {
     };
     (
         $(#[$m:meta])*
-        impl<T: IsIdCloneable> IntoIterator for Id<$ty:ident<T>> {
+        impl<T: Message + IsIdCloneable> IntoIterator for Id<$ty:ident<T>> {
             type IntoIter = $into_iter:ident<T>;
         }
 
         $($rest:tt)*
     ) => {
         $(#[$m])*
-        impl<T: IsIdCloneable> objc2::rc::IdIntoIterator for $ty<T> {
+        impl<T: Message + IsIdCloneable> objc2::rc::IdIntoIterator for $ty<T> {
             type Item = Id<T>;
             type IntoIter = $into_iter<T>;
 
diff --git a/crates/icrate/src/additions/Foundation/set.rs b/crates/icrate/src/additions/Foundation/set.rs
index 0d338b8fb..39eed720a 100644
--- a/crates/icrate/src/additions/Foundation/set.rs
+++ b/crates/icrate/src/additions/Foundation/set.rs
@@ -501,7 +501,7 @@ __impl_iter! {
 pub struct IterRetained<'a, T: Message>(iter::IterRetained<'a, NSSet<T>>);
 
 __impl_iter! {
-    impl<'a, T: IsIdCloneable> Iterator<Item = Id<T>> for IterRetained<'a, T> { ... }
+    impl<'a, T: Message + IsIdCloneable> Iterator<Item = Id<T>> for IterRetained<'a, T> { ... }
 }
 
 /// A consuming iterator over the items of a `NSSet`.
@@ -522,7 +522,7 @@ __impl_into_iter! {
         type IntoIter = Iter<'_, T>;
     }
 
-    impl<T: IsIdCloneable> IntoIterator for Id<NSSet<T>> {
+    impl<T: Message + IsIdCloneable> IntoIterator for Id<NSSet<T>> {
         type IntoIter = IntoIter<T>;
     }
 
@@ -549,7 +549,7 @@ impl<T: Message + Eq + Hash + HasStableHash> Extend<Id<T>> for NSMutableSet<T> {
 }
 
 #[cfg(feature = "Foundation_NSMutableSet")]
-impl<'a, T: IsRetainable + Eq + Hash + HasStableHash> Extend<&'a T> for NSMutableSet<T> {
+impl<'a, T: Message + Eq + Hash + HasStableHash + IsRetainable> Extend<&'a T> for NSMutableSet<T> {
     fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
         iter.into_iter().for_each(move |item| {
             self.insert(item);
@@ -557,7 +557,9 @@ impl<'a, T: IsRetainable + Eq + Hash + HasStableHash> Extend<&'a T> for NSMutabl
     }
 }
 
-impl<'a, T: IsRetainable + Eq + Hash + HasStableHash + 'a> IdFromIterator<&'a T> for NSSet<T> {
+impl<'a, T: Message + Eq + Hash + HasStableHash + IsRetainable + 'a> IdFromIterator<&'a T>
+    for NSSet<T>
+{
     fn id_from_iter<I: IntoIterator<Item = &'a T>>(iter: I) -> Id<Self> {
         let vec = Vec::from_iter(iter);
         Self::from_slice(&vec)
@@ -572,7 +574,7 @@ impl<T: Message + Eq + Hash + HasStableHash> IdFromIterator<Id<T>> for NSSet<T>
 }
 
 #[cfg(feature = "Foundation_NSMutableSet")]
-impl<'a, T: IsRetainable + Eq + Hash + HasStableHash + 'a> IdFromIterator<&'a T>
+impl<'a, T: Message + Eq + Hash + HasStableHash + IsRetainable + 'a> IdFromIterator<&'a T>
     for NSMutableSet<T>
 {
     fn id_from_iter<I: IntoIterator<Item = &'a T>>(iter: I) -> Id<Self> {
diff --git a/crates/icrate/src/additions/Foundation/util.rs b/crates/icrate/src/additions/Foundation/util.rs
index 181dcabc1..e49456b14 100644
--- a/crates/icrate/src/additions/Foundation/util.rs
+++ b/crates/icrate/src/additions/Foundation/util.rs
@@ -68,7 +68,7 @@ pub(crate) fn id_ptr_cast_const<T: ?Sized>(objects: *const Id<T>) -> *mut NonNul
 #[inline]
 pub(crate) unsafe fn collection_retain_id<T>(obj: &T) -> Id<T>
 where
-    T: IsIdCloneable,
+    T: Message + IsIdCloneable,
 {
     // SAFETY: We're allowed to access `&Id<T>` from `&self` in collections,
     // and since `T: IsIdCloneable`, we can convert that to `Id<T>`.
diff --git a/crates/icrate/src/fixes/Foundation/copy.rs b/crates/icrate/src/fixes/Foundation/copy.rs
index 4f4f03b28..a0eed6d09 100644
--- a/crates/icrate/src/fixes/Foundation/copy.rs
+++ b/crates/icrate/src/fixes/Foundation/copy.rs
@@ -4,7 +4,7 @@ use crate::common::*;
 use crate::Foundation::{self, NSCopying, NSMutableCopying};
 
 #[cfg(feature = "Foundation_NSArray")]
-impl<T: IsIdCloneable> ToOwned for Foundation::NSArray<T> {
+impl<T: Message + IsIdCloneable> ToOwned for Foundation::NSArray<T> {
     type Owned = Id<Self>;
     fn to_owned(&self) -> Self::Owned {
         self.copy()
@@ -12,7 +12,7 @@ impl<T: IsIdCloneable> ToOwned for Foundation::NSArray<T> {
 }
 
 #[cfg(feature = "Foundation_NSMutableArray")]
-impl<T: IsIdCloneable> ToOwned for Foundation::NSMutableArray<T> {
+impl<T: Message + IsIdCloneable> ToOwned for Foundation::NSMutableArray<T> {
     type Owned = Id<Self>;
     fn to_owned(&self) -> Self::Owned {
         self.mutableCopy()
@@ -44,7 +44,7 @@ impl ToOwned for Foundation::NSException {
 }
 
 #[cfg(feature = "Foundation_NSSet")]
-impl<T: IsIdCloneable> ToOwned for Foundation::NSSet<T> {
+impl<T: Message + IsIdCloneable> ToOwned for Foundation::NSSet<T> {
     type Owned = Id<Self>;
     fn to_owned(&self) -> Self::Owned {
         self.copy()
@@ -52,7 +52,7 @@ impl<T: IsIdCloneable> ToOwned for Foundation::NSSet<T> {
 }
 
 #[cfg(feature = "Foundation_NSMutableSet")]
-impl<T: IsIdCloneable> ToOwned for Foundation::NSMutableSet<T> {
+impl<T: Message + IsIdCloneable> ToOwned for Foundation::NSMutableSet<T> {
     type Owned = Id<Self>;
     fn to_owned(&self) -> Self::Owned {
         self.mutableCopy()
diff --git a/crates/icrate/tests/array.rs b/crates/icrate/tests/array.rs
index 68e0ee019..b02cf0229 100644
--- a/crates/icrate/tests/array.rs
+++ b/crates/icrate/tests/array.rs
@@ -1,8 +1,10 @@
 #![cfg(feature = "Foundation_NSArray")]
 #![cfg(feature = "Foundation_NSNumber")]
 use icrate::Foundation::{NSArray, NSNumber, NSObject};
-use objc2::rc::Id;
-use objc2::rc::{__RcTestObject, __ThreadTestData};
+use objc2::mutability::IsRetainable;
+use objc2::rc::{Id, __RcTestObject, __ThreadTestData};
+use objc2::runtime::ProtocolObject;
+use objc2::{extern_protocol, ProtocolType};
 
 fn sample_array(len: usize) -> Id<NSArray<NSObject>> {
     let mut vec = Vec::with_capacity(len);
@@ -262,3 +264,22 @@ fn test_generic_ownership_traits() {
 
     assert_partialeq::<NSArray<NSObject>>();
 }
+
+#[test]
+fn test_trait_retainable() {
+    extern_protocol!(
+        #[allow(clippy::missing_safety_doc)]
+        unsafe trait TestProtocol: IsRetainable {}
+
+        unsafe impl ProtocolType for dyn TestProtocol {
+            const NAME: &'static str = "NSObject";
+        }
+    );
+
+    unsafe impl TestProtocol for NSNumber {}
+
+    let obj: Id<ProtocolObject<dyn TestProtocol>> = ProtocolObject::from_id(NSNumber::new_i32(42));
+    let _ = NSArray::from_slice(&[&*obj, &*obj]);
+    let _ = NSArray::from_id_slice(&[obj.clone(), obj.clone()]);
+    let _ = NSArray::from_vec(vec![obj.clone(), obj.clone()]);
+}
diff --git a/crates/icrate/tests/copying.rs b/crates/icrate/tests/copying.rs
new file mode 100644
index 000000000..5bd8c4161
--- /dev/null
+++ b/crates/icrate/tests/copying.rs
@@ -0,0 +1,18 @@
+#![cfg(feature = "Foundation")]
+#![cfg(feature = "Foundation_NSString")]
+use icrate::Foundation::{NSCopying, NSMutableCopying, NSString};
+use objc2::{rc::Id, runtime::ProtocolObject};
+
+#[test]
+fn copy() {
+    let obj = NSString::new();
+    let protocol_object: &ProtocolObject<dyn NSCopying> = ProtocolObject::from_ref(&*obj);
+    let _: Id<ProtocolObject<dyn NSCopying>> = protocol_object.copy();
+}
+
+#[test]
+fn copy_mutable() {
+    let obj = NSString::new();
+    let protocol_object: &ProtocolObject<dyn NSMutableCopying> = ProtocolObject::from_ref(&*obj);
+    let _: Id<ProtocolObject<dyn NSMutableCopying>> = protocol_object.mutableCopy();
+}
diff --git a/crates/objc2/CHANGELOG.md b/crates/objc2/CHANGELOG.md
index 2ed8ef40e..30b4e28db 100644
--- a/crates/objc2/CHANGELOG.md
+++ b/crates/objc2/CHANGELOG.md
@@ -18,6 +18,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 ### Changed
 * **BREAKING**: `AnyClass::verify_sel` now take more well-defined types
   `EncodeArguments` and  `EncodeReturn`.
+* **BREAKING**: Changed how the `mutability` traits work; these no longer have
+  `ClassType` as a super trait, allowing them to work for `ProtocolObject` as
+  well.
+
+  This effectively means you can now `copy` a `ProtocolObject<dyn NSCopying>`.
+* **BREAKING**: Allow implementing `DefaultId` for any type, not just those
+  who are `IsAllocableAnyThread`.
 
 ### Deprecated
 * Soft deprecated using `msg_send!` without a comma between arguments (i.e.
diff --git a/crates/objc2/src/declare/mod.rs b/crates/objc2/src/declare/mod.rs
index 52a7f3777..2accc2688 100644
--- a/crates/objc2/src/declare/mod.rs
+++ b/crates/objc2/src/declare/mod.rs
@@ -167,17 +167,17 @@ pub trait MethodImplementation: private::Sealed + Sized {
 }
 
 macro_rules! method_decl_impl {
-    (@<$($l:lifetime),*> T: $t_bound:ident, $r:ident, $f:ty, $($t:ident),*) => {
+    (@<$($l:lifetime),*> T: $t_bound:ident $(+ $t_bound2:ident)?, $r:ident, $f:ty, $($t:ident),*) => {
         impl<$($l,)* T, $r, $($t),*> private::Sealed for $f
         where
-            T: ?Sized + $t_bound,
+            T: ?Sized + $t_bound $(+ $t_bound2)?,
             $r: EncodeReturn,
             $($t: EncodeArgument,)*
         {}
 
         impl<$($l,)* T, $r, $($t),*> MethodImplementation for $f
         where
-            T: ?Sized + $t_bound,
+            T: ?Sized + $t_bound $(+ $t_bound2)?,
             $r: EncodeReturn,
             $($t: EncodeArgument,)*
         {
@@ -244,11 +244,11 @@ macro_rules! method_decl_impl {
     };
     (# $abi:literal; $($t:ident),*) => {
         method_decl_impl!(@<'a> T: Message, R, extern $abi fn(&'a T, Sel $(, $t)*) -> R, $($t),*);
-        method_decl_impl!(@<'a> T: IsMutable, R, extern $abi fn(&'a mut T, Sel $(, $t)*) -> R, $($t),*);
+        method_decl_impl!(@<'a> T: Message + IsMutable, R, extern $abi fn(&'a mut T, Sel $(, $t)*) -> R, $($t),*);
         method_decl_impl!(@<> T: Message, R, unsafe extern $abi fn(*const T, Sel $(, $t)*) -> R, $($t),*);
         method_decl_impl!(@<> T: Message, R, unsafe extern $abi fn(*mut T, Sel $(, $t)*) -> R, $($t),*);
         method_decl_impl!(@<'a> T: Message, R, unsafe extern $abi fn(&'a T, Sel $(, $t)*) -> R, $($t),*);
-        method_decl_impl!(@<'a> T: IsMutable, R, unsafe extern $abi fn(&'a mut T, Sel $(, $t)*) -> R, $($t),*);
+        method_decl_impl!(@<'a> T: Message + IsMutable, R, unsafe extern $abi fn(&'a mut T, Sel $(, $t)*) -> R, $($t),*);
 
         method_decl_impl!(@<'a> AnyObject, R, extern $abi fn(&'a mut AnyObject, Sel $(, $t)*) -> R, $($t),*);
         method_decl_impl!(@<'a> AnyObject, R, unsafe extern $abi fn(&'a mut AnyObject, Sel $(, $t)*) -> R, $($t),*);
diff --git a/crates/objc2/src/message/mod.rs b/crates/objc2/src/message/mod.rs
index 4e797c330..e2dbdf13b 100644
--- a/crates/objc2/src/message/mod.rs
+++ b/crates/objc2/src/message/mod.rs
@@ -448,8 +448,8 @@ unsafe impl<'a, T: ?Sized + Message> MessageReceiver for &'a Id<T> {
     }
 }
 
-impl<'a, T: ?Sized + IsMutable> private::Sealed for &'a mut Id<T> {}
-unsafe impl<'a, T: ?Sized + IsMutable> MessageReceiver for &'a mut Id<T> {
+impl<'a, T: ?Sized + Message + IsMutable> private::Sealed for &'a mut Id<T> {}
+unsafe impl<'a, T: ?Sized + Message + IsMutable> MessageReceiver for &'a mut Id<T> {
     type __Inner = T;
 
     #[inline]
diff --git a/crates/objc2/src/mutability.rs b/crates/objc2/src/mutability.rs
index 2e621fd0f..d619dfbd0 100644
--- a/crates/objc2/src/mutability.rs
+++ b/crates/objc2/src/mutability.rs
@@ -32,7 +32,8 @@
 //! bug.
 use core::marker::PhantomData;
 
-use crate::ClassType;
+use crate::runtime::ProtocolObject;
+use crate::{ClassType, Message, ProtocolType};
 
 mod private_mutability {
     pub trait Sealed {}
@@ -259,6 +260,13 @@ pub struct MainThreadOnly {
     inner: Never,
 }
 
+mod private_traits {
+    pub trait Sealed {}
+}
+
+impl<T: ?Sized + ClassType> private_traits::Sealed for T {}
+impl<P: ?Sized + ProtocolType> private_traits::Sealed for ProtocolObject<P> {}
+
 /// Marker trait for classes where [`Id::clone`] is safe.
 ///
 /// Since the `Foundation` collection types (`NSArray<T>`,
@@ -274,7 +282,13 @@ pub struct MainThreadOnly {
 ///
 /// [`Id`]: crate::rc::Id
 /// [`Id::clone`]: crate::rc::Id#impl-Clone-for-Id<T>
-pub trait IsIdCloneable: ClassType {}
+///
+///
+/// # Safety
+///
+/// This is a sealed trait, and should not need to be implemented. Open an
+/// issue if you know a use-case where this restrition should be lifted!
+pub unsafe trait IsIdCloneable: private_traits::Sealed {}
 
 trait MutabilityIsIdCloneable: Mutability {}
 impl MutabilityIsIdCloneable for Root {}
@@ -283,7 +297,8 @@ impl<MS: ?Sized> MutabilityIsIdCloneable for ImmutableWithMutableSubclass<MS> {}
 impl MutabilityIsIdCloneable for InteriorMutable {}
 impl MutabilityIsIdCloneable for MainThreadOnly {}
 
-impl<T: ?Sized + ClassType> IsIdCloneable for T where T::Mutability: MutabilityIsIdCloneable {}
+unsafe impl<T: ?Sized + ClassType> IsIdCloneable for T where T::Mutability: MutabilityIsIdCloneable {}
+unsafe impl<P: ?Sized + ProtocolType + IsIdCloneable> IsIdCloneable for ProtocolObject<P> {}
 
 /// Marker trait for classes where the `retain` selector is always safe.
 ///
@@ -296,15 +311,25 @@ impl<T: ?Sized + ClassType> IsIdCloneable for T where T::Mutability: MutabilityI
 /// - [`InteriorMutable`].
 /// - [`MainThreadOnly`].
 ///
+/// This trait inherits [`IsIdCloneable`], so if a function is bound by this,
+/// functionality given with that trait is available.
+///
 /// [`Id::clone`]: crate::rc::Id#impl-Clone-for-Id<T>
-pub trait IsRetainable: IsIdCloneable {}
+///
+///
+/// # Safety
+///
+/// This is a sealed trait, and should not need to be implemented. Open an
+/// issue if you know a use-case where this restrition should be lifted!
+pub unsafe trait IsRetainable: IsIdCloneable {}
 
 trait MutabilityIsRetainable: MutabilityIsIdCloneable {}
 impl MutabilityIsRetainable for Immutable {}
 impl MutabilityIsRetainable for InteriorMutable {}
 impl MutabilityIsRetainable for MainThreadOnly {}
 
-impl<T: ?Sized + ClassType> IsRetainable for T where T::Mutability: MutabilityIsRetainable {}
+unsafe impl<T: ?Sized + ClassType> IsRetainable for T where T::Mutability: MutabilityIsRetainable {}
+unsafe impl<P: ?Sized + ProtocolType + IsRetainable> IsRetainable for ProtocolObject<P> {}
 
 /// Marker trait for classes that can be allocated from any thread.
 ///
@@ -315,7 +340,13 @@ impl<T: ?Sized + ClassType> IsRetainable for T where T::Mutability: MutabilityIs
 /// - [`ImmutableWithMutableSubclass`].
 /// - [`MutableWithImmutableSuperclass`].
 /// - [`InteriorMutable`].
-pub trait IsAllocableAnyThread: ClassType {}
+///
+///
+/// # Safety
+///
+/// This is a sealed trait, and should not need to be implemented. Open an
+/// issue if you know a use-case where this restrition should be lifted!
+pub unsafe trait IsAllocableAnyThread: private_traits::Sealed {}
 
 trait MutabilityIsAllocableAnyThread: Mutability {}
 impl MutabilityIsAllocableAnyThread for Root {}
@@ -325,10 +356,14 @@ impl<MS: ?Sized> MutabilityIsAllocableAnyThread for ImmutableWithMutableSubclass
 impl<IS: ?Sized> MutabilityIsAllocableAnyThread for MutableWithImmutableSuperclass<IS> {}
 impl MutabilityIsAllocableAnyThread for InteriorMutable {}
 
-impl<T: ?Sized + ClassType> IsAllocableAnyThread for T where
+unsafe impl<T: ?Sized + ClassType> IsAllocableAnyThread for T where
     T::Mutability: MutabilityIsAllocableAnyThread
 {
 }
+unsafe impl<P: ?Sized + ProtocolType + IsAllocableAnyThread> IsAllocableAnyThread
+    for ProtocolObject<P>
+{
+}
 
 /// Marker trait for classes that are only mutable through `&mut`.
 ///
@@ -339,13 +374,20 @@ impl<T: ?Sized + ClassType> IsAllocableAnyThread for T where
 /// Notably, [`InteriorMutable`] does not implement this (though it is
 /// technically mutable), since it is allowed to mutate through shared
 /// references.
-pub trait IsMutable: ClassType {}
+///
+///
+/// # Safety
+///
+/// This is a sealed trait, and should not need to be implemented. Open an
+/// issue if you know a use-case where this restrition should be lifted!
+pub unsafe trait IsMutable: private_traits::Sealed {}
 
 trait MutabilityIsMutable: Mutability {}
 impl MutabilityIsMutable for Mutable {}
 impl<IS: ?Sized> MutabilityIsMutable for MutableWithImmutableSuperclass<IS> {}
 
-impl<T: ?Sized + ClassType> IsMutable for T where T::Mutability: MutabilityIsMutable {}
+unsafe impl<T: ?Sized + ClassType> IsMutable for T where T::Mutability: MutabilityIsMutable {}
+unsafe impl<P: ?Sized + ProtocolType + IsMutable> IsMutable for ProtocolObject<P> {}
 
 /// Marker trait for classes that are only available on the main thread.
 ///
@@ -354,15 +396,23 @@ impl<T: ?Sized + ClassType> IsMutable for T where T::Mutability: MutabilityIsMut
 ///
 /// Since `MainThreadOnly` types must be `!Send` and `!Sync`, if you hold a
 /// type that implements this trait, then you're guaranteed to be on the main
-/// thread.
-//
-// Note: MainThreadMarker::from relies on this.
-pub trait IsMainThreadOnly: ClassType {}
+/// thread (and can get a `MainThreadMarker` using `MainThreadMarker::from`).
+///
+///
+/// # Safety
+///
+/// This is a sealed trait, and should not need to be implemented. Open an
+/// issue if you know a use-case where this restrition should be lifted!
+pub unsafe trait IsMainThreadOnly: private_traits::Sealed {}
 
 trait MutabilityIsMainThreadOnly: Mutability {}
 impl MutabilityIsMainThreadOnly for MainThreadOnly {}
 
-impl<T: ?Sized + ClassType> IsMainThreadOnly for T where T::Mutability: MutabilityIsMainThreadOnly {}
+unsafe impl<T: ?Sized + ClassType> IsMainThreadOnly for T where
+    T::Mutability: MutabilityIsMainThreadOnly
+{
+}
+unsafe impl<P: ?Sized + ProtocolType + IsMainThreadOnly> IsMainThreadOnly for ProtocolObject<P> {}
 
 /// Marker trait for classes whose `hash` and `isEqual:` methods are stable.
 ///
@@ -379,9 +429,15 @@ impl<T: ?Sized + ClassType> IsMainThreadOnly for T where T::Mutability: Mutabili
 /// and `isEqual:` methods are required to not use external sources like
 /// thread locals or randomness to determine their result, we can guarantee
 /// that the hash is stable for these types.
+///
+///
+/// # Safety
+///
+/// This is a sealed trait, and should not need to be implemented. Open an
+/// issue if you know a use-case where this restrition should be lifted!
 //
 // TODO: Exclude generic types like `NSArray<NSView>` from this!
-pub trait HasStableHash: ClassType {}
+pub unsafe trait HasStableHash: private_traits::Sealed {}
 
 trait MutabilityHashIsStable: Mutability {}
 impl MutabilityHashIsStable for Immutable {}
@@ -389,37 +445,57 @@ impl MutabilityHashIsStable for Mutable {}
 impl<MS: ?Sized> MutabilityHashIsStable for ImmutableWithMutableSubclass<MS> {}
 impl<IS: ?Sized> MutabilityHashIsStable for MutableWithImmutableSuperclass<IS> {}
 
-impl<T: ?Sized + ClassType> HasStableHash for T where T::Mutability: MutabilityHashIsStable {}
+unsafe impl<T: ?Sized + ClassType> HasStableHash for T where T::Mutability: MutabilityHashIsStable {}
+unsafe impl<P: ?Sized + ProtocolType + HasStableHash> HasStableHash for ProtocolObject<P> {}
 
 /// Retrieve the immutable/mutable counterpart class, and fall back to `Self`
 /// if not applicable.
 ///
-/// This is mostly used for describing the return type of `NSCopying` and
+/// This is used for describing the return type of `NSCopying` and
 /// `NSMutableCopying`, since due to Rust trait limitations, those two can't
-/// have associated types themselves (at least not since we want to use them
-/// in `ProtocolObject<dyn NSCopying>`).
-pub trait CounterpartOrSelf: ClassType {
+/// have associated types themselves (since we want to use them in
+/// `ProtocolObject<dyn NSCopying>`).
+///
+///
+/// # Usage notes
+///
+/// You may not rely on this being implemented entirely correctly for protocol
+/// objects, since we have less type-information available there.
+///
+/// In particular, the immutable counterpart of a mutable object converted to
+/// `ProtocolObject<dyn AProtocol>` may not itself implement the protocol, and
+/// invalidly assuming it does is unsound.
+///
+/// All of this is to say: Do not use this trait in isolation, either require
+/// `NSCopying` or `ClassType` along with it.
+///
+///
+/// # Safety
+///
+/// This is a sealed trait, and should not need to be implemented. Open an
+/// issue if you know a use-case where this restrition should be lifted!
+pub unsafe trait CounterpartOrSelf: Message + private_traits::Sealed {
     /// The immutable counterpart of the type, or `Self` if the type has no
     /// immutable counterpart.
     ///
     /// The implementation for `NSString` has itself (`NSString`) here, while
     /// `NSMutableString` instead has `NSString`.
-    type Immutable: ?Sized + ClassType;
+    type Immutable: ?Sized + Message;
 
     /// The mutable counterpart of the type, or `Self` if the type has no
     /// mutable counterpart.
     ///
     /// The implementation for `NSString` has `NSMutableString` here, while
     /// `NSMutableString` has itself (`NSMutableString`).
-    type Mutable: ?Sized + ClassType;
+    type Mutable: ?Sized + Message;
 }
 
 mod private_counterpart {
     use super::*;
 
     pub trait MutabilityCounterpartOrSelf<T: ?Sized>: Mutability {
-        type Immutable: ?Sized + ClassType;
-        type Mutable: ?Sized + ClassType;
+        type Immutable: ?Sized + Message;
+        type Mutable: ?Sized + Message;
     }
     impl<T: ClassType<Mutability = Root>> MutabilityCounterpartOrSelf<T> for Root {
         type Immutable = T;
@@ -461,7 +537,7 @@ mod private_counterpart {
     }
 }
 
-impl<T: ?Sized + ClassType> CounterpartOrSelf for T
+unsafe impl<T: ?Sized + ClassType> CounterpartOrSelf for T
 where
     T::Mutability: private_counterpart::MutabilityCounterpartOrSelf<T>,
 {
@@ -470,6 +546,27 @@ where
     type Mutable = <T::Mutability as private_counterpart::MutabilityCounterpartOrSelf<T>>::Mutable;
 }
 
+unsafe impl<P: ?Sized + ProtocolType> CounterpartOrSelf for ProtocolObject<P> {
+    // SAFETY: The only place where this would differ from `Self` is for
+    // classes with `MutableWithImmutableSuperclass<IS>`.
+    //
+    // Superclasses are not in general required to implement the same traits
+    // as their subclasses, but we're not dealing with normal classes, we're
+    // dealing with with immutable/mutable class counterparts!
+    //
+    // We could probably get away with requiring that mutable classes
+    // only implement the same protocols as their immutable counterparts, but
+    // for now we relax the requirements of `CounterpartOrSelf`.
+    type Immutable = Self;
+    // SAFETY: The only place where this would differ from `Self` is for
+    // classes with `ImmutableWithMutableSubclass<MS>`.
+    //
+    // But subclasses are required to always implement the same traits as
+    // their superclasses, so a mutable subclass is required to implement the
+    // same traits too.
+    type Mutable = Self;
+}
+
 #[cfg(test)]
 mod tests {
     use crate::runtime::NSObject;
diff --git a/crates/objc2/src/rc/id.rs b/crates/objc2/src/rc/id.rs
index a428982a6..c35af57c2 100644
--- a/crates/objc2/src/rc/id.rs
+++ b/crates/objc2/src/rc/id.rs
@@ -621,7 +621,7 @@ where
 }
 
 // TODO: Add ?Sized bound
-impl<T: IsIdCloneable> Clone for Id<T> {
+impl<T: Message + IsIdCloneable> Clone for Id<T> {
     /// Makes a clone of the shared object.
     ///
     /// This increases the object's reference count.
@@ -815,12 +815,12 @@ where
 //
 // See https://doc.rust-lang.org/1.54.0/src/alloc/boxed.rs.html#1652-1675
 // and the `Arc` implementation.
-impl<T: ?Sized + Message> Unpin for Id<T> {}
+impl<T: ?Sized> Unpin for Id<T> {}
 
-impl<T: ?Sized + Message + RefUnwindSafe> RefUnwindSafe for Id<T> {}
+impl<T: ?Sized + RefUnwindSafe> RefUnwindSafe for Id<T> {}
 
 // TODO: Relax this bound
-impl<T: ?Sized + Message + RefUnwindSafe + UnwindSafe> UnwindSafe for Id<T> {}
+impl<T: ?Sized + RefUnwindSafe + UnwindSafe> UnwindSafe for Id<T> {}
 
 #[cfg(test)]
 mod tests {
diff --git a/crates/objc2/src/rc/id_traits.rs b/crates/objc2/src/rc/id_traits.rs
index 38db37acc..4ab267273 100644
--- a/crates/objc2/src/rc/id_traits.rs
+++ b/crates/objc2/src/rc/id_traits.rs
@@ -1,11 +1,10 @@
 //! Helper traits for Id.
 
 use super::Id;
-use crate::mutability::{IsAllocableAnyThread, IsMutable};
+use crate::mutability::IsMutable;
 
 /// Helper trait to implement [`Default`] on [`Id`].
-// TODO: Maybe make this `unsafe` and provide a default implementation?
-pub trait DefaultId: IsAllocableAnyThread {
+pub trait DefaultId {
     /// The default [`Id`] for a type.
     ///
     /// On most objects the implementation would be sending a message to the
diff --git a/crates/objc2/src/rc/weak_id.rs b/crates/objc2/src/rc/weak_id.rs
index ead36e0bd..253e3112d 100644
--- a/crates/objc2/src/rc/weak_id.rs
+++ b/crates/objc2/src/rc/weak_id.rs
@@ -116,7 +116,7 @@ impl<T: ?Sized> Drop for WeakId<T> {
 }
 
 // TODO: Add ?Sized
-impl<T: IsRetainable> Clone for WeakId<T> {
+impl<T: Message + IsRetainable> Clone for WeakId<T> {
     /// Make a clone of the weak pointer that points to the same object.
     #[doc(alias = "objc_copyWeak")]
     fn clone(&self) -> Self {
@@ -130,7 +130,7 @@ impl<T: IsRetainable> Clone for WeakId<T> {
 }
 
 // TODO: Add ?Sized
-impl<T: IsRetainable> Default for WeakId<T> {
+impl<T: Message + IsRetainable> Default for WeakId<T> {
     /// Constructs a new weak pointer that doesn't reference any object.
     ///
     /// Calling [`Self::load`] on the return value always gives [`None`].
@@ -151,35 +151,35 @@ impl<T: ?Sized> fmt::Debug for WeakId<T> {
 }
 
 // Same as `std::sync::Weak<T>`.
-unsafe impl<T: Sync + Send + ?Sized + IsIdCloneable> Sync for WeakId<T> {}
+unsafe impl<T: Sync + Send + ?Sized + Message + IsIdCloneable> Sync for WeakId<T> {}
 
 // Same as `std::sync::Weak<T>`.
-unsafe impl<T: Sync + Send + ?Sized + IsIdCloneable> Send for WeakId<T> {}
+unsafe impl<T: Sync + Send + ?Sized + Message + IsIdCloneable> Send for WeakId<T> {}
 
 // Same as `std::sync::Weak<T>`.
 impl<T: ?Sized + Message> Unpin for WeakId<T> {}
 
 // Same as `std::sync::Weak<T>`.
-impl<T: RefUnwindSafe + ?Sized + IsIdCloneable> RefUnwindSafe for WeakId<T> {}
+impl<T: RefUnwindSafe + ?Sized + Message + IsIdCloneable> RefUnwindSafe for WeakId<T> {}
 
 // Same as `std::sync::Weak<T>`.
-impl<T: RefUnwindSafe + ?Sized + IsIdCloneable> UnwindSafe for WeakId<T> {}
+impl<T: RefUnwindSafe + ?Sized + Message + IsIdCloneable> UnwindSafe for WeakId<T> {}
 
-impl<T: IsRetainable> From<&T> for WeakId<T> {
+impl<T: Message + IsRetainable> From<&T> for WeakId<T> {
     #[inline]
     fn from(obj: &T) -> Self {
         WeakId::new(obj)
     }
 }
 
-impl<T: IsIdCloneable> From<&Id<T>> for WeakId<T> {
+impl<T: Message + IsIdCloneable> From<&Id<T>> for WeakId<T> {
     #[inline]
     fn from(obj: &Id<T>) -> Self {
         WeakId::from_id(obj)
     }
 }
 
-impl<T: IsIdCloneable> From<Id<T>> for WeakId<T> {
+impl<T: Message + IsIdCloneable> From<Id<T>> for WeakId<T> {
     #[inline]
     fn from(obj: Id<T>) -> Self {
         WeakId::from_id(&obj)
diff --git a/crates/test-ui/ui/mutability_traits_unimplementable.rs b/crates/test-ui/ui/mutability_traits_unimplementable.rs
index 8192b1091..96fe63505 100644
--- a/crates/test-ui/ui/mutability_traits_unimplementable.rs
+++ b/crates/test-ui/ui/mutability_traits_unimplementable.rs
@@ -1,6 +1,4 @@
-//! Check that the `mutability` traits are not implementable manually.
-//!
-//! Since they are not `unsafe`, it would be a soundness hole if you could.
+//! Check that `mutability` traits are not implementable manually.
 use objc2::runtime::NSObject;
 use objc2::{declare_class, mutability, ClassType};
 
@@ -14,6 +12,6 @@ declare_class!(
     }
 );
 
-impl mutability::IsMutable for CustomObject {}
+unsafe impl mutability::IsMutable for CustomObject {}
 
 fn main() {}
diff --git a/crates/test-ui/ui/mutability_traits_unimplementable.stderr b/crates/test-ui/ui/mutability_traits_unimplementable.stderr
index a64dc8752..8f857db41 100644
--- a/crates/test-ui/ui/mutability_traits_unimplementable.stderr
+++ b/crates/test-ui/ui/mutability_traits_unimplementable.stderr
@@ -1,8 +1,8 @@
 error[E0119]: conflicting implementations of trait `IsMutable` for type `CustomObject`
  --> ui/mutability_traits_unimplementable.rs
   |
-  | impl mutability::IsMutable for CustomObject {}
-  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  | unsafe impl mutability::IsMutable for CustomObject {}
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: conflicting implementation in crate `objc2`:
           - impl<T> IsMutable for T
diff --git a/crates/test-ui/ui/mutability_traits_unimplementable2.rs b/crates/test-ui/ui/mutability_traits_unimplementable2.rs
new file mode 100644
index 000000000..d75828407
--- /dev/null
+++ b/crates/test-ui/ui/mutability_traits_unimplementable2.rs
@@ -0,0 +1,8 @@
+//! Check that `mutability` traits are not implementable manually.
+use objc2::mutability;
+
+struct CustomStruct;
+
+unsafe impl mutability::IsMutable for CustomStruct {}
+
+fn main() {}
diff --git a/crates/test-ui/ui/mutability_traits_unimplementable2.stderr b/crates/test-ui/ui/mutability_traits_unimplementable2.stderr
new file mode 100644
index 000000000..a73104fe5
--- /dev/null
+++ b/crates/test-ui/ui/mutability_traits_unimplementable2.stderr
@@ -0,0 +1,17 @@
+error[E0277]: the trait bound `CustomStruct: ClassType` is not satisfied
+ --> ui/mutability_traits_unimplementable2.rs
+  |
+  | unsafe impl mutability::IsMutable for CustomStruct {}
+  |                                       ^^^^^^^^^^^^ the trait `ClassType` is not implemented for `CustomStruct`
+  |
+  = help: the following other types implement trait `ClassType`:
+            __RcTestObject
+            NSObject
+            __NSProxy
+  = note: required for `CustomStruct` to implement `mutability::private_traits::Sealed`
+note: required by a bound in `IsMutable`
+ --> $WORKSPACE/crates/objc2/src/mutability.rs
+  |
+  | pub unsafe trait IsMutable: private_traits::Sealed {}
+  |                             ^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `IsMutable`
+  = note: `IsMutable` is a "sealed trait", because to implement it you also need to implement `objc2::mutability::private_traits::Sealed`, which is not accessible; this is usually done to force you to use one of the provided types that already implement it
diff --git a/crates/test-ui/ui/mutable_id_not_clone_not_retain.stderr b/crates/test-ui/ui/mutable_id_not_clone_not_retain.stderr
index 0ab547688..0a3019975 100644
--- a/crates/test-ui/ui/mutable_id_not_clone_not_retain.stderr
+++ b/crates/test-ui/ui/mutable_id_not_clone_not_retain.stderr
@@ -24,8 +24,8 @@ error[E0599]: the method `clone` exists for struct `Id<NSMutableObject>`, but it
 note: the trait `IsIdCloneable` must be implemented
  --> $WORKSPACE/crates/objc2/src/mutability.rs
   |
-  | pub trait IsIdCloneable: ClassType {}
-  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  | pub unsafe trait IsIdCloneable: private_traits::Sealed {}
+  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0277]: the trait bound `Mutable: mutability::MutabilityIsRetainable` is not satisfied
  --> ui/mutable_id_not_clone_not_retain.rs