RustPython
diff --git a/crates/vm/src/builtins/builtin_func.rs b/crates/vm/src/builtins/builtin_func.rs
@@ -224,8 +224,44 @@ impl fmt::Debug for PyNativeMethod {
     }
 }
 
+/// Vectorcall for builtin functions (PEP 590).
+/// Avoids `prepend_arg` O(n) shift by building args with self at front.
+fn vectorcall_native_function(
+    zelf_obj: &PyObject,
+    args: Vec<PyObjectRef>,
+    nargs: usize,
+    kwnames: Option<&[PyObjectRef]>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let zelf: &Py<PyNativeFunction> = zelf_obj.downcast_ref().unwrap();
+
+    // Build FuncArgs with self already at position 0 (no insert(0) needed)
+    let needs_self = zelf
+        .zelf
+        .as_ref()
+        .is_some_and(|_| !zelf.value.flags.contains(PyMethodFlags::STATIC));
+
+    let func_args = if needs_self {
+        let self_obj = zelf.zelf.as_ref().unwrap().clone();
+        let mut all_args = Vec::with_capacity(args.len() + 1);
+        all_args.push(self_obj);
+        all_args.extend(args);
+        FuncArgs::from_vectorcall(&all_args, nargs + 1, kwnames)
+    } else {
+        FuncArgs::from_vectorcall(&args, nargs, kwnames)
+    };
+
+    (zelf.value.func)(vm, func_args)
+}
+
 pub fn init(context: &'static Context) {
     PyNativeFunction::extend_class(context, context.types.builtin_function_or_method_type);
+    context
+        .types
+        .builtin_function_or_method_type
+        .slots
+        .vectorcall
+        .store(Some(vectorcall_native_function));
 }
 
 /// Wrapper that provides access to the common PyNativeFunction data

diff --git a/crates/vm/src/builtins/function.rs b/crates/vm/src/builtins/function.rs
@@ -648,7 +648,7 @@ impl Py<PyFunction> {
     /// Skips FuncArgs allocation, prepend_arg, and fill_locals_from_args.
     /// Only valid when: no VARARGS, no VARKEYWORDS, no kwonlyargs, not generator/coroutine,
     /// and nargs == co_argcount.
-    pub fn invoke_exact_args(&self, args: &[PyObjectRef], vm: &VirtualMachine) -> PyResult {
+    pub fn invoke_exact_args(&self, mut args: Vec<PyObjectRef>, vm: &VirtualMachine) -> PyResult {
         let code: PyRef<PyCode> = (*self.code).to_owned();
 
         debug_assert_eq!(args.len(), code.arg_count as usize);
@@ -671,11 +671,11 @@ impl Py<PyFunction> {
         )
         .into_ref(&vm.ctx);
 
-        // Copy args directly into fastlocals
+        // Move args directly into fastlocals (no clone/refcount needed)
         {
             let fastlocals = unsafe { frame.fastlocals.borrow_mut() };
-            for (i, arg) in args.iter().enumerate() {
-                fastlocals[i] = Some(arg.clone());
+            for (slot, arg) in fastlocals.iter_mut().zip(args.drain(..)) {
+                *slot = Some(arg);
             }
         }
 
@@ -1253,8 +1253,107 @@ impl PyCell {
     }
 }
 
+/// Vectorcall implementation for PyFunction (PEP 590).
+/// Takes owned args to avoid cloning when filling fastlocals.
+pub(crate) fn vectorcall_function(
+    zelf_obj: &PyObject,
+    mut args: Vec<PyObjectRef>,
+    nargs: usize,
+    kwnames: Option<&[PyObjectRef]>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let zelf: &Py<PyFunction> = zelf_obj.downcast_ref().unwrap();
+    let code: &Py<PyCode> = &zelf.code;
+
+    let has_kwargs = kwnames.is_some_and(|kw| !kw.is_empty());
+    let is_simple = !has_kwargs
+        && !code.flags.contains(bytecode::CodeFlags::VARARGS)
+        && !code.flags.contains(bytecode::CodeFlags::VARKEYWORDS)
+        && code.kwonlyarg_count == 0
+        && !code
+            .flags
+            .intersects(bytecode::CodeFlags::GENERATOR | bytecode::CodeFlags::COROUTINE);
+
+    if is_simple && nargs == code.arg_count as usize {
+        // FAST PATH: simple positional-only call, exact arg count.
+        // Move owned args directly into fastlocals — no clone needed.
+        let locals = if code.flags.contains(bytecode::CodeFlags::NEWLOCALS) {
+            ArgMapping::from_dict_exact(vm.ctx.new_dict())
+        } else {
+            ArgMapping::from_dict_exact(zelf.globals.clone())
+        };
+
+        let frame = Frame::new(
+            code.to_owned(),
+            Scope::new(Some(locals), zelf.globals.clone()),
+            zelf.builtins.clone(),
+            zelf.closure.as_ref().map_or(&[], |c| c.as_slice()),
+            Some(zelf.to_owned().into()),
+            vm,
+        )
+        .into_ref(&vm.ctx);
+
+        {
+            let fastlocals = unsafe { frame.fastlocals.borrow_mut() };
+            for (slot, arg) in fastlocals.iter_mut().zip(args.drain(..nargs)) {
+                *slot = Some(arg);
+            }
+        }
+
+        if let Some(cell2arg) = code.cell2arg.as_deref() {
+            let fastlocals = unsafe { frame.fastlocals.borrow_mut() };
+            for (cell_idx, arg_idx) in cell2arg.iter().enumerate().filter(|(_, i)| **i != -1) {
+                let x = fastlocals[*arg_idx as usize].take();
+                frame.set_cell_contents(cell_idx, x);
+            }
+        }
+
+        return vm.run_frame(frame);
+    }
+
+    // SLOW PATH: construct FuncArgs from owned Vec and delegate to invoke()
+    let func_args = if has_kwargs {
+        FuncArgs::from_vectorcall(&args, nargs, kwnames)
+    } else {
+        args.truncate(nargs);
+        FuncArgs::from(args)
+    };
+    zelf.invoke(func_args, vm)
+}
+
+/// Vectorcall implementation for PyBoundMethod (PEP 590).
+fn vectorcall_bound_method(
+    zelf_obj: &PyObject,
+    mut args: Vec<PyObjectRef>,
+    nargs: usize,
+    kwnames: Option<&[PyObjectRef]>,
+    vm: &VirtualMachine,
+) -> PyResult {
+    let zelf: &Py<PyBoundMethod> = zelf_obj.downcast_ref().unwrap();
+
+    // Insert self at front of existing Vec (avoids 2nd allocation).
+    // O(n) memmove is cheaper than a 2nd heap alloc+dealloc for typical arg counts.
+    args.insert(0, zelf.object.clone());
+    let new_nargs = nargs + 1;
+    zelf.function.vectorcall(args, new_nargs, kwnames, vm)
+}
+
 pub fn init(context: &'static Context) {
     PyFunction::extend_class(context, context.types.function_type);
+    context
+        .types
+        .function_type
+        .slots
+        .vectorcall
+        .store(Some(vectorcall_function));
+
     PyBoundMethod::extend_class(context, context.types.bound_method_type);
+    context
+        .types
+        .bound_method_type
+        .slots
+        .vectorcall
+        .store(Some(vectorcall_bound_method));
+
     PyCell::extend_class(context, context.types.cell_type);
 }