diff --git a/examples/binds.rs b/examples/binds.rs
index 56565cbec9..04b8fad19e 100644
--- a/examples/binds.rs
+++ b/examples/binds.rs
@@ -23,14 +23,14 @@ mod app {
     fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
         rtic::pend(Interrupt::UART0);
 
-        hprintln!("init").unwrap();
+        hprintln!("init");
 
         (Shared {}, Local {}, init::Monotonics())
     }
 
     #[idle]
     fn idle(_: idle::Context) -> ! {
-        hprintln!("idle").unwrap();
+        hprintln!("idle");
 
         rtic::pend(Interrupt::UART0);
 
diff --git a/examples/capacity.rs b/examples/capacity.rs
index a617269869..e625249af8 100644
--- a/examples/capacity.rs
+++ b/examples/capacity.rs
@@ -37,12 +37,12 @@ mod app {
 
     #[task(capacity = 4)]
     fn foo(_: foo::Context, x: u32) {
-        hprintln!("foo({})", x).unwrap();
+        hprintln!("foo({})", x);
     }
 
     #[task]
     fn bar(_: bar::Context) {
-        hprintln!("bar").unwrap();
+        hprintln!("bar");
 
         debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
     }
diff --git a/examples/complex.rs b/examples/complex.rs
index e5cf6dbea3..653198746b 100644
--- a/examples/complex.rs
+++ b/examples/complex.rs
@@ -25,7 +25,7 @@ mod app {
 
     #[init]
     fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
-        hprintln!("init").unwrap();
+        hprintln!("init");
 
         (
             Shared {
diff --git a/examples/destructure.rs b/examples/destructure.rs
index 6019c225cc..fd577a6c9c 100644
--- a/examples/destructure.rs
+++ b/examples/destructure.rs
@@ -42,7 +42,7 @@ mod app {
         let b = cx.shared.b;
         let c = cx.shared.c;
 
-        hprintln!("foo: a = {}, b = {}, c = {}", a, b, c).unwrap();
+        hprintln!("foo: a = {}, b = {}, c = {}", a, b, c);
     }
 
     // De-structure-ing syntax
@@ -50,6 +50,6 @@ mod app {
     fn bar(cx: bar::Context) {
         let bar::SharedResources { a, b, c } = cx.shared;
 
-        hprintln!("bar: a = {}, b = {}, c = {}", a, b, c).unwrap();
+        hprintln!("bar: a = {}, b = {}, c = {}", a, b, c);
     }
 }
diff --git a/examples/extern_binds.rs b/examples/extern_binds.rs
index 4dc6633c5d..b6df2fb257 100644
--- a/examples/extern_binds.rs
+++ b/examples/extern_binds.rs
@@ -29,14 +29,14 @@ mod app {
     fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
         rtic::pend(Interrupt::UART0);
 
-        hprintln!("init").unwrap();
+        hprintln!("init");
 
         (Shared {}, Local {}, init::Monotonics())
     }
 
     #[idle]
     fn idle(_: idle::Context) -> ! {
-        hprintln!("idle").unwrap();
+        hprintln!("idle");
 
         rtic::pend(Interrupt::UART0);
 
diff --git a/examples/extern_spawn.rs b/examples/extern_spawn.rs
index 7f9b5a5f9b..2eec2dbc49 100644
--- a/examples/extern_spawn.rs
+++ b/examples/extern_spawn.rs
@@ -10,7 +10,7 @@ use panic_semihosting as _;
 
 // Free function implementing the spawnable task `foo`.
 fn foo(_c: app::foo::Context, x: i32, y: u32) {
-    hprintln!("foo {}, {}", x, y).unwrap();
+    hprintln!("foo {}, {}", x, y);
     if x == 2 {
         debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
     }
diff --git a/examples/generics.rs b/examples/generics.rs
index 72b861ba91..f9a6aacfc8 100644
--- a/examples/generics.rs
+++ b/examples/generics.rs
@@ -32,7 +32,7 @@ mod app {
 
     #[task(binds = UART0, shared = [shared], local = [state: u32 = 0])]
     fn uart0(c: uart0::Context) {
-        hprintln!("UART0(STATE = {})", *c.local.state).unwrap();
+        hprintln!("UART0(STATE = {})", *c.local.state);
 
         // second argument has type `shared::shared`
         super::advance(c.local.state, c.shared.shared);
@@ -44,7 +44,7 @@ mod app {
 
     #[task(binds = UART1, priority = 2, shared = [shared], local = [state: u32 = 0])]
     fn uart1(c: uart1::Context) {
-        hprintln!("UART1(STATE = {})", *c.local.state).unwrap();
+        hprintln!("UART1(STATE = {})", *c.local.state);
 
         // second argument has type `shared::shared`
         super::advance(c.local.state, c.shared.shared);
@@ -61,5 +61,5 @@ fn advance(state: &mut u32, mut shared: impl Mutex<T = u32>) {
         (old, *shared)
     });
 
-    hprintln!("shared: {} -> {}", old, new).unwrap();
+    hprintln!("shared: {} -> {}", old, new);
 }
diff --git a/examples/hardware.rs b/examples/hardware.rs
index 60632247fb..22cf5d928d 100644
--- a/examples/hardware.rs
+++ b/examples/hardware.rs
@@ -24,7 +24,7 @@ mod app {
         // `init` returns because interrupts are disabled
         rtic::pend(Interrupt::UART0); // equivalent to NVIC::pend
 
-        hprintln!("init").unwrap();
+        hprintln!("init");
 
         (Shared {}, Local {}, init::Monotonics())
     }
@@ -33,7 +33,7 @@ mod app {
     fn idle(_: idle::Context) -> ! {
         // interrupts are enabled again; the `UART0` handler runs at this point
 
-        hprintln!("idle").unwrap();
+        hprintln!("idle");
 
         rtic::pend(Interrupt::UART0);
 
diff --git a/examples/idle-wfi.rs b/examples/idle-wfi.rs
index 4a8a8dee2b..42fd7b49e0 100644
--- a/examples/idle-wfi.rs
+++ b/examples/idle-wfi.rs
@@ -19,7 +19,7 @@ mod app {
 
     #[init]
     fn init(mut cx: init::Context) -> (Shared, Local, init::Monotonics) {
-        hprintln!("init").unwrap();
+        hprintln!("init");
 
         // Set the ARM SLEEPONEXIT bit to go to sleep after handling interrupts
         // See https://developer.arm.com/docs/100737/0100/power-management/sleep-mode/sleep-on-exit-bit
@@ -33,7 +33,7 @@ mod app {
         // Locals in idle have lifetime 'static
         let _x: &'static mut u32 = cx.local.x;
 
-        hprintln!("idle").unwrap();
+        hprintln!("idle");
 
         debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
 
diff --git a/examples/idle.rs b/examples/idle.rs
index 55d6b15352..ad04fd68e4 100644
--- a/examples/idle.rs
+++ b/examples/idle.rs
@@ -19,7 +19,7 @@ mod app {
 
     #[init]
     fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
-        hprintln!("init").unwrap();
+        hprintln!("init");
 
         (Shared {}, Local {}, init::Monotonics())
     }
@@ -29,7 +29,7 @@ mod app {
         // Locals in idle have lifetime 'static
         let _x: &'static mut u32 = cx.local.x;
 
-        hprintln!("idle").unwrap();
+        hprintln!("idle");
 
         debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
 
diff --git a/examples/init.rs b/examples/init.rs
index b8a5bc5b98..7a10149692 100644
--- a/examples/init.rs
+++ b/examples/init.rs
@@ -32,7 +32,7 @@ mod app {
         // to indicate that this is a critical seciton
         let _cs_token: bare_metal::CriticalSection = cx.cs;
 
-        hprintln!("init").unwrap();
+        hprintln!("init");
 
         debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
 
diff --git a/examples/locals.rs b/examples/locals.rs
index aa5d0fee30..1889775316 100644
--- a/examples/locals.rs
+++ b/examples/locals.rs
@@ -45,7 +45,7 @@ mod app {
         let local_to_idle = cx.local.local_to_idle;
         *local_to_idle += 1;
 
-        hprintln!("idle: local_to_idle = {}", local_to_idle).unwrap();
+        hprintln!("idle: local_to_idle = {}", local_to_idle);
 
         debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
 
@@ -69,7 +69,7 @@ mod app {
         // error: no `local_to_bar` field in `foo::LocalResources`
         // cx.local.local_to_bar += 1;
 
-        hprintln!("foo: local_to_foo = {}", local_to_foo).unwrap();
+        hprintln!("foo: local_to_foo = {}", local_to_foo);
     }
 
     // `local_to_bar` can only be accessed from this context
@@ -81,6 +81,6 @@ mod app {
         // error: no `local_to_foo` field in `bar::LocalResources`
         // cx.local.local_to_foo += 1;
 
-        hprintln!("bar: local_to_bar = {}", local_to_bar).unwrap();
+        hprintln!("bar: local_to_bar = {}", local_to_bar);
     }
 }
diff --git a/examples/lock-free.rs b/examples/lock-free.rs
index ea6ff1bf37..32853e44ed 100644
--- a/examples/lock-free.rs
+++ b/examples/lock-free.rs
@@ -33,7 +33,7 @@ mod app {
 
         *c.shared.counter += 1; // <- no lock API required
         let counter = *c.shared.counter;
-        hprintln!("  foo = {}", counter).unwrap();
+        hprintln!("  foo = {}", counter);
     }
 
     #[task(shared = [counter])] // <- same priority
@@ -42,7 +42,7 @@ mod app {
 
         *c.shared.counter += 1; // <- no lock API required
         let counter = *c.shared.counter;
-        hprintln!("  bar = {}", counter).unwrap();
+        hprintln!("  bar = {}", counter);
 
         debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
     }
diff --git a/examples/lock.rs b/examples/lock.rs
index f1a16968ce..16f3b33812 100644
--- a/examples/lock.rs
+++ b/examples/lock.rs
@@ -29,7 +29,7 @@ mod app {
     // when omitted priority is assumed to be `1`
     #[task(shared = [shared])]
     fn foo(mut c: foo::Context) {
-        hprintln!("A").unwrap();
+        hprintln!("A");
 
         // the lower priority task requires a critical section to access the data
         c.shared.shared.lock(|shared| {
@@ -39,7 +39,7 @@ mod app {
             // bar will *not* run right now due to the critical section
             bar::spawn().unwrap();
 
-            hprintln!("B - shared = {}", *shared).unwrap();
+            hprintln!("B - shared = {}", *shared);
 
             // baz does not contend for `shared` so it's allowed to run now
             baz::spawn().unwrap();
@@ -47,7 +47,7 @@ mod app {
 
         // critical section is over: bar can now start
 
-        hprintln!("E").unwrap();
+        hprintln!("E");
 
         debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
     }
@@ -61,11 +61,11 @@ mod app {
             *shared
         });
 
-        hprintln!("D - shared = {}", shared).unwrap();
+        hprintln!("D - shared = {}", shared);
     }
 
     #[task(priority = 3)]
     fn baz(_: baz::Context) {
-        hprintln!("C").unwrap();
+        hprintln!("C");
     }
 }
diff --git a/examples/message.rs b/examples/message.rs
index 76c5675aaa..a5c89199ee 100644
--- a/examples/message.rs
+++ b/examples/message.rs
@@ -26,7 +26,7 @@ mod app {
 
     #[task(local = [count: u32 = 0])]
     fn foo(cx: foo::Context) {
-        hprintln!("foo").unwrap();
+        hprintln!("foo");
 
         bar::spawn(*cx.local.count).unwrap();
         *cx.local.count += 1;
@@ -34,14 +34,14 @@ mod app {
 
     #[task]
     fn bar(_: bar::Context, x: u32) {
-        hprintln!("bar({})", x).unwrap();
+        hprintln!("bar({})", x);
 
         baz::spawn(x + 1, x + 2).unwrap();
     }
 
     #[task]
     fn baz(_: baz::Context, x: u32, y: u32) {
-        hprintln!("baz({}, {})", x, y).unwrap();
+        hprintln!("baz({}, {})", x, y);
 
         if x + y > 4 {
             debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
diff --git a/examples/message_passing.rs b/examples/message_passing.rs
index ffa9537127..13e3b98de3 100644
--- a/examples/message_passing.rs
+++ b/examples/message_passing.rs
@@ -29,7 +29,7 @@ mod app {
 
     #[task(capacity = 3)]
     fn foo(_c: foo::Context, x: i32, y: u32) {
-        hprintln!("foo {}, {}", x, y).unwrap();
+        hprintln!("foo {}, {}", x, y);
         if x == 2 {
             debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
         }
diff --git a/examples/multilock.rs b/examples/multilock.rs
index d99bae695e..83df8d7d4e 100644
--- a/examples/multilock.rs
+++ b/examples/multilock.rs
@@ -48,7 +48,7 @@ mod app {
             *s2 += 1;
             *s3 += 1;
 
-            hprintln!("Multiple locks, s1: {}, s2: {}, s3: {}", *s1, *s2, *s3).unwrap();
+            hprintln!("Multiple locks, s1: {}, s2: {}, s3: {}", *s1, *s2, *s3);
         });
 
         debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
diff --git a/examples/only-shared-access.rs b/examples/only-shared-access.rs
index 8b0a77ef8c..c9826d09b0 100644
--- a/examples/only-shared-access.rs
+++ b/examples/only-shared-access.rs
@@ -30,13 +30,13 @@ mod app {
     #[task(shared = [&key])]
     fn foo(cx: foo::Context) {
         let key: &u32 = cx.shared.key;
-        hprintln!("foo(key = {:#x})", key).unwrap();
+        hprintln!("foo(key = {:#x})", key);
 
         debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
     }
 
     #[task(priority = 2, shared = [&key])]
     fn bar(cx: bar::Context) {
-        hprintln!("bar(key = {:#x})", cx.shared.key).unwrap();
+        hprintln!("bar(key = {:#x})", cx.shared.key);
     }
 }
diff --git a/examples/pool.rs b/examples/pool.rs
index d59bd91607..5014e216d3 100644
--- a/examples/pool.rs
+++ b/examples/pool.rs
@@ -56,7 +56,7 @@ mod app {
 
     #[task]
     fn foo(_: foo::Context, x: Box<P>) {
-        hprintln!("foo({:?})", x.as_ptr()).unwrap();
+        hprintln!("foo({:?})", x.as_ptr());
 
         // explicitly return the block to the pool
         drop(x);
@@ -66,7 +66,7 @@ mod app {
 
     #[task(priority = 2)]
     fn bar(_: bar::Context, x: Box<P>) {
-        hprintln!("bar({:?})", x.as_ptr()).unwrap();
+        hprintln!("bar({:?})", x.as_ptr());
 
         // this is done automatically so we can omit the call to `drop`
         // drop(x);
diff --git a/examples/preempt.rs b/examples/preempt.rs
index d0c8cc7d3f..3c7f242990 100644
--- a/examples/preempt.rs
+++ b/examples/preempt.rs
@@ -25,21 +25,21 @@ mod app {
 
     #[task(priority = 1)]
     fn foo(_: foo::Context) {
-        hprintln!("foo - start").unwrap();
+        hprintln!("foo - start");
         baz::spawn().unwrap();
-        hprintln!("foo - end").unwrap();
+        hprintln!("foo - end");
         debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
     }
 
     #[task(priority = 2)]
     fn bar(_: bar::Context) {
-        hprintln!(" bar").unwrap();
+        hprintln!(" bar");
     }
 
     #[task(priority = 2)]
     fn baz(_: baz::Context) {
-        hprintln!(" baz - start").unwrap();
+        hprintln!(" baz - start");
         bar::spawn().unwrap();
-        hprintln!(" baz - end").unwrap();
+        hprintln!(" baz - end");
     }
 }
diff --git a/examples/ramfunc.rs b/examples/ramfunc.rs
index b3b8012c38..049af18fbe 100644
--- a/examples/ramfunc.rs
+++ b/examples/ramfunc.rs
@@ -33,7 +33,7 @@ mod app {
     #[inline(never)]
     #[task]
     fn foo(_: foo::Context) {
-        hprintln!("foo").unwrap();
+        hprintln!("foo");
 
         debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
     }
diff --git a/examples/resource-user-struct.rs b/examples/resource-user-struct.rs
index ae1918d05d..39a5b16c8a 100644
--- a/examples/resource-user-struct.rs
+++ b/examples/resource-user-struct.rs
@@ -55,7 +55,7 @@ mod app {
             *shared
         });
 
-        hprintln!("UART0: shared = {}", shared).unwrap();
+        hprintln!("UART0: shared = {}", shared);
     }
 
     // `shared` can be accessed from this context
@@ -66,6 +66,6 @@ mod app {
             *shared
         });
 
-        hprintln!("UART1: shared = {}", shared).unwrap();
+        hprintln!("UART1: shared = {}", shared);
     }
 }
diff --git a/examples/shared.rs b/examples/shared.rs
index d87dca5263..58d64e4191 100644
--- a/examples/shared.rs
+++ b/examples/shared.rs
@@ -34,7 +34,7 @@ mod app {
     fn idle(mut c: idle::Context) -> ! {
         loop {
             if let Some(byte) = c.shared.c.lock(|c| c.dequeue()) {
-                hprintln!("received message: {}", byte).unwrap();
+                hprintln!("received message: {}", byte);
 
                 debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
             } else {
diff --git a/examples/spawn.rs b/examples/spawn.rs
index 2db1ab8a28..75b7f85fe8 100644
--- a/examples/spawn.rs
+++ b/examples/spawn.rs
@@ -19,7 +19,7 @@ mod app {
 
     #[init]
     fn init(_: init::Context) -> (Shared, Local, init::Monotonics) {
-        hprintln!("init").unwrap();
+        hprintln!("init");
         foo::spawn().unwrap();
 
         (Shared {}, Local {}, init::Monotonics())
@@ -27,7 +27,7 @@ mod app {
 
     #[task]
     fn foo(_: foo::Context) {
-        hprintln!("foo").unwrap();
+        hprintln!("foo");
 
         debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
     }
diff --git a/examples/static.rs b/examples/static.rs
index c9aa6046b5..abeb9c525a 100644
--- a/examples/static.rs
+++ b/examples/static.rs
@@ -37,7 +37,7 @@ mod app {
         loop {
             // Lock-free access to the same underlying queue!
             if let Some(data) = c.local.c.dequeue() {
-                hprintln!("received message: {}", data).unwrap();
+                hprintln!("received message: {}", data);
 
                 // Run foo until data
                 if data == 3 {
diff --git a/examples/task.rs b/examples/task.rs
index 2c53aa2359..d24fca6261 100644
--- a/examples/task.rs
+++ b/examples/task.rs
@@ -26,31 +26,31 @@ mod app {
 
     #[task]
     fn foo(_: foo::Context) {
-        hprintln!("foo - start").unwrap();
+        hprintln!("foo - start");
 
         // spawns `bar` onto the task scheduler
         // `foo` and `bar` have the same priority so `bar` will not run until
         // after `foo` terminates
         bar::spawn().unwrap();
 
-        hprintln!("foo - middle").unwrap();
+        hprintln!("foo - middle");
 
         // spawns `baz` onto the task scheduler
         // `baz` has higher priority than `foo` so it immediately preempts `foo`
         baz::spawn().unwrap();
 
-        hprintln!("foo - end").unwrap();
+        hprintln!("foo - end");
     }
 
     #[task]
     fn bar(_: bar::Context) {
-        hprintln!("bar").unwrap();
+        hprintln!("bar");
 
         debug::exit(debug::EXIT_SUCCESS); // Exit QEMU simulator
     }
 
     #[task(priority = 2)]
     fn baz(_: baz::Context) {
-        hprintln!("baz").unwrap();
+        hprintln!("baz");
     }
 }