diff --git a/Cargo.toml b/Cargo.toml
index 19de548286..a649a7ed0f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -190,9 +190,13 @@ wasm-bindgen = "0.2.100"
 [workspace.lints.rust]
 unsafe_code = "allow"
 unsafe_op_in_unsafe_fn = "deny"
+
+# rust_2024_compatibility
 missing_unsafe_on_extern = "deny"
 unsafe_attr_outside_unsafe = "deny"
 deprecated_safe_2024 = "deny"
+rust_2024_incompatible_pat = "deny"
+keyword_idents_2024 = "deny"
 
 [workspace.lints.clippy]
 perf = "warn"
diff --git a/common/src/int.rs b/common/src/int.rs
index ca449ac708..00b5231dff 100644
--- a/common/src/int.rs
+++ b/common/src/int.rs
@@ -50,7 +50,7 @@ pub fn bytes_to_int(lit: &[u8], mut base: u32) -> Option<BigInt> {
                     base = parsed;
                     true
                 } else {
-                    if let [_first, ref others @ .., last] = lit {
+                    if let [_first, others @ .., last] = lit {
                         let is_zero =
                             others.iter().all(|&c| c == b'0' || c == b'_') && *last == b'0';
                         if !is_zero {
diff --git a/compiler/codegen/src/compile.rs b/compiler/codegen/src/compile.rs
index d650e998ea..7f8696baf2 100644
--- a/compiler/codegen/src/compile.rs
+++ b/compiler/codegen/src/compile.rs
@@ -3302,13 +3302,13 @@ impl Compiler {
                 elt, generators, ..
             }) => {
                 Self::contains_await(elt)
-                    || generators.iter().any(|gen| Self::contains_await(&gen.iter))
+                    || generators.iter().any(|jen| Self::contains_await(&jen.iter))
             }
             Expr::SetComp(located_ast::ExprSetComp {
                 elt, generators, ..
             }) => {
                 Self::contains_await(elt)
-                    || generators.iter().any(|gen| Self::contains_await(&gen.iter))
+                    || generators.iter().any(|jen| Self::contains_await(&jen.iter))
             }
             Expr::DictComp(located_ast::ExprDictComp {
                 key,
@@ -3318,13 +3318,13 @@ impl Compiler {
             }) => {
                 Self::contains_await(key)
                     || Self::contains_await(value)
-                    || generators.iter().any(|gen| Self::contains_await(&gen.iter))
+                    || generators.iter().any(|jen| Self::contains_await(&jen.iter))
             }
             Expr::GeneratorExp(located_ast::ExprGeneratorExp {
                 elt, generators, ..
             }) => {
                 Self::contains_await(elt)
-                    || generators.iter().any(|gen| Self::contains_await(&gen.iter))
+                    || generators.iter().any(|jen| Self::contains_await(&jen.iter))
             }
             Expr::Starred(expr) => Self::contains_await(&expr.value),
             Expr::IfExp(located_ast::ExprIfExp {
diff --git a/derive-impl/src/pytraverse.rs b/derive-impl/src/pytraverse.rs
index d2fe2dac81..728722b83a 100644
--- a/derive-impl/src/pytraverse.rs
+++ b/derive-impl/src/pytraverse.rs
@@ -70,7 +70,7 @@ fn gen_trace_code(item: &mut DeriveInput) -> Result<TokenStream> {
         syn::Data::Struct(s) => {
             let fields = &mut s.fields;
             match fields {
-                syn::Fields::Named(ref mut fields) => {
+                syn::Fields::Named(fields) => {
                     let res: Vec<TokenStream> = fields
                         .named
                         .iter_mut()
diff --git a/derive-impl/src/util.rs b/derive-impl/src/util.rs
index bd568032c3..cfe54a5c72 100644
--- a/derive-impl/src/util.rs
+++ b/derive-impl/src/util.rs
@@ -529,7 +529,7 @@ impl AttributeExt for Attribute {
     fn try_remove_name(&mut self, item_name: &str) -> Result<Option<NestedMeta>> {
         self.try_meta_mut(|meta| {
             let nested = match meta {
-                Meta::List(MetaList { ref mut nested, .. }) => Ok(nested),
+                Meta::List(MetaList { nested, .. }) => Ok(nested),
                 other => Err(syn::Error::new(
                     other.span(),
                     format!(
diff --git a/jit/src/lib.rs b/jit/src/lib.rs
index 78619eaf62..37f1f2a3dd 100644
--- a/jit/src/lib.rs
+++ b/jit/src/lib.rs
@@ -215,9 +215,9 @@ pub enum AbiValue {
 impl AbiValue {
     fn to_libffi_arg(&self) -> libffi::middle::Arg {
         match self {
-            AbiValue::Int(ref i) => libffi::middle::Arg::new(i),
-            AbiValue::Float(ref f) => libffi::middle::Arg::new(f),
-            AbiValue::Bool(ref b) => libffi::middle::Arg::new(b),
+            AbiValue::Int(i) => libffi::middle::Arg::new(i),
+            AbiValue::Float(f) => libffi::middle::Arg::new(f),
+            AbiValue::Bool(b) => libffi::middle::Arg::new(b),
         }
     }
 }
diff --git a/stdlib/src/csv.rs b/stdlib/src/csv.rs
index 2dd7f2ae12..7b3448e6b5 100644
--- a/stdlib/src/csv.rs
+++ b/stdlib/src/csv.rs
@@ -272,12 +272,12 @@ mod _csv {
         let Some(name) = name.payload_if_subclass::<PyStr>(vm) else {
             return Err(vm.new_type_error("argument 0 must be a string".to_string()));
         };
-        let mut dialect = match dialect {
+        let dialect = match dialect {
             OptionalArg::Present(d) => PyDialect::try_from_object(vm, d)
                 .map_err(|_| vm.new_type_error("argument 1 must be a dialect object".to_owned()))?,
             OptionalArg::Missing => opts.result(vm)?,
         };
-        opts.update_pydialect(&mut dialect);
+        let dialect = opts.update_pydialect(dialect);
         GLOBAL_HASHMAP
             .lock()
             .insert(name.as_str().to_owned(), dialect);
@@ -665,7 +665,7 @@ mod _csv {
     }
 
     impl FormatOptions {
-        fn update_pydialect<'b>(&self, res: &'b mut PyDialect) -> &'b mut PyDialect {
+        fn update_pydialect(&self, mut res: PyDialect) -> PyDialect {
             macro_rules! check_and_fill {
                 ($res:ident, $e:ident) => {{
                     if let Some(t) = self.$e {
@@ -699,24 +699,18 @@ mod _csv {
                 DialectItem::Str(name) => {
                     let g = GLOBAL_HASHMAP.lock();
                     if let Some(dialect) = g.get(name) {
-                        let mut dialect = *dialect;
-                        self.update_pydialect(&mut dialect);
-                        Ok(dialect)
+                        Ok(self.update_pydialect(*dialect))
                     } else {
                         Err(new_csv_error(vm, format!("{} is not registed.", name)))
                     }
                     // TODO
                     // Maybe need to update the obj from HashMap
                 }
-                DialectItem::Obj(mut o) => {
-                    self.update_pydialect(&mut o);
-                    Ok(o)
-                }
+                DialectItem::Obj(o) => Ok(self.update_pydialect(*o)),
                 DialectItem::None => {
                     let g = GLOBAL_HASHMAP.lock();
-                    let mut res = *g.get("excel").unwrap();
-                    self.update_pydialect(&mut res);
-                    Ok(res)
+                    let res = *g.get("excel").unwrap();
+                    Ok(self.update_pydialect(res))
                 }
             }
         }
diff --git a/stdlib/src/json/machinery.rs b/stdlib/src/json/machinery.rs
index fc6b530866..0614314f4f 100644
--- a/stdlib/src/json/machinery.rs
+++ b/stdlib/src/json/machinery.rs
@@ -135,7 +135,7 @@ pub fn scanstring<'a>(
     };
     let unterminated_err = || DecodeError::new("Unterminated string starting at", end - 1);
     let mut chars = s.char_indices().enumerate().skip(end).peekable();
-    let (_, (mut chunk_start, _)) = chars.peek().ok_or_else(unterminated_err)?;
+    let &(_, (mut chunk_start, _)) = chars.peek().ok_or_else(unterminated_err)?;
     while let Some((char_i, (byte_i, c))) = chars.next() {
         match c {
             '"' => {
diff --git a/stdlib/src/mmap.rs b/stdlib/src/mmap.rs
index 8b657532c4..aed665222e 100644
--- a/stdlib/src/mmap.rs
+++ b/stdlib/src/mmap.rs
@@ -497,8 +497,8 @@ mod mmap {
         fn as_bytes(&self) -> BorrowedValue<[u8]> {
             PyMutexGuard::map_immutable(self.mmap.lock(), |m| {
                 match m.as_ref().expect("mmap closed or invalid") {
-                    MmapObj::Read(ref mmap) => &mmap[..],
-                    MmapObj::Write(ref mmap) => &mmap[..],
+                    MmapObj::Read(mmap) => &mmap[..],
+                    MmapObj::Write(mmap) => &mmap[..],
                 }
             })
             .into()
diff --git a/stdlib/src/socket.rs b/stdlib/src/socket.rs
index 4172c5bb35..95f03ee4f8 100644
--- a/stdlib/src/socket.rs
+++ b/stdlib/src/socket.rs
@@ -1924,7 +1924,7 @@ mod _socket {
         let host = opts.host.as_ref().map(|s| s.as_str());
         let port = opts.port.as_ref().map(|p| -> std::borrow::Cow<str> {
             match p {
-                Either::A(ref s) => s.as_str().into(),
+                Either::A(s) => s.as_str().into(),
                 Either::B(i) => i.to_string().into(),
             }
         });
diff --git a/stdlib/src/syslog.rs b/stdlib/src/syslog.rs
index 9879f3ffaf..5fc6e30a56 100644
--- a/stdlib/src/syslog.rs
+++ b/stdlib/src/syslog.rs
@@ -49,7 +49,7 @@ mod syslog {
     impl GlobalIdent {
         fn as_ptr(&self) -> *const c_char {
             match self {
-                GlobalIdent::Explicit(ref cstr) => cstr.as_ptr(),
+                GlobalIdent::Explicit(cstr) => cstr.as_ptr(),
                 GlobalIdent::Implicit => std::ptr::null(),
             }
         }
diff --git a/vm/src/builtins/iter.rs b/vm/src/builtins/iter.rs
index 2fed23a5c4..dbe4fc6597 100644
--- a/vm/src/builtins/iter.rs
+++ b/vm/src/builtins/iter.rs
@@ -28,7 +28,7 @@ pub enum IterStatus<T> {
 unsafe impl<T: Traverse> Traverse for IterStatus<T> {
     fn traverse(&self, tracer_fn: &mut TraverseFn) {
         match self {
-            IterStatus::Active(ref r) => r.traverse(tracer_fn),
+            IterStatus::Active(r) => r.traverse(tracer_fn),
             IterStatus::Exhausted => (),
         }
     }
diff --git a/vm/src/builtins/mappingproxy.rs b/vm/src/builtins/mappingproxy.rs
index 7b2386a39b..297ddd0a77 100644
--- a/vm/src/builtins/mappingproxy.rs
+++ b/vm/src/builtins/mappingproxy.rs
@@ -29,8 +29,8 @@ enum MappingProxyInner {
 unsafe impl Traverse for MappingProxyInner {
     fn traverse(&self, tracer_fn: &mut TraverseFn) {
         match self {
-            MappingProxyInner::Class(ref r) => r.traverse(tracer_fn),
-            MappingProxyInner::Mapping(ref arg) => arg.traverse(tracer_fn),
+            MappingProxyInner::Class(r) => r.traverse(tracer_fn),
+            MappingProxyInner::Mapping(arg) => arg.traverse(tracer_fn),
         }
     }
 }
diff --git a/vm/src/coroutine.rs b/vm/src/coroutine.rs
index 6d6b743310..5dd34a799d 100644
--- a/vm/src/coroutine.rs
+++ b/vm/src/coroutine.rs
@@ -36,8 +36,8 @@ pub struct Coro {
     exception: PyMutex<Option<PyBaseExceptionRef>>, // exc_state
 }
 
-fn gen_name(gen: &PyObject, vm: &VirtualMachine) -> &'static str {
-    let typ = gen.class();
+fn gen_name(jen: &PyObject, vm: &VirtualMachine) -> &'static str {
+    let typ = jen.class();
     if typ.is(vm.ctx.types.coroutine_type) {
         "coroutine"
     } else if typ.is(vm.ctx.types.async_generator) {
@@ -67,7 +67,7 @@ impl Coro {
 
     fn run_with_context<F>(
         &self,
-        gen: &PyObject,
+        jen: &PyObject,
         vm: &VirtualMachine,
         func: F,
     ) -> PyResult<ExecutionResult>
@@ -75,7 +75,7 @@ impl Coro {
         F: FnOnce(FrameRef) -> PyResult<ExecutionResult>,
     {
         if self.running.compare_exchange(false, true).is_err() {
-            return Err(vm.new_value_error(format!("{} already executing", gen_name(gen, vm))));
+            return Err(vm.new_value_error(format!("{} already executing", gen_name(jen, vm))));
         }
 
         vm.push_exception(self.exception.lock().take());
@@ -90,7 +90,7 @@ impl Coro {
 
     pub fn send(
         &self,
-        gen: &PyObject,
+        jen: &PyObject,
         value: PyObjectRef,
         vm: &VirtualMachine,
     ) -> PyResult<PyIterReturn> {
@@ -102,22 +102,22 @@ impl Coro {
         } else if !vm.is_none(&value) {
             return Err(vm.new_type_error(format!(
                 "can't send non-None value to a just-started {}",
-                gen_name(gen, vm),
+                gen_name(jen, vm),
             )));
         } else {
             None
         };
-        let result = self.run_with_context(gen, vm, |f| f.resume(value, vm));
+        let result = self.run_with_context(jen, vm, |f| f.resume(value, vm));
         self.maybe_close(&result);
         match result {
             Ok(exec_res) => Ok(exec_res.into_iter_return(vm)),
             Err(e) => {
                 if e.fast_isinstance(vm.ctx.exceptions.stop_iteration) {
                     let err =
-                        vm.new_runtime_error(format!("{} raised StopIteration", gen_name(gen, vm)));
+                        vm.new_runtime_error(format!("{} raised StopIteration", gen_name(jen, vm)));
                     err.set_cause(Some(e));
                     Err(err)
-                } else if gen.class().is(vm.ctx.types.async_generator)
+                } else if jen.class().is(vm.ctx.types.async_generator)
                     && e.fast_isinstance(vm.ctx.exceptions.stop_async_iteration)
                 {
                     let err = vm
@@ -132,7 +132,7 @@ impl Coro {
     }
     pub fn throw(
         &self,
-        gen: &PyObject,
+        jen: &PyObject,
         exc_type: PyObjectRef,
         exc_val: PyObjectRef,
         exc_tb: PyObjectRef,
@@ -141,16 +141,16 @@ impl Coro {
         if self.closed.load() {
             return Err(vm.normalize_exception(exc_type, exc_val, exc_tb)?);
         }
-        let result = self.run_with_context(gen, vm, |f| f.gen_throw(vm, exc_type, exc_val, exc_tb));
+        let result = self.run_with_context(jen, vm, |f| f.gen_throw(vm, exc_type, exc_val, exc_tb));
         self.maybe_close(&result);
         Ok(result?.into_iter_return(vm))
     }
 
-    pub fn close(&self, gen: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
+    pub fn close(&self, jen: &PyObject, vm: &VirtualMachine) -> PyResult<()> {
         if self.closed.load() {
             return Ok(());
         }
-        let result = self.run_with_context(gen, vm, |f| {
+        let result = self.run_with_context(jen, vm, |f| {
             f.gen_throw(
                 vm,
                 vm.ctx.exceptions.generator_exit.to_owned().into(),
@@ -161,7 +161,7 @@ impl Coro {
         self.closed.store(true);
         match result {
             Ok(ExecutionResult::Yield(_)) => {
-                Err(vm.new_runtime_error(format!("{} ignored GeneratorExit", gen_name(gen, vm))))
+                Err(vm.new_runtime_error(format!("{} ignored GeneratorExit", gen_name(jen, vm))))
             }
             Err(e) if !is_gen_exit(&e, vm) => Err(e),
             _ => Ok(()),
@@ -183,10 +183,10 @@ impl Coro {
     pub fn set_name(&self, name: PyStrRef) {
         *self.name.lock() = name;
     }
-    pub fn repr(&self, gen: &PyObject, id: usize, vm: &VirtualMachine) -> String {
+    pub fn repr(&self, jen: &PyObject, id: usize, vm: &VirtualMachine) -> String {
         format!(
             "<{} object {} at {:#x}>",
-            gen_name(gen, vm),
+            gen_name(jen, vm),
             self.name.lock(),
             id
         )
diff --git a/vm/src/frame.rs b/vm/src/frame.rs
index fac6da8df5..afa5c708e7 100644
--- a/vm/src/frame.rs
+++ b/vm/src/frame.rs
@@ -426,19 +426,19 @@ impl ExecutingFrame<'_> {
         exc_val: PyObjectRef,
         exc_tb: PyObjectRef,
     ) -> PyResult<ExecutionResult> {
-        if let Some(gen) = self.yield_from_target() {
+        if let Some(jen) = self.yield_from_target() {
             // borrow checker shenanigans - we only need to use exc_type/val/tb if the following
             // variable is Some
-            let thrower = if let Some(coro) = self.builtin_coro(gen) {
+            let thrower = if let Some(coro) = self.builtin_coro(jen) {
                 Some(Either::A(coro))
             } else {
-                vm.get_attribute_opt(gen.to_owned(), "throw")?
+                vm.get_attribute_opt(jen.to_owned(), "throw")?
                     .map(Either::B)
             };
             if let Some(thrower) = thrower {
                 let ret = match thrower {
                     Either::A(coro) => coro
-                        .throw(gen, exc_type, exc_val, exc_tb, vm)
+                        .throw(jen, exc_type, exc_val, exc_tb, vm)
                         .to_pyresult(vm), // FIXME:
                     Either::B(meth) => meth.call((exc_type, exc_val, exc_tb), vm),
                 };
@@ -1568,16 +1568,16 @@ impl ExecutingFrame<'_> {
 
     fn _send(
         &self,
-        gen: &PyObject,
+        jen: &PyObject,
         val: PyObjectRef,
         vm: &VirtualMachine,
     ) -> PyResult<PyIterReturn> {
-        match self.builtin_coro(gen) {
-            Some(coro) => coro.send(gen, val, vm),
+        match self.builtin_coro(jen) {
+            Some(coro) => coro.send(jen, val, vm),
             // FIXME: turn return type to PyResult<PyIterReturn> then ExecutionResult will be simplified
-            None if vm.is_none(&val) => PyIter::new(gen).next(vm),
+            None if vm.is_none(&val) => PyIter::new(jen).next(vm),
             None => {
-                let meth = gen.get_attr("send", vm)?;
+                let meth = jen.get_attr("send", vm)?;
                 PyIterReturn::from_pyresult(meth.call((val,), vm), vm)
             }
         }
diff --git a/vm/src/function/argument.rs b/vm/src/function/argument.rs
index bc60cfa253..b0e731ff57 100644
--- a/vm/src/function/argument.rs
+++ b/vm/src/function/argument.rs
@@ -497,7 +497,7 @@ where
 {
     fn traverse(&self, tracer_fn: &mut TraverseFn) {
         match self {
-            OptionalArg::Present(ref o) => o.traverse(tracer_fn),
+            OptionalArg::Present(o) => o.traverse(tracer_fn),
             OptionalArg::Missing => (),
         }
     }
diff --git a/vm/src/stdlib/ast.rs b/vm/src/stdlib/ast.rs
index 8b081294b9..616d84368c 100644
--- a/vm/src/stdlib/ast.rs
+++ b/vm/src/stdlib/ast.rs
@@ -3,7 +3,7 @@
 //! This module makes use of the parser logic, and translates all ast nodes
 //! into python ast.AST objects.
 
-mod gen;
+mod r#gen;
 
 use crate::{
     builtins::{self, PyDict, PyModule, PyStrRef, PyType},
@@ -398,6 +398,6 @@ pub const PY_COMPILE_FLAGS_MASK: i32 = PY_COMPILE_FLAG_AST_ONLY
 
 pub fn make_module(vm: &VirtualMachine) -> PyRef<PyModule> {
     let module = _ast::make_module(vm);
-    gen::extend_module_nodes(vm, &module);
+    r#gen::extend_module_nodes(vm, &module);
     module
 }
diff --git a/vm/src/stdlib/ctypes/base.rs b/vm/src/stdlib/ctypes/base.rs
index 5d0316352c..a4147c62b2 100644
--- a/vm/src/stdlib/ctypes/base.rs
+++ b/vm/src/stdlib/ctypes/base.rs
@@ -176,7 +176,7 @@ impl Constructor for PyCSimple {
         let attributes = cls.get_attributes();
         let _type_ = attributes
             .iter()
-            .find(|(&k, _)| k.to_object().str(vm).unwrap().to_string() == *"_type_")
+            .find(|(k, _)| k.to_object().str(vm).unwrap().to_string() == *"_type_")
             .unwrap()
             .1
             .str(vm)?
diff --git a/vm/src/stdlib/os.rs b/vm/src/stdlib/os.rs
index 380887656b..6a4233f3be 100644
--- a/vm/src/stdlib/os.rs
+++ b/vm/src/stdlib/os.rs
@@ -380,8 +380,8 @@ pub(super) mod _os {
 
     fn env_bytes_as_bytes(obj: &Either<PyStrRef, PyBytesRef>) -> &[u8] {
         match obj {
-            Either::A(ref s) => s.as_str().as_bytes(),
-            Either::B(ref b) => b.as_bytes(),
+            Either::A(s) => s.as_str().as_bytes(),
+            Either::B(b) => b.as_bytes(),
         }
     }
 
diff --git a/wasm/lib/src/vm_class.rs b/wasm/lib/src/vm_class.rs
index 0c62bb32e7..4ba5760511 100644
--- a/wasm/lib/src/vm_class.rs
+++ b/wasm/lib/src/vm_class.rs
@@ -233,7 +233,7 @@ impl WASMVirtualMachine {
 
     #[wasm_bindgen(js_name = addToScope)]
     pub fn add_to_scope(&self, name: String, value: JsValue) -> Result<(), JsValue> {
-        self.with_vm(move |vm, StoredVirtualMachine { ref scope, .. }| {
+        self.with_vm(move |vm, StoredVirtualMachine { scope, .. }| {
             let value = convert::js_to_py(vm, value);
             scope.globals.set_item(&name, value, vm).into_js(vm)
         })?
@@ -335,7 +335,7 @@ impl WASMVirtualMachine {
         mode: Mode,
         source_path: Option<String>,
     ) -> Result<JsValue, JsValue> {
-        self.with_vm(|vm, StoredVirtualMachine { ref scope, .. }| {
+        self.with_vm(|vm, StoredVirtualMachine { scope, .. }| {
             let source_path = source_path.unwrap_or_else(|| "<wasm>".to_owned());
             let code = vm.compile(source, mode, source_path);
             let code = code.map_err(convert::syntax_err)?;