diff --git a/vm/src/builtins/asyncgenerator.rs b/vm/src/builtins/asyncgenerator.rs
index d49e0797a..3e8c44870 100644
--- a/vm/src/builtins/asyncgenerator.rs
+++ b/vm/src/builtins/asyncgenerator.rs
@@ -1,4 +1,4 @@
-use super::{PyCode, PyStrRef, PyTypeRef};
+use super::{PyCode, PyGenericAlias, PyStrRef, PyTypeRef};
 use crate::{
     builtins::PyBaseExceptionRef,
     coroutine::Coro,
@@ -123,6 +123,11 @@ impl PyAsyncGen {
     fn ag_code(&self, _vm: &VirtualMachine) -> PyRef<PyCode> {
         self.inner.frame().code.clone()
     }
+
+    #[pyclassmethod(magic)]
+    fn class_getitem(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
+        PyGenericAlias::new(cls, args, vm)
+    }
 }
 impl Unconstructible for PyAsyncGen {}
 
diff --git a/vm/src/builtins/dict.rs b/vm/src/builtins/dict.rs
index a7fe30dce..d760bc83b 100644
--- a/vm/src/builtins/dict.rs
+++ b/vm/src/builtins/dict.rs
@@ -1,6 +1,6 @@
 use super::{
-    set::PySetInner, IterStatus, PositionIterInternal, PyBaseExceptionRef, PySet, PyStrRef,
-    PyTypeRef,
+    set::PySetInner, IterStatus, PositionIterInternal, PyBaseExceptionRef, PyGenericAlias, PySet,
+    PyStrRef, PyTypeRef,
 };
 use crate::{
     builtins::PyTuple,
@@ -413,6 +413,11 @@ impl PyDict {
     fn reversed(zelf: PyRef<Self>) -> PyDictReverseKeyIterator {
         PyDictReverseKeyIterator::new(zelf)
     }
+
+    #[pyclassmethod(magic)]
+    fn class_getitem(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
+        PyGenericAlias::new(cls, args, vm)
+    }
 }
 
 impl AsMapping for PyDict {
diff --git a/vm/src/builtins/enumerate.rs b/vm/src/builtins/enumerate.rs
index 302c5ac99..34809fa45 100644
--- a/vm/src/builtins/enumerate.rs
+++ b/vm/src/builtins/enumerate.rs
@@ -1,4 +1,4 @@
-use super::{IterStatus, PositionIterInternal, PyIntRef, PyTupleRef, PyTypeRef};
+use super::{IterStatus, PositionIterInternal, PyGenericAlias, PyIntRef, PyTupleRef, PyTypeRef};
 use crate::common::lock::{PyMutex, PyRwLock};
 use crate::{
     function::{IntoPyObject, OptionalArg},
@@ -47,7 +47,12 @@ impl Constructor for PyEnumerate {
 }
 
 #[pyimpl(with(IterNext, Constructor), flags(BASETYPE))]
-impl PyEnumerate {}
+impl PyEnumerate {
+    #[pyclassmethod(magic)]
+    fn class_getitem(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
+        PyGenericAlias::new(cls, args, vm)
+    }
+}
 
 impl IterNextIterable for PyEnumerate {}
 impl IterNext for PyEnumerate {
diff --git a/vm/src/builtins/mappingproxy.rs b/vm/src/builtins/mappingproxy.rs
index f0326ff79..dded8320a 100644
--- a/vm/src/builtins/mappingproxy.rs
+++ b/vm/src/builtins/mappingproxy.rs
@@ -1,4 +1,4 @@
-use super::{PyDict, PyList, PyStrRef, PyTuple, PyTypeRef};
+use super::{PyDict, PyGenericAlias, PyList, PyStrRef, PyTuple, PyTypeRef};
 use crate::{
     function::{IntoPyObject, OptionalArg},
     protocol::{PyMapping, PyMappingMethods},
@@ -148,6 +148,11 @@ impl PyMappingProxy {
         };
         Ok(format!("mappingproxy({})", vm.to_repr(&obj)?))
     }
+
+    #[pyclassmethod(magic)]
+    fn class_getitem(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
+        PyGenericAlias::new(cls, args, vm)
+    }
 }
 
 impl AsMapping for PyMappingProxy {
diff --git a/vm/src/builtins/set.rs b/vm/src/builtins/set.rs
index 14966274c..c47578e88 100644
--- a/vm/src/builtins/set.rs
+++ b/vm/src/builtins/set.rs
@@ -1,7 +1,10 @@
 /*
  * Builtin set type with a sequence of unique items.
  */
-use super::{builtins_iter, IterStatus, PositionIterInternal, PyDictRef, PyTupleRef, PyTypeRef};
+use super::{
+    builtins_iter, IterStatus, PositionIterInternal, PyDictRef, PyGenericAlias, PyTupleRef,
+    PyTypeRef,
+};
 use crate::common::{ascii, hash::PyHash, lock::PyMutex, rc::PyRc};
 use crate::{
     dictdatatype::{self, DictSize},
@@ -619,6 +622,11 @@ impl PySet {
     ) -> PyResult<(PyTypeRef, PyTupleRef, Option<PyDictRef>)> {
         reduce_set(zelf.as_ref(), vm)
     }
+
+    #[pyclassmethod(magic)]
+    fn class_getitem(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
+        PyGenericAlias::new(cls, args, vm)
+    }
 }
 
 impl Comparable for PySet {
@@ -810,6 +818,11 @@ impl PyFrozenSet {
     ) -> PyResult<(PyTypeRef, PyTupleRef, Option<PyDictRef>)> {
         reduce_set(zelf.as_ref(), vm)
     }
+
+    #[pyclassmethod(magic)]
+    fn class_getitem(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
+        PyGenericAlias::new(cls, args, vm)
+    }
 }
 
 impl Hashable for PyFrozenSet {
diff --git a/vm/src/builtins/tuple.rs b/vm/src/builtins/tuple.rs
index 920123001..497a26245 100644
--- a/vm/src/builtins/tuple.rs
+++ b/vm/src/builtins/tuple.rs
@@ -1,4 +1,4 @@
-use super::{PositionIterInternal, PyTypeRef};
+use super::{PositionIterInternal, PyGenericAlias, PyTypeRef};
 use crate::common::hash::PyHash;
 use crate::{
     function::{IntoPyObject, OptionalArg},
@@ -303,6 +303,11 @@ impl PyTuple {
         };
         (tup_arg,)
     }
+
+    #[pyclassmethod(magic)]
+    fn class_getitem(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
+        PyGenericAlias::new(cls, args, vm)
+    }
 }
 
 impl AsMapping for PyTuple {
diff --git a/vm/src/builtins/weakref.rs b/vm/src/builtins/weakref.rs
index 4de8f2bc8..5b80f301c 100644
--- a/vm/src/builtins/weakref.rs
+++ b/vm/src/builtins/weakref.rs
@@ -1,4 +1,4 @@
-use super::PyTypeRef;
+use super::{PyGenericAlias, PyTypeRef};
 use crate::common::hash::PyHash;
 use crate::{
     function::OptionalArg,
@@ -83,6 +83,11 @@ impl PyWeak {
             format!("<weakref at {:#x}; dead>", id)
         }
     }
+
+    #[pyclassmethod(magic)]
+    fn class_getitem(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
+        PyGenericAlias::new(cls, args, vm)
+    }
 }
 
 impl Hashable for PyWeak {
diff --git a/vm/src/stdlib/collections.rs b/vm/src/stdlib/collections.rs
index 6bfb7d7d8..2e47a71cf 100644
--- a/vm/src/stdlib/collections.rs
+++ b/vm/src/stdlib/collections.rs
@@ -2,7 +2,7 @@ pub(crate) use _collections::make_module;
 
 #[pymodule]
 mod _collections {
-    use crate::builtins::PositionIterInternal;
+    use crate::builtins::{PositionIterInternal, PyGenericAlias};
     use crate::common::lock::{PyMutex, PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard};
     use crate::{
         builtins::{
@@ -529,6 +529,11 @@ mod _collections {
             };
             Ok(vm.new_pyobj((cls, value, vm.ctx.none(), PyDequeIterator::new(zelf))))
         }
+
+        #[pyclassmethod(magic)]
+        fn class_getitem(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
+            PyGenericAlias::new(cls, args, vm)
+        }
     }
 
     impl Comparable for PyDeque {
diff --git a/vm/src/stdlib/itertools.rs b/vm/src/stdlib/itertools.rs
index 60c4490ad..5b6be730f 100644
--- a/vm/src/stdlib/itertools.rs
+++ b/vm/src/stdlib/itertools.rs
@@ -7,7 +7,7 @@ mod decl {
         rc::PyRc,
     };
     use crate::{
-        builtins::{int, PyInt, PyIntRef, PyTuple, PyTupleRef, PyTypeRef},
+        builtins::{int, PyGenericAlias, PyInt, PyIntRef, PyTuple, PyTupleRef, PyTypeRef},
         function::{ArgCallable, FuncArgs, IntoPyObject, OptionalArg, OptionalOption, PosArgs},
         protocol::{PyIter, PyIterReturn},
         stdlib::sys,
@@ -54,6 +54,11 @@ mod decl {
             }
             .into_ref_with_type(vm, cls)
         }
+
+        #[pyclassmethod(magic)]
+        fn class_getitem(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
+            PyGenericAlias::new(cls, args, vm)
+        }
     }
     impl IterNextIterable for PyItertoolsChain {}
     impl IterNext for PyItertoolsChain {
diff --git a/vm/src/stdlib/os.rs b/vm/src/stdlib/os.rs
index e55b3425d..2815184cf 100644
--- a/vm/src/stdlib/os.rs
+++ b/vm/src/stdlib/os.rs
@@ -429,7 +429,9 @@ pub(super) mod _os {
     };
     use crate::common::lock::{OnceCell, PyRwLock};
     use crate::{
-        builtins::{PyBytesRef, PyIntRef, PyStrRef, PyTuple, PyTupleRef, PyTypeRef},
+        builtins::{
+            PyBytesRef, PyGenericAlias, PyIntRef, PyStrRef, PyTuple, PyTupleRef, PyTypeRef,
+        },
         crt_fd::{Fd, Offset},
         function::{ArgBytesLike, FuncArgs, IntoPyException, IntoPyObject, OptionalArg},
         protocol::PyIterReturn,
@@ -890,6 +892,11 @@ pub(super) mod _os {
                 Ok(format!("<{}>", zelf.class()))
             }
         }
+
+        #[pyclassmethod(magic)]
+        fn class_getitem(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
+            PyGenericAlias::new(cls, args, vm)
+        }
     }
 
     #[pyattr]
diff --git a/vm/src/stdlib/sre.rs b/vm/src/stdlib/sre.rs
index 2006283a1..03078ff24 100644
--- a/vm/src/stdlib/sre.rs
+++ b/vm/src/stdlib/sre.rs
@@ -4,7 +4,8 @@ pub(crate) use _sre::make_module;
 mod _sre {
     use crate::{
         builtins::{
-            PyCallableIterator, PyDictRef, PyInt, PyList, PyStr, PyStrRef, PyTuple, PyTupleRef,
+            PyCallableIterator, PyDictRef, PyGenericAlias, PyInt, PyList, PyStr, PyStrRef, PyTuple,
+            PyTupleRef, PyTypeRef,
         },
         common::{ascii, hash::PyHash},
         function::{ArgCallable, IntoPyObject, OptionalArg, PosArgs},
@@ -513,6 +514,11 @@ mod _sre {
                 })
             })
         }
+
+        #[pyclassmethod(magic)]
+        fn class_getitem(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
+            PyGenericAlias::new(cls, args, vm)
+        }
     }
 
     impl Hashable for Pattern {
@@ -787,6 +793,11 @@ mod _sre {
             }
             Some(slice_drive(&str_drive, start as usize, end as usize, vm))
         }
+
+        #[pyclassmethod(magic)]
+        fn class_getitem(cls: PyTypeRef, args: PyObjectRef, vm: &VirtualMachine) -> PyGenericAlias {
+            PyGenericAlias::new(cls, args, vm)
+        }
     }
 
     #[pyattr]