diff --git a/src/class/basic.rs b/src/class/basic.rs
index d95053bf828..cd7bc713b8b 100644
--- a/src/class/basic.rs
+++ b/src/class/basic.rs
@@ -9,8 +9,9 @@
 //! [typeobj docs](https://docs.python.org/3/c-api/typeobj.html)
 
 use crate::callback::{HashCallbackOutput, IntoPyCallbackOutput};
+use crate::pyclass::maybe_push_slot;
 use crate::{exceptions, ffi, FromPyObject, PyAny, PyCell, PyClass, PyErr, PyObject, PyResult};
-use std::os::raw::c_int;
+use std::os::raw::{c_int, c_void};
 
 /// Operators for the __richcmp__ method
 #[derive(Debug)]
@@ -147,13 +148,38 @@ pub struct PyObjectMethods {
 
 #[doc(hidden)]
 impl PyObjectMethods {
-    pub(crate) fn update_typeobj(&self, type_object: &mut ffi::PyTypeObject) {
-        type_object.tp_str = self.tp_str;
-        type_object.tp_repr = self.tp_repr;
-        type_object.tp_hash = self.tp_hash;
-        type_object.tp_getattro = self.tp_getattro;
-        type_object.tp_richcompare = self.tp_richcompare;
-        type_object.tp_setattro = self.tp_setattro;
+    pub(crate) fn update_slots(&self, slots: &mut Vec<ffi::PyType_Slot>) {
+        maybe_push_slot(slots, ffi::Py_tp_str, self.tp_str.map(|v| v as *mut c_void));
+        maybe_push_slot(
+            slots,
+            ffi::Py_tp_repr,
+            self.tp_repr.map(|v| v as *mut c_void),
+        );
+        maybe_push_slot(
+            slots,
+            ffi::Py_tp_hash,
+            self.tp_hash.map(|v| v as *mut c_void),
+        );
+        maybe_push_slot(
+            slots,
+            ffi::Py_tp_getattro,
+            self.tp_getattro.map(|v| v as *mut c_void),
+        );
+        maybe_push_slot(
+            slots,
+            ffi::Py_tp_richcompare,
+            self.tp_richcompare.map(|v| v as *mut c_void),
+        );
+        maybe_push_slot(
+            slots,
+            ffi::Py_tp_setattro,
+            self.tp_setattro.map(|v| v as *mut c_void),
+        );
+        maybe_push_slot(
+            slots,
+            ffi::Py_nb_bool,
+            self.nb_bool.map(|v| v as *mut c_void),
+        );
     }
     // Set functions used by `#[pyproto]`.
     pub fn set_str<T>(&mut self)
diff --git a/src/pyclass.rs b/src/pyclass.rs
index a4c10876493..91b8e5f1cf2 100644
--- a/src/pyclass.rs
+++ b/src/pyclass.rs
@@ -9,7 +9,7 @@ use crate::types::PyAny;
 use crate::{class, ffi, PyCell, PyErr, PyNativeType, PyResult, PyTypeInfo, Python};
 use std::ffi::CString;
 use std::marker::PhantomData;
-use std::os::raw::c_void;
+use std::os::raw::{c_int, c_void};
 use std::{ptr, thread};
 
 #[inline]
@@ -107,98 +107,230 @@ pub trait PyClass:
     type BaseNativeType: PyTypeInfo + PyNativeType;
 }
 
-#[cfg(not(Py_LIMITED_API))]
-pub(crate) fn initialize_type_object<T>(
+pub(crate) fn maybe_push_slot(
+    slots: &mut Vec<ffi::PyType_Slot>,
+    slot: c_int,
+    val: Option<*mut c_void>,
+) {
+    if let Some(v) = val {
+        slots.push(ffi::PyType_Slot { slot, pfunc: v });
+    }
+}
+
+fn push_numbers_slots(slots: &mut Vec<ffi::PyType_Slot>, numbers: &ffi::PyNumberMethods) {
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_add,
+        numbers.nb_add.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_subtract,
+        numbers.nb_subtract.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_multiply,
+        numbers.nb_multiply.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_remainder,
+        numbers.nb_remainder.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_divmod,
+        numbers.nb_divmod.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_power,
+        numbers.nb_power.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_negative,
+        numbers.nb_negative.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_positive,
+        numbers.nb_positive.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_absolute,
+        numbers.nb_absolute.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_bool,
+        numbers.nb_bool.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_invert,
+        numbers.nb_invert.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_lshift,
+        numbers.nb_lshift.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_rshift,
+        numbers.nb_rshift.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_and,
+        numbers.nb_and.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_xor,
+        numbers.nb_xor.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_or,
+        numbers.nb_or.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_int,
+        numbers.nb_int.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_float,
+        numbers.nb_float.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_inplace_add,
+        numbers.nb_inplace_add.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_inplace_subtract,
+        numbers.nb_inplace_subtract.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_inplace_multiply,
+        numbers.nb_inplace_multiply.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_inplace_remainder,
+        numbers.nb_inplace_remainder.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_inplace_power,
+        numbers.nb_inplace_power.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_inplace_lshift,
+        numbers.nb_inplace_lshift.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_inplace_rshift,
+        numbers.nb_inplace_rshift.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_inplace_and,
+        numbers.nb_inplace_and.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_inplace_xor,
+        numbers.nb_inplace_xor.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_inplace_or,
+        numbers.nb_inplace_or.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_floor_divide,
+        numbers.nb_floor_divide.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_true_divide,
+        numbers.nb_true_divide.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_inplace_floor_divide,
+        numbers.nb_inplace_floor_divide.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_inplace_true_divide,
+        numbers.nb_inplace_true_divide.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_index,
+        numbers.nb_index.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_matrix_multiply,
+        numbers.nb_matrix_multiply.map(|v| v as *mut c_void),
+    );
+    maybe_push_slot(
+        slots,
+        ffi::Py_nb_inplace_matrix_multiply,
+        numbers.nb_inplace_matrix_multiply.map(|v| v as *mut c_void),
+    );
+}
+
+pub(crate) fn create_type_object<T>(
     py: Python,
     module_name: Option<&str>,
-    type_object: &mut ffi::PyTypeObject,
-) -> PyResult<()>
+) -> PyResult<*mut ffi::PyTypeObject>
 where
     T: PyClass,
 {
-    type_object.tp_doc = match T::DESCRIPTION {
-        // PyPy will segfault if passed only a nul terminator as `tp_doc`, ptr::null() is OK though.
-        "\0" => ptr::null(),
-        s if s.as_bytes().ends_with(b"\0") => s.as_ptr() as _,
-        // If the description is not null-terminated, create CString and leak it
-        s => CString::new(s)?.into_raw(),
-    };
-
-    type_object.tp_base = T::BaseType::type_object_raw(py);
+    let mut slots = vec![];
 
-    type_object.tp_name = match module_name {
-        Some(module_name) => CString::new(format!("{}.{}", module_name, T::NAME))?.into_raw(),
-        None => CString::new(T::NAME)?.into_raw(),
+    let doc = match T::DESCRIPTION {
+        "\0" => None,
+        s if s.as_bytes().ends_with(b"\0") => Some(s.as_ptr() as _),
+        // If the description is not null-terminated, create CString and leak it
+        s => Some(CString::new(s)?.into_raw() as _),
     };
+    maybe_push_slot(&mut slots, ffi::Py_tp_doc, doc);
 
-    // dealloc
-    type_object.tp_dealloc = tp_dealloc::<T>();
-
-    // type size
-    type_object.tp_basicsize = std::mem::size_of::<T::Layout>() as ffi::Py_ssize_t;
-
-    // __dict__ support
-    if let Some(dict_offset) = PyCell::<T>::dict_offset() {
-        type_object.tp_dictoffset = dict_offset as ffi::Py_ssize_t;
-    }
-
-    // weakref support
-    if let Some(weakref_offset) = PyCell::<T>::weakref_offset() {
-        type_object.tp_weaklistoffset = weakref_offset as ffi::Py_ssize_t;
-    }
-
-    // GC support
-    if let Some(gc) = T::gc_methods() {
-        unsafe { gc.as_ref() }.update_typeobj(type_object);
-    }
-
-    // descriptor protocol
-    if let Some(descr) = T::descr_methods() {
-        unsafe { descr.as_ref() }.update_typeobj(type_object);
-    }
-
-    // iterator methods
-    if let Some(iter) = T::iter_methods() {
-        unsafe { iter.as_ref() }.update_typeobj(type_object);
-    }
-
-    // nb_bool is a part of PyObjectProtocol, but should be placed under tp_as_number
-    let mut nb_bool = None;
-    // basic methods
-    if let Some(basic) = T::basic_methods() {
-        unsafe { basic.as_ref() }.update_typeobj(type_object);
-        nb_bool = unsafe { basic.as_ref() }.nb_bool;
-    }
-
-    // number methods
-    type_object.tp_as_number = T::number_methods()
-        .map(|mut p| {
-            unsafe { p.as_mut() }.nb_bool = nb_bool;
-            p.as_ptr()
-        })
-        .unwrap_or_else(|| nb_bool.map_or_else(ptr::null_mut, ffi::PyNumberMethods::from_nb_bool));
-    // mapping methods
-    type_object.tp_as_mapping = T::mapping_methods().map_or_else(ptr::null_mut, |p| p.as_ptr());
-    // sequence methods
-    type_object.tp_as_sequence = T::sequence_methods().map_or_else(ptr::null_mut, |p| p.as_ptr());
-    // async methods
-    type_object.tp_as_async = T::async_methods().map_or_else(ptr::null_mut, |p| p.as_ptr());
-    // buffer protocol
-    type_object.tp_as_buffer = T::buffer_methods().map_or_else(ptr::null_mut, |p| p.as_ptr());
+    maybe_push_slot(
+        &mut slots,
+        ffi::Py_tp_dealloc,
+        tp_dealloc::<T>().map(|v| v as *mut c_void),
+    );
 
     let (new, call, mut methods) = py_class_method_defs::<T>();
-
+    maybe_push_slot(&mut slots, ffi::Py_tp_new, new.map(|v| v as *mut c_void));
+    maybe_push_slot(&mut slots, ffi::Py_tp_call, call.map(|v| v as *mut c_void));
     // normal methods
     if !methods.is_empty() {
         methods.push(ffi::PyMethodDef_INIT);
-        type_object.tp_methods = Box::into_raw(methods.into_boxed_slice()) as _;
+        maybe_push_slot(
+            &mut slots,
+            ffi::Py_tp_methods,
+            Some(Box::into_raw(methods.into_boxed_slice()) as *mut c_void),
+        );
     }
 
-    // __new__ method
-    type_object.tp_new = new;
-    // __call__ method
-    type_object.tp_call = call;
-
     // properties
     let mut props = py_class_properties::<T>();
 
@@ -207,20 +339,87 @@ where
     }
     if !props.is_empty() {
         props.push(ffi::PyGetSetDef_INIT);
-        type_object.tp_getset = Box::into_raw(props.into_boxed_slice()) as _;
+        maybe_push_slot(
+            &mut slots,
+            ffi::Py_tp_getset,
+            Some(Box::into_raw(props.into_boxed_slice()) as *mut c_void),
+        );
     }
 
-    // set type flags
-    py_class_flags::<T>(type_object);
+    if let Some(basic) = T::basic_methods() {
+        unsafe { basic.as_ref() }.update_slots(&mut slots);
+    }
 
-    // register type object
-    unsafe {
-        if ffi::PyType_Ready(type_object) == 0 {
-            Ok(())
-        } else {
-            PyErr::fetch(py).into()
+    if let Some(number) = T::number_methods() {
+        push_numbers_slots(&mut slots, unsafe { number.as_ref() })
+    }
+
+    slots.push(ffi::PyType_Slot {
+        slot: 0,
+        pfunc: ptr::null_mut(),
+    });
+    let mut spec = ffi::PyType_Spec {
+        name: match module_name {
+            Some(module_name) => CString::new(format!("{}.{}", module_name, T::NAME))?.into_raw(),
+            None => CString::new(T::NAME)?.into_raw(),
+        },
+        basicsize: std::mem::size_of::<T::Layout>() as c_int,
+        itemsize: 0,
+        flags: 0, // XXXX: FILL ME IN PROPERLY,
+        slots: slots.as_mut_slice().as_mut_ptr(),
+    };
+
+    let type_object = unsafe { ffi::PyType_FromSpec(&mut spec) };
+    if type_object.is_null() {
+        PyErr::fetch(py).into()
+    } else {
+        let mut type_object = type_object as *mut ffi::PyTypeObject;
+        if let Some(buffer) = T::buffer_methods() {
+            unsafe {
+                (*(*type_object).tp_as_buffer).bf_getbuffer = buffer.as_ref().bf_getbuffer;
+                (*(*type_object).tp_as_buffer).bf_releasebuffer = buffer.as_ref().bf_releasebuffer;
+            }
         }
+        Ok(type_object)
     }
+
+    // TODO:
+    // type_object.tp_base = T::BaseType::type_object_raw(py);
+
+    // // __dict__ support
+    // if let Some(dict_offset) = PyCell::<T>::dict_offset() {
+    //     type_object.tp_dictoffset = dict_offset as ffi::Py_ssize_t;
+    // }
+
+    // // weakref support
+    // if let Some(weakref_offset) = PyCell::<T>::weakref_offset() {
+    //     type_object.tp_weaklistoffset = weakref_offset as ffi::Py_ssize_t;
+    // }
+
+    // // GC support
+    // if let Some(gc) = T::gc_methods() {
+    //     unsafe { gc.as_ref() }.update_typeobj(type_object);
+    // }
+
+    // // descriptor protocol
+    // if let Some(descr) = T::descr_methods() {
+    //     unsafe { descr.as_ref() }.update_typeobj(type_object);
+    // }
+
+    // // iterator methods
+    // if let Some(iter) = T::iter_methods() {
+    //     unsafe { iter.as_ref() }.update_typeobj(type_object);
+    // }
+
+    // // mapping methods
+    // type_object.tp_as_mapping = T::mapping_methods().map_or_else(ptr::null_mut, |p| p.as_ptr());
+    // // sequence methods
+    // type_object.tp_as_sequence = T::sequence_methods().map_or_else(ptr::null_mut, |p| p.as_ptr());
+    // // async methods
+    // type_object.tp_as_async = T::async_methods().map_or_else(ptr::null_mut, |p| p.as_ptr());
+
+    // // set type flags
+    // py_class_flags::<T>(type_object);
 }
 
 fn py_class_flags<T: PyTypeInfo>(type_object: &mut ffi::PyTypeObject) {
diff --git a/src/type_object.rs b/src/type_object.rs
index 546f87824fb..487e738036e 100644
--- a/src/type_object.rs
+++ b/src/type_object.rs
@@ -3,7 +3,7 @@
 
 use crate::conversion::IntoPyPointer;
 use crate::once_cell::GILOnceCell;
-use crate::pyclass::{initialize_type_object, py_class_attributes, PyClass};
+use crate::pyclass::{create_type_object, py_class_attributes, PyClass};
 use crate::pyclass_init::PyObjectInit;
 use crate::types::{PyAny, PyType};
 use crate::{ffi, AsPyPointer, PyErr, PyNativeType, PyObject, PyResult, Python};
@@ -157,12 +157,10 @@ impl LazyStaticType {
 
     pub fn get_or_init<T: PyClass>(&self, py: Python) -> *mut ffi::PyTypeObject {
         let type_object = *self.value.get_or_init(py, || {
-            let mut type_object = Box::new(ffi::PyTypeObject_INIT);
-            initialize_type_object::<T>(py, T::MODULE, type_object.as_mut()).unwrap_or_else(|e| {
+            create_type_object::<T>(py, T::MODULE).unwrap_or_else(|e| {
                 e.print(py);
                 panic!("An error occurred while initializing class {}", T::NAME)
-            });
-            Box::into_raw(type_object)
+            })
         });
 
         // We might want to fill the `tp_dict` with python instances of `T`
diff --git a/tests/test_class_attributes.rs b/tests/test_class_attributes.rs
index 752935d76e5..b6d502edc07 100644
--- a/tests/test_class_attributes.rs
+++ b/tests/test_class_attributes.rs
@@ -51,14 +51,6 @@ fn class_attributes() {
     py_assert!(py, foo_obj, "foo_obj.MY_CONST == 'foobar'");
 }
 
-#[test]
-fn class_attributes_are_immutable() {
-    let gil = Python::acquire_gil();
-    let py = gil.python();
-    let foo_obj = py.get_type::<Foo>();
-    py_expect_exception!(py, foo_obj, "foo_obj.a = 6", PyTypeError);
-}
-
 #[pymethods]
 impl Bar {
     #[classattr]