diff --git a/Cargo.toml b/Cargo.toml
index 765fef1c41..3bd8d4e16b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -42,7 +42,7 @@ owned-singleton = "0.1.0"
 
 [dev-dependencies]
 alloc-singleton = "0.1.0"
-cortex-m-semihosting = "0.3.1"
+cortex-m-semihosting = "0.3.2"
 lm3s6965 = "0.1.3"
 panic-halt = "0.2.0"
 
diff --git a/examples/baseline.rs b/examples/baseline.rs
index 73ef4c9a81..fdf368383d 100644
--- a/examples/baseline.rs
+++ b/examples/baseline.rs
@@ -7,26 +7,16 @@
 
 extern crate panic_semihosting;
 
-use cortex_m_semihosting::debug;
+use cortex_m_semihosting::{debug, hprintln};
 use lm3s6965::Interrupt;
 use rtfm::app;
 
-macro_rules! println {
-    ($($tt:tt)*) => {
-        if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
-            use core::fmt::Write;
-
-            writeln!(stdout, $($tt)*).ok();
-        }
-    };
-}
-
 // NOTE: does NOT properly work on QEMU
 #[app(device = lm3s6965)]
 const APP: () = {
     #[init(spawn = [foo])]
     fn init() {
-        println!("init(baseline = {:?})", start);
+        hprintln!("init(baseline = {:?})", start).unwrap();
 
         // `foo` inherits the baseline of `init`: `Instant(0)`
         spawn.foo().unwrap();
@@ -36,7 +26,7 @@ const APP: () = {
     fn foo() {
         static mut ONCE: bool = true;
 
-        println!("foo(baseline = {:?})", scheduled);
+        hprintln!("foo(baseline = {:?})", scheduled).unwrap();
 
         if *ONCE {
             *ONCE = false;
@@ -49,7 +39,7 @@ const APP: () = {
 
     #[interrupt(spawn = [foo])]
     fn UART0() {
-        println!("UART0(baseline = {:?})", start);
+        hprintln!("UART0(baseline = {:?})", start).unwrap();
 
         // `foo` inherits the baseline of `UART0`: its `start` time
         spawn.foo().unwrap();
diff --git a/examples/capacity.rs b/examples/capacity.rs
index fca7fe2bdf..a7132ba0f4 100644
--- a/examples/capacity.rs
+++ b/examples/capacity.rs
@@ -7,20 +7,10 @@
 
 extern crate panic_semihosting;
 
-use cortex_m_semihosting::debug;
+use cortex_m_semihosting::{debug, hprintln};
 use lm3s6965::Interrupt;
 use rtfm::app;
 
-macro_rules! println {
-    ($($tt:tt)*) => {
-        if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
-            use core::fmt::Write;
-
-            writeln!(stdout, $($tt)*).ok();
-        }
-    };
-}
-
 #[app(device = lm3s6965)]
 const APP: () = {
     #[init]
@@ -40,12 +30,12 @@ const APP: () = {
 
     #[task(capacity = 4)]
     fn foo(x: u32) {
-        println!("foo({})", x);
+        hprintln!("foo({})", x).unwrap();
     }
 
     #[task]
     fn bar() {
-        println!("bar");
+        hprintln!("bar").unwrap();
 
         debug::exit(debug::EXIT_SUCCESS);
     }
diff --git a/examples/generics.rs b/examples/generics.rs
index aee70611cd..c8ce839351 100644
--- a/examples/generics.rs
+++ b/examples/generics.rs
@@ -7,22 +7,10 @@
 
 extern crate panic_semihosting;
 
-use cortex_m_semihosting::debug;
+use cortex_m_semihosting::{debug, hprintln};
 use lm3s6965::Interrupt;
 use rtfm::{app, Mutex};
 
-// NOTE: This convenience macro will appear in all the other examples and
-// will always look the same
-macro_rules! println {
-    ($($tt:tt)*) => {
-        if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
-            use core::fmt::Write;
-
-            writeln!(stdout, $($tt)*).ok();
-        }
-    };
-}
-
 #[app(device = lm3s6965)]
 const APP: () = {
     static mut SHARED: u32 = 0;
@@ -37,7 +25,7 @@ const APP: () = {
     fn UART0() {
         static mut STATE: u32 = 0;
 
-        println!("UART0(STATE = {})", *STATE);
+        hprintln!("UART0(STATE = {})", *STATE).unwrap();
 
         advance(STATE, resources.SHARED);
 
@@ -50,7 +38,7 @@ const APP: () = {
     fn UART1() {
         static mut STATE: u32 = 0;
 
-        println!("UART1(STATE = {})", *STATE);
+        hprintln!("UART1(STATE = {})", *STATE).unwrap();
 
         // just to show that `SHARED` can be accessed directly and ..
         *resources.SHARED += 0;
@@ -70,5 +58,5 @@ fn advance(state: &mut u32, mut shared: impl Mutex<T = u32>) {
         (old, *shared)
     });
 
-    println!("SHARED: {} -> {}", old, new);
+    hprintln!("SHARED: {} -> {}", old, new).unwrap();
 }
diff --git a/examples/idle.rs b/examples/idle.rs
index 013cccea27..1f21a37f4a 100644
--- a/examples/idle.rs
+++ b/examples/idle.rs
@@ -7,24 +7,14 @@
 
 extern crate panic_semihosting;
 
-use cortex_m_semihosting::debug;
+use cortex_m_semihosting::{debug, hprintln};
 use rtfm::app;
 
-macro_rules! println {
-    ($($tt:tt)*) => {
-        if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
-            use core::fmt::Write;
-
-            writeln!(stdout, $($tt)*).ok();
-        }
-    };
-}
-
 #[app(device = lm3s6965)]
 const APP: () = {
     #[init]
     fn init() {
-        println!("init");
+        hprintln!("init").unwrap();
     }
 
     #[idle]
@@ -34,7 +24,7 @@ const APP: () = {
         // Safe access to local `static mut` variable
         let _x: &'static mut u32 = X;
 
-        println!("idle");
+        hprintln!("idle").unwrap();
 
         debug::exit(debug::EXIT_SUCCESS);
 
diff --git a/examples/init.rs b/examples/init.rs
index d6caa60967..be6cfe3eb3 100644
--- a/examples/init.rs
+++ b/examples/init.rs
@@ -7,21 +7,9 @@
 
 extern crate panic_semihosting;
 
-use cortex_m_semihosting::debug;
+use cortex_m_semihosting::{debug, hprintln};
 use rtfm::app;
 
-// NOTE: This convenience macro will appear in all the other examples and
-// will always look the same
-macro_rules! println {
-    ($($tt:tt)*) => {
-        if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
-            use core::fmt::Write;
-
-            writeln!(stdout, $($tt)*).ok();
-        }
-    };
-}
-
 #[app(device = lm3s6965)]
 const APP: () = {
     #[init]
@@ -37,7 +25,7 @@ const APP: () = {
         // Safe access to local `static mut` variable
         let _x: &'static mut u32 = X;
 
-        println!("init");
+        hprintln!("init").unwrap();
 
         debug::exit(debug::EXIT_SUCCESS);
     }
diff --git a/examples/interrupt.rs b/examples/interrupt.rs
index 19b1fed0d5..3c669d9ef2 100644
--- a/examples/interrupt.rs
+++ b/examples/interrupt.rs
@@ -7,20 +7,10 @@
 
 extern crate panic_semihosting;
 
-use cortex_m_semihosting::debug;
+use cortex_m_semihosting::{debug, hprintln};
 use lm3s6965::Interrupt;
 use rtfm::app;
 
-macro_rules! println {
-    ($($tt:tt)*) => {
-        if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
-            use core::fmt::Write;
-
-            writeln!(stdout, $($tt)*).ok();
-        }
-    };
-}
-
 #[app(device = lm3s6965)]
 const APP: () = {
     #[init]
@@ -29,14 +19,14 @@ const APP: () = {
         // `init` returns because interrupts are disabled
         rtfm::pend(Interrupt::UART0);
 
-        println!("init");
+        hprintln!("init").unwrap();
     }
 
     #[idle]
     fn idle() -> ! {
         // interrupts are enabled again; the `UART0` handler runs at this point
 
-        println!("idle");
+        hprintln!("idle").unwrap();
 
         rtfm::pend(Interrupt::UART0);
 
@@ -52,10 +42,11 @@ const APP: () = {
         // Safe access to local `static mut` variable
         *TIMES += 1;
 
-        println!(
+        hprintln!(
             "UART0 called {} time{}",
             *TIMES,
             if *TIMES > 1 { "s" } else { "" }
-        );
+        )
+        .unwrap();
     }
 };
diff --git a/examples/late.rs b/examples/late.rs
index 6d76c58ab2..be656408cf 100644
--- a/examples/late.rs
+++ b/examples/late.rs
@@ -7,7 +7,7 @@
 
 extern crate panic_semihosting;
 
-use cortex_m_semihosting::debug;
+use cortex_m_semihosting::{debug, hprintln};
 use heapless::{
     consts::*,
     spsc::{Consumer, Producer, Queue},
@@ -15,16 +15,6 @@ use heapless::{
 use lm3s6965::Interrupt;
 use rtfm::app;
 
-macro_rules! println {
-    ($($tt:tt)*) => {
-        if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
-            use core::fmt::Write;
-
-            writeln!(stdout, $($tt)*).ok();
-        }
-    };
-}
-
 #[app(device = lm3s6965)]
 const APP: () = {
     // Late resources
@@ -49,7 +39,7 @@ const APP: () = {
     fn idle() -> ! {
         loop {
             if let Some(byte) = resources.C.dequeue() {
-                println!("received message: {}", byte);
+                hprintln!("received message: {}", byte).unwrap();
 
                 debug::exit(debug::EXIT_SUCCESS);
             } else {
diff --git a/examples/lock.rs b/examples/lock.rs
index 097bd5c3e3..4ca862e316 100644
--- a/examples/lock.rs
+++ b/examples/lock.rs
@@ -7,20 +7,10 @@
 
 extern crate panic_semihosting;
 
-use cortex_m_semihosting::debug;
+use cortex_m_semihosting::{debug, hprintln};
 use lm3s6965::Interrupt;
 use rtfm::app;
 
-macro_rules! println {
-    ($($tt:tt)*) => {
-        if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
-            use core::fmt::Write;
-
-            writeln!(stdout, $($tt)*).ok();
-        }
-    };
-}
-
 #[app(device = lm3s6965)]
 const APP: () = {
     static mut SHARED: u32 = 0;
@@ -33,7 +23,7 @@ const APP: () = {
     // when omitted priority is assumed to be `1`
     #[interrupt(resources = [SHARED])]
     fn GPIOA() {
-        println!("A");
+        hprintln!("A").unwrap();
 
         // the lower priority task requires a critical section to access the data
         resources.SHARED.lock(|shared| {
@@ -43,7 +33,7 @@ const APP: () = {
             // GPIOB will *not* run right now due to the critical section
             rtfm::pend(Interrupt::GPIOB);
 
-            println!("B - SHARED = {}", *shared);
+            hprintln!("B - SHARED = {}", *shared).unwrap();
 
             // GPIOC does not contend for `SHARED` so it's allowed to run now
             rtfm::pend(Interrupt::GPIOC);
@@ -51,7 +41,7 @@ const APP: () = {
 
         // critical section is over: GPIOB can now start
 
-        println!("E");
+        hprintln!("E").unwrap();
 
         debug::exit(debug::EXIT_SUCCESS);
     }
@@ -61,11 +51,11 @@ const APP: () = {
         // the higher priority task does *not* need a critical section
         *resources.SHARED += 1;
 
-        println!("D - SHARED = {}", *resources.SHARED);
+        hprintln!("D - SHARED = {}", *resources.SHARED).unwrap();
     }
 
     #[interrupt(priority = 3)]
     fn GPIOC() {
-        println!("C");
+        hprintln!("C").unwrap();
     }
 };
diff --git a/examples/message.rs b/examples/message.rs
index 1ff08b22a7..b5d68a607b 100644
--- a/examples/message.rs
+++ b/examples/message.rs
@@ -7,19 +7,9 @@
 
 extern crate panic_semihosting;
 
-use cortex_m_semihosting::debug;
+use cortex_m_semihosting::{debug, hprintln};
 use rtfm::app;
 
-macro_rules! println {
-    ($($tt:tt)*) => {
-        if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
-            use core::fmt::Write;
-
-            writeln!(stdout, $($tt)*).ok();
-        }
-    };
-}
-
 #[app(device = lm3s6965)]
 const APP: () = {
     #[init(spawn = [foo])]
@@ -31,7 +21,7 @@ const APP: () = {
     fn foo() {
         static mut COUNT: u32 = 0;
 
-        println!("foo");
+        hprintln!("foo").unwrap();
 
         spawn.bar(*COUNT).unwrap();
         *COUNT += 1;
@@ -39,14 +29,14 @@ const APP: () = {
 
     #[task(spawn = [baz])]
     fn bar(x: u32) {
-        println!("bar({})", x);
+        hprintln!("bar({})", x).unwrap();
 
         spawn.baz(x + 1, x + 2).unwrap();
     }
 
     #[task(spawn = [foo])]
     fn baz(x: u32, y: u32) {
-        println!("baz({}, {})", x, y);
+        hprintln!("baz({}, {})", x, y).unwrap();
 
         if x + y > 4 {
             debug::exit(debug::EXIT_SUCCESS);
diff --git a/examples/periodic.rs b/examples/periodic.rs
index 0fb8bdf4fa..ba2b4933df 100644
--- a/examples/periodic.rs
+++ b/examples/periodic.rs
@@ -7,18 +7,9 @@
 
 extern crate panic_semihosting;
 
+use cortex_m_semihosting::hprintln;
 use rtfm::{app, Instant};
 
-macro_rules! println {
-    ($($tt:tt)*) => {
-        if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
-            use core::fmt::Write;
-
-            writeln!(stdout, $($tt)*).ok();
-        }
-    };
-}
-
 const PERIOD: u32 = 8_000_000;
 
 // NOTE: does NOT work on QEMU!
@@ -32,7 +23,7 @@ const APP: () = {
     #[task(schedule = [foo])]
     fn foo() {
         let now = Instant::now();
-        println!("foo(scheduled = {:?}, now = {:?})", scheduled, now);
+        hprintln!("foo(scheduled = {:?}, now = {:?})", scheduled, now).unwrap();
 
         schedule.foo(scheduled + PERIOD.cycles()).unwrap();
     }
diff --git a/examples/ramfunc.rs b/examples/ramfunc.rs
index b7fe252357..37ea82a77e 100644
--- a/examples/ramfunc.rs
+++ b/examples/ramfunc.rs
@@ -7,19 +7,9 @@
 
 extern crate panic_semihosting;
 
-use cortex_m_semihosting::debug;
+use cortex_m_semihosting::{debug, hprintln};
 use rtfm::app;
 
-macro_rules! println {
-    ($($tt:tt)*) => {
-        if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
-            use core::fmt::Write;
-
-            writeln!(stdout, $($tt)*).ok();
-        }
-    };
-}
-
 #[app(device = lm3s6965)]
 const APP: () = {
     #[init(spawn = [bar])]
@@ -30,7 +20,7 @@ const APP: () = {
     #[inline(never)]
     #[task]
     fn foo() {
-        println!("foo");
+        hprintln!("foo").unwrap();
 
         debug::exit(debug::EXIT_SUCCESS);
     }
diff --git a/examples/resource.rs b/examples/resource.rs
index 2777da1747..5ddab9e8da 100644
--- a/examples/resource.rs
+++ b/examples/resource.rs
@@ -7,20 +7,10 @@
 
 extern crate panic_semihosting;
 
-use cortex_m_semihosting::debug;
+use cortex_m_semihosting::{debug, hprintln};
 use lm3s6965::Interrupt;
 use rtfm::app;
 
-macro_rules! println {
-    ($($tt:tt)*) => {
-        if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
-            use core::fmt::Write;
-
-            writeln!(stdout, $($tt)*).ok();
-        }
-    };
-}
-
 #[app(device = lm3s6965)]
 const APP: () = {
     // A resource
@@ -47,7 +37,7 @@ const APP: () = {
     fn UART0() {
         *resources.SHARED += 1;
 
-        println!("UART0: SHARED = {}", resources.SHARED);
+        hprintln!("UART0: SHARED = {}", resources.SHARED).unwrap();
     }
 
     // `SHARED` can be access from this context
@@ -55,6 +45,6 @@ const APP: () = {
     fn UART1() {
         *resources.SHARED += 1;
 
-        println!("UART1: SHARED = {}", resources.SHARED);
+        hprintln!("UART1: SHARED = {}", resources.SHARED).unwrap();
     }
 };
diff --git a/examples/schedule.rs b/examples/schedule.rs
index 9fb2796d1a..fd63347308 100644
--- a/examples/schedule.rs
+++ b/examples/schedule.rs
@@ -7,18 +7,9 @@
 
 extern crate panic_semihosting;
 
+use cortex_m_semihosting::hprintln;
 use rtfm::{app, Instant};
 
-macro_rules! println {
-    ($($tt:tt)*) => {
-        if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
-            use core::fmt::Write;
-
-            writeln!(stdout, $($tt)*).ok();
-        }
-    };
-}
-
 // NOTE: does NOT work on QEMU!
 #[app(device = lm3s6965)]
 const APP: () = {
@@ -26,7 +17,7 @@ const APP: () = {
     fn init() {
         let now = Instant::now();
 
-        println!("init @ {:?}", now);
+        hprintln!("init @ {:?}", now).unwrap();
 
         // Schedule `foo` to run 8e6 cycles (clock cycles) in the future
         schedule.foo(now + 8_000_000.cycles()).unwrap();
@@ -37,12 +28,12 @@ const APP: () = {
 
     #[task]
     fn foo() {
-        println!("foo  @ {:?}", Instant::now());
+        hprintln!("foo  @ {:?}", Instant::now()).unwrap();
     }
 
     #[task]
     fn bar() {
-        println!("bar  @ {:?}", Instant::now());
+        hprintln!("bar  @ {:?}", Instant::now()).unwrap();
     }
 
     extern "C" {
diff --git a/examples/singleton.rs b/examples/singleton.rs
index 888a5a6787..79815e8852 100644
--- a/examples/singleton.rs
+++ b/examples/singleton.rs
@@ -8,20 +8,10 @@
 extern crate panic_semihosting;
 
 use alloc_singleton::stable::pool::{Box, Pool};
-use cortex_m_semihosting::debug;
+use cortex_m_semihosting::{debug, hprintln};
 use lm3s6965::Interrupt;
 use rtfm::app;
 
-macro_rules! println {
-    ($($tt:tt)*) => {
-        if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
-            use core::fmt::Write;
-
-            writeln!(stdout, $($tt)*).ok();
-        }
-    };
-}
-
 #[app(device = lm3s6965)]
 const APP: () = {
     #[Singleton(Send)]
@@ -48,7 +38,7 @@ const APP: () = {
 
     #[task(resources = [P])]
     fn foo(x: Box<M>) {
-        println!("foo({})", x);
+        hprintln!("foo({})", x).unwrap();
 
         resources.P.lock(|p| p.dealloc(x));
 
@@ -57,7 +47,7 @@ const APP: () = {
 
     #[task(priority = 2, resources = [P])]
     fn bar(x: Box<M>) {
-        println!("bar({})", x);
+        hprintln!("bar({})", x).unwrap();
 
         resources.P.dealloc(x);
     }
diff --git a/examples/static.rs b/examples/static.rs
index 3dc0e89c0d..d40fdb1a6d 100644
--- a/examples/static.rs
+++ b/examples/static.rs
@@ -7,20 +7,10 @@
 
 extern crate panic_semihosting;
 
-use cortex_m_semihosting::debug;
+use cortex_m_semihosting::{debug, hprintln};
 use lm3s6965::Interrupt;
 use rtfm::app;
 
-macro_rules! println {
-    ($($tt:tt)*) => {
-        if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
-            use core::fmt::Write;
-
-            writeln!(stdout, $($tt)*).ok();
-        }
-    };
-}
-
 #[app(device = lm3s6965)]
 const APP: () = {
     static KEY: u32 = ();
@@ -35,13 +25,13 @@ const APP: () = {
 
     #[interrupt(resources = [KEY])]
     fn UART0() {
-        println!("UART0(KEY = {:#x})", resources.KEY);
+        hprintln!("UART0(KEY = {:#x})", resources.KEY).unwrap();
 
         debug::exit(debug::EXIT_SUCCESS);
     }
 
     #[interrupt(priority = 2, resources = [KEY])]
     fn UART1() {
-        println!("UART1(KEY = {:#x})", resources.KEY);
+        hprintln!("UART1(KEY = {:#x})", resources.KEY).unwrap();
     }
 };
diff --git a/examples/task.rs b/examples/task.rs
index b1cd7ae1df..4f168bb814 100644
--- a/examples/task.rs
+++ b/examples/task.rs
@@ -7,19 +7,9 @@
 
 extern crate panic_semihosting;
 
-use cortex_m_semihosting::debug;
+use cortex_m_semihosting::{debug, hprintln};
 use rtfm::app;
 
-macro_rules! println {
-    ($($tt:tt)*) => {
-        if let Ok(mut stdout) = cortex_m_semihosting::hio::hstdout() {
-            use core::fmt::Write;
-
-            writeln!(stdout, $($tt)*).ok();
-        }
-    };
-}
-
 #[app(device = lm3s6965)]
 const APP: () = {
     #[init(spawn = [foo])]
@@ -29,7 +19,7 @@ const APP: () = {
 
     #[task(spawn = [bar, baz])]
     fn foo() {
-        println!("foo");
+        hprintln!("foo").unwrap();
 
         // spawns `bar` onto the task scheduler
         // `foo` and `bar` have the same priority so `bar` will not run until
@@ -43,14 +33,14 @@ const APP: () = {
 
     #[task]
     fn bar() {
-        println!("bar");
+        hprintln!("bar").unwrap();
 
         debug::exit(debug::EXIT_SUCCESS);
     }
 
     #[task(priority = 2)]
     fn baz() {
-        println!("baz");
+        hprintln!("baz").unwrap();
     }
 
     // Interrupt handlers used to dispatch software tasks