diff --git a/ui-app/src/lib.rs b/ui-app/src/lib.rs
index 9bf6bbc8..e4fee8ea 100644
--- a/ui-app/src/lib.rs
+++ b/ui-app/src/lib.rs
@@ -119,8 +119,21 @@ pub trait Led {
     }
 }
 
+fn rgb565(r: u8, g: u8, b: u8) -> u16 {
+    // Discard the low-order bits of the colors
+    (((r as u16) >> 3) << 11) | (((g as u16) >> 2) << 5) | ((b as u16) >> 3)
+}
+
+pub trait Screen {
+    fn width(&self) -> usize;
+    fn height(&self) -> usize;
+    fn fill(&mut self, color: u16);
+    fn draw(&mut self, left: usize, right: usize, top: usize, bottom: usize, data: &[u16]);
+}
+
 pub trait Outputs {
     fn status_led(&mut self) -> &mut impl Led;
+    fn screen(&mut self) -> &mut impl Screen;
     fn log(&mut self, message: &str);
 }
 
@@ -140,7 +153,51 @@ impl App {
     }
 
     pub fn start(&mut self, out: &mut impl Outputs) {
+        // Extinguish the status LED
         out.status_led().set_color(Color::Black);
+
+        // Draw a test pattern to the screen
+        const SIZE: usize = 10;
+        let screen = out.screen();
+        let mut data = [0_u16; SIZE * SIZE];
+
+        // Background
+        screen.fill(rgb565(0x88, 0x88, 0x88));
+
+        // Upper left = R
+        let (x0, x1, y0, y1) = (SIZE, SIZE + SIZE, SIZE, SIZE + SIZE);
+        data.fill(rgb565(0xFF, 0x00, 0x00));
+        screen.draw(x0, x1, y0, y1, &data);
+
+        // Upper right = G
+        let (x0, x1, y0, y1) = (
+            screen.width() - SIZE - SIZE,
+            screen.width() - SIZE,
+            SIZE,
+            SIZE + SIZE,
+        );
+        data.fill(rgb565(0x00, 0xFF, 0x00));
+        screen.draw(x0, x1, y0, y1, &data);
+
+        // Lower left = B
+        let (x0, x1, y0, y1) = (
+            SIZE,
+            SIZE + SIZE,
+            screen.height() - SIZE - SIZE,
+            screen.height() - SIZE,
+        );
+        data.fill(rgb565(0x00, 0x00, 0xFF));
+        screen.draw(x0, x1, y0, y1, &data);
+
+        // Lower right = Y
+        let (x0, x1, y0, y1) = (
+            screen.width() - SIZE - SIZE,
+            screen.width() - SIZE,
+            screen.height() - SIZE - SIZE,
+            screen.height() - SIZE,
+        );
+        data.fill(rgb565(0xFF, 0xFF, 0x00));
+        screen.draw(x0, x1, y0, y1, &data);
     }
 
     pub fn handle(&mut self, event: Event, out: &mut impl Outputs) {
diff --git a/ui-app/tests/integration.rs b/ui-app/tests/integration.rs
index 623bb421..2652442a 100644
--- a/ui-app/tests/integration.rs
+++ b/ui-app/tests/integration.rs
@@ -11,9 +11,32 @@ impl Led for MockLed {
     }
 }
 
+// TODO: Test screen logic
+#[derive(Default)]
+struct MockScreen;
+
+impl Screen for MockScreen {
+    fn width(&self) -> usize {
+        240
+    }
+
+    fn height(&self) -> usize {
+        320
+    }
+
+    fn fill(&mut self, _color: u16) {
+        // TODO: Store pixels
+    }
+
+    fn draw(&mut self, _left: usize, _right: usize, _top: usize, _bottom: usize, _data: &[u16]) {
+        // TODO: Store pixels
+    }
+}
+
 #[derive(Default)]
 struct MockOutputs {
     status_led: MockLed,
+    screen: MockScreen,
     last_message: String,
 }
 
@@ -22,6 +45,10 @@ impl Outputs for MockOutputs {
         &mut self.status_led
     }
 
+    fn screen(&mut self) -> &mut impl Screen {
+        &mut self.screen
+    }
+
     fn log(&mut self, message: &str) {
         self.last_message = message.into();
     }
diff --git a/ui-stm32/Cargo.toml b/ui-stm32/Cargo.toml
index 8cdb6612..23bb70cc 100644
--- a/ui-stm32/Cargo.toml
+++ b/ui-stm32/Cargo.toml
@@ -20,12 +20,13 @@ defmt-rtt = "1.0.0"
 
 embassy-executor = { version = "0.8.0", features = ["arch-cortex-m", "executor-thread", "executor-interrupt", "defmt"] }
 embassy-futures = { version = "0.1.1", features = ["defmt"] }
-embassy-stm32 = { version = "0.3.0", features = ["defmt", "stm32f405rg", "memory-x", "time-driver-tim4", "exti", "chrono"] }
+embassy-stm32 = { version = "0.3.0", features = ["defmt", "stm32f405rg", "memory-x", "time-driver-tim1", "exti", "chrono"] }
 embassy-time = { version = "0.4.0", features = ["defmt", "defmt-timestamp-uptime", "tick-hz-32_768"] }
 
 heapless = { version = "0.8", default-features = false }
 panic-probe = { version = "1.0.0", features = ["print-defmt"] }
 embassy-sync = { version = "0.7.1", features = ["defmt"] }
+num_enum = { version = "0.7.4", default-features = false }
 
 [profile.release]
 debug = 2
diff --git a/ui-stm32/src/board/ev12.rs b/ui-stm32/src/board/ev12.rs
index b58e5e5a..af90eff1 100644
--- a/ui-stm32/src/board/ev12.rs
+++ b/ui-stm32/src/board/ev12.rs
@@ -1,20 +1,52 @@
-use super::{Button, Keyboard, StatusLed};
+use super::{Button, Keyboard, Screen, StatusLed};
 use embassy_stm32::{
     exti::ExtiInput,
     gpio::{Input, Level, Output, Pull, Speed},
+    spi::Spi,
 };
 use ui_app::{Led, Outputs};
 
 pub struct Board {
     status_led: StatusLed,
+    screen: Screen,
     pub ptt_button: Option<Button>,
     pub ai_button: Option<Button>,
     pub keyboard: Option<Keyboard>,
 }
 
 impl Board {
-    pub fn new() -> Self {
-        let p = embassy_stm32::init(Default::default());
+    pub async fn new() -> Self {
+        let config = {
+            use embassy_stm32::{rcc::*, time::Hertz};
+
+            let mut config = embassy_stm32::Config::default();
+
+            config.rcc.hse = Some(Hse {
+                freq: Hertz(6_000_000),
+                mode: HseMode::Bypass,
+            });
+            config.rcc.sys = Sysclk::PLL1_P;
+            config.rcc.pll_src = PllSource::HSE;
+            config.rcc.pll = Some(Pll {
+                prediv: PllPreDiv::DIV3,
+                mul: PllMul::MUL168,
+                divp: Some(PllPDiv::DIV2),
+                divq: Some(PllQDiv::DIV7),
+                divr: None,
+            });
+
+            config.rcc.ahb_pre = AHBPrescaler::DIV1;
+            config.rcc.apb1_pre = APBPrescaler::DIV4;
+            config.rcc.apb2_pre = APBPrescaler::DIV2;
+            config.rcc.ls = LsConfig {
+                rtc: RtcClockSource::LSI,
+                lsi: true,
+                lse: None,
+            };
+
+            config
+        };
+        let p = embassy_stm32::init(config);
 
         // Status LED
         let r = Output::new(p.PA6, Level::Low, Speed::Low);
@@ -45,8 +77,29 @@ impl Board {
         ];
         let keyboard = Keyboard::new(cols, rows);
 
+        // Screen
+        let chip_select = Output::new(p.PB8, Level::Low, Speed::Low);
+        let data_command = Output::new(p.PB9, Level::Low, Speed::Low);
+        let reset = Output::new(p.PC13, Level::Low, Speed::Low);
+        let backlight = Output::new(p.PC14, Level::Low, Speed::Low);
+
+        let config = {
+            use embassy_stm32::spi::*;
+            let mut config = Config::default();
+            config.mode.polarity = Polarity::IdleLow;
+            config.mode.phase = Phase::CaptureOnFirstTransition;
+            config.bit_order = BitOrder::MsbFirst;
+            config
+        };
+        let spi1 = Spi::new_blocking_txonly(p.SPI1, p.PA5, p.PA7, config);
+        let screen = Screen::new(chip_select, data_command, reset, backlight, spi1).await;
+
+        // TODO(RLB): NET UART
+        // TODO(RLB): MGMT UART
+
         Self {
             status_led,
+            screen,
             ptt_button: Some(ptt_button),
             ai_button: Some(ai_button),
             keyboard: Some(keyboard),
@@ -59,6 +112,10 @@ impl Outputs for Board {
         &mut self.status_led
     }
 
+    fn screen(&mut self) -> &mut impl ui_app::Screen {
+        &mut self.screen
+    }
+
     fn log(&mut self, message: &str) {
         defmt::info!("{}", message);
     }
diff --git a/ui-stm32/src/board/ev13.rs b/ui-stm32/src/board/ev13.rs
index a6a44beb..0507e652 100644
--- a/ui-stm32/src/board/ev13.rs
+++ b/ui-stm32/src/board/ev13.rs
@@ -1,19 +1,21 @@
-use super::{Button, Keyboard, StatusLed};
+use super::{Button, Keyboard, Screen, StatusLed};
 use embassy_stm32::{
     exti::ExtiInput,
     gpio::{Input, Level, Output, Pull, Speed},
+    spi::Spi,
 };
 use ui_app::{Led, Outputs};
 
 pub struct Board {
     status_led: StatusLed,
+    screen: Screen,
     pub ptt_button: Option<Button>,
     pub ai_button: Option<Button>,
     pub keyboard: Option<Keyboard>,
 }
 
 impl Board {
-    pub fn new() -> Self {
+    pub async fn new() -> Self {
         let p = embassy_stm32::init(Default::default());
 
         // Status LED
@@ -45,8 +47,29 @@ impl Board {
         ];
         let keyboard = Keyboard::new(cols, rows);
 
+        // Screen
+        let chip_select = Output::new(p.PB8, Level::Low, Speed::Low);
+        let data_command = Output::new(p.PB9, Level::Low, Speed::Low);
+        let reset = Output::new(p.PC13, Level::Low, Speed::Low);
+        let backlight = Output::new(p.PC14, Level::Low, Speed::Low);
+
+        let config = {
+            use embassy_stm32::spi::*;
+            let mut config = Config::default();
+            config.mode.polarity = Polarity::IdleLow;
+            config.mode.phase = Phase::CaptureOnFirstTransition;
+            config.bit_order = BitOrder::MsbFirst;
+            config
+        };
+        let spi1 = Spi::new_blocking_txonly(p.SPI1, p.PA5, p.PA7, config);
+        let screen = Screen::new(chip_select, data_command, reset, backlight, spi1).await;
+
+        // TODO(RLB): NET UART
+        // TODO(RLB): MGMT UART
+
         Self {
             status_led,
+            screen,
             ptt_button: Some(ptt_button),
             ai_button: Some(ai_button),
             keyboard: Some(keyboard),
@@ -59,6 +82,10 @@ impl Outputs for Board {
         &mut self.status_led
     }
 
+    fn screen(&mut self) -> &mut impl ui_app::Screen {
+        &mut self.screen
+    }
+
     fn log(&mut self, message: &str) {
         defmt::info!("{}", message);
     }
diff --git a/ui-stm32/src/board/mod.rs b/ui-stm32/src/board/mod.rs
index 028d9745..b9e27446 100644
--- a/ui-stm32/src/board/mod.rs
+++ b/ui-stm32/src/board/mod.rs
@@ -27,6 +27,9 @@ use ui_app::Led;
 mod keyboard;
 pub use keyboard::Keyboard;
 
+mod screen;
+pub use screen::Screen;
+
 struct StatusLed {
     r: Output<'static>,
     g: Output<'static>,
diff --git a/ui-stm32/src/board/screen.rs b/ui-stm32/src/board/screen.rs
new file mode 100644
index 00000000..7ec1cb67
--- /dev/null
+++ b/ui-stm32/src/board/screen.rs
@@ -0,0 +1,165 @@
+use embassy_stm32::{
+    gpio::Output,
+    mode::Blocking,
+    spi::{Spi, Word},
+};
+use embassy_time::Timer;
+use num_enum::IntoPrimitive;
+
+pub struct Screen {
+    chip_select: Output<'static>,
+    data_command: Output<'static>,
+    reset: Output<'static>,
+    backlight: Output<'static>,
+    spi: Spi<'static, Blocking>,
+}
+
+impl ui_app::Screen for Screen {
+    fn width(&self) -> usize {
+        Self::WIDTH
+    }
+
+    fn height(&self) -> usize {
+        Self::HEIGHT
+    }
+
+    fn fill(&mut self, color: u16) {
+        let row = [color; Self::WIDTH];
+
+        self.set_window(0, 0, Self::WIDTH, Self::HEIGHT);
+        self.send_command(Command::WriteMemory, &[]);
+        for _ in 0..Self::HEIGHT {
+            self.spi.blocking_write(&row).unwrap();
+        }
+    }
+
+    fn draw(&mut self, left: usize, right: usize, top: usize, bottom: usize, data: &[u16]) {
+        self.set_window(left, right, top, bottom);
+        self.send_command(Command::WriteMemory, &[]);
+        self.send_data(data);
+    }
+}
+
+impl Screen {
+    const WIDTH: usize = 240;
+    const HEIGHT: usize = 320;
+
+    // Initial command sequence borrowed from
+    //
+    // https://github.com/yuri91/ili9341-rs/blob/master/src/lib.rs#L139
+    pub async fn new(
+        chip_select: Output<'static>,
+        data_command: Output<'static>,
+        reset: Output<'static>,
+        backlight: Output<'static>,
+        spi: Spi<'static, Blocking>,
+    ) -> Self {
+        let mut screen = Self {
+            chip_select,
+            data_command,
+            reset,
+            backlight,
+            spi,
+        };
+
+        // Chip select pin is always held low
+        screen.chip_select.set_low();
+
+        // Do hardware reset by holding reset low for at least 10us, then wait 5ms for the reset to
+        // occur before sending more commands.
+        screen.reset.set_low();
+        Timer::after_millis(200).await;
+        screen.reset.set_high();
+        Timer::after_millis(200).await;
+
+        // Do hardware reset, then wait 120ms for the reset to occur before sending more commands.
+        screen.send_command(Command::SoftwareReset, &[]);
+        Timer::after_millis(200).await;
+
+        // Set portrait orientation
+        screen.send_command(
+            Command::MemoryAccessControl,
+            &[u8::from(Orientation::Portrait)],
+        );
+
+        // Set the pixel format to rgb565
+        screen.send_command(Command::SetPixelFormat, &[0x55]);
+
+        // Have the display emerge from sleep, then wait 5ms for it to wake up
+        screen.send_command(Command::SleepModeOff, &[]);
+        Timer::after_millis(200).await;
+
+        // Turn the display on
+        screen.send_command(Command::DisplayOn, &[]);
+
+        // Turn on the backlight
+        screen.set_backlight(true);
+
+        screen
+    }
+
+    fn set_window(&mut self, x0: usize, x1: usize, y0: usize, y1: usize) {
+        let mut x_data = [0u8; 4];
+        x_data[..2].copy_from_slice(&(x0 as u16).to_be_bytes());
+        x_data[2..].copy_from_slice(&(x1 as u16).to_be_bytes());
+
+        let mut y_data = [0u8; 4];
+        y_data[..2].copy_from_slice(&(y0 as u16).to_be_bytes());
+        y_data[2..].copy_from_slice(&(y1 as u16).to_be_bytes());
+
+        self.send_command(Command::SetColumnAddress, &x_data);
+        self.send_command(Command::SetPageAddress, &y_data);
+    }
+
+    fn send_command(&mut self, cmd: Command, data: &[u8]) {
+        self.data_command.set_low();
+        self.spi.blocking_write(&[u8::from(cmd)]).unwrap();
+
+        self.send_data(data);
+    }
+
+    fn send_data<W: Word>(&mut self, data: &[W]) {
+        self.data_command.set_high();
+        self.spi.blocking_write(data).unwrap();
+    }
+
+    pub fn set_backlight(&mut self, on: bool) {
+        self.backlight.set_level(on.into());
+    }
+}
+
+#[allow(dead_code)]
+#[derive(Copy, Clone, IntoPrimitive)]
+#[repr(u8)]
+enum Command {
+    SetColumnAddress = 0x2a,
+    ContentAdaptiveBrightness = 0x55,
+    DisplayOff = 0x28,
+    DisplayOn = 0x29,
+    IdleModeFrameRate = 0xb2,
+    IdleModeOff = 0x38,
+    IdleModeOn = 0x39,
+    InvertOff = 0x20,
+    InvertOn = 0x21,
+    MemoryAccessControl = 0x36,
+    WriteMemory = 0x2c,
+    NormalModeFrameRate = 0xb1,
+    SetPageAddress = 0x2b,
+    SetPixelFormat = 0x3a,
+    SetBrightness = 0x51,
+    SleepModeOff = 0x11,
+    SleepModeOn = 0x10,
+    SoftwareReset = 0x01,
+    VerticalScrollAddr = 0x37,
+    DefineVerticalScroll = 0x33,
+}
+
+#[allow(dead_code)]
+#[derive(Copy, Clone, IntoPrimitive)]
+#[repr(u8)]
+enum Orientation {
+    Portrait = 0x40 | 0x08,
+    Landscape = 0x20 | 0x08,
+    PortraitFlipped = 0x80 | 0x08,
+    LandscapeFlipped = 0x40 | 0x80 | 0x20 | 0x08,
+}
diff --git a/ui-stm32/src/main.rs b/ui-stm32/src/main.rs
index e107889c..e2f6b3c8 100644
--- a/ui-stm32/src/main.rs
+++ b/ui-stm32/src/main.rs
@@ -46,7 +46,7 @@ async fn monitor_keyboard(mut keyboard: Keyboard, events: EventSender) {
 
 #[embassy_executor::main]
 async fn main(spawner: Spawner) {
-    let mut board = Board::new();
+    let mut board = Board::new().await;
     let mut app = App::new();
 
     // Capture button events
@@ -68,9 +68,9 @@ async fn main(spawner: Spawner) {
         EVENT_QUEUE.sender()
     )));
 
-    // Main event loop
     app.start(&mut board);
 
+    // Main event loop
     loop {
         let event = EVENT_QUEUE.receive().await;
         app.handle(event, &mut board);
diff --git a/ui-tauri/src-tauri/src/lib.rs b/ui-tauri/src-tauri/src/lib.rs
index 34c088bb..235be230 100644
--- a/ui-tauri/src-tauri/src/lib.rs
+++ b/ui-tauri/src-tauri/src/lib.rs
@@ -5,7 +5,7 @@ use core::ops::DerefMut;
 use once_cell::sync::OnceCell;
 use std::sync::Mutex;
 use tauri::Emitter;
-use ui_app::{App, Button, Event, Key, KeyValue, Led, Outputs};
+use ui_app::{App, Button, Event, Key, KeyValue, Led, Outputs, Screen};
 
 mod hactar_vaporwave;
 
@@ -19,6 +19,17 @@ mod cmd {
         pub g: usize,
         pub b: usize,
     }
+
+    #[derive(Clone, Serialize)]
+    pub struct Draw<'a> {
+        pub left: usize,
+        pub right: usize,
+        pub top: usize,
+        pub bottom: usize,
+
+        /// Data in <canvas> RGBA format
+        pub data: &'a [u8],
+    }
 }
 
 const UI_LED_NAME: &str = "led-ui";
@@ -47,11 +58,69 @@ impl Led for Board {
     }
 }
 
+impl Screen for Board {
+    fn width(&self) -> usize {
+        320
+    }
+
+    fn height(&self) -> usize {
+        240
+    }
+
+    fn fill(&mut self, color: u16) {
+        let data = [color; 320 * 240];
+        self.draw(0, self.width(), 0, self.height(), &data);
+    }
+
+    fn draw(&mut self, left: usize, right: usize, top: usize, bottom: usize, data: &[u16]) {
+        println!(
+            "draw {} {} {} {} ({} x {} == {}? {})",
+            left,
+            right,
+            top,
+            bottom,
+            (right - left),
+            (bottom - top),
+            data.len(),
+            data.len() == (right - left) * (bottom - top)
+        );
+
+        // Unpack the rgb565 values to RGBA tuples
+        let data: Vec<u8> = data
+            .iter()
+            .map(|rgb565| {
+                [
+                    (((rgb565 & 0b11111_000000_00000) >> 11) << 3) as u8, // R
+                    (((rgb565 & 0b00000_111111_00000) >> 5) << 2) as u8,  // G
+                    (((rgb565 & 0b00000_000000_11111) >> 0) << 3) as u8,  // B
+                    (0xff as u8),                                         // A
+                ]
+            })
+            .flatten()
+            .collect();
+
+        // Send the draw command to the UI
+        let cmd = cmd::Draw {
+            left,
+            right,
+            top,
+            bottom,
+            data: data.as_slice(),
+        };
+
+        self.app.emit("Screen", cmd).unwrap();
+    }
+}
+
 impl Outputs for Board {
     fn status_led(&mut self) -> &mut impl Led {
         self
     }
 
+    fn screen(&mut self) -> &mut impl Screen {
+        self
+    }
+
     fn log(&mut self, message: &str) {
         println!("LOG: {}", message);
     }
diff --git a/ui-tauri/src/main.js b/ui-tauri/src/main.js
index 6b1e22d6..3b3ffa8d 100644
--- a/ui-tauri/src/main.js
+++ b/ui-tauri/src/main.js
@@ -68,11 +68,13 @@ async function handle_ptt(e) {
 }
 
 async function handle_screen(e) {
-  let { left, top, width, height, data } = e.payload;
+  let { left, right, top, bottom, data } = e.payload;
 
   const screen = document.getElementById("screen");
   const ctx = screen.getContext("2d");
 
+  const width = right - left;
+  const height = bottom - top;
   const imageData = ctx.createImageData(width, height);
 
   if (data.length != imageData.data.length) {
@@ -100,7 +102,7 @@ async function handle_events() {
   const ptt_state = listen('PttState', handle_ptt);
   const screen = listen('Screen', handle_screen);
   const led = listen('LED', handle_led);
-  return Promise.all([ptt_state, screen])
+  return Promise.all([ptt_state, screen, led])
 }
 
 window.addEventListener("DOMContentLoaded", async () => {