diff --git a/rt/src/scheduler/inactive.rs b/rt/src/scheduler/inactive.rs
index db4b06166..9c682290c 100644
--- a/rt/src/scheduler/inactive.rs
+++ b/rt/src/scheduler/inactive.rs
@@ -449,7 +449,7 @@ mod tests {
 
         impl Drop for DropTest {
             fn drop(&mut self) {
-                let _ = self.0.fetch_add(1, Ordering::SeqCst);
+                let _ = self.0.fetch_add(1, Ordering::AcqRel);
             }
         }
 
diff --git a/rt/src/scheduler/shared/inactive.rs b/rt/src/scheduler/shared/inactive.rs
index 63fdbec4e..5d6326a5a 100644
--- a/rt/src/scheduler/shared/inactive.rs
+++ b/rt/src/scheduler/shared/inactive.rs
@@ -825,7 +825,7 @@ mod tests {
 
     impl Drop for DropTest {
         fn drop(&mut self) {
-            let _ = self.0.fetch_add(1, Ordering::SeqCst);
+            let _ = self.0.fetch_add(1, Ordering::AcqRel);
         }
     }
 
diff --git a/rt/src/test.rs b/rt/src/test.rs
index bfcce69e3..913546210 100644
--- a/rt/src/test.rs
+++ b/rt/src/test.rs
@@ -605,7 +605,7 @@ where
     M: Send + 'static,
 {
     static SYNC_WORKER_TEST_ID: AtomicUsize = AtomicUsize::new(10_000);
-    let id = SYNC_WORKER_TEST_ID.fetch_add(1, Ordering::SeqCst);
+    let id = SYNC_WORKER_TEST_ID.fetch_add(1, Ordering::AcqRel);
 
     let shared = shared_internals();
     sync_worker::start(id, supervisor, actor, arg, options, shared, None).map(
diff --git a/rt/src/timers/tests.rs b/rt/src/timers/tests.rs
index 4ecb10125..14efb46fd 100644
--- a/rt/src/timers/tests.rs
+++ b/rt/src/timers/tests.rs
@@ -33,7 +33,7 @@ impl<const N: usize> WakerBuilder<N> {
     }
 
     fn is_awoken(&self, n: usize) -> bool {
-        self.awoken[n].load(Ordering::SeqCst)
+        self.awoken[n].load(Ordering::Acquire)
     }
 }
 
@@ -45,7 +45,7 @@ struct TaskWaker<const N: usize> {
 
 impl<const N: usize> Wake for TaskWaker<N> {
     fn wake(self: Arc<Self>) {
-        self.awoken[self.n].store(true, Ordering::SeqCst)
+        self.awoken[self.n].store(true, Ordering::Release)
     }
 }
 
diff --git a/rt/src/wakers/shared.rs b/rt/src/wakers/shared.rs
index 70e6ab0c8..65defb8a5 100644
--- a/rt/src/wakers/shared.rs
+++ b/rt/src/wakers/shared.rs
@@ -28,7 +28,7 @@ impl Wakers {
         /// Static used to determine unique indices into `RUNTIMES`.
         static IDS: AtomicU8 = AtomicU8::new(0);
 
-        let id = IDS.fetch_add(1, Ordering::SeqCst);
+        let id = IDS.fetch_add(1, Ordering::AcqRel);
         assert!(
             (id as usize) < MAX_RUNTIMES,
             "Created too many Heph `Runtime`s, maximum of {MAX_RUNTIMES}",
diff --git a/rt/tests/functional/runtime.rs b/rt/tests/functional/runtime.rs
index dd348fc7c..9c55c592b 100644
--- a/rt/tests/functional/runtime.rs
+++ b/rt/tests/functional/runtime.rs
@@ -325,11 +325,11 @@ fn running_actors() {
     }
 
     fn get(value: &AtomicUsize) -> usize {
-        value.load(Ordering::SeqCst)
+        value.load(Ordering::Acquire)
     }
 
     fn incr(value: &AtomicUsize) {
-        let _ = value.fetch_add(1, Ordering::SeqCst);
+        let _ = value.fetch_add(1, Ordering::AcqRel);
     }
 
     impl<NA> Supervisor<NA> for RunningSupervisor<NA::Argument>
@@ -513,12 +513,12 @@ fn external_thread_wakes_sync_actor() {
 }
 
 async fn panic_actor<RT>(_: actor::Context<!, RT>, mark: &'static AtomicBool) {
-    mark.store(true, Ordering::SeqCst);
+    mark.store(true, Ordering::Release);
     panic!("on purpose panic");
 }
 
 async fn ok_actor<RT>(_: actor::Context<!, RT>, mark: &'static AtomicBool) {
-    mark.store(true, Ordering::SeqCst);
+    mark.store(true, Ordering::Release);
 }
 
 fn actor_drop_panic<RT>(_: actor::Context<!, RT>, mark: &'static AtomicBool) -> PanicOnDropFuture {
@@ -531,7 +531,7 @@ impl Future for PanicOnDropFuture {
     type Output = ();
 
     fn poll(self: Pin<&mut Self>, _: &mut task::Context<'_>) -> Poll<Self::Output> {
-        self.0.store(true, Ordering::SeqCst);
+        self.0.store(true, Ordering::Release);
         Poll::Ready(())
     }
 }
@@ -543,12 +543,12 @@ impl Drop for PanicOnDropFuture {
 }
 
 async fn panic_future(mark: &'static AtomicBool) {
-    mark.store(true, Ordering::SeqCst);
+    mark.store(true, Ordering::Release);
     panic!("on purpose panic");
 }
 
 async fn ok_future(mark: &'static AtomicBool) {
-    mark.store(true, Ordering::SeqCst);
+    mark.store(true, Ordering::Release);
 }
 
 #[test]
@@ -571,8 +571,8 @@ fn catches_actor_panics() {
     );
     runtime.start().unwrap();
 
-    assert!(PANIC_RAN.load(Ordering::SeqCst));
-    assert!(OK_RAN.load(Ordering::SeqCst));
+    assert!(PANIC_RAN.load(Ordering::Acquire));
+    assert!(OK_RAN.load(Ordering::Acquire));
 }
 
 #[test]
@@ -600,8 +600,8 @@ fn catches_local_actor_panics() {
         .unwrap();
     runtime.start().unwrap();
 
-    assert!(PANIC_RAN.load(Ordering::SeqCst));
-    assert!(OK_RAN.load(Ordering::SeqCst));
+    assert!(PANIC_RAN.load(Ordering::Acquire));
+    assert!(OK_RAN.load(Ordering::Acquire));
 }
 
 #[test]
@@ -624,8 +624,8 @@ fn catches_actor_panics_on_drop() {
     );
     runtime.start().unwrap();
 
-    assert!(PANIC_RAN.load(Ordering::SeqCst));
-    assert!(OK_RAN.load(Ordering::SeqCst));
+    assert!(PANIC_RAN.load(Ordering::Acquire));
+    assert!(OK_RAN.load(Ordering::Acquire));
 }
 
 #[test]
@@ -653,8 +653,8 @@ fn catches_local_actor_panics_on_drop() {
         .unwrap();
     runtime.start().unwrap();
 
-    assert!(PANIC_RAN.load(Ordering::SeqCst));
-    assert!(OK_RAN.load(Ordering::SeqCst));
+    assert!(PANIC_RAN.load(Ordering::Acquire));
+    assert!(OK_RAN.load(Ordering::Acquire));
 }
 
 #[test]
@@ -673,8 +673,8 @@ fn catches_future_panics() {
     );
     runtime.start().unwrap();
 
-    assert!(PANIC_RAN.load(Ordering::SeqCst));
-    assert!(OK_RAN.load(Ordering::SeqCst));
+    assert!(PANIC_RAN.load(Ordering::Acquire));
+    assert!(OK_RAN.load(Ordering::Acquire));
 }
 
 #[test]
@@ -698,8 +698,8 @@ fn catches_local_future_panics() {
         .unwrap();
     runtime.start().unwrap();
 
-    assert!(PANIC_RAN.load(Ordering::SeqCst));
-    assert!(OK_RAN.load(Ordering::SeqCst));
+    assert!(PANIC_RAN.load(Ordering::Acquire));
+    assert!(OK_RAN.load(Ordering::Acquire));
 }
 
 #[test]
@@ -718,8 +718,8 @@ fn catches_future_panics_on_drop() {
     );
     runtime.start().unwrap();
 
-    assert!(PANIC_RAN.load(Ordering::SeqCst));
-    assert!(OK_RAN.load(Ordering::SeqCst));
+    assert!(PANIC_RAN.load(Ordering::Acquire));
+    assert!(OK_RAN.load(Ordering::Acquire));
 }
 
 #[test]
@@ -743,6 +743,6 @@ fn catches_local_future_panics_on_drop() {
         .unwrap();
     runtime.start().unwrap();
 
-    assert!(PANIC_RAN.load(Ordering::SeqCst));
-    assert!(OK_RAN.load(Ordering::SeqCst));
+    assert!(PANIC_RAN.load(Ordering::Acquire));
+    assert!(OK_RAN.load(Ordering::Acquire));
 }
diff --git a/rt/tests/process_signals.rs b/rt/tests/process_signals.rs
index abc485e86..023247ac5 100644
--- a/rt/tests/process_signals.rs
+++ b/rt/tests/process_signals.rs
@@ -86,18 +86,18 @@ fn with_signal_handles() {
     runtime.start().unwrap();
 
     // Make sure that all the actor received the signal once.
-    assert_eq!(thread_local.load(Ordering::SeqCst), 1);
-    assert_eq!(thread_safe1.load(Ordering::SeqCst), 1);
-    assert_eq!(thread_safe2.load(Ordering::SeqCst), 1);
-    assert_eq!(sync.load(Ordering::SeqCst), 1);
+    assert_eq!(thread_local.load(Ordering::Acquire), 1);
+    assert_eq!(thread_safe1.load(Ordering::Acquire), 1);
+    assert_eq!(thread_safe2.load(Ordering::Acquire), 1);
+    assert_eq!(sync.load(Ordering::Acquire), 1);
 }
 
 async fn actor<RT>(mut ctx: actor::Context<Signal, RT>, got_signal: Arc<AtomicUsize>) {
     let _msg = ctx.receive_next().await.unwrap();
-    got_signal.fetch_add(1, Ordering::SeqCst);
+    got_signal.fetch_add(1, Ordering::AcqRel);
 }
 
 fn sync_actor<RT>(mut ctx: sync::Context<Signal, RT>, got_signal: Arc<AtomicUsize>) {
     let _msg = ctx.receive_next().unwrap();
-    got_signal.fetch_add(1, Ordering::SeqCst);
+    got_signal.fetch_add(1, Ordering::AcqRel);
 }