diff --git a/pw_kernel/kernel/BUILD.bazel b/pw_kernel/kernel/BUILD.bazel
index 6694411..e270a01 100644
--- a/pw_kernel/kernel/BUILD.bazel
+++ b/pw_kernel/kernel/BUILD.bazel
@@ -62,6 +62,7 @@
         "//pw_kernel/lib/foreign_box",
         "//pw_kernel/lib/list",
         "//pw_kernel/lib/log_if",
+        "//pw_kernel/lib/pw_assert",
         "//pw_kernel/lib/pw_status",
         "//pw_kernel/lib/regs",
         "//pw_kernel/lib/time",
diff --git a/pw_kernel/kernel/arch/arm_cortex_m/regs/nvic.rs b/pw_kernel/kernel/arch/arm_cortex_m/regs/nvic.rs
index 1203e0a..bdcf678 100644
--- a/pw_kernel/kernel/arch/arm_cortex_m/regs/nvic.rs
+++ b/pw_kernel/kernel/arch/arm_cortex_m/regs/nvic.rs
@@ -21,6 +21,7 @@
 const IPR_BASE: *mut u32 = 0xe000e400 as *mut u32;
 
 const unsafe fn bit_reg_and_mask(index: usize, reg_base: *mut u32) -> (*mut u32, u32) {
+    // core::assert! used due to const context.
     assert!(index < 32 * 16);
     let offset = index / 32;
     let mask = 1 << (index % 32);
@@ -38,6 +39,7 @@
 }
 
 const unsafe fn priority_reg_and_offset(index: usize, reg_base: *mut u32) -> (*mut u32, usize) {
+    // core::assert! used due to const context.
     assert!(index < 32 * 16);
     let reg_offset = index / 4;
     let field_offset = (index % 4) * 8;
diff --git a/pw_kernel/kernel/arch/arm_cortex_m/threads.rs b/pw_kernel/kernel/arch/arm_cortex_m/threads.rs
index 7f7dbee..88e92d5 100644
--- a/pw_kernel/kernel/arch/arm_cortex_m/threads.rs
+++ b/pw_kernel/kernel/arch/arm_cortex_m/threads.rs
@@ -53,7 +53,8 @@
         old_thread_state: *mut ArchThreadState,
         new_thread_state: *mut ArchThreadState,
     ) -> SpinLockGuard<'a, SchedulerState> {
-        assert!(new_thread_state == sched_state.get_current_arch_thread_state());
+        pw_assert::assert!(new_thread_state == sched_state.get_current_arch_thread_state());
+        // TODO - konkers: Allow $expr to be tokenized.
 
         // info!(
         //     "context switch from thread {:#08x} to thread {:#08x}",
@@ -91,7 +92,7 @@
             sched_state = SCHEDULER_STATE.lock();
         } else {
             // in interrupt context the pendsv should have already triggered it
-            assert!(SCB::is_pendsv_pending());
+            pw_assert::assert!(SCB::is_pendsv_pending());
         }
         sched_state
     }
@@ -128,7 +129,7 @@
     //     initial_function as usize, arg0
     // );
 
-    assert!(Arch::interrupts_enabled());
+    pw_assert::assert!(Arch::interrupts_enabled());
 
     // Call the actual initial function of the thread.
     initial_function(arg0);
@@ -154,8 +155,8 @@
     // in the middle of an atomic sequence.
     asm!("clrex");
 
-    assert!(in_interrupt_handler());
-    assert!(!Arch::interrupts_enabled());
+    pw_assert::assert!(in_interrupt_handler());
+    pw_assert::assert!(!Arch::interrupts_enabled());
 
     // Save the incoming frame to the current active thread's arch state, that will function
     // as the context switch frame for when it is returned to later. Clear active thread
@@ -164,7 +165,7 @@
     // info!("inside pendsv: currently active thread {:08x}", at as usize);
     // info!("old frame {:08x}: pc {:08x}", frame as usize, (*frame).pc);
 
-    assert!(at != core::ptr::null_mut());
+    pw_assert::assert!(at != core::ptr::null_mut());
 
     (*at).frame = frame;
     set_active_thread(core::ptr::null_mut());
diff --git a/pw_kernel/kernel/arch/arm_cortex_m/timer.rs b/pw_kernel/kernel/arch/arm_cortex_m/timer.rs
index 5090da0..db83a7d 100644
--- a/pw_kernel/kernel/arch/arm_cortex_m/timer.rs
+++ b/pw_kernel/kernel/arch/arm_cortex_m/timer.rs
@@ -59,7 +59,7 @@
 
 pub fn systick_init() {
     info!("ticks_per_10ms: {}", SYST::get_ticks_per_10ms());
-    assert_eq!(SYST::get_ticks_per_10ms() * 100, TICKS_PER_SEC);
+    pw_assert::eq!(SYST::get_ticks_per_10ms() * 100, TICKS_PER_SEC);
 }
 
 #[no_mangle]
diff --git a/pw_kernel/kernel/arch/host.rs b/pw_kernel/kernel/arch/host.rs
index 3ed07a2..157b276 100644
--- a/pw_kernel/kernel/arch/host.rs
+++ b/pw_kernel/kernel/arch/host.rs
@@ -32,10 +32,10 @@
         _old_thread_state: *mut ThreadState,
         _new_thread_state: *mut ThreadState,
     ) -> SpinLockGuard<'_, SchedulerState> {
-        panic!("unimplemented");
+        pw_assert::panic!("unimplemented");
     }
     fn initialize_frame(&mut self, _stack: Stack, _initial_function: fn(usize), _arg0: usize) {
-        panic!("unimplemented");
+        pw_assert::panic!("unimplemented");
     }
 }
 
diff --git a/pw_kernel/kernel/lib.rs b/pw_kernel/kernel/lib.rs
index 4b841ce..eb9c2b2 100644
--- a/pw_kernel/kernel/lib.rs
+++ b/pw_kernel/kernel/lib.rs
@@ -32,6 +32,12 @@
 use sync::mutex::Mutex;
 use timer::{Clock, Duration};
 
+#[no_mangle]
+#[allow(non_snake_case)]
+pub extern "C" fn pw_assert_HandleFailure() -> ! {
+    Arch::panic();
+}
+
 // A structure intended to be statically allocated to hold a Thread structure that will
 // be constructed at run time.
 #[repr(C, align(4))]
@@ -51,7 +57,7 @@
     // make sure this function can only be called once.
     #[inline(never)]
     unsafe fn alloc_thread(&mut self, name: &'static str) -> ForeignBox<Thread> {
-        assert!(self.buffer.as_ptr().align_offset(align_of::<Thread>()) == 0);
+        pw_assert::eq!(self.buffer.as_ptr().align_offset(align_of::<Thread>()), 0);
         let thread_ptr = self.buffer.as_mut_ptr() as *mut Thread;
         thread_ptr.write(Thread::new(name));
         ForeignBox::new_from_ptr(&mut *thread_ptr)
@@ -95,7 +101,7 @@
 // completion of main in thread context
 fn bootstrap_thread_entry(_arg: usize) {
     info!("Welcome to the first thread, continuing bootstrap");
-    assert!(Arch::interrupts_enabled());
+    pw_assert::assert!(Arch::interrupts_enabled());
 
     Arch::init();
 
@@ -155,7 +161,7 @@
     SCHEDULER_STATE.lock().dump_all_threads();
 
     info!("End of kernel test");
-    assert!(Arch::interrupts_enabled());
+    pw_assert::assert!(Arch::interrupts_enabled());
 
     info!("Exiting bootstrap thread");
 }
@@ -163,7 +169,7 @@
 #[allow(dead_code)]
 fn idle_thread_entry(_arg: usize) {
     // Fake idle thread to keep the runqueue from being empty if all threads are blocked.
-    assert!(Arch::interrupts_enabled());
+    pw_assert::assert!(Arch::interrupts_enabled());
     loop {
         Arch::idle();
     }
@@ -174,7 +180,7 @@
 #[allow(dead_code)]
 fn test_thread_entry_a(_arg: usize) {
     info!("I'm thread A");
-    assert!(Arch::interrupts_enabled());
+    pw_assert::assert!(Arch::interrupts_enabled());
     loop {
         let mut counter = TEST_COUNTER.lock();
         info!("Thread A incrementing counter");
@@ -186,13 +192,14 @@
 #[allow(dead_code)]
 fn test_thread_entry_b(_arg: usize) {
     info!("I'm thread B");
-    assert!(Arch::interrupts_enabled());
+    pw_assert::assert!(Arch::interrupts_enabled());
     loop {
         let Ok(counter) = TEST_COUNTER.lock_until(Clock::now() + Duration::from_millis(500)) else {
             info!("Thread B: timeout");
             continue;
         };
         info!("Thread B: counter value {}", *counter as u64);
+        pw_assert::ne!(*counter, 2);
         drop(counter);
         yield_timeslice();
     }
diff --git a/pw_kernel/kernel/scheduler.rs b/pw_kernel/kernel/scheduler.rs
index 2f6595a..bd1a8db 100644
--- a/pw_kernel/kernel/scheduler.rs
+++ b/pw_kernel/kernel/scheduler.rs
@@ -135,7 +135,7 @@
     // thread prior to starting it
     #[allow(dead_code)]
     pub fn initialize(&mut self, stack: Stack, entry_point: fn(usize), arg: usize) -> &mut Thread {
-        assert!(self.state == State::New);
+        pw_assert::assert!(self.state == State::New);
         self.stack = stack;
 
         // Call the arch to arrange for the thread to start directly
@@ -154,7 +154,8 @@
     pub fn start(mut thread: ForeignBox<Self>) {
         info!("starting thread {:#x}", thread.id() as usize);
 
-        assert!(thread.state == State::Initial);
+        pw_assert::assert!(thread.state == State::Initial);
+
         thread.state = State::Ready;
 
         let mut sched_state = SCHEDULER_STATE.lock();
@@ -205,7 +206,7 @@
 
     // TODO: assert that this is called exactly once at bootup to switch
     // to this particular thread.
-    assert!(thread.state == State::Initial);
+    pw_assert::assert!(thread.state == State::Initial);
     thread.state = State::Ready;
 
     sched_state.run_queue.push_back(thread);
@@ -217,7 +218,7 @@
     sched_state.current_arch_thread_state = &raw mut temp_arch_thread_state;
 
     reschedule(sched_state, Thread::null_id());
-    panic!("should not reach here");
+    pw_assert::panic!("should not reach here");
 }
 
 // Global scheduler state (single processor for now)
@@ -252,7 +253,7 @@
 
     fn move_current_thread_to_back(&mut self) -> usize {
         let Some(mut current_thread) = self.current_thread.take() else {
-            panic!("no current thread");
+            pw_assert::panic!("no current thread");
         };
         let current_thread_id = current_thread.id();
         current_thread.state = State::Ready;
@@ -263,7 +264,7 @@
     #[allow(dead_code)]
     fn move_current_thread_to_front(&mut self) -> usize {
         let Some(mut current_thread) = self.current_thread.take() else {
-            panic!("no current thread");
+            pw_assert::panic!("no current thread");
         };
         let current_thread_id = current_thread.id();
         current_thread.state = State::Ready;
@@ -315,7 +316,7 @@
 
     #[allow(dead_code)]
     fn insert_in_run_queue_head(&mut self, thread: ForeignBox<Thread>) {
-        assert!(thread.state == State::Ready);
+        pw_assert::assert!(thread.state == State::Ready);
         // info!("pushing thread {:#x} on run queue head", thread.id());
 
         self.run_queue.push_front(thread);
@@ -323,7 +324,7 @@
 
     #[allow(dead_code)]
     fn insert_in_run_queue_tail(&mut self, thread: ForeignBox<Thread>) {
-        assert!(thread.state == State::Ready);
+        pw_assert::assert!(thread.state == State::Ready);
         // info!("pushing thread {:#x} on run queue tail", thread.id());
 
         self.run_queue.push_back(thread);
@@ -338,7 +339,7 @@
     // Caller to reschedule is responsible for removing current thread and
     // put it in the correct run/wait queue.
 
-    assert!(sched_state.current_thread.is_none());
+    pw_assert::assert!(sched_state.current_thread.is_none());
 
     // info!("reschedule");
 
@@ -346,13 +347,14 @@
     // At the moment cannot handle an empty queue, so will panic in that case.
     // TODO: Implement either an idle thread or a special idle routine for that case.
     let Some(mut new_thread) = sched_state.run_queue.pop_head() else {
-        panic!("run_queue empty");
+        pw_assert::panic!("run_queue empty");
     };
 
-    if new_thread.state != State::Ready {
-        info!("<{}> not ready", new_thread.name);
-    }
-    assert!(new_thread.state == State::Ready);
+    pw_assert::assert!(
+        new_thread.state == State::Ready,
+        "<{}> not ready",
+        new_thread.name
+    );
     new_thread.state = State::Running;
 
     if current_thread_id == new_thread.id() {
@@ -420,7 +422,7 @@
     let mut sched_state = SCHEDULER_STATE.lock();
 
     let Some(mut current_thread) = sched_state.current_thread.take() else {
-        panic!("no current thread");
+        pw_assert::panic!("no current thread");
     };
     let current_thread_id = current_thread.id();
 
@@ -478,7 +480,7 @@
             self.queue
                 .remove_element(NonNull::new_unchecked(waiting_thread))
         }) else {
-            panic!("thread no longer in wait queue");
+            pw_assert::panic!("thread no longer in wait queue");
         };
 
         wait_queue_debug!("<{}> timeout", thread.name);
@@ -499,7 +501,7 @@
 
     pub fn wait(mut self) -> Self {
         let Some(thread) = self.sched_mut().current_thread.take() else {
-            panic!("no active thread");
+            pw_assert::panic!("no active thread");
         };
         wait_queue_debug!("<{}> waiting", thread.name);
         self = self.add_to_queue_and_reschedule(thread);
@@ -509,7 +511,7 @@
 
     pub fn wait_until(mut self, deadline: Instant) -> (Self, Result<()>) {
         let Some(mut thread) = self.sched_mut().current_thread.take() else {
-            panic!("no active thread");
+            pw_assert::panic!("no active thread");
         };
 
         wait_queue_debug!("<{}> wait_until", thread.name);
diff --git a/pw_kernel/kernel/sync/mutex.rs b/pw_kernel/kernel/sync/mutex.rs
index 8f19577..f26fe1c 100644
--- a/pw_kernel/kernel/sync/mutex.rs
+++ b/pw_kernel/kernel/sync/mutex.rs
@@ -119,8 +119,8 @@
     fn unlock(&self) {
         let mut state = self.state.lock();
 
-        assert!(state.count > 0);
-        assert_eq!(state.holder_thread_id, state.sched().current_thread_id());
+        pw_assert::assert!(state.count > 0);
+        pw_assert::eq!(state.holder_thread_id, state.sched().current_thread_id());
         state.holder_thread_id = Thread::null_id();
 
         state.count -= 1;
diff --git a/pw_kernel/kernel/timer.rs b/pw_kernel/kernel/timer.rs
index 4fd2f77..71978ef 100644
--- a/pw_kernel/kernel/timer.rs
+++ b/pw_kernel/kernel/timer.rs
@@ -128,7 +128,7 @@
             drop(timer_queue);
 
             let Some(mut callback_fn) = callback.callback.take() else {
-                panic!("Non callback function found on timer");
+                pw_assert::panic!("Non callback function found on timer");
             };
             (callback_fn)(callback, now);
             let _ = callback_fn.consume();
diff --git a/pw_kernel/lib/foreign_box/BUILD.bazel b/pw_kernel/lib/foreign_box/BUILD.bazel
index 8e917ee..3994591 100644
--- a/pw_kernel/lib/foreign_box/BUILD.bazel
+++ b/pw_kernel/lib/foreign_box/BUILD.bazel
@@ -21,7 +21,7 @@
     name = "foreign_box",
     srcs = ["foreign_box.rs"],
     tags = ["kernel"],
-    deps = ["//pw_log/rust:pw_log"],
+    deps = ["//pw_kernel/lib/pw_assert"],
 )
 
 # foreign_box uses the std rust test harness to allow asserting that it panics
@@ -29,6 +29,7 @@
 rust_test(
     name = "foreign_box_test",
     crate = ":foreign_box",
+    crate_features = ["core_panic"],
     tags = ["kernel"],
     target_compatible_with = incompatible_with_mcu(),
     deps = ["//pw_kernel/subsys/console:console_backend"],
diff --git a/pw_kernel/lib/foreign_box/foreign_box.rs b/pw_kernel/lib/foreign_box/foreign_box.rs
index 3a68e10..0f55d90 100644
--- a/pw_kernel/lib/foreign_box/foreign_box.rs
+++ b/pw_kernel/lib/foreign_box/foreign_box.rs
@@ -21,8 +21,6 @@
     ptr::NonNull,
 };
 
-use pw_log::fatal;
-
 pub struct ForeignBox<T: ?Sized> {
     inner: NonNull<T>,
 
@@ -61,7 +59,11 @@
     /// of the `ForeignBox` object.
     pub unsafe fn new_from_ptr(ptr: *mut T) -> Self {
         let Some(ptr) = NonNull::new(ptr) else {
-            panic!("Null pointer");
+            if cfg!(feature = "core_panic") {
+                panic!("Null pointer");
+            } else {
+                pw_assert::panic!("Null pointer");
+            }
         };
         Self::new(ptr)
     }
@@ -91,12 +93,17 @@
 impl<T: ?Sized> Drop for ForeignBox<T> {
     fn drop(&mut self) {
         if !self.consumed {
-            // TODO: Build out `pw_log` friendly panics.
-            fatal!(
-                "ForeignBox@{:08x} dropped before being consumed!",
-                self.inner.as_ptr() as *const () as usize
-            );
-            panic!("ForeignBox dropped before being consumed!");
+            if cfg!(feature = "core_panic") {
+                panic!(
+                    "ForeignBox@{:08x} dropped before being consumed!",
+                    self.inner.as_ptr() as *const () as usize
+                );
+            } else {
+                pw_assert::panic!(
+                    "ForeignBox@{:08x} dropped before being consumed!",
+                    self.inner.as_ptr() as *const () as usize
+                );
+            }
         }
     }
 }
@@ -133,7 +140,6 @@
 
     // Ensure that the console backend (needed for pw_log) is linked.
     use console_backend as _;
-
     #[test]
     fn consume_returns_the_same_pointer() {
         let mut value = 0xdecafbad_u32;
diff --git a/pw_kernel/lib/unittest/BUILD.bazel b/pw_kernel/lib/unittest/BUILD.bazel
index cec0180..07d7c41 100644
--- a/pw_kernel/lib/unittest/BUILD.bazel
+++ b/pw_kernel/lib/unittest/BUILD.bazel
@@ -65,6 +65,7 @@
     visibility = ["//visibility:public"],
     deps = [
         ":unittest_core",
+        "//pw_kernel/kernel",
         "//pw_kernel/subsys/console:console_backend",
         "@pigweed//pw_log/rust:pw_log",
     ],
diff --git a/pw_kernel/lib/unittest/unittest_runner_host.rs b/pw_kernel/lib/unittest/unittest_runner_host.rs
index 8abc7a6..de55fc7 100644
--- a/pw_kernel/lib/unittest/unittest_runner_host.rs
+++ b/pw_kernel/lib/unittest/unittest_runner_host.rs
@@ -12,6 +12,7 @@
 // License for the specific language governing permissions and limitations under
 // the License.
 use console_backend as _;
+use kernel as _;
 use pw_log::{error, info};
 
 #[no_mangle]