@@ -1,5 +1,5 @@
 use crate::get_main_interpreter;
-use crate::pystate::attach_vm_to_thread;
+use crate::pystate::ensure_thread_has_vm_attached;
 use core::ffi::c_int;
 use rustpython_vm::Interpreter;
 use rustpython_vm::vm::thread::ThreadedVirtualMachine;
@@ -31,7 +31,7 @@ pub extern "C" fn Py_InitializeEx(_initsigs: c_int) {
     if interp.is_none() {
         *interp = Interpreter::with_init(Default::default(), |_vm| {}).into();
         drop(interp);
-        attach_vm_to_thread();
+        ensure_thread_has_vm_attached();
     }
 }
 
 
@@ -2,12 +2,30 @@ use crate::pylifecycle::request_vm_from_interpreter;
 use core::cell::RefCell;
 use core::ffi::c_int;
 use core::ptr;
-use rustpython_vm::vm::thread::ThreadedVirtualMachine;
+use rustpython_vm::VirtualMachine;
+use rustpython_vm::vm::thread::{ThreadedVirtualMachine, VM_CURRENT, with_current_vm};
 
 thread_local! {
     static VM: RefCell<Option<ThreadedVirtualMachine>> = const { RefCell::new(None) };
 }
 
+pub(crate) fn with_vm<R>(f: impl FnOnce(&VirtualMachine) -> R) -> R {
+    if VM_CURRENT.is_set() {
+        // We have an active VM set, so use that.
+        with_current_vm(f)
+    } else {
+        // We do not have an active vm running in this thread. Let's use our own.
+        // This will panic if `PyGILState_Ensure` was not called beforehand.
+        VM.with(|vm_ref| {
+            let vm = vm_ref.borrow();
+            let vm = vm
+                .as_ref()
+                .expect("Thread was not attached to an interpreter");
+            vm.run(|vm| f(vm))
+        })
+    }
+}
+
 #[allow(non_camel_case_types)]
 type PyGILState_STATE = c_int;
 
@@ -16,16 +34,20 @@ pub struct PyThreadState {
     _interp: *mut core::ffi::c_void,
 }
 
-pub(crate) fn attach_vm_to_thread() {
-    VM.with(|vm| {
-        vm.borrow_mut()
-            .get_or_insert_with(request_vm_from_interpreter);
-    });
+/// Make sure this thread has a running vm attached. This only creates a new vm if we don't already
+/// have one. So this will only create a new vm when we are in a new thread created outside RustPython.
+pub(crate) fn ensure_thread_has_vm_attached() {
+    if !VM_CURRENT.is_set() {
+        VM.with(|vm| {
+            vm.borrow_mut()
+                .get_or_insert_with(request_vm_from_interpreter);
+        });
+    }
 }
 
 #[unsafe(no_mangle)]
 pub extern "C" fn PyGILState_Ensure() -> PyGILState_STATE {
-    attach_vm_to_thread();
+    ensure_thread_has_vm_attached();
 
     0
 }
@@ -40,23 +62,28 @@ pub extern "C" fn PyEval_SaveThread() -> *mut PyThreadState {
 
 #[cfg(test)]
 mod tests {
-    use crate::pystate::VM;
+    use crate::pystate::{VM, with_vm};
     use pyo3::prelude::*;
+    use rustpython_vm::vm::thread::VM_CURRENT;
 
     #[test]
     fn test_new_thread() {
         Python::attach(|_py| {
-            assert!(
-                VM.with(|vm| vm.borrow().is_some()),
-                "This thread did not have a vm attached"
-            );
+            with_vm(|vm| {
+                assert!(
+                    VM_CURRENT.is_set(),
+                    "This thread did not have a vm attached"
+                )
+            });
 
             std::thread::spawn(move || {
                 Python::attach(|_py| {
-                    assert!(
-                        VM.with(|vm| vm.borrow().is_some()),
-                        "This thread did not have a vm attached"
-                    );
+                    with_vm(|vm| {
+                        assert!(
+                            VM_CURRENT.is_set(),
+                            "This thread did not have a vm attached"
+                        )
+                    });
                 });
             })
             .join()
 
@@ -66,7 +66,7 @@ thread_local! {
 
 }
 
-scoped_tls::scoped_thread_local!(static VM_CURRENT: VirtualMachine);
+scoped_tls::scoped_thread_local!(pub static VM_CURRENT: VirtualMachine);
 
 pub fn with_current_vm<R>(f: impl FnOnce(&VirtualMachine) -> R) -> R {
     if !VM_CURRENT.is_set() {
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`use crate::get_main_interpreter;`
`2`		`-use crate::pystate::attach_vm_to_thread;`
	`2`	`+use crate::pystate::ensure_thread_has_vm_attached;`
`3`	`3`	`use core::ffi::c_int;`
`4`	`4`	`use rustpython_vm::Interpreter;`
`5`	`5`	`use rustpython_vm::vm::thread::ThreadedVirtualMachine;`
`@@ -31,7 +31,7 @@ pub extern "C" fn Py_InitializeEx(_initsigs: c_int) {`
`31`	`31`	`if interp.is_none() {`
`32`	`32`	`*interp = Interpreter::with_init(Default::default(), \|_vm\| {}).into();`
`33`	`33`	`drop(interp);`
`34`		`- attach_vm_to_thread();`
	`34`	`+ ensure_thread_has_vm_attached();`
`35`	`35`	`}`
`36`	`36`	`}`
`37`	`37`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ thread_local! {`
`66`	`66`
`67`	`67`	`}`
`68`	`68`
`69`		`-scoped_tls::scoped_thread_local!(static VM_CURRENT: VirtualMachine);`
	`69`	`+scoped_tls::scoped_thread_local!(pub static VM_CURRENT: VirtualMachine);`
`70`	`70`
`71`	`71`	`pub fn with_current_vm<R>(f: impl FnOnce(&VirtualMachine) -> R) -> R {`
`72`	`72`	`if !VM_CURRENT.is_set() {`