diff --git a/crates/cast/bin/cmd/call.rs b/crates/cast/bin/cmd/call.rs
index 3d8afbfd25b9..ece090bf74ae 100644
--- a/crates/cast/bin/cmd/call.rs
+++ b/crates/cast/bin/cmd/call.rs
@@ -140,9 +140,7 @@ impl CallArgs {
                     let (env, fork, chain) =
                         TracingExecutor::get_fork_material(&config, evm_opts).await?;
 
-                    let mut executor =
-                        foundry_evm::executors::TracingExecutor::new(env, fork, evm_version, debug)
-                            .await;
+                    let mut executor = TracingExecutor::new(env, fork, evm_version, debug);
 
                     let trace = match executor.deploy(
                         sender,
@@ -175,9 +173,7 @@ impl CallArgs {
                     let (env, fork, chain) =
                         TracingExecutor::get_fork_material(&config, evm_opts).await?;
 
-                    let mut executor =
-                        foundry_evm::executors::TracingExecutor::new(env, fork, evm_version, debug)
-                            .await;
+                    let mut executor = TracingExecutor::new(env, fork, evm_version, debug);
 
                     let (tx, _) = builder.build();
 
diff --git a/crates/cast/bin/cmd/run.rs b/crates/cast/bin/cmd/run.rs
index 796368c69ae1..ca83c084d07b 100644
--- a/crates/cast/bin/cmd/run.rs
+++ b/crates/cast/bin/cmd/run.rs
@@ -121,8 +121,7 @@ impl RunArgs {
 
         let (mut env, fork, chain) = TracingExecutor::get_fork_material(&config, evm_opts).await?;
 
-        let mut executor =
-            TracingExecutor::new(env.clone(), fork, self.evm_version, self.debug).await;
+        let mut executor = TracingExecutor::new(env.clone(), fork, self.evm_version, self.debug);
 
         env.block.number = U256::from(tx_block_number);
 
diff --git a/crates/chisel/src/executor.rs b/crates/chisel/src/executor.rs
index 3b243b7b0ef4..6d76d5b0e896 100644
--- a/crates/chisel/src/executor.rs
+++ b/crates/chisel/src/executor.rs
@@ -292,10 +292,8 @@ impl SessionSource {
         let backend = match self.config.backend.take() {
             Some(backend) => backend,
             None => {
-                let backend = Backend::spawn(
-                    self.config.evm_opts.get_fork(&self.config.foundry_config, env.clone()),
-                )
-                .await;
+                let fork = self.config.evm_opts.get_fork(&self.config.foundry_config, env.clone());
+                let backend = Backend::spawn(fork);
                 self.config.backend = Some(backend.clone());
                 backend
             }
diff --git a/crates/common/src/compile.rs b/crates/common/src/compile.rs
index 935e098eeefe..96574f460f25 100644
--- a/crates/common/src/compile.rs
+++ b/crates/common/src/compile.rs
@@ -26,7 +26,7 @@ use std::{
 ///
 /// This is merely a wrapper for [`Project::compile()`] which also prints to stdout depending on its
 /// settings.
-#[must_use = "this builder does nothing unless you call a `compile*` method"]
+#[must_use = "ProjectCompiler does nothing unless you call a `compile*` method"]
 pub struct ProjectCompiler {
     /// Whether we are going to verify the contracts after compilation.
     verify: Option<bool>,
diff --git a/crates/evm/core/src/backend/mod.rs b/crates/evm/core/src/backend/mod.rs
index 1ea450d2351a..5e2c8fdadecb 100644
--- a/crates/evm/core/src/backend/mod.rs
+++ b/crates/evm/core/src/backend/mod.rs
@@ -405,8 +405,8 @@ pub struct Backend {
 
 impl Backend {
     /// Creates a new Backend with a spawned multi fork thread.
-    pub async fn spawn(fork: Option<CreateFork>) -> Self {
-        Self::new(MultiFork::spawn().await, fork)
+    pub fn spawn(fork: Option<CreateFork>) -> Self {
+        Self::new(MultiFork::spawn(), fork)
     }
 
     /// Creates a new instance of `Backend`
@@ -449,16 +449,11 @@ impl Backend {
 
     /// Creates a new instance of `Backend` with fork added to the fork database and sets the fork
     /// as active
-    pub(crate) async fn new_with_fork(
-        id: &ForkId,
-        fork: Fork,
-        journaled_state: JournaledState,
-    ) -> Self {
-        let mut backend = Self::spawn(None).await;
+    pub(crate) fn new_with_fork(id: &ForkId, fork: Fork, journaled_state: JournaledState) -> Self {
+        let mut backend = Self::spawn(None);
         let fork_ids = backend.inner.insert_new_fork(id.clone(), fork.db, journaled_state);
         backend.inner.launched_with_fork = Some((id.clone(), fork_ids.0, fork_ids.1));
         backend.active_fork_ids = Some(fork_ids);
-
         backend
     }
 
@@ -1885,8 +1880,7 @@ fn commit_transaction<I: Inspector<Backend>>(
 
         let fork = fork.clone();
         let journaled_state = journaled_state.clone();
-        let db = crate::utils::RuntimeOrHandle::new()
-            .block_on(async move { Backend::new_with_fork(fork_id, fork, journaled_state).await });
+        let db = Backend::new_with_fork(fork_id, fork, journaled_state);
         evm.database(db);
 
         match evm.inspect(inspector) {
diff --git a/crates/evm/core/src/fork/backend.rs b/crates/evm/core/src/fork/backend.rs
index e319069d065a..ccf64fd10e76 100644
--- a/crates/evm/core/src/fork/backend.rs
+++ b/crates/evm/core/src/fork/backend.rs
@@ -74,7 +74,7 @@ enum BackendRequest {
 ///
 /// This handler will remain active as long as it is reachable (request channel still open) and
 /// requests are in progress.
-#[must_use = "BackendHandler does nothing unless polled."]
+#[must_use = "futures do nothing unless polled"]
 pub struct BackendHandler<P> {
     provider: P,
     /// Stores all the data.
@@ -759,7 +759,7 @@ mod tests {
             evm_opts,
         };
 
-        let backend = Backend::spawn(Some(fork)).await;
+        let backend = Backend::spawn(Some(fork));
 
         // some rng contract from etherscan
         let address: Address = "63091244180ae240c87d1f528f5f269134cb07b3".parse().unwrap();
diff --git a/crates/evm/core/src/fork/multi.rs b/crates/evm/core/src/fork/multi.rs
index deb0e9f55161..f84af067c020 100644
--- a/crates/evm/core/src/fork/multi.rs
+++ b/crates/evm/core/src/fork/multi.rs
@@ -83,7 +83,7 @@ impl MultiFork {
     }
 
     /// Creates a new pair and spawns the `MultiForkHandler` on a background thread.
-    pub async fn spawn() -> Self {
+    pub fn spawn() -> Self {
         trace!(target: "fork::multi", "spawning multifork");
 
         let (fork, mut handler) = Self::new();
diff --git a/crates/evm/evm/src/executors/tracing.rs b/crates/evm/evm/src/executors/tracing.rs
index 19db5fc57755..5beabdd1de0d 100644
--- a/crates/evm/evm/src/executors/tracing.rs
+++ b/crates/evm/evm/src/executors/tracing.rs
@@ -11,13 +11,13 @@ pub struct TracingExecutor {
 }
 
 impl TracingExecutor {
-    pub async fn new(
+    pub fn new(
         env: revm::primitives::Env,
         fork: Option<CreateFork>,
         version: Option<EvmVersion>,
         debug: bool,
     ) -> Self {
-        let db = Backend::spawn(fork).await;
+        let db = Backend::spawn(fork);
         Self {
             // configures a bare version of the evm executor: no cheatcode inspector is enabled,
             // tracing will be enabled only for the targeted transaction
diff --git a/crates/forge/bin/cmd/coverage.rs b/crates/forge/bin/cmd/coverage.rs
index 718d1079058a..7acfa8fdf346 100644
--- a/crates/forge/bin/cmd/coverage.rs
+++ b/crates/forge/bin/cmd/coverage.rs
@@ -313,7 +313,7 @@ impl CoverageArgs {
         let known_contracts = runner.known_contracts.clone();
         let filter = self.filter;
         let (tx, rx) = channel::<(String, SuiteResult)>();
-        let handle = tokio::task::spawn(async move { runner.test(&filter, tx).await });
+        let handle = tokio::task::spawn_blocking(move || runner.test(&filter, tx));
 
         // Add hit data to the coverage report
         let data = rx
diff --git a/crates/forge/bin/cmd/script/executor.rs b/crates/forge/bin/cmd/script/executor.rs
index 071cbcbb219d..a78f5b9f451a 100644
--- a/crates/forge/bin/cmd/script/executor.rs
+++ b/crates/forge/bin/cmd/script/executor.rs
@@ -281,7 +281,7 @@ impl ScriptArgs {
                 Some(db) => db.clone(),
                 None => {
                     let fork = script_config.evm_opts.get_fork(&script_config.config, env.clone());
-                    let backend = Backend::spawn(fork).await;
+                    let backend = Backend::spawn(fork);
                     script_config.backends.insert(url.clone(), backend.clone());
                     backend
                 }
@@ -291,7 +291,6 @@ impl ScriptArgs {
                 // no need to cache it, since there won't be any onchain simulation that we'd need
                 // to cache the backend for.
                 Backend::spawn(script_config.evm_opts.get_fork(&script_config.config, env.clone()))
-                    .await
             }
         };
 
diff --git a/crates/forge/bin/cmd/test/mod.rs b/crates/forge/bin/cmd/test/mod.rs
index 0d49b4640671..2a0e7bbdbbfa 100644
--- a/crates/forge/bin/cmd/test/mod.rs
+++ b/crates/forge/bin/cmd/test/mod.rs
@@ -289,7 +289,7 @@ impl TestArgs {
         }
 
         if self.json {
-            let results = runner.test_collect(filter).await;
+            let results = runner.test_collect(filter);
             println!("{}", serde_json::to_string(&results)?);
             return Ok(TestOutcome::new(results, self.allow_failure));
         }
@@ -303,9 +303,9 @@ impl TestArgs {
         // Run tests.
         let (tx, rx) = channel::<(String, SuiteResult)>();
         let timer = Instant::now();
-        let handle = tokio::task::spawn({
+        let handle = tokio::task::spawn_blocking({
             let filter = filter.clone();
-            async move { runner.test(&filter, tx).await }
+            move || runner.test(&filter, tx)
         });
 
         let mut gas_report =
diff --git a/crates/forge/src/multi_runner.rs b/crates/forge/src/multi_runner.rs
index ea6c79c98374..6a8e821b23a0 100644
--- a/crates/forge/src/multi_runner.rs
+++ b/crates/forge/src/multi_runner.rs
@@ -120,8 +120,8 @@ impl MultiContractRunner {
     /// The same as [`test`](Self::test), but returns the results instead of streaming them.
     ///
     /// Note that this method returns only when all tests have been executed.
-    pub async fn test_collect(&mut self, filter: &dyn TestFilter) -> BTreeMap<String, SuiteResult> {
-        self.test_iter(filter).await.collect()
+    pub fn test_collect(&mut self, filter: &dyn TestFilter) -> BTreeMap<String, SuiteResult> {
+        self.test_iter(filter).collect()
     }
 
     /// Executes _all_ tests that match the given `filter`.
@@ -129,12 +129,12 @@ impl MultiContractRunner {
     /// The same as [`test`](Self::test), but returns the results instead of streaming them.
     ///
     /// Note that this method returns only when all tests have been executed.
-    pub async fn test_iter(
+    pub fn test_iter(
         &mut self,
         filter: &dyn TestFilter,
     ) -> impl Iterator<Item = (String, SuiteResult)> {
         let (tx, rx) = mpsc::channel();
-        self.test(filter, tx).await;
+        self.test(filter, tx);
         rx.into_iter()
     }
 
@@ -144,11 +144,11 @@ impl MultiContractRunner {
     /// before executing all contracts and their tests in _parallel_.
     ///
     /// Each Executor gets its own instance of the `Backend`.
-    pub async fn test(&mut self, filter: &dyn TestFilter, tx: mpsc::Sender<(String, SuiteResult)>) {
+    pub fn test(&mut self, filter: &dyn TestFilter, tx: mpsc::Sender<(String, SuiteResult)>) {
         trace!("running all tests");
 
         // The DB backend that serves all the data.
-        let db = Backend::spawn(self.fork.take()).await;
+        let db = Backend::spawn(self.fork.take());
         let executor = ExecutorBuilder::new()
             .inspectors(|stack| {
                 stack
diff --git a/crates/forge/tests/it/cheats.rs b/crates/forge/tests/it/cheats.rs
index 2959014bc0e1..8fa7ae31e438 100644
--- a/crates/forge/tests/it/cheats.rs
+++ b/crates/forge/tests/it/cheats.rs
@@ -20,7 +20,7 @@ async fn test_cheats_local() {
 
     let mut config = Config::with_root(PROJECT.root());
     config.fs_permissions = FsPermissions::new(vec![PathPermission::read_write("./")]);
-    let runner = runner_with_config(config).await;
+    let runner = runner_with_config(config);
 
     TestConfig::with_filter(runner, filter).run().await;
 }
diff --git a/crates/forge/tests/it/config.rs b/crates/forge/tests/it/config.rs
index c56a626c49a8..bc56b5c1c2cc 100644
--- a/crates/forge/tests/it/config.rs
+++ b/crates/forge/tests/it/config.rs
@@ -31,8 +31,8 @@ impl TestConfig {
         Self::with_filter(runner, Filter::matches_all())
     }
 
-    pub async fn filter(filter: Filter) -> Self {
-        Self::with_filter(runner().await, filter)
+    pub fn filter(filter: Filter) -> Self {
+        Self::with_filter(runner(), filter)
     }
 
     pub fn with_filter(runner: MultiContractRunner, filter: Filter) -> Self {
@@ -55,8 +55,8 @@ impl TestConfig {
     }
 
     /// Executes the test runner
-    pub async fn test(&mut self) -> BTreeMap<String, SuiteResult> {
-        self.runner.test_collect(&self.filter).await
+    pub fn test(&mut self) -> BTreeMap<String, SuiteResult> {
+        self.runner.test_collect(&self.filter)
     }
 
     pub async fn run(&mut self) {
@@ -69,7 +69,7 @@ impl TestConfig {
     ///    * filter matched 0 test cases
     ///    * a test results deviates from the configured `should_fail` setting
     pub async fn try_run(&mut self) -> eyre::Result<()> {
-        let suite_result = self.test().await;
+        let suite_result = self.test();
         if suite_result.is_empty() {
             eyre::bail!("empty test result");
         }
@@ -127,20 +127,20 @@ pub fn base_runner() -> MultiContractRunnerBuilder {
 }
 
 /// Builds a non-tracing runner
-pub async fn runner() -> MultiContractRunner {
+pub fn runner() -> MultiContractRunner {
     let mut config = Config::with_root(PROJECT.root());
     config.fs_permissions = FsPermissions::new(vec![PathPermission::read_write(manifest_root())]);
-    runner_with_config(config).await
+    runner_with_config(config)
 }
 
 /// Builds a non-tracing runner
-pub async fn runner_with_config(mut config: Config) -> MultiContractRunner {
+pub fn runner_with_config(mut config: Config) -> MultiContractRunner {
     config.rpc_endpoints = rpc_endpoints();
     config.allow_paths.push(manifest_root().to_path_buf());
 
     let root = &PROJECT.paths.root;
     let opts = &*EVM_OPTS;
-    let env = opts.evm_env().await.expect("could not instantiate fork environment");
+    let env = opts.local_evm_env();
     let output = COMPILED.clone();
     base_runner()
         .with_cheats_config(CheatsConfig::new(&config, opts.clone(), None))
@@ -150,16 +150,11 @@ pub async fn runner_with_config(mut config: Config) -> MultiContractRunner {
 }
 
 /// Builds a tracing runner
-pub async fn tracing_runner() -> MultiContractRunner {
+pub fn tracing_runner() -> MultiContractRunner {
     let mut opts = EVM_OPTS.clone();
     opts.verbosity = 5;
     base_runner()
-        .build(
-            &PROJECT.paths.root,
-            (*COMPILED).clone(),
-            EVM_OPTS.evm_env().await.expect("Could not instantiate fork environment"),
-            opts,
-        )
+        .build(&PROJECT.paths.root, (*COMPILED).clone(), EVM_OPTS.local_evm_env(), opts)
         .unwrap()
 }
 
diff --git a/crates/forge/tests/it/core.rs b/crates/forge/tests/it/core.rs
index 29ce68c9eedf..f581407d573c 100644
--- a/crates/forge/tests/it/core.rs
+++ b/crates/forge/tests/it/core.rs
@@ -9,8 +9,8 @@ use std::{collections::BTreeMap, env};
 #[tokio::test(flavor = "multi_thread")]
 async fn test_core() {
     let filter = Filter::new(".*", ".*", ".*core");
-    let mut runner = runner().await;
-    let results = runner.test_collect(&filter).await;
+    let mut runner = runner();
+    let results = runner.test_collect(&filter);
 
     assert_multiple(
         &results,
@@ -79,8 +79,8 @@ async fn test_core() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_linking() {
     let filter = Filter::new(".*", ".*", ".*linking");
-    let mut runner = runner().await;
-    let results = runner.test_collect(&filter).await;
+    let mut runner = runner();
+    let results = runner.test_collect(&filter);
 
     assert_multiple(
         &results,
@@ -113,8 +113,8 @@ async fn test_linking() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_logs() {
     let filter = Filter::new(".*", ".*", ".*logs");
-    let mut runner = runner().await;
-    let results = runner.test_collect(&filter).await;
+    let mut runner = runner();
+    let results = runner.test_collect(&filter);
 
     assert_multiple(
         &results,
@@ -678,8 +678,8 @@ async fn test_env_vars() {
     env::remove_var(env_var_key);
 
     let filter = Filter::new("testSetEnv", ".*", ".*");
-    let mut runner = runner().await;
-    let _ = runner.test_collect(&filter).await;
+    let mut runner = runner();
+    let _ = runner.test_collect(&filter);
 
     assert_eq!(env::var(env_var_key).unwrap(), env_var_val);
 }
@@ -687,8 +687,8 @@ async fn test_env_vars() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_doesnt_run_abstract_contract() {
     let filter = Filter::new(".*", ".*", ".*Abstract.t.sol".to_string().as_str());
-    let mut runner = runner().await;
-    let results = runner.test_collect(&filter).await;
+    let mut runner = runner();
+    let results = runner.test_collect(&filter);
     assert!(results.get("core/Abstract.t.sol:AbstractTestBase").is_none());
     assert!(results.get("core/Abstract.t.sol:AbstractTest").is_some());
 }
@@ -696,8 +696,8 @@ async fn test_doesnt_run_abstract_contract() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_trace() {
     let filter = Filter::new(".*", ".*", ".*trace");
-    let mut runner = tracing_runner().await;
-    let suite_result = runner.test_collect(&filter).await;
+    let mut runner = tracing_runner();
+    let suite_result = runner.test_collect(&filter);
 
     // TODO: This trace test is very basic - it is probably a good candidate for snapshot
     // testing.
diff --git a/crates/forge/tests/it/fork.rs b/crates/forge/tests/it/fork.rs
index 76a06e57b670..da103801c0e3 100644
--- a/crates/forge/tests/it/fork.rs
+++ b/crates/forge/tests/it/fork.rs
@@ -16,8 +16,8 @@ async fn test_cheats_fork_revert() {
         ".*",
         &format!(".*cheats{RE_PATH_SEPARATOR}Fork"),
     );
-    let mut runner = runner().await;
-    let suite_result = runner.test_collect(&filter).await;
+    let mut runner = runner();
+    let suite_result = runner.test_collect(&filter);
     assert_eq!(suite_result.len(), 1);
 
     for (_, SuiteResult { test_results, .. }) in suite_result {
@@ -38,7 +38,7 @@ async fn test_cheats_fork() {
     let runner = runner_with_config(config);
     let filter = Filter::new(".*", ".*", &format!(".*cheats{RE_PATH_SEPARATOR}Fork"))
         .exclude_tests(".*Revert");
-    TestConfig::with_filter(runner.await, filter).run().await;
+    TestConfig::with_filter(runner, filter).run().await;
 }
 
 /// Executes eth_getLogs cheatcode
@@ -49,7 +49,7 @@ async fn test_get_logs_fork() {
     let runner = runner_with_config(config);
     let filter = Filter::new("testEthGetLogs", ".*", &format!(".*cheats{RE_PATH_SEPARATOR}Fork"))
         .exclude_tests(".*Revert");
-    TestConfig::with_filter(runner.await, filter).run().await;
+    TestConfig::with_filter(runner, filter).run().await;
 }
 
 /// Executes rpc cheatcode
@@ -60,7 +60,7 @@ async fn test_rpc_fork() {
     let runner = runner_with_config(config);
     let filter = Filter::new("testRpc", ".*", &format!(".*cheats{RE_PATH_SEPARATOR}Fork"))
         .exclude_tests(".*Revert");
-    TestConfig::with_filter(runner.await, filter).run().await;
+    TestConfig::with_filter(runner, filter).run().await;
 }
 
 /// Tests that we can launch in forking mode
@@ -85,12 +85,12 @@ async fn test_launch_fork_ws() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_transact_fork() {
     let filter = Filter::new(".*", ".*", &format!(".*fork{RE_PATH_SEPARATOR}Transact"));
-    TestConfig::filter(filter).await.run().await;
+    TestConfig::filter(filter).run().await;
 }
 
 /// Tests that we can create the same fork (provider,block) concurretnly in different tests
 #[tokio::test(flavor = "multi_thread")]
 async fn test_create_same_fork() {
     let filter = Filter::new(".*", ".*", &format!(".*fork{RE_PATH_SEPARATOR}ForkSame"));
-    TestConfig::filter(filter).await.run().await;
+    TestConfig::filter(filter).run().await;
 }
diff --git a/crates/forge/tests/it/fs.rs b/crates/forge/tests/it/fs.rs
index 29affe05c851..72ae2cb32fe4 100644
--- a/crates/forge/tests/it/fs.rs
+++ b/crates/forge/tests/it/fs.rs
@@ -8,7 +8,7 @@ use foundry_test_utils::Filter;
 async fn test_fs_disabled() {
     let mut config = Config::with_root(PROJECT.root());
     config.fs_permissions = FsPermissions::new(vec![PathPermission::none("./")]);
-    let runner = runner_with_config(config).await;
+    let runner = runner_with_config(config);
     let filter = Filter::new(".*", ".*", ".*fs/Disabled");
     TestConfig::with_filter(runner, filter).run().await;
 }
@@ -19,5 +19,5 @@ async fn test_fs_default() {
     config.fs_permissions = FsPermissions::new(vec![PathPermission::read("./fixtures")]);
     let runner = runner_with_config(config);
     let filter = Filter::new(".*", ".*", ".*fs/Default");
-    TestConfig::with_filter(runner.await, filter).run().await;
+    TestConfig::with_filter(runner, filter).run().await;
 }
diff --git a/crates/forge/tests/it/fuzz.rs b/crates/forge/tests/it/fuzz.rs
index 011497f4ce47..14a27d6b442a 100644
--- a/crates/forge/tests/it/fuzz.rs
+++ b/crates/forge/tests/it/fuzz.rs
@@ -11,8 +11,8 @@ async fn test_fuzz() {
     let filter = Filter::new(".*", ".*", ".*fuzz/")
         .exclude_tests(r"invariantCounter|testIncrement\(address\)|testNeedle\(uint256\)|testSuccessChecker\(uint256\)|testSuccessChecker2\(int256\)|testSuccessChecker3\(uint32\)")
         .exclude_paths("invariant");
-    let mut runner = runner().await;
-    let suite_result = runner.test_collect(&filter).await;
+    let mut runner = runner();
+    let suite_result = runner.test_collect(&filter);
 
     assert!(!suite_result.is_empty());
 
@@ -48,8 +48,8 @@ async fn test_successful_fuzz_cases() {
     let filter = Filter::new(".*", ".*", ".*fuzz/FuzzPositive")
         .exclude_tests(r"invariantCounter|testIncrement\(address\)|testNeedle\(uint256\)")
         .exclude_paths("invariant");
-    let mut runner = runner().await;
-    let suite_result = runner.test_collect(&filter).await;
+    let mut runner = runner();
+    let suite_result = runner.test_collect(&filter);
 
     assert!(!suite_result.is_empty());
 
@@ -78,12 +78,12 @@ async fn test_successful_fuzz_cases() {
 #[ignore]
 async fn test_fuzz_collection() {
     let filter = Filter::new(".*", ".*", ".*fuzz/FuzzCollection.t.sol");
-    let mut runner = runner().await;
+    let mut runner = runner();
     runner.test_options.invariant.depth = 100;
     runner.test_options.invariant.runs = 1000;
     runner.test_options.fuzz.runs = 1000;
     runner.test_options.fuzz.seed = Some(U256::from(6u32));
-    let results = runner.test_collect(&filter).await;
+    let results = runner.test_collect(&filter);
 
     assert_multiple(
         &results,
diff --git a/crates/forge/tests/it/inline.rs b/crates/forge/tests/it/inline.rs
index 3503606d7088..3e7b4616380a 100644
--- a/crates/forge/tests/it/inline.rs
+++ b/crates/forge/tests/it/inline.rs
@@ -14,8 +14,8 @@ use foundry_test_utils::Filter;
 #[tokio::test(flavor = "multi_thread")]
 async fn inline_config_run_fuzz() {
     let filter = Filter::new(".*", ".*", ".*inline/FuzzInlineConf.t.sol");
-    let mut runner = runner().await;
-    let result = runner.test_collect(&filter).await;
+    let mut runner = runner();
+    let result = runner.test_collect(&filter);
     let suite_result: &SuiteResult =
         result.get("inline/FuzzInlineConf.t.sol:FuzzInlineConf").unwrap();
     let test_result: &TestResult =
@@ -35,9 +35,9 @@ async fn inline_config_run_invariant() {
     const ROOT: &str = "inline/InvariantInlineConf.t.sol";
 
     let filter = Filter::new(".*", ".*", ".*inline/InvariantInlineConf.t.sol");
-    let mut runner = runner().await;
+    let mut runner = runner();
     runner.test_options = default_test_options();
-    let result = runner.test_collect(&filter).await;
+    let result = runner.test_collect(&filter);
 
     let suite_result_1 = result.get(&format!("{ROOT}:InvariantInlineConf")).expect("Result exists");
     let suite_result_2 =
diff --git a/crates/forge/tests/it/invariant.rs b/crates/forge/tests/it/invariant.rs
index b5132fefab9f..6178893716cd 100644
--- a/crates/forge/tests/it/invariant.rs
+++ b/crates/forge/tests/it/invariant.rs
@@ -9,8 +9,8 @@ use std::collections::BTreeMap;
 #[tokio::test(flavor = "multi_thread")]
 async fn test_invariant() {
     let filter = Filter::new(".*", ".*", ".*fuzz/invariant/(target|targetAbi|common)");
-    let mut runner = runner().await;
-    let results = runner.test_collect(&filter).await;
+    let mut runner = runner();
+    let results = runner.test_collect(&filter);
 
     assert_multiple(
         &results,
@@ -144,9 +144,9 @@ async fn test_invariant() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_invariant_override() {
     let filter = Filter::new(".*", ".*", ".*fuzz/invariant/common/InvariantReentrancy.t.sol");
-    let mut runner = runner().await;
+    let mut runner = runner();
     runner.test_options.invariant.call_override = true;
-    let results = runner.test_collect(&filter).await;
+    let results = runner.test_collect(&filter);
 
     assert_multiple(
         &results,
@@ -160,11 +160,11 @@ async fn test_invariant_override() {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_invariant_fail_on_revert() {
     let filter = Filter::new(".*", ".*", ".*fuzz/invariant/common/InvariantHandlerFailure.t.sol");
-    let mut runner = runner().await;
+    let mut runner = runner();
     runner.test_options.invariant.fail_on_revert = true;
     runner.test_options.invariant.runs = 1;
     runner.test_options.invariant.depth = 10;
-    let results = runner.test_collect(&filter).await;
+    let results = runner.test_collect(&filter);
 
     assert_multiple(
         &results,
@@ -185,10 +185,10 @@ async fn test_invariant_fail_on_revert() {
 #[ignore]
 async fn test_invariant_storage() {
     let filter = Filter::new(".*", ".*", ".*fuzz/invariant/storage/InvariantStorageTest.t.sol");
-    let mut runner = runner().await;
+    let mut runner = runner();
     runner.test_options.invariant.depth = 100 + (50 * cfg!(windows) as u32);
     runner.test_options.fuzz.seed = Some(U256::from(6u32));
-    let results = runner.test_collect(&filter).await;
+    let results = runner.test_collect(&filter);
 
     assert_multiple(
         &results,
@@ -208,9 +208,9 @@ async fn test_invariant_storage() {
 #[cfg_attr(windows, ignore = "for some reason there's different rng")]
 async fn test_invariant_shrink() {
     let filter = Filter::new(".*", ".*", ".*fuzz/invariant/common/InvariantInnerContract.t.sol");
-    let mut runner = runner().await;
+    let mut runner = runner();
     runner.test_options.fuzz.seed = Some(U256::from(119u32));
-    let results = runner.test_collect(&filter).await;
+    let results = runner.test_collect(&filter);
 
     let results =
         results.values().last().expect("`InvariantInnerContract.t.sol` should be testable.");
@@ -264,9 +264,9 @@ async fn test_shrink(opts: TestOptions, contract_pattern: &str) {
         contract_pattern,
         ".*fuzz/invariant/common/InvariantShrinkWithAssert.t.sol",
     );
-    let mut runner = runner().await;
+    let mut runner = runner();
     runner.test_options = opts.clone();
-    let results = runner.test_collect(&filter).await;
+    let results = runner.test_collect(&filter);
     let results = results.values().last().expect("`InvariantShrinkWithAssert` should be testable.");
 
     let result = results
@@ -293,10 +293,10 @@ async fn test_shrink(opts: TestOptions, contract_pattern: &str) {
 #[tokio::test(flavor = "multi_thread")]
 async fn test_invariant_preserve_state() {
     let filter = Filter::new(".*", ".*", ".*fuzz/invariant/common/InvariantPreserveState.t.sol");
-    let mut runner = runner().await;
+    let mut runner = runner();
     // Should not fail with default options.
     runner.test_options.invariant.fail_on_revert = true;
-    let results = runner.test_collect(&filter).await;
+    let results = runner.test_collect(&filter);
     assert_multiple(
         &results,
         BTreeMap::from([(
@@ -308,7 +308,7 @@ async fn test_invariant_preserve_state() {
     // same test should revert when preserve state enabled
     runner.test_options.invariant.fail_on_revert = true;
     runner.test_options.invariant.preserve_state = true;
-    let results = runner.test_collect(&filter).await;
+    let results = runner.test_collect(&filter);
     assert_multiple(
         &results,
         BTreeMap::from([(
diff --git a/crates/forge/tests/it/repros.rs b/crates/forge/tests/it/repros.rs
index 8506a248de01..d8b4447cfb9e 100644
--- a/crates/forge/tests/it/repros.rs
+++ b/crates/forge/tests/it/repros.rs
@@ -32,7 +32,7 @@ macro_rules! test_repro {
         paste::paste! {
             #[tokio::test(flavor = "multi_thread")]
             async fn [< issue_ $issue_number >]() {
-                let mut $res = repro_config($issue_number, $should_fail, $sender.into()).await.test().await;
+                let mut $res = repro_config($issue_number, $should_fail, $sender.into()).await.test();
                 $e
             }
         }
@@ -60,7 +60,7 @@ async fn repro_config(issue: usize, should_fail: bool, sender: Option<Address>)
         config.sender = sender;
     }
 
-    let runner = runner_with_config(config).await;
+    let runner = runner_with_config(config);
     TestConfig::with_filter(runner, filter).set_should_fail(should_fail)
 }
 
diff --git a/crates/forge/tests/it/spec.rs b/crates/forge/tests/it/spec.rs
index 724aaa0ff4ff..4dd6aeee50b1 100644
--- a/crates/forge/tests/it/spec.rs
+++ b/crates/forge/tests/it/spec.rs
@@ -7,5 +7,5 @@ use foundry_test_utils::Filter;
 #[tokio::test(flavor = "multi_thread")]
 async fn test_shanghai_compat() {
     let filter = Filter::new("", "ShanghaiCompat", ".*spec");
-    TestConfig::filter(filter).await.evm_spec(SpecId::SHANGHAI).run().await;
+    TestConfig::filter(filter).evm_spec(SpecId::SHANGHAI).run().await;
 }
diff --git a/crates/test-utils/src/util.rs b/crates/test-utils/src/util.rs
index a26936489314..48b3562b2426 100644
--- a/crates/test-utils/src/util.rs
+++ b/crates/test-utils/src/util.rs
@@ -51,7 +51,7 @@ pub const OTHER_SOLC_VERSION: &str = "0.8.22";
 
 /// External test builder
 #[derive(Clone, Debug)]
-#[must_use = "call run()"]
+#[must_use = "ExtTester does nothing unless you `run` it"]
 pub struct ExtTester {
     pub org: &'static str,
     pub name: &'static str,