diff --git a/.idea/copyright/ASLv2.xml b/.idea/copyright/ASLv2.xml
index e3cfc22148..f8de65083d 100644
--- a/.idea/copyright/ASLv2.xml
+++ b/.idea/copyright/ASLv2.xml
@@ -1,6 +1,6 @@
 <component name="CopyrightManager">
   <copyright>
-    <option name="notice" value="/*&#10; * Copyright &amp;#36;today.year the original author or authors.&#10; *&#10; * Licensed under the Apache License, Version 2.0 (the &quot;License&quot;);&#10; * you may not use this file except in compliance with the License.&#10; * You may obtain a copy of the License at&#10; *     http://www.apache.org/licenses/LICENSE-2.0&#10; * Unless required by applicable law or agreed to in writing, software&#10; * distributed under the License is distributed on an &quot;AS IS&quot; BASIS,&#10; * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.&#10; * See the License for the specific language governing permissions and&#10; * limitations under the License.&#10; */" />
+    <option name="notice" value="Copyright &amp;#36;today.year the original author or authors.&#10; *&#10;Licensed under the Apache License, Version 2.0 (the &quot;License&quot;);&#10;you may not use this file except in compliance with the License.&#10;You may obtain a copy of the License at&#10;    https://www.apache.org/licenses/LICENSE-2.0&#10;Unless required by applicable law or agreed to in writing, software&#10;distributed under the License is distributed on an &quot;AS IS&quot; BASIS,&#10;WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.&#10;See the License for the specific language governing permissions and&#10;limitations under the License.&#10;" />
     <option name="keyword" value="Copyright" />
     <option name="allowReplaceKeyword" value="" />
     <option name="myName" value="ASLv2" />
diff --git a/docs/extensions.adoc b/docs/extensions.adoc
index 22bb4793d5..10157977bb 100644
--- a/docs/extensions.adoc
+++ b/docs/extensions.adoc
@@ -311,8 +311,7 @@ def "I fail if I run for more than five seconds"() { ... }
 def "I better be quick" { ... }
 ----
 
-Applying `Timeout` to a spec class has the same effect as applying it to each feature that is not already annotated
-with `Timeout`, excluding time spent in fixtures:
+Applying `@Timeout` to a spec class has the same effect as applying it to each feature and fixture method that is not already annotated with `@Timeout`:
 
 [source,groovy]
 ----
@@ -323,6 +322,11 @@ class TimedSpec extends Specification {
 
   @Timeout(value = 250, unit = MILLISECONDS)
   def "I fail much faster"() { ... }
+
+  def setup() { /* I have 10 seconds */}
+
+  @Timeout(value = 25, unit = SECONDS)
+  def cleanup() { /* I have 25 seconds */ }
 }
 ----
 
@@ -337,6 +341,11 @@ the timeout was exceeded. Additionally, thread dumps can be captured and logged
 include::{sourcedir}/timeout/TimeoutConfigurationDoc.groovy[tag=example]
 ----
 
+Since Spock 2.4, you can also configure a global timeout via the configuration file.
+This will apply to all features that are not already annotated with `@Timeout`.
+Setting the global to non-null will have the same effect as applying `@Timeout` it to all features.
+With the flag `applyGlobalTimeoutToFixtures` you can control if the global timeout should also be applied to fixture methods.
+
 === Retry
 
 The `@Retry` extensions can be used for flaky integration tests, where remote systems can fail sometimes.
diff --git a/docs/release_notes.adoc b/docs/release_notes.adoc
index ea7d9e60bb..47def0a044 100644
--- a/docs/release_notes.adoc
+++ b/docs/release_notes.adoc
@@ -12,7 +12,9 @@ include::include.adoc[]
 
 === Misc
 
-* Types constraints or arguments in interactions can now handle primitive types like `_ as int` spockIssue:1974[]
+* Add `globalTimeout` to  `@Timeout` extension, to apply a timeout to all features in a specification, configurable via the spock configuration file spockPull:1986[]
+* Improve `@Timeout` extension will now use virtual threads if available spockPull:1986[]
+* Improve mock argument matching, types constraints or arguments in interactions can now handle primitive types like `_ as int` spockIssue:1974[]
 
 == 2.4-M4 (2024-03-21)
 
diff --git a/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/GlobalTimeoutExtension.java b/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/GlobalTimeoutExtension.java
new file mode 100644
index 0000000000..fe90e3f88d
--- /dev/null
+++ b/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/GlobalTimeoutExtension.java
@@ -0,0 +1,71 @@
+/*
+ *  Copyright 2024 the original author or authors.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package org.spockframework.runtime.extension.builtin;
+
+import spock.lang.Timeout;
+
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+import org.spockframework.runtime.extension.IGlobalExtension;
+import org.spockframework.runtime.model.FeatureInfo;
+import org.spockframework.runtime.model.MethodInfo;
+import org.spockframework.runtime.model.SpecInfo;
+import org.spockframework.util.Assert;
+import org.spockframework.util.Beta;
+import org.spockframework.util.Nullable;
+
+/**
+ * Applies a timeout to every feature and fixture depending on the configuration.
+ *
+ * @author Leonard Brünings
+ * @since 2.4
+ */
+@Beta
+public class GlobalTimeoutExtension implements IGlobalExtension {
+  private final TimeoutConfiguration timeoutConfiguration;
+  private @Nullable TimeoutInterceptor timeoutInterceptor;
+
+  public GlobalTimeoutExtension(TimeoutConfiguration timeoutConfiguration) {
+    // TimeoutConfiguration is mutable and will be configured after the extension is created,
+    // so we need to store a reference to it and delay until the extension is started to create the interceptor.
+    this.timeoutConfiguration = Assert.notNull(timeoutConfiguration, "timeoutConfiguration is null");
+  }
+
+  @Override
+  public void start() {
+    timeoutInterceptor = timeoutConfiguration.globalTimeout == null
+        ? null
+        : new TimeoutInterceptor(timeoutConfiguration.globalTimeout, timeoutConfiguration);
+  }
+
+  @Override
+  public void visitSpec(SpecInfo spec) {
+    if (timeoutInterceptor == null
+        || spec.getReflection().isAnnotationPresent(Timeout.class)) {
+      return;
+    }
+
+    Stream<MethodInfo> features = spec.getAllFeatures().stream()
+        .map(FeatureInfo::getFeatureMethod);
+    Stream<MethodInfo> fixtures = timeoutConfiguration.applyGlobalTimeoutToFixtures
+        ? StreamSupport.stream(spec.getAllFixtureMethods().spliterator(), false)
+        : Stream.empty();
+
+    Stream.concat(features, fixtures)
+        .filter(method -> !method.getReflection().isAnnotationPresent(Timeout.class))
+        .forEach(method -> method.addInterceptor(timeoutInterceptor));
+  }
+}
diff --git a/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutConfiguration.java b/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutConfiguration.java
index ec30dac39f..c573c93eb7 100644
--- a/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutConfiguration.java
+++ b/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutConfiguration.java
@@ -1,24 +1,25 @@
 /*
- * Copyright 2023 the original author or authors.
+ *  Copyright 2024 the original author or authors.
  *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
  */
 
 package org.spockframework.runtime.extension.builtin;
 
 import org.spockframework.util.Beta;
+import org.spockframework.util.Nullable;
+
 import spock.config.ConfigurationObject;
 
+import java.time.Duration;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -45,6 +46,18 @@
 @ConfigurationObject("timeout")
 public class TimeoutConfiguration {
 
+  /**
+   * If set to a valid duration, it will apply for all features that do not have a specific timeout set, default null.
+   * @since 2.4
+   */
+  public @Nullable Duration globalTimeout = null;
+
+  /**
+   * Determines whether the global timeout will be applied to fixtures, default false.
+   * @since 2.4
+   */
+  public boolean applyGlobalTimeoutToFixtures = false;
+
   /**
    * Determines whether thread dumps will be captured and logged on feature timeout or unsuccessful interrupt attempts, default false.
    */
diff --git a/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutExtension.java b/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutExtension.java
index d3f2f587e5..34b28b164a 100644
--- a/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutExtension.java
+++ b/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutExtension.java
@@ -1,17 +1,15 @@
 /*
- * Copyright 2009 the original author or authors.
+ *  Copyright 2024 the original author or authors.
  *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
  */
 
 package org.spockframework.runtime.extension.builtin;
@@ -22,6 +20,8 @@
 import org.spockframework.runtime.model.SpecInfo;
 import spock.lang.Timeout;
 
+import java.time.Duration;
+
 /**
  * @author Peter Niederwieser
  */
@@ -44,11 +44,11 @@ public void visitSpecAnnotation(Timeout timeout, SpecInfo spec) {
 
   @Override
   public void visitFeatureAnnotation(Timeout timeout, FeatureInfo feature) {
-    feature.getFeatureMethod().addInterceptor(new TimeoutInterceptor(timeout, configuration));
+    feature.getFeatureMethod().addInterceptor(new TimeoutInterceptor(Duration.ofNanos(timeout.unit().toNanos(timeout.value())), configuration));
   }
 
   @Override
   public void visitFixtureAnnotation(Timeout timeout, MethodInfo fixtureMethod) {
-    fixtureMethod.addInterceptor(new TimeoutInterceptor(timeout, configuration));
+    fixtureMethod.addInterceptor(new TimeoutInterceptor(Duration.ofNanos(timeout.unit().toNanos(timeout.value())), configuration));
   }
 }
diff --git a/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutInterceptor.java b/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutInterceptor.java
index 28bc6da492..7891eb7220 100644
--- a/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutInterceptor.java
+++ b/spock-core/src/main/java/org/spockframework/runtime/extension/builtin/TimeoutInterceptor.java
@@ -1,17 +1,15 @@
 /*
- * Copyright 2009 the original author or authors.
+ *  Copyright 2024 the original author or authors.
  *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
  */
 
 package org.spockframework.runtime.extension.builtin;
@@ -20,7 +18,6 @@
 import org.spockframework.runtime.extension.IMethodInterceptor;
 import org.spockframework.runtime.extension.IMethodInvocation;
 import org.spockframework.util.*;
-import spock.lang.Timeout;
 
 import java.io.ByteArrayOutputStream;
 import java.io.PrintStream;
@@ -40,14 +37,15 @@
  *
  * @author Peter Niederwieser
  */
-
+@ThreadSafe
 public class TimeoutInterceptor implements IMethodInterceptor {
 
-  private final Timeout timeout;
+  private final Duration timeout;
   private final TimeoutConfiguration configuration;
   private final JavaProcessThreadDumpCollector threadDumpCollector;
 
-  public TimeoutInterceptor(Timeout timeout, TimeoutConfiguration configuration) {
+  public TimeoutInterceptor(Duration timeout, TimeoutConfiguration configuration) {
+    Checks.checkArgument(timeout.toNanos() > 0, () -> "timeout must be positive but was " + timeout);
     this.timeout = timeout;
     this.configuration = configuration;
     this.threadDumpCollector = JavaProcessThreadDumpCollector.create(configuration.threadDumpUtilityType);
@@ -59,13 +57,11 @@ public void intercept(final IMethodInvocation invocation) throws Throwable {
     final SynchronousQueue<StackTraceElement[]> sync = new SynchronousQueue<>();
     final CountDownLatch startLatch = new CountDownLatch(2);
     final String methodName = invocation.getMethod().getName();
-    final double timeoutSeconds = TimeUtil.toSeconds(timeout.value(), timeout.unit());
+    final double timeoutSeconds = TimeUtil.toSeconds(timeout);
 
-    new Thread(String.format("[spock.lang.Timeout] Watcher for method '%s'", methodName)) {
-      @Override
-      public void run() {
+    ThreadSupport.virtualThreadIfSupported(String.format("[spock.lang.Timeout] Watcher for method '%s'", methodName), () -> {
         StackTraceElement[] stackTrace = new StackTraceElement[0];
-        long waitMillis = timeout.unit().toMillis(timeout.value());
+        long waitMillis = timeout.toMillis();
         boolean synced = false;
         long timeoutAt = 0;
         int unsuccessfulInterruptAttempts = 0;
@@ -92,9 +88,8 @@ public void run() {
             }
             mainThread.interrupt();
           }
-        }
       }
-    }.start();
+    }).start();
 
     syncWithThread(startLatch, "watcher", methodName);
 
@@ -137,7 +132,7 @@ private void logUnsuccessfulInterrupt(String methodName, long now, long timeoutA
     System.err.printf(
       "[spock.lang.Timeout] Method '%s' has not stopped after timing out %1.2f seconds ago - interrupting. Next try in %1.2f seconds.\n%n",
       methodName,
-      Duration.ofNanos(now - timeoutAt).toMillis() / 1000d,
+      TimeUtil.toSeconds(Duration.ofNanos(now - timeoutAt)),
       waitMillis / 1000d
     );
 
diff --git a/spock-core/src/main/java/org/spockframework/util/ThreadSupport.java b/spock-core/src/main/java/org/spockframework/util/ThreadSupport.java
new file mode 100644
index 0000000000..36bb0cc917
--- /dev/null
+++ b/spock-core/src/main/java/org/spockframework/util/ThreadSupport.java
@@ -0,0 +1,40 @@
+/*
+ *  Copyright 2024 the original author or authors.
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+package org.spockframework.util;
+
+import java.lang.reflect.Method;
+
+public class ThreadSupport {
+  private static final @Nullable Class<?> THREAD_OF_VIRTUAL_CLASS = ReflectionUtil.loadClassIfAvailable("java.lang.Thread$Builder$OfVirtual");
+  private static final @Nullable Method OF_VIRTUAL = THREAD_OF_VIRTUAL_CLASS != null ? ReflectionUtil.getMethodByName(Thread.class, "ofVirtual") : null;
+  private static final @Nullable Method THREAD_OF_VIRTUAL_NAME = THREAD_OF_VIRTUAL_CLASS != null ? ReflectionUtil.getMethodBySignature(THREAD_OF_VIRTUAL_CLASS, "name", String.class) : null;
+  private static final @Nullable Method THREAD_OF_VIRTUAL_UNSTARTED = THREAD_OF_VIRTUAL_CLASS != null ? ReflectionUtil.getMethodBySignature(THREAD_OF_VIRTUAL_CLASS, "unstarted", Runnable.class) : null;
+
+  /**
+   * Creates a virtual thread if supported by the current JVM.
+   *
+   * @param name the name of the thread
+   * @param target the target to run on the thread
+   * @return the created thread
+   */
+  public static Thread virtualThreadIfSupported(String name, Runnable target) {
+    if (THREAD_OF_VIRTUAL_CLASS == null) {
+      return new Thread(target, name);
+    }
+    Object builder = ReflectionUtil.invokeMethod(Thread.class, OF_VIRTUAL);
+    ReflectionUtil.invokeMethod(builder, THREAD_OF_VIRTUAL_NAME, name);
+    return (Thread) ReflectionUtil.invokeMethod(builder, THREAD_OF_VIRTUAL_UNSTARTED, target);
+  }
+}
diff --git a/spock-core/src/main/java/org/spockframework/util/TimeUtil.java b/spock-core/src/main/java/org/spockframework/util/TimeUtil.java
index 9a927dc487..8e788b0e2e 100644
--- a/spock-core/src/main/java/org/spockframework/util/TimeUtil.java
+++ b/spock-core/src/main/java/org/spockframework/util/TimeUtil.java
@@ -1,19 +1,20 @@
 /*
- * Copyright 2012 the original author or authors.
+ *  Copyright 2024 the original author or authors.
  *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *     https://www.apache.org/licenses/LICENSE-2.0
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
  */
 
 package org.spockframework.util;
 
+import java.time.Duration;
 import java.util.concurrent.TimeUnit;
 
 public abstract class TimeUtil {
@@ -23,4 +24,8 @@ public static double toSeconds(long value, TimeUnit unit) {
     }
     return value / (double) unit.convert(1, TimeUnit.SECONDS);
   }
+
+  public static double toSeconds(Duration duration) {
+    return duration.toMillis() / 1000d;
+  }
 }
diff --git a/spock-core/src/main/resources/META-INF/services/org.spockframework.runtime.extension.IGlobalExtension b/spock-core/src/main/resources/META-INF/services/org.spockframework.runtime.extension.IGlobalExtension
index 778826130b..86b823c7f4 100644
--- a/spock-core/src/main/resources/META-INF/services/org.spockframework.runtime.extension.IGlobalExtension
+++ b/spock-core/src/main/resources/META-INF/services/org.spockframework.runtime.extension.IGlobalExtension
@@ -1,3 +1,4 @@
+org.spockframework.runtime.extension.builtin.GlobalTimeoutExtension
 org.spockframework.runtime.extension.builtin.IncludeExcludeExtension
 org.spockframework.runtime.extension.builtin.OptimizeRunOrderExtension
 org.spockframework.runtime.extension.builtin.UnrollExtension
diff --git a/spock-specs/SpockTestConfig.groovy b/spock-specs/SpockTestConfig.groovy
index cfa0ebc263..3ccd339282 100644
--- a/spock-specs/SpockTestConfig.groovy
+++ b/spock-specs/SpockTestConfig.groovy
@@ -1,5 +1,14 @@
+import java.time.Duration
+
 runner {
   parallel {
     enabled true
   }
 }
+
+timeout {
+  globalTimeout Duration.ofMinutes(1)
+  applyGlobalTimeoutToFixtures true
+  maxInterruptAttemptsWithThreadDumps 1
+  printThreadDumpsOnInterruptAttempts true
+}
diff --git a/spock-specs/src/test/groovy/org/spockframework/docs/timeout/TimeoutConfigurationDoc.groovy b/spock-specs/src/test/groovy/org/spockframework/docs/timeout/TimeoutConfigurationDoc.groovy
index b41ede85fa..131af103d4 100644
--- a/spock-specs/src/test/groovy/org/spockframework/docs/timeout/TimeoutConfigurationDoc.groovy
+++ b/spock-specs/src/test/groovy/org/spockframework/docs/timeout/TimeoutConfigurationDoc.groovy
@@ -13,6 +13,10 @@ class TimeoutConfigurationDoc extends BaseTimeoutExtensionSpecification {
     runner.configurationScript {
       // tag::example[]
       timeout {
+        // java.time.Duration, default null: If set applies global timeout for all features, unless overridden
+        globalTimeout java.time.Duration.ofMinutes(1);
+        // boolean, default false: Determines whether the global timeout will be applied to fixtures
+        applyGlobalTimeoutToFixtures false
         // boolean, default false
         printThreadDumpsOnInterruptAttempts true
         // integer, default 3
diff --git a/spock-specs/src/test/groovy/org/spockframework/runtime/ExtensionClassesLoaderSpec.groovy b/spock-specs/src/test/groovy/org/spockframework/runtime/ExtensionClassesLoaderSpec.groovy
index eff12ef629..7cc2191472 100644
--- a/spock-specs/src/test/groovy/org/spockframework/runtime/ExtensionClassesLoaderSpec.groovy
+++ b/spock-specs/src/test/groovy/org/spockframework/runtime/ExtensionClassesLoaderSpec.groovy
@@ -17,6 +17,7 @@ package org.spockframework.runtime
 
 import org.spockframework.mock.runtime.MockMakerConfiguration
 import org.spockframework.report.log.ReportLogConfiguration
+import org.spockframework.runtime.extension.builtin.GlobalTimeoutExtension
 import org.spockframework.runtime.extension.builtin.IncludeExcludeExtension
 import org.spockframework.runtime.extension.builtin.OptimizeRunOrderExtension
 import org.spockframework.runtime.extension.builtin.SnapshotConfig
@@ -33,7 +34,7 @@ class ExtensionClassesLoaderSpec extends Specification {
     def result = new ExtensionClassesLoader().loadExtensionClassesFromDefaultLocation()
 
     then:
-    result == [IncludeExcludeExtension, OptimizeRunOrderExtension, UnrollExtension]
+    result == [GlobalTimeoutExtension, IncludeExcludeExtension, OptimizeRunOrderExtension, UnrollExtension]
   }
 
   def "loads global ConfigObjects"() {
diff --git a/spock-specs/src/test/groovy/org/spockframework/smoke/extension/GlobalTimeoutExtension.groovy b/spock-specs/src/test/groovy/org/spockframework/smoke/extension/GlobalTimeoutExtension.groovy
new file mode 100644
index 0000000000..cc39e73fd1
--- /dev/null
+++ b/spock-specs/src/test/groovy/org/spockframework/smoke/extension/GlobalTimeoutExtension.groovy
@@ -0,0 +1,192 @@
+package org.spockframework.smoke.extension
+
+
+import spock.timeout.BaseTimeoutExtensionSpecification
+
+import java.time.Duration
+
+import org.spockframework.runtime.SpockTimeoutError
+
+class GlobalTimeoutExtension extends BaseTimeoutExtensionSpecification {
+  def "applies timeout to features"() {
+    given:
+    enableGlobalTimeout()
+
+    when:
+    runner.runFeatureBody("""
+        given: Thread.sleep 99999999999
+        expect: true
+    """)
+
+    then:
+    thrown SpockTimeoutError
+  }
+
+  def "supports inheritance for features"() {
+    given:
+    enableGlobalTimeout()
+
+    when:
+    runner.runWithImports("""
+        abstract class A extends Specification {
+            def "a test"() {
+                given: Thread.sleep 99999999999
+                expect: true
+            }
+        }
+        
+        class B extends A {
+            def "normal test"() {
+                expect: true
+            }
+        }
+    """)
+
+    then:
+    thrown SpockTimeoutError
+  }
+
+  def "applies timeout to fixtures"() {
+    given:
+    enableGlobalTimeout(true)
+
+    when:
+    runner.runSpecBody("""
+        def "$fixtureMethod"() {
+            Thread.sleep 99999999999
+        }
+        
+        def "a test"() {
+            expect: true
+        }
+    """)
+
+    then:
+    thrown SpockTimeoutError
+
+    where:
+    fixtureMethod << ["setupSpec", "setup", "cleanup", "cleanupSpec"]
+  }
+
+  def "supports inheritance for fixtures"() {
+    given:
+    enableGlobalTimeout(true)
+
+    when:
+    runner.runWithImports("""
+        abstract class A extends Specification {
+            def "$fixtureMethod"() {
+                Thread.sleep 99999999999
+            }
+        }
+        
+        class B extends A {
+            def "normal test"() {
+                expect: true
+            }
+        }
+    """)
+
+    then:
+    thrown SpockTimeoutError
+
+    where:
+    fixtureMethod << ["setupSpec", "setup", "cleanup", "cleanupSpec"]
+  }
+
+  def "can be overwritten by feature annotation"() {
+    given:
+    enableGlobalTimeout()
+
+    when:
+    runner.runSpecBody("""
+        @Timeout(value = 10, unit = SECONDS)
+        def "a test"() {
+            given: 
+            
+            Thread.sleep 100
+            expect: true
+        }
+    """)
+
+    then:
+    noExceptionThrown()
+  }
+
+  def "can be overwritten by class-level annotation"() {
+    given:
+    enableGlobalTimeout()
+
+    when:
+    runner.runWithImports("""
+        @Timeout(value = 10, unit = SECONDS)
+        class A extends Specification {
+          def setupSpec() {
+              Thread.sleep 25
+          }
+          
+          def setup() {
+              Thread.sleep 25
+          }
+        
+          def "a test"() {
+              given: 
+              Thread.sleep 25
+              expect: true
+          }
+          
+          def cleanup() {
+              Thread.sleep 25
+          }
+          
+          def cleanupSpec() {
+              Thread.sleep 25
+          }
+        }
+    """)
+
+    then:
+    noExceptionThrown()
+  }
+
+  def "can exclude fixture methods from global timeout"() {
+    given:
+    enableGlobalTimeout(false, Duration.ofMillis(5))
+
+    when:
+    runner.runSpecBody("""
+        def setupSpec() {
+            Thread.sleep 25
+        }
+        
+        def setup() {
+            Thread.sleep 25
+        }
+      
+        def "a test"() {
+            expect: true
+        }
+        
+        def cleanup() {
+            Thread.sleep 25
+        }
+        
+        def cleanupSpec() {
+            Thread.sleep 25
+        }
+    """)
+
+    then:
+    noExceptionThrown()
+  }
+
+  def enableGlobalTimeout(boolean applyToFixtureMethods = false, Duration globalTimeoutDuration = Duration.ofNanos(1)) {
+    runner.configurationScript {
+      timeout {
+        globalTimeout globalTimeoutDuration
+        printThreadDumpsOnInterruptAttempts false
+        applyGlobalTimeoutToFixtures applyToFixtureMethods
+      }
+    }
+  }
+}
diff --git a/spock-specs/src/test/groovy/org/spockframework/smoke/extension/TimeoutExtension.groovy b/spock-specs/src/test/groovy/org/spockframework/smoke/extension/TimeoutExtension.groovy
index 2d55363e3e..1f54029ec0 100644
--- a/spock-specs/src/test/groovy/org/spockframework/smoke/extension/TimeoutExtension.groovy
+++ b/spock-specs/src/test/groovy/org/spockframework/smoke/extension/TimeoutExtension.groovy
@@ -16,6 +16,8 @@
 
 package org.spockframework.smoke.extension
 
+import java.util.concurrent.CountDownLatch
+
 import org.spockframework.runtime.SpockTimeoutError
 import org.spockframework.runtime.extension.builtin.ThreadDumpUtilityType
 import spock.lang.*
@@ -295,6 +297,10 @@ class TimeoutExtension extends BaseTimeoutExtensionSpecification {
   }
 
   @Timeout(1)
+  @IgnoreIf(
+      value = { jvm.java21Compatible },
+      reason = "The TimeoutExtension uses virtual threads if available, which can't be enumerated"
+  )
   def "watcher thread has descriptive name"() {
     def group = Thread.currentThread().threadGroup
     def threads = new Thread[group.activeCount()]
diff --git a/spock-specs/src/test/groovy/org/spockframework/util/ThreadSupportSpec.groovy b/spock-specs/src/test/groovy/org/spockframework/util/ThreadSupportSpec.groovy
new file mode 100644
index 0000000000..0af5d6402b
--- /dev/null
+++ b/spock-specs/src/test/groovy/org/spockframework/util/ThreadSupportSpec.groovy
@@ -0,0 +1,29 @@
+package org.spockframework.util
+
+import spock.lang.IgnoreIf
+import spock.lang.Requires
+import spock.lang.Specification
+
+class ThreadSupportSpec extends Specification {
+
+  @Requires({ jvm.java21Compatible })
+  def "creates virtual threads if available"() {
+    when:
+    def thread = ThreadSupport.virtualThreadIfSupported("test", {  })
+
+    then:
+    thread.virtual
+    thread.class != Thread
+    thread.name == "test"
+  }
+
+  @IgnoreIf({ jvm.java21Compatible })
+  def "creates regular threads if not available"() {
+    when:
+    def thread = ThreadSupport.virtualThreadIfSupported("test", {  })
+
+    then:
+    thread.class == Thread
+    thread.name == "test"
+  }
+}