Merge branch 'main' into nes

fix release

.gitignore

@@ -2,3 +2,5 @@
 *.uf2
 abi_sys.h
 assets/gif/bad_apple.gif
+picolibc
+user-apps/gboy/Peanut-GB

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "picolibc"]
+	path = picolibc
+	url = https://github.com/picolibc/picolibc
+[submodule "user-apps/gboy/Peanut-GB"]
+	path = user-apps/gboy/Peanut-GB
+	url = https://github.com/deltabeard/Peanut-GB

Cargo.toml

@@ -4,10 +4,12 @@ members = [
   "kernel",
   "abi_sys",
   "abi",
+  "selection_ui",
   "user-apps/calculator",
   "user-apps/snake",
   "user-apps/gallery",
   "user-apps/gif",
+  "user-apps/gboy",
 ]
 
 [profile.release]
@@ -22,8 +24,8 @@ codegen-units = 1
 lto = true
 debug = false
 opt-level = "z"
-panic = "abort"
+panic = "unwind"
 
 [profile.dev]
 lto = true
-opt-level = "z"
+opt-level = "s"

abi/Cargo.toml

@@ -4,8 +4,7 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
-embedded-sdmmc = { version = "0.9.0", default-features = false }
-embedded-graphics = "0.8.1"
 abi_sys = { path = "../abi_sys" }
+embedded-graphics = "0.8.1"
 once_cell = { version = "1", default-features = false }
 rand_core = "0.9.3"

abi/src/lib.rs

@@ -3,8 +3,8 @@
 
 extern crate alloc;
 
-pub use abi_sys::{self, keyboard};
 use abi_sys::{RngRequest, alloc, dealloc, keyboard::KeyEvent};
+pub use abi_sys::{keyboard, print};
 pub use alloc::format;
 use core::alloc::{GlobalAlloc, Layout};
 use rand_core::RngCore;
@@ -25,10 +25,10 @@ unsafe impl GlobalAlloc for Alloc {
 }
 
 #[macro_export]
-macro_rules! print {
+macro_rules! println {
     ($($arg:tt)*) => {{
         let s = $crate::format!($($arg)*);
-        $crate::abi_sys::print(s.as_ptr(), s.len());
+        $crate::print(s.as_ptr(), s.len());
     }};
 }
 
@@ -45,8 +45,9 @@ pub fn get_key() -> KeyEvent {
 }
 
 pub mod display {
+    use core::sync::atomic::{AtomicBool, Ordering};
+
     use abi_sys::CPixel;
-    // use alloc::{vec, vec::Vec};
     use embedded_graphics::{
         Pixel,
         geometry::{Dimensions, Point},
@@ -54,19 +55,34 @@ pub mod display {
         prelude::{DrawTarget, Size},
         primitives::Rectangle,
     };
-    // use once_cell::unsync::Lazy;
 
     pub const SCREEN_WIDTH: usize = 320;
     pub const SCREEN_HEIGHT: usize = 320;
 
     pub type Pixel565 = Pixel<Rgb565>;
 
-    const BUF_SIZE: usize = 15 * 1024; // tune this for performance
+    const BUF_SIZE: usize = 1024;
     static mut BUF: [CPixel; BUF_SIZE] = [CPixel::new(); BUF_SIZE];
-    // const BUF_SIZE: usize = 250 * 1024; // tune this for performance
-    // static mut BUF: Lazy<Vec<CPixel>> = Lazy::new(|| vec![const { CPixel::new() }; BUF_SIZE]);
 
-    pub struct Display;
+    static DISPLAY_TAKEN: AtomicBool = AtomicBool::new(false);
+
+    pub struct Display {
+        _private: (),
+    }
+
+    impl Display {
+        /// Only one instance of Display can be taken
+        pub fn take() -> Option<Display> {
+            if DISPLAY_TAKEN
+                .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed)
+                .is_ok()
+            {
+                Some(Self { _private: () })
+            } else {
+                None
+            }
+        }
+    }
 
     impl Dimensions for Display {
         fn bounding_box(&self) -> Rectangle {
@@ -142,20 +158,109 @@ impl RngCore for Rng {
 }
 
 pub mod fs {
-    use embedded_sdmmc::DirEntry;
+    use alloc::vec::Vec;
+    use core::fmt::Display;
 
-    pub fn read_file(file: &str, read_from: usize, buf: &mut [u8]) -> usize {
+    pub fn read_file(file: &str, start_from: usize, buf: &mut [u8]) -> usize {
         abi_sys::read_file(
             file.as_ptr(),
             file.len(),
-            read_from,
+            start_from,
             buf.as_mut_ptr(),
             buf.len(),
         )
     }
 
-    pub fn list_dir(path: &str, files: &mut [Option<DirEntry>]) -> usize {
-        abi_sys::list_dir(path.as_ptr(), path.len(), files.as_mut_ptr(), files.len())
+    pub fn write_file(file: &str, start_from: usize, buf: &[u8]) {
+        abi_sys::write_file(
+            file.as_ptr(),
+            file.len(),
+            start_from,
+            buf.as_ptr(),
+            buf.len(),
+        )
+    }
+
+    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+    pub struct FileName<'a> {
+        full: &'a str,
+        base: &'a str,
+        ext: Option<&'a str>,
+    }
+
+    impl<'a> FileName<'a> {
+        pub fn full_name(&self) -> &str {
+            self.full
+        }
+
+        pub fn base(&self) -> &str {
+            self.base
+        }
+
+        pub fn extension(&self) -> Option<&str> {
+            self.ext
+        }
+    }
+
+    impl<'a> Display for FileName<'a> {
+        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+            write!(f, "{}", self.full_name())
+        }
+    }
+
+    impl<'a> From<&'a str> for FileName<'a> {
+        fn from(s: &'a str) -> FileName<'a> {
+            let full = s;
+
+            // Split on last dot for extension
+            let (base, ext) = match s.rfind('.') {
+                Some(idx) => (&s[..idx], Some(&s[idx + 1..])),
+                None => (s, None),
+            };
+
+            FileName { full, base, ext }
+        }
+    }
+
+    const MAX_ENTRY_NAME_LEN: usize = 25;
+    const MAX_ENTRIES: usize = 25;
+
+    #[derive(Clone, Copy, Debug)]
+    pub struct Entries([[u8; MAX_ENTRY_NAME_LEN]; MAX_ENTRIES]);
+
+    impl Entries {
+        pub fn new() -> Self {
+            Self([[0; MAX_ENTRY_NAME_LEN]; MAX_ENTRIES])
+        }
+
+        /// Get list of file names after listing
+        pub fn entries<'a>(&'a self) -> Vec<FileName<'a>> {
+            self.0
+                .iter()
+                .filter_map(|buf| {
+                    let nul_pos = buf.iter().position(|&b| b == 0).unwrap_or(buf.len());
+                    Some(core::str::from_utf8(&buf[..nul_pos]).ok()?.into())
+                })
+                .collect()
+        }
+
+        fn as_ptrs(&mut self) -> [*mut u8; MAX_ENTRIES] {
+            let mut ptrs: [*mut u8; MAX_ENTRIES] = [core::ptr::null_mut(); MAX_ENTRIES];
+            for (i, buf) in self.0.iter_mut().enumerate() {
+                ptrs[i] = buf.as_mut_ptr();
+            }
+            ptrs
+        }
+    }
+
+    pub fn list_dir(path: &str, entries: &mut Entries) -> usize {
+        abi_sys::list_dir(
+            path.as_ptr(),
+            path.len(),
+            entries.as_ptrs().as_mut_ptr(),
+            MAX_ENTRIES,
+            MAX_ENTRY_NAME_LEN,
+        )
     }
 
     pub fn file_len(str: &str) -> usize {

abi_sys/Cargo.toml

@@ -12,7 +12,6 @@ defmt = ["dep:defmt"]
 strum = { version = "0.27.2", default-features = false, features = ["derive"] }
 bitflags = "2.9.4"
 embedded-graphics = "0.8.1"
-embedded-sdmmc = { version = "0.9.0", default-features = false }
 defmt = { version = "0.3", optional = true }
 
 [build-dependencies]

abi_sys/src/lib.rs

@@ -1,19 +1,18 @@
 #![no_std]
-
 #[cfg(feature = "alloc")]
 use core::alloc::Layout;
 
+use core::ffi::c_char;
 use embedded_graphics::{
     Pixel,
     pixelcolor::{Rgb565, raw::RawU16},
     prelude::{IntoStorage, Point},
 };
-use embedded_sdmmc::DirEntry;
 use strum::{EnumCount, EnumIter};
 
 pub type EntryFn = fn();
 
-pub const ABI_CALL_TABLE_COUNT: usize = 11;
+pub const ABI_CALL_TABLE_COUNT: usize = 12;
 const _: () = assert!(ABI_CALL_TABLE_COUNT == CallTable::COUNT);
 
 #[derive(Clone, Copy, EnumIter, EnumCount)]
@@ -29,7 +28,8 @@ pub enum CallTable {
     GenRand = 7,
     ListDir = 8,
     ReadFile = 9,
-    FileLen = 10,
+    WriteFile = 10,
+    FileLen = 11,
 }
 
 #[unsafe(no_mangle)]
@@ -46,7 +46,7 @@ pub struct CLayout {
 #[cfg(feature = "alloc")]
 impl Into<Layout> for CLayout {
     fn into(self) -> Layout {
-        Layout::from_size_align(self.size, self.alignment).unwrap()
+        unsafe { Layout::from_size_align_unchecked(self.size, self.alignment) }
     }
 }
 
@@ -396,21 +396,23 @@ pub extern "C" fn gen_rand(req: &mut RngRequest) {
 pub type ListDir = extern "C" fn(
     str: *const u8,
     len: usize,
-    files: *mut Option<DirEntry>,
+    entries: *mut *mut c_char,
     file_len: usize,
+    max_entry_str_len: usize,
 ) -> usize;
 
 #[unsafe(no_mangle)]
 pub extern "C" fn list_dir(
     str: *const u8,
     len: usize,
-    files: *mut Option<DirEntry>,
-    file_len: usize,
+    entries: *mut *mut c_char,
+    entry_count: usize,
+    max_entry_str_len: usize,
 ) -> usize {
     unsafe {
         let ptr = CALL_ABI_TABLE[CallTable::ListDir as usize];
         let f: ListDir = core::mem::transmute(ptr);
-        f(str, len, files, file_len)
+        f(str, len, entries, entry_count, max_entry_str_len)
     }
 }
 
@@ -437,6 +439,24 @@ pub extern "C" fn read_file(
     }
 }
 
+pub type WriteFile =
+    extern "C" fn(str: *const u8, len: usize, write_from: usize, buf: *const u8, buf_len: usize);
+
+#[unsafe(no_mangle)]
+pub extern "C" fn write_file(
+    str: *const u8,
+    len: usize,
+    write_from: usize,
+    buf: *const u8,
+    buf_len: usize,
+) {
+    unsafe {
+        let ptr = CALL_ABI_TABLE[CallTable::WriteFile as usize];
+        let f: WriteFile = core::mem::transmute(ptr);
+        f(str, len, write_from, buf, buf_len)
+    }
+}
+
 pub type FileLen = extern "C" fn(str: *const u8, len: usize) -> usize;
 
 #[unsafe(no_mangle)]

justfile

@@ -1,5 +1,7 @@
 kernel-dev board:
-    cargo run --bin kernel --features {{board}}
+    cargo run --bin kernel --features {{board}}  --features fps
+kernel-release-probe board:
+    cargo run --bin kernel --profile release --features {{board}}  --features fps
 kernel-release board:
     cargo build --bin kernel --release --no-default-features --features {{board}}
     elf2uf2-rs -d target/thumbv8m.main-none-eabihf/release/kernel
@@ -9,6 +11,26 @@ binary-args := "RUSTFLAGS=\"-C link-arg=-pie -C relocation-model=pic\""
 cbindgen:
     cbindgen abi_sys --output abi_sys.h -q
 
+newlib:
+    #!/bin/bash
+    cd picolibc
+    mkdir build
+    cd build
+    CONFIG_PICOLIBC=true ../scripts/do-configure thumbv8m_main_fp-none-eabi \
+        --buildtype=minsize \
+        -Dtests=true \
+        -Dtinystdio=false \
+        -Dsingle-thread=true \
+        -Db_pie=true \
+        -Ddefault_library=static \
+        -Dtinystdio=false \
+        -Dnewlib-nano-malloc=true \
+        -Dmultilib=false \
+        -Dpicolib=true \
+        "$@" 
+    DESTDIR=./install meson install
+    ninja
+
 userapp app:
      {{binary-args}} cargo build --bin {{app}} --profile release-binary
 
@@ -17,3 +39,19 @@ userapps: cbindgen
     just userapp snake
     just userapp gallery
     just userapp gif
+    just userapp gboy
+
+copy-userapp app:
+    cp ./target/thumbv8m.main-none-eabihf/release-binary/{{app}} /run/media/$(whoami)/PICOCALC/{{app}}.bin
+
+copy-userapps:
+    #!/bin/bash
+    just userapps
+    just copy-userapp calculator
+    just copy-userapp snake
+    just copy-userapp gallery
+    just copy-userapp gif
+
+    DEV=$(lsblk -o LABEL,NAME -nr | awk -v L="PICOCALC" '$1==L {print "/dev/" $2}')
+    udisksctl unmount -b "$DEV"
+    udisksctl power-off -b "$DEV"    

kernel/Cargo.toml

@@ -11,11 +11,14 @@ doctest = false
 bench = false
 
 [features]
-default = ["rp235x", "defmt", "pimoroni2w"]
-pimoroni2w = ["rp235x"]
-rp2040 = ["embassy-rp/rp2040"]
+default = ["rp235x", "defmt"]
+pimoroni2w = ["rp235x", "psram"]
+# rp2040 = ["embassy-rp/rp2040"] # unsupported, ram too small for fb
 rp235x = ["embassy-rp/rp235xb"]
 trouble = ["dep:bt-hci", "dep:cyw43", "dep:cyw43-pio", "dep:trouble-host"]
+psram = ["dep:embedded-alloc"]
+overclock = []
+fps = []
 defmt = [
   "dep:defmt",
   "panic-probe/print-defmt",
@@ -70,15 +73,14 @@ panic-probe = "0.3"
 portable-atomic = { version = "1.11", features = ["critical-section"] }
 assign-resources = "0.5.0"
 
-defmt = { version = "0.3", optional = true }
-defmt-rtt = "0.4.2"
+defmt = { version = "1.0.1", optional = true }
+defmt-rtt = "1.1.0"
 
 embedded-sdmmc = { version = "0.9", default-features = false }
 st7365p-lcd = { git = "https://github.com/legitcamper/st7365p-lcd-rs", rev = "a784b9e6df0769371dfc522528e770cf8fc6403a" } # async branch
 embedded-graphics = { version = "0.8.1" }
 embedded-text = "0.7.2"
 embedded-layout = "0.4.2"
-kolibri-embedded-gui = "0.1.0"
 
 strum = { version = "0.27.2", default-features = false }
 rand = { version = "0.9.0", default-features = false }
@@ -90,7 +92,9 @@ spin = "0.10.0"
 num_enum = { version = "0.7.4", default-features = false }
 goblin = { version = "0.10.1", default-features = false, features = ["elf32"] }
 talc = "4.4.3"
-embedded-alloc = { version = "0.6.0", features = ["allocator_api"] }
+embedded-alloc = { version = "0.6.0", features = [
+  "allocator_api",
+], optional = true }
 bumpalo = "3.19.0"
 
 abi_sys = { path = "../abi_sys" }

kernel/src/abi.rs

@@ -1,17 +1,24 @@
 use abi_sys::{
     AllocAbi, CLayout, CPixel, DeallocAbi, DrawIterAbi, FileLen, GenRand, GetMsAbi, ListDir,
-    PrintAbi, ReadFile, RngRequest, SleepMsAbi, keyboard::*,
+    PrintAbi, ReadFile, RngRequest, SleepMsAbi, WriteFile, keyboard::*,
 };
 use alloc::{string::ToString, vec::Vec};
-use core::{alloc::GlobalAlloc, ops::DerefMut, sync::atomic::Ordering};
+use core::{ffi::c_char, ptr, sync::atomic::Ordering};
 use embassy_rp::clocks::{RoscRng, clk_sys_freq};
 use embassy_time::Instant;
 use embedded_graphics::draw_target::DrawTarget;
-use embedded_sdmmc::{DirEntry, LfnBuffer};
+use embedded_sdmmc::LfnBuffer;
 use heapless::spsc::Queue;
 
+#[cfg(feature = "psram")]
+use crate::heap::HEAP;
+
+#[cfg(feature = "psram")]
+use core::alloc::GlobalAlloc;
+
 use crate::{
-    display::{FRAMEBUFFER, FRAMEBUFFER2, WRITE_FRAMEBUFFER2},
+    display::FRAMEBUFFER,
+    framebuffer::FB_PAUSED,
     storage::{Dir, File, SDCARD},
 };
 
@@ -19,10 +26,14 @@ const _: AllocAbi = alloc;
 pub extern "C" fn alloc(layout: CLayout) -> *mut u8 {
     // SAFETY: caller guarantees layout is valid
     unsafe {
-        if cfg!(feature = "pimoroni2w") {
-            crate::heap::HEAP.alloc(layout.into())
-        } else {
-            alloc::alloc::alloc(layout.into())
+        #[cfg(feature = "psram")]
+        {
+            return HEAP.alloc(layout.into());
+        }
+
+        #[cfg(not(feature = "psram"))]
+        {
+            return alloc::alloc::alloc(layout.into());
         }
     }
 }
@@ -30,12 +41,14 @@ pub extern "C" fn alloc(layout: CLayout) -> *mut u8 {
 const _: DeallocAbi = dealloc;
 pub extern "C" fn dealloc(ptr: *mut u8, layout: CLayout) {
     // SAFETY: caller guarantees ptr and layout are valid
-    unsafe {
-        if cfg!(feature = "pimoroni2w") {
-            crate::heap::HEAP.dealloc(ptr, layout.into())
-        } else {
-            alloc::alloc::dealloc(ptr, layout.into())
-        }
+    #[cfg(feature = "psram")]
+    {
+        unsafe { HEAP.dealloc(ptr, layout.into()) }
+    }
+
+    #[cfg(not(feature = "psram"))]
+    {
+        unsafe { alloc::alloc::dealloc(ptr, layout.into()) }
     }
 }
 
@@ -79,19 +92,9 @@ pub extern "C" fn draw_iter(cpixels: *const CPixel, len: usize) {
 
     let iter = cpixels.iter().copied().map(|c: CPixel| c.into());
 
-    let fb = if cfg!(feature = "pimoroni2w") {
-        if WRITE_FRAMEBUFFER2.load(Ordering::Acquire) {
-            unsafe { FRAMEBUFFER2.deref_mut() }
-        } else {
-            unsafe { &mut FRAMEBUFFER }
-        }
-    } else {
-        unsafe { &mut FRAMEBUFFER }
-    };
-
-    fb.draw_iter(iter).unwrap();
-
-    WRITE_FRAMEBUFFER2.fetch_not(Ordering::AcqRel);
+    FB_PAUSED.store(true, Ordering::Release);
+    unsafe { FRAMEBUFFER.as_mut().unwrap().draw_iter(iter).unwrap() }
+    FB_PAUSED.store(false, Ordering::Release);
 }
 
 pub static mut KEY_CACHE: Queue<KeyEvent, 32> = Queue::new();
@@ -125,11 +128,27 @@ pub extern "C" fn gen_rand(req: &mut RngRequest) {
     }
 }
 
-fn get_dir_entries(dir: &Dir, files: &mut [Option<DirEntry>]) -> usize {
+unsafe fn copy_entry_to_user_buf(name: &[u8], dest: *mut c_char, max_str_len: usize) {
+    if !dest.is_null() {
+        let len = name.len().min(max_str_len - 1);
+        unsafe {
+            ptr::copy_nonoverlapping(name.as_ptr(), dest as *mut u8, len);
+            *dest.add(len) = 0; // nul terminator
+        }
+    }
+}
+
+unsafe fn get_dir_entries(dir: &Dir, entries: &mut [*mut c_char], max_str_len: usize) -> usize {
+    let mut b = [0; 25];
+    let mut buf = LfnBuffer::new(&mut b);
     let mut i = 0;
-    dir.iterate_dir(|entry| {
-        if i < files.len() {
-            files[i] = Some(entry.clone());
+    dir.iterate_dir_lfn(&mut buf, |entry, lfn_name| {
+        if i < entries.len() {
+            if let Some(name) = lfn_name {
+                unsafe { copy_entry_to_user_buf(name.as_bytes(), entries[i], max_str_len) };
+            } else {
+                unsafe { copy_entry_to_user_buf(entry.name.base_name(), entries[i], max_str_len) };
+            }
             i += 1;
         }
     })
@@ -137,24 +156,30 @@ fn get_dir_entries(dir: &Dir, files: &mut [Option<DirEntry>]) -> usize {
     i
 }
 
-fn recurse_dir(dir: &Dir, dirs: &[&str], files: &mut [Option<DirEntry>]) -> usize {
+unsafe fn recurse_dir(
+    dir: &Dir,
+    dirs: &[&str],
+    entries: &mut [*mut c_char],
+    max_str_len: usize,
+) -> usize {
     if dirs.is_empty() {
-        return get_dir_entries(dir, files);
+        return unsafe { get_dir_entries(dir, entries, max_str_len) };
     }
 
     let dir = dir.open_dir(dirs[0]).unwrap();
-    recurse_dir(&dir, &dirs[1..], files)
+    unsafe { recurse_dir(&dir, &dirs[1..], entries, max_str_len) }
 }
 
 const _: ListDir = list_dir;
 pub extern "C" fn list_dir(
     dir: *const u8,
     len: usize,
-    files: *mut Option<DirEntry>,
+    entries: *mut *mut c_char,
     files_len: usize,
+    max_entry_str_len: usize,
 ) -> usize {
     // SAFETY: caller guarantees `ptr` is valid for `len` bytes
-    let files = unsafe { core::slice::from_raw_parts_mut(files, files_len) };
+    let files = unsafe { core::slice::from_raw_parts_mut(entries, files_len) };
     // SAFETY: caller guarantees `ptr` is valid for `len` bytes
     let dir = unsafe { core::str::from_raw_parts(dir, len) };
     let dirs: Vec<&str> = dir.split('/').collect();
@@ -165,10 +190,12 @@ pub extern "C" fn list_dir(
     let mut wrote = 0;
     sd.access_root_dir(|root| {
         if dirs[0] == "" && dirs.len() >= 2 {
-            if dir == "/" {
-                wrote = get_dir_entries(&root, files);
-            } else {
-                wrote = recurse_dir(&root, &dirs[1..], files);
+            unsafe {
+                if dir == "/" {
+                    wrote = get_dir_entries(&root, files, max_entry_str_len);
+                } else {
+                    wrote = recurse_dir(&root, &dirs[1..], files, max_entry_str_len);
+                }
             }
         }
     });
@@ -180,6 +207,7 @@ fn recurse_file<T>(
     dirs: &[&str],
     mut access: impl FnMut(&mut File) -> T,
 ) -> Result<T, ()> {
+    defmt::info!("dir: {}, dirs: {}", dir, dirs);
     if dirs.len() == 1 {
         let mut b = [0_u8; 50];
         let mut buf = LfnBuffer::new(&mut b);
@@ -191,7 +219,8 @@ fn recurse_file<T>(
                 }
             }
         })
-        .unwrap();
+        .expect("Failed to iterate dir");
+
         if let Some(name) = short_name {
             let mut file = dir
                 .open_file_in_dir(name, embedded_sdmmc::Mode::ReadWriteAppend)
@@ -215,7 +244,17 @@ pub extern "C" fn read_file(
 ) -> usize {
     // SAFETY: caller guarantees `ptr` is valid for `len` bytes
     let file = unsafe { core::str::from_raw_parts(str, len) };
-    let file: Vec<&str> = file.split('/').collect();
+
+    let mut components: [&str; 8] = [""; 8];
+    let mut count = 0;
+    for part in file.split('/') {
+        if count >= components.len() {
+            break;
+        }
+        components[count] = part;
+        count += 1;
+    }
+
     // SAFETY: caller guarantees `ptr` is valid for `len` bytes
     let mut buf = unsafe { core::slice::from_raw_parts_mut(buf, buf_len) };
 
@@ -225,8 +264,8 @@ pub extern "C" fn read_file(
     let sd = guard.as_mut().unwrap();
     if !file.is_empty() {
         sd.access_root_dir(|root| {
-            if let Ok(result) = recurse_file(&root, &file[1..], |file| {
-                file.seek_from_start(start_from as u32).unwrap();
+            if let Ok(result) = recurse_file(&root, &components[1..count], |file| {
+                file.seek_from_start(start_from as u32).unwrap_or(());
                 file.read(&mut buf).unwrap()
             }) {
                 read = result
@@ -236,9 +275,46 @@ pub extern "C" fn read_file(
     read
 }
 
+const _: WriteFile = write_file;
+pub extern "C" fn write_file(
+    str: *const u8,
+    len: usize,
+    start_from: usize,
+    buf: *const u8,
+    buf_len: usize,
+) {
+    // SAFETY: caller guarantees str ptr is valid for `len` bytes
+    let file = unsafe { core::str::from_raw_parts(str, len) };
+
+    let mut components: [&str; 8] = [""; 8];
+    let mut count = 0;
+    for part in file.split('/') {
+        if count >= components.len() {
+            break;
+        }
+        components[count] = part;
+        count += 1;
+    }
+
+    // SAFETY: caller guarantees buf ptr is valid for `buf_len` bytes
+    let buf = unsafe { core::slice::from_raw_parts(buf, buf_len) };
+
+    let mut guard = SDCARD.get().try_lock().expect("Failed to get sdcard");
+    let sd = guard.as_mut().unwrap();
+    if !file.is_empty() {
+        sd.access_root_dir(|root| {
+            recurse_file(&root, &components[1..count], |file| {
+                file.seek_from_start(start_from as u32).unwrap();
+                file.write(&buf).unwrap()
+            })
+            .unwrap_or(())
+        });
+    };
+}
+
 const _: FileLen = file_len;
 pub extern "C" fn file_len(str: *const u8, len: usize) -> usize {
-    // SAFETY: caller guarantees `ptr` is valid for `len` bytes
+    // SAFETY: caller guarantees str ptr is valid for `len` bytes
     let file = unsafe { core::str::from_raw_parts(str, len) };
     let file: Vec<&str> = file.split('/').collect();
 

kernel/src/display.rs

@@ -1,9 +1,5 @@
-use crate::framebuffer::{self, AtomicFrameBuffer};
-use alloc::vec;
-use core::alloc::GlobalAlloc;
-use core::alloc::Layout;
-#[cfg(feature = "pimoroni2w")]
-use core::sync::atomic::AtomicBool;
+use crate::framebuffer::{self, AtomicFrameBuffer, FB_PAUSED};
+use core::alloc::{GlobalAlloc, Layout};
 use core::sync::atomic::Ordering;
 use embassy_rp::{
     Peri,
@@ -12,10 +8,19 @@ use embassy_rp::{
     spi::{Async, Spi},
 };
 use embassy_time::{Delay, Timer};
+use embedded_graphics::{
+    pixelcolor::Rgb565,
+    prelude::{DrawTarget, RgbColor},
+};
 use embedded_hal_bus::spi::ExclusiveDevice;
-use once_cell::unsync::Lazy;
 use st7365p_lcd::ST7365P;
 
+#[cfg(feature = "psram")]
+use crate::heap::HEAP;
+
+#[cfg(feature = "fps")]
+pub use framebuffer::fps::{FPS_CANVAS, FPS_COUNTER};
+
 type DISPLAY = ST7365P<
     ExclusiveDevice<Spi<'static, SPI1, Async>, Output<'static>, Delay>,
     Output<'static>,
@@ -26,33 +31,27 @@ type DISPLAY = ST7365P<
 pub const SCREEN_WIDTH: usize = 320;
 pub const SCREEN_HEIGHT: usize = 320;
 
-// used to switch which fb is being used for read/write
-#[cfg(feature = "pimoroni2w")]
-pub static WRITE_FRAMEBUFFER2: AtomicBool = AtomicBool::new(false);
+pub static mut FRAMEBUFFER: Option<AtomicFrameBuffer> = None;
 
-// the default screen buffer - the only one on boards without extra ram or psram
-pub static mut FRAMEBUFFER: Lazy<AtomicFrameBuffer> = Lazy::new(|| {
-    static mut BUF: [u16; framebuffer::SIZE] = [0; framebuffer::SIZE];
-    AtomicFrameBuffer::new(unsafe { &mut BUF })
-});
+fn init_fb() {
+    unsafe {
+        #[cfg(feature = "psram")]
+        {
+            let slab = HEAP.alloc(Layout::array::<u16>(framebuffer::SIZE).unwrap()) as *mut u16;
+            let buf = core::slice::from_raw_parts_mut(slab, framebuffer::SIZE);
 
-#[cfg(feature = "pimoroni2w")]
-pub static mut FRAMEBUFFER2: Lazy<AtomicFrameBuffer> = Lazy::new(|| {
-    use embedded_graphics::{
-        pixelcolor::Rgb565,
-        prelude::{DrawTarget, RgbColor},
-    };
+            let mut fb = AtomicFrameBuffer::new(buf);
+            fb.clear(Rgb565::BLACK).unwrap();
+            FRAMEBUFFER = Some(fb);
+        }
 
-    let buf = unsafe {
-        let slab =
-            crate::heap::HEAP.alloc(Layout::array::<u16>(framebuffer::SIZE).unwrap()) as *mut u16;
-        core::slice::from_raw_parts_mut(slab, framebuffer::SIZE)
-    };
-    let mut fb = AtomicFrameBuffer::new(buf);
-    fb.set_all_tiles(false);
-    fb.clear(Rgb565::BLACK).unwrap();
-    fb
-});
+        #[cfg(not(feature = "psram"))]
+        {
+            static mut BUF: [u16; framebuffer::SIZE] = [0; framebuffer::SIZE];
+            FRAMEBUFFER = Some(AtomicFrameBuffer::new(&mut BUF));
+        }
+    }
+}
 
 pub async fn init_display(
     spi: Spi<'static, SPI1, Async>,
@@ -60,6 +59,8 @@ pub async fn init_display(
     data: Peri<'static, PIN_14>,
     reset: Peri<'static, PIN_15>,
 ) -> DISPLAY {
+    init_fb();
+
     let spi_device = ExclusiveDevice::new(spi, Output::new(cs, Level::Low), Delay).unwrap();
     let mut display = ST7365P::new(
         spi_device,
@@ -71,7 +72,14 @@ pub async fn init_display(
     );
     display.init().await.unwrap();
     display.set_custom_orientation(0x40).await.unwrap();
-    unsafe { FRAMEBUFFER.draw(&mut display).await.unwrap() }
+    unsafe {
+        FRAMEBUFFER
+            .as_mut()
+            .unwrap()
+            .draw(&mut display)
+            .await
+            .unwrap()
+    }
     display.set_on().await.unwrap();
 
     display
@@ -79,19 +87,37 @@ pub async fn init_display(
 
 #[embassy_executor::task]
 pub async fn display_handler(mut display: DISPLAY) {
-    loop {
-        let fb = if cfg!(feature = "pimoroni2w") {
-            if WRITE_FRAMEBUFFER2.load(Ordering::Acquire) {
-                unsafe { &mut FRAMEBUFFER }
-            } else {
-                unsafe { &mut FRAMEBUFFER2 }
-            }
-        } else {
-            unsafe { &mut FRAMEBUFFER }
-        };
-        fb.safe_draw(&mut display).await.unwrap();
+    use embassy_time::{Instant, Timer};
 
-        // small yield to allow other tasks to run
-        Timer::after_nanos(100).await;
+    // Target ~60 Hz refresh (≈16.67 ms per frame)
+    const FRAME_TIME_MS: u64 = 1000 / 60;
+
+    loop {
+        let start = Instant::now();
+
+        #[cfg(feature = "fps")]
+        unsafe {
+            if FPS_COUNTER.should_draw() {
+                FPS_CANVAS.draw_fps().await;
+            }
+        }
+
+        if !FB_PAUSED.load(Ordering::Acquire) {
+            unsafe {
+                FRAMEBUFFER
+                    .as_mut()
+                    .unwrap()
+                    .partial_draw(&mut display)
+                    .await
+                    .unwrap();
+            }
+        }
+
+        let elapsed = start.elapsed().as_millis() as u64;
+        if elapsed < FRAME_TIME_MS {
+            Timer::after_millis(FRAME_TIME_MS - elapsed).await;
+        } else {
+            Timer::after_millis(1).await;
+        }
     }
 }

kernel/src/elf.rs

@@ -206,6 +206,7 @@ fn patch_abi(
                             CallTable::GenRand => abi::gen_rand as usize,
                             CallTable::ListDir => abi::list_dir as usize,
                             CallTable::ReadFile => abi::read_file as usize,
+                            CallTable::WriteFile => abi::write_file as usize,
                             CallTable::FileLen => abi::file_len as usize,
                         };
                         unsafe {

kernel/src/framebuffer.rs

@@ -1,6 +1,5 @@
 use crate::display::{SCREEN_HEIGHT, SCREEN_WIDTH};
 use core::sync::atomic::{AtomicBool, Ordering};
-use embassy_sync::lazy_lock::LazyLock;
 use embedded_graphics::{
     draw_target::DrawTarget,
     pixelcolor::{
@@ -14,37 +13,35 @@ use embedded_hal_2::digital::OutputPin;
 use embedded_hal_async::{delay::DelayNs, spi::SpiDevice};
 use st7365p_lcd::ST7365P;
 
-pub const TILE_SIZE: usize = 16; // 16x16 tile
-pub const TILE_COUNT: usize = (SCREEN_WIDTH / TILE_SIZE) * (SCREEN_HEIGHT / TILE_SIZE); // 400 tiles
+#[cfg(feature = "fps")]
+use fps::{FPS_CANVAS, FPS_CANVAS_HEIGHT, FPS_CANVAS_WIDTH, FPS_CANVAS_X, FPS_CANVAS_Y};
 
-// Group of tiles for batching
-pub const MAX_META_TILES: usize = (SCREEN_WIDTH / TILE_SIZE) * 2; // max number of meta tiles in buffer
-type MetaTileVec = heapless::Vec<Rectangle, { TILE_COUNT / MAX_META_TILES }>;
+const TILE_SIZE: usize = 16; // 16x16 tile
+const TILE_COUNT: usize = (SCREEN_WIDTH / TILE_SIZE) * (SCREEN_HEIGHT / TILE_SIZE); // 400 tiles
+const NUM_TILE_ROWS: usize = SCREEN_WIDTH / TILE_SIZE;
+const NUM_TILE_COLS: usize = SCREEN_WIDTH / TILE_SIZE;
+
+const MAX_BATCH_TILES: usize = (SCREEN_WIDTH / TILE_SIZE) * 2;
+type BatchTileBuf = [u16; MAX_BATCH_TILES * TILE_SIZE * TILE_SIZE];
 
 pub const SIZE: usize = SCREEN_HEIGHT * SCREEN_WIDTH;
 
+pub static FB_PAUSED: AtomicBool = AtomicBool::new(false);
+
 #[allow(dead_code)]
 pub struct AtomicFrameBuffer<'a> {
     fb: &'a mut [u16],
-    dirty_tiles: heapless::Vec<AtomicBool, TILE_COUNT>,
+    dirty_tiles: [AtomicBool; TILE_COUNT],
+    batch_tile_buf: BatchTileBuf,
 }
 
 impl<'a> AtomicFrameBuffer<'a> {
     pub fn new(buffer: &'a mut [u16]) -> Self {
         assert!(buffer.len() == SIZE);
-        let mut dirty_tiles = heapless::Vec::new();
-        for _ in 0..TILE_COUNT {
-            dirty_tiles.push(AtomicBool::new(true)).unwrap()
-        }
         Self {
             fb: buffer,
-            dirty_tiles,
-        }
-    }
-
-    pub fn set_all_tiles(&mut self, set: bool) {
-        for t in self.dirty_tiles.iter_mut() {
-            t.store(set, Ordering::Release);
+            dirty_tiles: core::array::from_fn(|_| AtomicBool::new(true)),
+            batch_tile_buf: [0; MAX_BATCH_TILES * TILE_SIZE * TILE_SIZE],
         }
     }
 
@@ -99,59 +96,17 @@ impl<'a> AtomicFrameBuffer<'a> {
         Ok(())
     }
 
-    // walk the dirty tiles and mark groups of tiles(meta-tiles) for batched updates
-    fn find_meta_tiles(&mut self, tiles_x: usize, tiles_y: usize) -> MetaTileVec {
-        let mut meta_tiles: MetaTileVec = heapless::Vec::new();
+    // Checks if a full draw would be faster than individual tile batches
+    fn should_full_draw(&self) -> bool {
+        let threshold_pixels = SIZE * 80 / 100;
+        let mut dirty_pixels = 0;
 
-        for ty in 0..tiles_y {
-            let mut tx = 0;
-            while tx < tiles_x {
-                let idx = ty * tiles_x + tx;
-                if !self.dirty_tiles[idx].load(Ordering::Acquire) {
-                    tx += 1;
-                    continue;
-                }
-
-                // Start meta-tile at this tile
-                let mut width_tiles = 1;
-                let height_tiles = 1;
-
-                // Grow horizontally, but keep under MAX_TILES_PER_METATILE
-                while tx + width_tiles < tiles_x
-                    && unsafe {
-                        self.dirty_tiles[ty * tiles_x + tx + width_tiles].load(Ordering::Acquire)
-                    }
-                    && (width_tiles + height_tiles) <= MAX_META_TILES
-                {
-                    width_tiles += 1;
-                }
-
-                // TODO: for simplicity, skipped vertical growth
-
-                for x_off in 0..width_tiles {
-                    unsafe {
-                        self.dirty_tiles[ty * tiles_x + tx + x_off].store(false, Ordering::Release);
-                    };
-                }
-
-                // new meta-tile pos
-                let rect = Rectangle::new(
-                    Point::new((tx * TILE_SIZE) as i32, (ty * TILE_SIZE) as i32),
-                    Size::new(
-                        (width_tiles * TILE_SIZE) as u32,
-                        (height_tiles * TILE_SIZE) as u32,
-                    ),
-                );
-
-                if meta_tiles.push(rect).is_err() {
-                    return meta_tiles;
-                };
-
-                tx += width_tiles;
+        self.dirty_tiles.iter().any(|tile| {
+            if tile.load(Ordering::Acquire) {
+                dirty_pixels += TILE_SIZE * TILE_SIZE;
             }
-        }
-
-        meta_tiles
+            dirty_pixels >= threshold_pixels
+        })
     }
 
     /// Sends the entire framebuffer to the display
@@ -174,68 +129,100 @@ impl<'a> AtomicFrameBuffer<'a> {
             )
             .await?;
 
+        for tile in self.dirty_tiles.iter() {
+            tile.store(false, Ordering::Release);
+        }
+
+        #[cfg(feature = "fps")]
         unsafe {
-            for tile in self.dirty_tiles.iter() {
-                tile.store(false, Ordering::Release);
-            }
-        };
-
-        Ok(())
-    }
-
-    pub async fn safe_draw<SPI, DC, RST, DELAY>(
-        &mut self,
-        display: &mut ST7365P<SPI, DC, RST, DELAY>,
-    ) -> Result<(), ()>
-    where
-        SPI: SpiDevice,
-        DC: OutputPin,
-        RST: OutputPin,
-        DELAY: DelayNs,
-    {
-        let tiles_x = SCREEN_WIDTH / TILE_SIZE;
-        let _tiles_y = SCREEN_HEIGHT / TILE_SIZE;
-
-        let mut pixel_buffer: heapless::Vec<u16, { TILE_SIZE * TILE_SIZE }> = heapless::Vec::new();
-
-        for tile_idx in 0..TILE_COUNT {
-            if self.dirty_tiles[tile_idx].swap(false, Ordering::AcqRel) {
-                let tx = tile_idx % tiles_x;
-                let ty = tile_idx / tiles_x;
-
-                let x_start = tx * TILE_SIZE;
-                let y_start = ty * TILE_SIZE;
-
-                let x_end = (x_start + TILE_SIZE).min(SCREEN_WIDTH);
-                let y_end = (y_start + TILE_SIZE).min(SCREEN_HEIGHT);
-
-                pixel_buffer.clear();
-
-                for y in y_start..y_end {
-                    let start = y * SCREEN_WIDTH + x_start;
-                    let end = y * SCREEN_WIDTH + x_end;
-                    pixel_buffer
-                        .extend_from_slice(&self.fb[start..end])
-                        .unwrap();
-                }
-
-                display
-                    .set_pixels_buffered(
-                        x_start as u16,
-                        y_start as u16,
-                        (x_end - 1) as u16,
-                        (y_end - 1) as u16,
-                        &pixel_buffer,
-                    )
-                    .await
-                    .unwrap();
-            }
+            crate::display::FPS_COUNTER.measure()
         }
 
         Ok(())
     }
 
-    /// Sends only dirty tiles (16x16px) in batches to the display
+    // used when doing a full screen refresh fps must be drawn into fb
+    // unfortunately it is not garenteed to not be drawn over before
+    // being pushed to the display
+    #[cfg(feature = "fps")]
+    pub fn draw_fps_into_fb(&mut self) {
+        unsafe {
+            let canvas = &FPS_CANVAS.canvas;
+
+            for y in 0..FPS_CANVAS_HEIGHT {
+                let fb_y = FPS_CANVAS_Y + y;
+                let fb_row_start = fb_y * SCREEN_WIDTH + FPS_CANVAS_X;
+                let canvas_row_start = y * FPS_CANVAS_WIDTH;
+
+                self.fb[fb_row_start..fb_row_start + FPS_CANVAS_WIDTH].copy_from_slice(
+                    &canvas[canvas_row_start..canvas_row_start + FPS_CANVAS_WIDTH],
+                );
+            }
+        }
+    }
+
+    // copy N tiles horizontally to the right into batch tile buf
+    fn append_tiles_to_batch(
+        &mut self,
+        tile_x: u16,
+        tile_y: u16,
+        total_tiles: u16, // number of tiles being written to buf
+    ) {
+        debug_assert!(total_tiles as usize <= NUM_TILE_COLS);
+        for batch_row_num in 0..TILE_SIZE {
+            let batch_row_offset = batch_row_num * total_tiles as usize * TILE_SIZE;
+            let batch_row = &mut self.batch_tile_buf
+                [batch_row_offset..batch_row_offset + (total_tiles as usize * TILE_SIZE)];
+
+            let fb_row_offset = (tile_y as usize * TILE_SIZE + batch_row_num) * SCREEN_WIDTH
+                + tile_x as usize * TILE_SIZE;
+            let fb_row =
+                &self.fb[fb_row_offset..fb_row_offset + (total_tiles as usize * TILE_SIZE)];
+
+            batch_row.copy_from_slice(fb_row);
+
+            // override fps pixel region with fps
+            // avoids writing to fps, and having it overridden before draw
+            #[cfg(feature = "fps")]
+            {
+                let global_y = tile_y as usize * TILE_SIZE + batch_row_num;
+
+                if global_y >= FPS_CANVAS_Y && global_y < FPS_CANVAS_Y + FPS_CANVAS_HEIGHT {
+                    let start_x = tile_x as usize * TILE_SIZE;
+                    let end_x = start_x + (total_tiles as usize * TILE_SIZE);
+
+                    // horizontal overlap check
+                    let fps_x0 = FPS_CANVAS_X;
+                    let fps_x1 = FPS_CANVAS_X + FPS_CANVAS_WIDTH;
+
+                    let x0 = start_x.max(fps_x0);
+                    let x1 = end_x.min(fps_x1);
+
+                    if x1 > x0 {
+                        let row_in_fps = global_y - FPS_CANVAS_Y;
+                        let fps_off = row_in_fps
+                            .checked_mul(FPS_CANVAS_WIDTH)
+                            .and_then(|v| v.checked_add(x0 - fps_x0));
+                        let batch_off = x0 - start_x;
+                        let len = x1 - x0;
+
+                        if let Some(fps_off) = fps_off {
+                            let fps_len_ok = fps_off + len <= unsafe { FPS_CANVAS.canvas.len() };
+                            let batch_len_ok = batch_off + len <= batch_row.len();
+
+                            if fps_len_ok && batch_len_ok {
+                                batch_row[batch_off..batch_off + len].copy_from_slice(unsafe {
+                                    &FPS_CANVAS.canvas[fps_off..fps_off + len]
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    // Pushes tiles to the display in batches to avoid full frame pushes (unless needed)
     pub async fn partial_draw<SPI, DC, RST, DELAY>(
         &mut self,
         display: &mut ST7365P<SPI, DC, RST, DELAY>,
@@ -246,60 +233,77 @@ impl<'a> AtomicFrameBuffer<'a> {
         RST: OutputPin,
         DELAY: DelayNs,
     {
-        if unsafe { self.dirty_tiles.iter().any(|p| p.load(Ordering::Acquire)) } {
-            let tiles_x = (SCREEN_WIDTH + TILE_SIZE - 1) / TILE_SIZE;
-            let tiles_y = (SCREEN_HEIGHT + TILE_SIZE - 1) / TILE_SIZE;
+        if self.should_full_draw() {
+            #[cfg(feature = "fps")]
+            self.draw_fps_into_fb();
+            return self.draw(display).await;
+        }
 
-            let meta_tiles = self.find_meta_tiles(tiles_x, tiles_y);
+        #[cfg(feature = "fps")]
+        {
+            let fps_tile_x = FPS_CANVAS_X / TILE_SIZE;
+            let fps_tile_y = FPS_CANVAS_Y / TILE_SIZE;
+            let fps_tile_w = (FPS_CANVAS_WIDTH + TILE_SIZE - 1) / TILE_SIZE;
+            let fps_tile_h = (FPS_CANVAS_HEIGHT + TILE_SIZE - 1) / TILE_SIZE;
 
-            // buffer for copying meta tiles before sending to display
-            let mut pixel_buffer: heapless::Vec<u16, { MAX_META_TILES * TILE_SIZE * TILE_SIZE }> =
-                heapless::Vec::new();
-
-            for rect in meta_tiles {
-                let rect_width = rect.size.width as usize;
-                let rect_height = rect.size.height as usize;
-                let rect_x = rect.top_left.x as usize;
-                let rect_y = rect.top_left.y as usize;
-
-                pixel_buffer.clear();
-
-                for row in 0..rect_height {
-                    let y = rect_y + row;
-                    let start = y * SCREEN_WIDTH + rect_x;
-                    let end = start + rect_width;
-
-                    // Safe: we guarantee buffer will not exceed MAX_META_TILE_PIXELS
-                    pixel_buffer
-                        .extend_from_slice(&self.fb[start..end])
-                        .unwrap();
-                }
-
-                display
-                    .set_pixels_buffered(
-                        rect_x as u16,
-                        rect_y as u16,
-                        (rect_x + rect_width - 1) as u16,
-                        (rect_y + rect_height - 1) as u16,
-                        &pixel_buffer,
-                    )
-                    .await?;
-
-                // walk the meta-tile and set as clean
-                let start_tx = rect_x / TILE_SIZE;
-                let start_ty = rect_y / TILE_SIZE;
-                let end_tx = (rect_x + rect_width - 1) / TILE_SIZE;
-                let end_ty = (rect_y + rect_height - 1) / TILE_SIZE;
-
-                for ty in start_ty..=end_ty {
-                    for tx in start_tx..=end_tx {
-                        let tile_idx = ty * tiles_x + tx;
-                        self.dirty_tiles[tile_idx].store(false, Ordering::Release);
-                    }
+            for ty in fps_tile_y..fps_tile_y + fps_tile_h {
+                for tx in fps_tile_x..fps_tile_x + fps_tile_w {
+                    self.dirty_tiles[ty * NUM_TILE_COLS + tx].store(true, Ordering::Release);
                 }
             }
         }
 
+        for tile_row in 0..NUM_TILE_ROWS {
+            let row_start_idx = tile_row * NUM_TILE_COLS;
+            let mut col = 0;
+
+            while col < NUM_TILE_COLS {
+                // Check for dirty tile
+                if self.dirty_tiles[row_start_idx + col].swap(false, Ordering::Acquire) {
+                    let run_start = col;
+                    let mut run_len = 1;
+
+                    // Extend run while contiguous dirty tiles and within MAX_BATCH_TILES
+                    while col + 1 < NUM_TILE_COLS
+                        && self.dirty_tiles[row_start_idx + col + 1].load(Ordering::Acquire)
+                        && run_len < MAX_BATCH_TILES
+                    {
+                        col += 1;
+                        run_len += 1;
+                    }
+
+                    // Copy the whole horizontal run into the batch buffer in one call
+                    let tile_x = run_start;
+                    let tile_y = tile_row;
+                    self.append_tiles_to_batch(tile_x as u16, tile_y as u16, run_len as u16);
+
+                    // Compute coordinates for display write
+                    let start_x = tile_x * TILE_SIZE;
+                    let end_x = start_x + run_len * TILE_SIZE - 1;
+                    let start_y = tile_y * TILE_SIZE;
+                    let end_y = start_y + TILE_SIZE - 1;
+
+                    // Send batch to display
+                    display
+                        .set_pixels_buffered(
+                            start_x as u16,
+                            start_y as u16,
+                            end_x as u16,
+                            end_y as u16,
+                            &self.batch_tile_buf[..run_len * TILE_SIZE * TILE_SIZE],
+                        )
+                        .await?;
+                }
+
+                col += 1;
+            }
+        }
+
+        #[cfg(feature = "fps")]
+        unsafe {
+            crate::display::FPS_COUNTER.measure()
+        }
+
         Ok(())
     }
 }
@@ -317,8 +321,8 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> {
 
         for Pixel(coord, color) in pixels {
             if coord.x >= 0 && coord.y >= 0 {
-                let x = coord.x as i32;
-                let y = coord.y as i32;
+                let x = coord.x;
+                let y = coord.y;
 
                 if (x as usize) < SCREEN_WIDTH && (y as usize) < SCREEN_HEIGHT {
                     let idx = (y as usize) * SCREEN_WIDTH + (x as usize);
@@ -425,3 +429,146 @@ impl<'a> OriginDimensions for AtomicFrameBuffer<'a> {
         Size::new(SCREEN_WIDTH as u32, SCREEN_HEIGHT as u32)
     }
 }
+
+#[cfg(feature = "fps")]
+pub mod fps {
+    use crate::display::SCREEN_WIDTH;
+    use core::fmt::Write;
+    use embassy_time::{Duration, Instant};
+    use embedded_graphics::{
+        Drawable, Pixel,
+        draw_target::DrawTarget,
+        geometry::Point,
+        mono_font::{MonoTextStyle, ascii::FONT_8X13},
+        pixelcolor::Rgb565,
+        prelude::{IntoStorage, OriginDimensions, RgbColor, Size},
+        text::{Alignment, Text},
+    };
+
+    pub static mut FPS_COUNTER: FpsCounter = FpsCounter::new();
+    pub static mut FPS_CANVAS: FpsCanvas = FpsCanvas::new();
+
+    // "FPS: 120" = 8 len
+    const FPS_LEN: usize = 8;
+    pub const FPS_CANVAS_WIDTH: usize = (FONT_8X13.character_size.width + 4) as usize * FPS_LEN;
+    pub const FPS_CANVAS_HEIGHT: usize = FONT_8X13.character_size.height as usize;
+
+    // puts canvas in the top right of the display
+    // top left point of canvas
+    pub const FPS_CANVAS_X: usize = SCREEN_WIDTH - FPS_CANVAS_WIDTH;
+    pub const FPS_CANVAS_Y: usize = 0;
+
+    pub struct FpsCanvas {
+        pub canvas: [u16; FPS_CANVAS_HEIGHT * FPS_CANVAS_WIDTH],
+    }
+
+    impl FpsCanvas {
+        const fn new() -> Self {
+            Self {
+                canvas: [0; FPS_CANVAS_HEIGHT * FPS_CANVAS_WIDTH],
+            }
+        }
+
+        fn clear(&mut self) {
+            for p in &mut self.canvas {
+                *p = 0;
+            }
+        }
+
+        pub async fn draw_fps(&mut self) {
+            let mut buf: heapless::String<FPS_LEN> = heapless::String::new();
+            let fps = unsafe { FPS_COUNTER.smoothed };
+            let _ = write!(buf, "FPS: {}", fps as u8);
+
+            self.clear();
+            let text_style = MonoTextStyle::new(&FONT_8X13, Rgb565::WHITE);
+            Text::with_alignment(
+                buf.as_str(),
+                Point::new(
+                    FPS_CANVAS_WIDTH as i32 / 2,
+                    (FPS_CANVAS_HEIGHT as i32 + 8) / 2,
+                ),
+                text_style,
+                Alignment::Center,
+            )
+            .draw(self)
+            .unwrap();
+        }
+    }
+
+    impl DrawTarget for FpsCanvas {
+        type Error = ();
+        type Color = Rgb565;
+
+        fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>
+        where
+            I: IntoIterator<Item = Pixel<Self::Color>>,
+        {
+            for Pixel(point, color) in pixels {
+                if point.x < 0
+                    || point.x >= FPS_CANVAS_WIDTH as i32
+                    || point.y < 0
+                    || point.y >= FPS_CANVAS_HEIGHT as i32
+                {
+                    continue;
+                }
+
+                let index = (point.y as usize) * FPS_CANVAS_WIDTH + point.x as usize;
+                self.canvas[index] = color.into_storage();
+            }
+            Ok(())
+        }
+    }
+
+    impl OriginDimensions for FpsCanvas {
+        fn size(&self) -> Size {
+            Size::new(FPS_CANVAS_WIDTH as u32, FPS_CANVAS_HEIGHT as u32)
+        }
+    }
+
+    pub struct FpsCounter {
+        last_frame: Option<Instant>,
+        smoothed: f32,
+        last_draw: Option<Instant>,
+    }
+
+    impl FpsCounter {
+        pub const fn new() -> Self {
+            Self {
+                last_frame: None,
+                smoothed: 0.0,
+                last_draw: None,
+            }
+        }
+
+        // Is called once per frame or partial frame to update FPS
+        pub fn measure(&mut self) {
+            let now = Instant::now();
+
+            if let Some(last) = self.last_frame {
+                let dt_us = (now - last).as_micros() as f32;
+                if dt_us > 0.0 {
+                    let current = 1_000_000.0 / dt_us;
+                    self.smoothed = if self.smoothed == 0.0 {
+                        current
+                    } else {
+                        0.9 * self.smoothed + 0.1 * current
+                    };
+                }
+            }
+
+            self.last_frame = Some(now);
+        }
+
+        pub fn should_draw(&mut self) -> bool {
+            let now = Instant::now();
+            match self.last_draw {
+                Some(last) if now - last < Duration::from_millis(200) => false,
+                _ => {
+                    self.last_draw = Some(now);
+                    true
+                }
+            }
+        }
+    }
+}

kernel/src/main.rs

@@ -12,17 +12,22 @@ mod abi;
 mod display;
 mod elf;
 mod framebuffer;
-mod heap;
 mod peripherals;
-mod psram;
 mod scsi;
 mod storage;
 mod ui;
 mod usb;
 mod utils;
 
-#[cfg(feature = "pimoroni2w")]
-use crate::{heap::init_qmi_psram_heap, psram::init_psram_qmi};
+#[cfg(feature = "psram")]
+#[allow(unused)]
+mod heap;
+#[cfg(feature = "psram")]
+#[allow(unused)]
+mod psram;
+
+#[cfg(feature = "psram")]
+use crate::{heap::HEAP, heap::init_qmi_psram_heap, psram::init_psram, psram::init_psram_qmi};
 
 use crate::{
     abi::{KEY_CACHE, MS_SINCE_LAUNCH},
@@ -31,7 +36,6 @@ use crate::{
         conf_peripherals,
         keyboard::{KeyState, read_keyboard_fifo},
     },
-    psram::init_psram,
     scsi::MSC_SHUTDOWN,
     storage::{SDCARD, SdCard},
     ui::{SELECTIONS, clear_selection, ui_handler},
@@ -43,6 +47,8 @@ use embassy_executor::{Executor, Spawner};
 use embassy_futures::{join::join, select::select};
 use embassy_rp::{
     Peri,
+    clocks::ClockConfig,
+    config::Config,
     gpio::{Input, Level, Output, Pull},
     i2c::{self, I2c},
     multicore::{Stack, spawn_core1},
@@ -80,7 +86,10 @@ static mut CORE1_STACK: Stack<16384> = Stack::new();
 static EXECUTOR0: StaticCell<Executor> = StaticCell::new();
 static EXECUTOR1: StaticCell<Executor> = StaticCell::new();
 
+#[cfg(not(feature = "pimoroni2w"))]
 static mut ARENA: [u8; 250 * 1024] = [0; 250 * 1024];
+#[cfg(feature = "pimoroni2w")]
+static mut ARENA: [u8; 400 * 1024] = [0; 400 * 1024];
 
 #[global_allocator]
 static ALLOCATOR: Talck<spin::Mutex<()>, ClaimOnOom> =
@@ -90,11 +99,12 @@ static ALLOCATOR: Talck<spin::Mutex<()>, ClaimOnOom> =
 #[embassy_executor::task]
 async fn watchdog_task(mut watchdog: Watchdog) {
     if let Some(reason) = watchdog.reset_reason() {
-        let reason = match reason {
+        let _reason = match reason {
             ResetReason::Forced => "forced",
             ResetReason::TimedOut => "timed out",
         };
-        defmt::error!("Watchdog reset reason: {}", reason);
+        #[cfg(feature = "debug")]
+        defmt::error!("Watchdog reset reason: {}", _reason);
     }
 
     watchdog.start(Duration::from_secs(3));
@@ -111,7 +121,13 @@ static UI_CHANGE: Signal<CriticalSectionRawMutex, ()> = Signal::new();
 
 #[embassy_executor::main]
 async fn main(_spawner: Spawner) {
-    let p = embassy_rp::init(Default::default());
+    let p = if cfg!(feature = "overclock") {
+        let clocks = ClockConfig::system_freq(300_000_000).unwrap();
+        let config = Config::new(clocks);
+        embassy_rp::init(config)
+    } else {
+        embassy_rp::init(Default::default())
+    };
 
     spawn_core1(
         p.CORE1,
@@ -194,7 +210,7 @@ async fn userland_task() {
         {
             ENABLE_UI.store(true, Ordering::Release);
             UI_CHANGE.signal(());
-            unsafe { FRAMEBUFFER.clear(Rgb565::BLACK).unwrap() };
+            unsafe { FRAMEBUFFER.as_mut().unwrap().clear(Rgb565::BLACK).unwrap() };
 
             let mut selections = SELECTIONS.lock().await;
             selections.set_changed(true);
@@ -221,6 +237,7 @@ struct Sd {
     cs: Peri<'static, PIN_17>,
     det: Peri<'static, PIN_22>,
 }
+#[allow(dead_code)]
 struct Psram {
     pio: Peri<'static, PIO0>,
     sclk: Peri<'static, PIN_21>,
@@ -246,7 +263,7 @@ async fn setup_mcu(mcu: Mcu) {
 
 async fn setup_display(display: Display, spawner: Spawner) {
     let mut config = spi::Config::default();
-    config.frequency = 16_000_000;
+    config.frequency = 192_000_000;
     let spi = Spi::new(
         display.spi,
         display.clk,
@@ -262,37 +279,35 @@ async fn setup_display(display: Display, spawner: Spawner) {
 
 // psram is kind of useless on the pico calc
 // ive opted to use the pimoroni with on onboard xip psram instead
-async fn setup_psram(psram: Psram) {
-    let psram = init_psram(
-        psram.pio, psram.sclk, psram.mosi, psram.miso, psram.cs, psram.dma1, psram.dma2,
-    )
-    .await;
+// async fn setup_psram(psram: Psram) {
+//     let psram = init_psram(
+//         psram.pio, psram.sclk, psram.mosi, psram.miso, psram.cs, psram.dma1, psram.dma2,
+//     )
+//     .await;
 
-    #[cfg(feature = "defmt")]
-    defmt::info!("psram size: {}", psram.size);
+//     #[cfg(feature = "defmt")]
+//     defmt::info!("psram size: {}", psram.size);
 
-    if psram.size == 0 {
-        #[cfg(feature = "defmt")]
-        defmt::info!("\u{1b}[1mExternal PSRAM was NOT found!\u{1b}[0m");
-    }
-}
+//     if psram.size == 0 {
+//         #[cfg(feature = "defmt")]
+//         defmt::info!("\u{1b}[1mExternal PSRAM was NOT found!\u{1b}[0m");
+//     }
+// }
 
-#[cfg(feature = "pimoroni2w")]
+#[cfg(feature = "psram")]
 async fn setup_qmi_psram() {
-    let mut tries = 5;
     Timer::after_millis(250).await;
-    while tries > 1 {
-        let psram_qmi_size = init_psram_qmi(&embassy_rp::pac::QMI, &embassy_rp::pac::XIP_CTRL);
-        defmt::info!("size:  {}", psram_qmi_size);
-        Timer::after_millis(100).await;
-        if psram_qmi_size > 0 {
-            init_qmi_psram_heap(psram_qmi_size);
-            return;
-        }
-        defmt::info!("failed to init qmi psram... trying again");
-        tries -= 1;
+    let psram_qmi_size = init_psram_qmi(&embassy_rp::pac::QMI, &embassy_rp::pac::XIP_CTRL);
+    #[cfg(feature = "debug")]
+    defmt::info!("size:  {}", psram_qmi_size);
+    Timer::after_millis(100).await;
+
+    if psram_qmi_size > 0 {
+        init_qmi_psram_heap(psram_qmi_size);
+        return;
+    } else {
+        panic!("qmi psram not initialized");
     }
-    panic!("qmi psram not initialized");
 }
 
 async fn setup_sd(sd: Sd) {
@@ -316,7 +331,7 @@ async fn kernel_task(
     watchdog: Peri<'static, WATCHDOG>,
     display: Display,
     sd: Sd,
-    psram: Psram,
+    _psram: Psram,
     mcu: Mcu,
     usb: Peri<'static, USB>,
 ) {
@@ -324,11 +339,20 @@ async fn kernel_task(
         .spawn(watchdog_task(Watchdog::new(watchdog)))
         .unwrap();
 
-    // setup_psram(psram).await;
-    #[cfg(feature = "pimoroni2w")]
-    setup_qmi_psram().await;
+    #[cfg(feature = "debug")]
+    defmt::info!("Clock: {}", embassy_rp::clocks::clk_sys_freq());
 
     setup_mcu(mcu).await;
+
+    #[cfg(feature = "defmt")]
+    defmt::info!("setting up psram");
+    Timer::after_millis(100).await;
+
+    // setup_psram(psram).await;
+    #[cfg(feature = "psram")]
+    setup_qmi_psram().await;
+
+    Timer::after_millis(100).await;
     setup_display(display, spawner).await;
     setup_sd(sd).await;
 
@@ -351,7 +375,8 @@ async fn prog_search_handler() {
             let mut guard = SDCARD.get().lock().await;
             let sd = guard.as_mut().unwrap();
 
-            let files = sd.list_files_by_extension(".bin").unwrap();
+            let mut files = sd.list_files_by_extension(".bin").unwrap();
+            files.sort();
             let mut select = SELECTIONS.lock().await;
 
             if *select.selections() != files {
@@ -366,10 +391,8 @@ async fn prog_search_handler() {
 async fn key_handler() {
     loop {
         if let Some(event) = read_keyboard_fifo().await {
-            if let KeyState::Pressed = event.state {
-                unsafe {
-                    let _ = KEY_CACHE.enqueue(event);
-                }
+            unsafe {
+                let _ = KEY_CACHE.enqueue(event);
             }
         }
         Timer::after_millis(50).await;

kernel/src/psram.rs

@@ -526,6 +526,7 @@ pub fn init_psram_qmi(
     let psram_size = detect_psram_qmi(qmi);
 
     if psram_size == 0 {
+        #[cfg(feature = "debug")]
         defmt::error!("qmi psram size 0");
         return 0;
     }
@@ -548,13 +549,13 @@ pub fn init_psram_qmi(
     let min_deselect: u32 = ((18 * 1_000_000 + (clock_period_fs - 1)) / clock_period_fs
         - u64::from(divisor + 1) / 2) as u32;
 
-    #[cfg(feature = "defmt")]
-    defmt::info!(
-        "clock_period_fs={} max_select={} min_deselect={}",
-        clock_period_fs,
-        max_select,
-        min_deselect
-    );
+    // #[cfg(feature = "defmt")]
+    // defmt::info!(
+    //     "clock_period_fs={} max_select={} min_deselect={}",
+    //     clock_period_fs,
+    //     max_select,
+    //     min_deselect
+    // );
 
     qmi.direct_csr().write(|w| {
         w.set_clkdiv(10);

kernel/src/storage.rs

@@ -35,12 +35,24 @@ impl TimeSource for DummyTimeSource {
     }
 }
 
-#[derive(Clone, PartialEq)]
+#[derive(Clone, PartialEq, Eq)]
 pub struct FileName {
     pub long_name: String,
     pub short_name: ShortFileName,
 }
 
+impl PartialOrd for FileName {
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+        Some(self.long_name.cmp(&other.long_name))
+    }
+}
+
+impl Ord for FileName {
+    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
+        self.long_name.cmp(&other.long_name)
+    }
+}
+
 pub struct SdCard {
     det: Input<'static>,
     volume_mgr: VolMgr,

kernel/src/ui.rs

@@ -1,13 +1,10 @@
 use crate::{
-    BINARY_CH,
-    display::{FRAMEBUFFER, FRAMEBUFFER2, WRITE_FRAMEBUFFER2},
-    elf::load_binary,
-    peripherals::keyboard,
-    storage::FileName,
+    BINARY_CH, display::FRAMEBUFFER, elf::load_binary, framebuffer::FB_PAUSED,
+    peripherals::keyboard, storage::FileName,
 };
 use abi_sys::keyboard::{KeyCode, KeyState};
 use alloc::{str::FromStr, string::String, vec::Vec};
-use core::{ops::DerefMut, sync::atomic::Ordering};
+use core::sync::atomic::Ordering;
 use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, mutex::Mutex};
 use embedded_graphics::{
     Drawable,
@@ -71,30 +68,22 @@ pub async fn clear_selection() {
     if let Some(area) = sel.last_bounds {
         Rectangle::new(area.top_left, area.size)
             .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
-            .draw(unsafe { &mut *FRAMEBUFFER })
+            .draw(unsafe { &mut *FRAMEBUFFER.as_mut().unwrap() })
             .unwrap();
     }
 }
 
 async fn draw_selection() {
     let mut guard = SELECTIONS.lock().await;
-    let file_names = &guard.selections.clone();
+    let file_names = guard.selections.clone();
 
     let text_style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
-    let display_area = unsafe { FRAMEBUFFER.bounding_box() };
+    let display_area = unsafe { FRAMEBUFFER.as_mut().unwrap().bounding_box() };
 
     const NO_BINS: &str = "No Programs found on SD Card. Ensure programs end with '.bin', and are located in the root directory";
     let no_bins = String::from_str(NO_BINS).unwrap();
 
-    let mut fb = if cfg!(feature = "pimoroni2w") {
-        if WRITE_FRAMEBUFFER2.load(Ordering::Acquire) {
-            unsafe { FRAMEBUFFER2.deref_mut() }
-        } else {
-            unsafe { &mut FRAMEBUFFER }
-        }
-    } else {
-        unsafe { &mut FRAMEBUFFER }
-    };
+    FB_PAUSED.store(true, Ordering::Release); // ensure all elements show up at once
 
     if file_names.is_empty() {
         TextBox::new(
@@ -105,12 +94,12 @@ async fn draw_selection() {
             ),
             text_style,
         )
-        .draw(fb.deref_mut())
+        .draw(unsafe { &mut *FRAMEBUFFER.as_mut().unwrap() })
         .unwrap();
     } else {
         let mut views: alloc::vec::Vec<Text<MonoTextStyle<Rgb565>>> = Vec::new();
 
-        for i in file_names {
+        for i in &file_names {
             views.push(Text::new(&i.long_name, Point::zero(), text_style));
         }
 
@@ -130,17 +119,18 @@ async fn draw_selection() {
             .bounding_box();
         Rectangle::new(selected_bounds.top_left, selected_bounds.size)
             .into_styled(PrimitiveStyle::with_stroke(Rgb565::WHITE, 1))
-            .draw(fb.deref_mut())
+            .draw(unsafe { &mut *FRAMEBUFFER.as_mut().unwrap() })
             .unwrap();
 
         guard.last_bounds = Some(layout.bounds());
 
-        layout.draw(fb.deref_mut()).unwrap();
+        layout
+            .draw(unsafe { &mut *FRAMEBUFFER.as_mut().unwrap() })
+            .unwrap();
     }
 
     guard.changed = false;
-
-    WRITE_FRAMEBUFFER2.fetch_not(Ordering::AcqRel);
+    FB_PAUSED.store(false, Ordering::Release); // ensure all elements show up at once
 }
 
 #[derive(Clone)]

selection_ui/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "selection_ui"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+abi = { path = "../abi" }
+embedded-graphics = "0.8.1"
+embedded-layout = "0.4.2"
+embedded-text = "0.7.3"

selection_ui/src/lib.rs

@@ -0,0 +1,148 @@
+#![no_std]
+
+extern crate alloc;
+
+use abi::{
+    display::Display,
+    get_key,
+    keyboard::{KeyCode, KeyState},
+};
+use alloc::vec::Vec;
+use embedded_graphics::{
+    Drawable,
+    mono_font::{MonoTextStyle, ascii::FONT_10X20},
+    pixelcolor::Rgb565,
+    prelude::{Dimensions, DrawTarget, Point, Primitive, RgbColor},
+    primitives::{PrimitiveStyle, Rectangle},
+    text::{Alignment, Text, renderer::TextRenderer},
+};
+use embedded_layout::{
+    align::{horizontal, vertical},
+    layout::linear::{FixedMargin, LinearLayout},
+    prelude::*,
+};
+
+#[derive(Debug)]
+pub enum SelectionUiError<DisplayError> {
+    SelectionListEmpty,
+    DisplayError(DisplayError),
+}
+
+pub struct SelectionUi<'a> {
+    selection: usize,
+    items: &'a [&'a str],
+    last_bounds: Option<Rectangle>,
+}
+
+impl<'a> SelectionUi<'a> {
+    pub fn new(items: &'a [&'a str]) -> Self {
+        Self {
+            selection: 0,
+            items,
+            last_bounds: None,
+        }
+    }
+
+    pub fn run_selection_ui(
+        &mut self,
+        display: &mut Display,
+    ) -> Result<Option<usize>, SelectionUiError<<Display as DrawTarget>::Error>> {
+        self.draw(display)?;
+        let selection;
+        loop {
+            let key = get_key();
+            if key.state == KeyState::Pressed {
+                if let Some(s) = self.update(display, key.key)? {
+                    selection = Some(s);
+                    display
+                        .clear(Rgb565::BLACK)
+                        .map_err(|e| SelectionUiError::DisplayError(e))?;
+                    break;
+                }
+            }
+        }
+        Ok(selection)
+    }
+
+    /// updates the display with a new keypress.
+    /// returns selection idx if selected
+    pub fn update(
+        &mut self,
+        display: &mut Display,
+        key: KeyCode,
+    ) -> Result<Option<usize>, SelectionUiError<<Display as DrawTarget>::Error>> {
+        match key {
+            KeyCode::Down => {
+                self.selection = (self.selection + 1).min(self.items.len() - 1);
+            }
+            KeyCode::Up => {
+                self.selection = self.selection.saturating_sub(1);
+            }
+            KeyCode::Enter | KeyCode::Right => return Ok(Some(self.selection)),
+            _ => return Ok(None),
+        };
+        self.draw(display)?;
+        Ok(None)
+    }
+
+    fn draw(
+        &mut self,
+        display: &mut Display,
+    ) -> Result<(), SelectionUiError<<Display as DrawTarget>::Error>> {
+        let text_style = MonoTextStyle::new(&FONT_10X20, Rgb565::WHITE);
+        let display_area = display.bounding_box();
+
+        if self.items.is_empty() {
+            return Err(SelectionUiError::SelectionListEmpty);
+        }
+
+        if let Some(bounds) = self.last_bounds {
+            Rectangle::new(bounds.top_left, bounds.size)
+                .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
+                .draw(display)
+                .map_err(|e| SelectionUiError::DisplayError(e))?;
+        }
+
+        let mut views: Vec<Text<MonoTextStyle<Rgb565>>> = Vec::new();
+
+        for i in self.items {
+            views.push(Text::new(i, Point::zero(), text_style));
+        }
+
+        let views_group = Views::new(views.as_mut_slice());
+
+        let layout = LinearLayout::vertical(views_group)
+            .with_alignment(horizontal::Center)
+            .with_spacing(FixedMargin(5))
+            .arrange()
+            .align_to(&display_area, horizontal::Center, vertical::Center);
+
+        layout
+            .draw(display)
+            .map_err(|e| SelectionUiError::DisplayError(e))?;
+
+        // draw selected box
+        if let Some(selected_bounds) = layout.inner().get(self.selection) {
+            let selected_bounds = selected_bounds.bounding_box();
+            Rectangle::new(selected_bounds.top_left, selected_bounds.size)
+                .into_styled(PrimitiveStyle::with_stroke(Rgb565::WHITE, 1))
+                .draw(display)
+                .map_err(|e| SelectionUiError::DisplayError(e))?;
+
+            self.last_bounds = Some(selected_bounds);
+        }
+
+        Ok(())
+    }
+}
+
+pub fn draw_text_center<'a, S>(
+    display: &mut Display,
+    text: &'a str,
+    style: S,
+) -> Result<Point, <Display as DrawTarget>::Error>
+where
+    S: TextRenderer<Color = <Display as DrawTarget>::Color>,
+{
+    Text::with_alignment(text, Point::zero(), style, Alignment::Center).draw(display)
+}

user-apps/calculator/src/main.rs

@@ -6,7 +6,7 @@ use abi::{
     display::Display,
     get_key,
     keyboard::{KeyCode, KeyState},
-    print,
+    println,
 };
 use alloc::{format, string::String, vec, vec::Vec};
 use core::panic::PanicInfo;
@@ -28,7 +28,7 @@ use embedded_layout::{
 
 #[panic_handler]
 fn panic(info: &PanicInfo) -> ! {
-    print!("user panic: {} @ {:?}", info.message(), info.location(),);
+    println!("user panic: {} @ {:?}", info.message(), info.location(),);
     loop {}
 }
 
@@ -38,8 +38,8 @@ pub extern "Rust" fn _start() {
 }
 
 pub fn main() {
-    print!("Starting Calculator app");
-    let mut display = Display;
+    println!("Starting Calculator app");
+    let mut display = Display::take().unwrap();
 
     let mut input = vec!['e', 'x', 'p', 'r', ':', ' '];
     let input_min = input.len();
@@ -104,7 +104,7 @@ pub fn main() {
         }
 
         let event = get_key();
-        if event.state != KeyState::Idle {
+        if event.state == KeyState::Released {
             match event.key {
                 KeyCode::Char(ch) => {
                     input.push(ch);

user-apps/gallery/src/main.rs

@@ -5,12 +5,12 @@
 extern crate alloc;
 use abi::{
     display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH},
-    fs::{list_dir, read_file},
+    fs::{Entries, list_dir, read_file},
     get_key,
     keyboard::{KeyCode, KeyState},
-    print,
+    println,
 };
-use alloc::{format, string::ToString, vec};
+use alloc::{format, vec};
 use core::panic::PanicInfo;
 use embedded_graphics::{
     Drawable, image::Image, mono_font::MonoTextStyle, mono_font::ascii::FONT_6X10,
@@ -20,7 +20,7 @@ use tinybmp::Bmp;
 
 #[panic_handler]
 fn panic(info: &PanicInfo) -> ! {
-    print!("user panic: {} @ {:?}", info.message(), info.location());
+    println!("user panic: {} @ {:?}", info.message(), info.location());
     loop {}
 }
 
@@ -30,11 +30,10 @@ pub extern "Rust" fn _start() {
 }
 
 pub fn main() {
-    print!("Starting Gallery app");
+    println!("Starting Gallery app");
     let mut bmp_buf = vec![0_u8; 100_000];
-    let mut display = Display;
+    let mut display = Display::take().unwrap();
 
-    // Grid parameters
     let grid_cols = 3;
     let grid_rows = 3;
     let cell_width = SCREEN_WIDTH as i32 / grid_cols;
@@ -42,50 +41,44 @@ pub fn main() {
 
     let mut images_drawn = 0;
 
-    let mut files = [const { None }; 18];
-    let files_num = list_dir("/images", &mut files);
+    let mut entries = Entries::new();
+    let files_num = list_dir("/images", &mut entries);
 
-    for file in &files[2..files_num] {
+    for file in &entries.entries()[2..files_num] {
         if images_drawn >= grid_cols * grid_rows {
             break; // only draw 3x3
         }
 
-        if let Some(f) = file {
-            print!("file: {}", f.name);
-            if f.name.extension() == b"bmp" || f.name.extension() == b"BMP" {
-                let file = format!("/images/{}", f.name);
+        println!("file: {}", file);
+        if file.extension().unwrap_or("") == "bmp" || file.extension().unwrap_or("") == "BMP" {
+            let file_path = format!("/images/{}", file);
 
-                let read = read_file(&file, 0, &mut &mut bmp_buf[..]);
-                if read > 0 {
-                    let bmp = Bmp::from_slice(&bmp_buf).expect("failed to parse bmp");
+            let read = read_file(&file_path, 0, &mut &mut bmp_buf[..]);
+            if read > 0 {
+                let bmp = Bmp::from_slice(&bmp_buf).expect("failed to parse bmp");
 
-                    let row = images_drawn / grid_cols;
-                    let col = images_drawn % grid_cols;
-                    let cell_x = col * cell_width;
-                    let cell_y = row * cell_height;
+                let row = images_drawn / grid_cols;
+                let col = images_drawn % grid_cols;
+                let cell_x = col * cell_width;
+                let cell_y = row * cell_height;
 
-                    // Center image inside cell
-                    let bmp_w = bmp.size().width as i32;
-                    let bmp_h = bmp.size().height as i32;
-                    let x = cell_x + (cell_width - bmp_w) / 2;
-                    let y = cell_y + 5; // 5px top margin
+                // Center image inside cell
+                let bmp_w = bmp.size().width as i32;
+                let bmp_h = bmp.size().height as i32;
+                let x = cell_x + (cell_width - bmp_w) / 2;
+                let y = cell_y + 5; // 5px top margin
 
-                    Image::new(&bmp, Point::new(x, y))
-                        .draw(&mut display)
-                        .unwrap();
-
-                    let text_style = MonoTextStyle::new(&FONT_6X10, Rgb565::WHITE);
-                    let text_y = y + bmp_h + 2; // 2px gap under image
-                    Text::new(
-                        f.name.to_string().as_str(),
-                        Point::new(cell_x + 2, text_y),
-                        text_style,
-                    )
+                Image::new(&bmp, Point::new(x, y))
                     .draw(&mut display)
                     .unwrap();
 
-                    images_drawn += 1;
-                }
+                let text_style = MonoTextStyle::new(&FONT_6X10, Rgb565::WHITE);
+                let text_y = y + bmp_h + 2; // 2px gap under image
+                Text::new(&file.base(), Point::new(cell_x + 2, text_y), text_style)
+                    .draw(&mut display)
+                    .unwrap();
+
+                images_drawn += 1;
             }
         }
     }

user-apps/gboy/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "gboy"
+version = "0.1.0"
+edition = "2024"
+
+[build-dependencies]
+bindgen = "0.71.0"
+cc = "1.2.44"
+
+[dependencies]
+abi = { path = "../../abi" }
+selection_ui = { path = "../../selection_ui" }
+embedded-graphics = "0.8.1"

user-apps/gboy/build.rs

@@ -0,0 +1,64 @@
+//! This build script copies the `memory.x` file from the crate root into
+//! a directory where the linker can always find it at build time.
+//! For many projects this is optional, as the linker always searches the
+//! project root directory -- wherever `Cargo.toml` is. However, if you
+//! are using a workspace or have a more complicated build setup, this
+//! build script becomes required. Additionally, by requesting that
+//! Cargo re-run the build script whenever `memory.x` is changed,
+//! updating `memory.x` ensures a rebuild of the application with the
+//! new memory settings.
+
+use std::env;
+use std::fs::File;
+use std::io::Write;
+use std::path::PathBuf;
+
+fn main() {
+    bindgen();
+
+    // Put `memory.x` in our output directory and ensure it's
+    // on the linker search path.
+    let out = &PathBuf::from(env::var_os("OUT_DIR").unwrap());
+    File::create(out.join("memory.x"))
+        .unwrap()
+        .write_all(include_bytes!("../memory.x"))
+        .unwrap();
+    println!("cargo:rustc-link-search={}", out.display());
+
+    println!("cargo:rerun-if-changed=memory.x");
+    println!("cargo:rustc-link-arg-bins=-Tmemory.x");
+}
+
+fn bindgen() {
+    let bindings = bindgen::Builder::default()
+        .header("Peanut-GB/peanut_gb.h")
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
+        .disable_nested_struct_naming()
+        .clang_arg("-I../../picolibc/newlib/libc/include/")
+        .clang_arg("-I../../picolibc/build/")
+        .use_core()
+        .generate()
+        .expect("Unable to generate bindings");
+
+    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
+    bindings
+        .write_to_file(out_path.join("bindings.rs"))
+        .expect("Couldn't write bindings!");
+
+    cc::Build::new()
+        .define("PEANUT_GB_IS_LITTLE_ENDIAN", None)
+        .define("ENABLE_LCD", None)
+        .file("peanut_gb_stub.c")
+        .include("Peanut-GB")
+        // optimization flags
+        .flag("-Ofast")
+        .flag("-fdata-sections")
+        .flag("-ffunction-sections")
+        .flag("-mcpu=cortex-m33")
+        .flag("-mthumb")
+        .flag("-g0")
+        .compile("peanut_gb");
+
+    println!("cargo:rustc-link-search=Peanut-GB");
+    println!("cargo:rustc-link-lib=peanut_gb");
+}

user-apps/gboy/peanut_gb_stub.c

@@ -0,0 +1 @@
+#include <peanut_gb.h>

user-apps/gboy/src/main.rs

@@ -0,0 +1,206 @@
+#![no_std]
+#![no_main]
+#![allow(static_mut_refs)]
+
+extern crate alloc;
+use abi::{
+    display::Display,
+    format,
+    fs::{Entries, file_len, list_dir, read_file, write_file},
+    get_key,
+    keyboard::{KeyCode, KeyState},
+    println,
+};
+use alloc::{vec, vec::Vec};
+use core::{cell::LazyCell, mem::MaybeUninit, panic::PanicInfo};
+use embedded_graphics::{
+    mono_font::{MonoTextStyle, ascii::FONT_6X10},
+    pixelcolor::Rgb565,
+    prelude::RgbColor,
+};
+use selection_ui::{SelectionUi, SelectionUiError, draw_text_center};
+
+mod peanut;
+use peanut::gb_run_frame;
+
+use crate::peanut::{
+    JOYPAD_A, JOYPAD_B, JOYPAD_DOWN, JOYPAD_LEFT, JOYPAD_RIGHT, JOYPAD_SELECT, JOYPAD_START,
+    JOYPAD_UP, gb_cart_ram_read, gb_cart_ram_write, gb_error, gb_get_rom_name, gb_get_save_size,
+    gb_init, gb_init_lcd, gb_reset, gb_rom_read, gb_s, lcd_draw_line,
+};
+
+static mut DISPLAY: LazyCell<Display> = LazyCell::new(|| Display::take().unwrap());
+
+const RAM_SIZE: usize = 32 * 1024; // largest ram size is 32k
+static mut RAM: [u8; RAM_SIZE] = [0; RAM_SIZE];
+
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    println!("user panic: {} @ {:?}", info.message(), info.location(),);
+    loop {}
+}
+
+#[unsafe(no_mangle)]
+pub extern "Rust" fn _start() {
+    main()
+}
+
+const GAME_PATH: &'static str = "/games/gameboy";
+
+static mut GAME_ROM: Option<Vec<u8>> = None;
+
+pub fn main() {
+    println!("Starting Gameboy app");
+
+    let mut entries = Entries::new();
+    list_dir(GAME_PATH, &mut entries);
+
+    let mut files = entries.entries();
+    files.retain(|e| {
+        let ext = e.extension().unwrap_or("");
+        ext == "gb" || ext == "GB"
+    });
+    let mut roms = files.iter().map(|e| e.full_name()).collect::<Vec<&str>>();
+    roms.sort();
+
+    let selection = {
+        let display = unsafe { &mut *DISPLAY };
+        let mut selection_ui = SelectionUi::new(&roms);
+        match selection_ui.run_selection_ui(display) {
+            Ok(maybe_sel) => maybe_sel,
+            Err(e) => match e {
+                SelectionUiError::SelectionListEmpty => {
+                    draw_text_center(
+                        display,
+                        &format!("No Roms were found in {}", GAME_PATH),
+                        MonoTextStyle::new(&FONT_6X10, Rgb565::RED),
+                    )
+                    .expect("Display Error");
+                    None
+                }
+                SelectionUiError::DisplayError(_) => panic!("Display Error"),
+            },
+        }
+    };
+
+    assert!(selection.is_some());
+
+    let file_name = format!("{}/{}", GAME_PATH, roms[selection.unwrap()]);
+    let size = file_len(&file_name);
+    unsafe { GAME_ROM = Some(vec![0_u8; size]) };
+    let read = read_file(&file_name, 0, unsafe { GAME_ROM.as_mut().unwrap() });
+    assert!(size == read);
+    println!("Rom size: {}", read);
+
+    let mut gb = MaybeUninit::<gb_s>::uninit();
+
+    let init_status = unsafe {
+        gb_init(
+            gb.as_mut_ptr(),
+            Some(gb_rom_read),
+            Some(gb_cart_ram_read),
+            Some(gb_cart_ram_write),
+            Some(gb_error),
+            core::ptr::null_mut(),
+        )
+    };
+    println!("gb init status: {}", init_status);
+
+    unsafe {
+        load_save(&mut gb.assume_init());
+    }
+
+    unsafe {
+        gb_init_lcd(gb.as_mut_ptr(), Some(lcd_draw_line));
+
+        // enable frame skip
+        // gb.assume_init().direct.set_frame_skip(!true); // active low
+    };
+
+    loop {
+        let event = get_key();
+        let button = match event.key {
+            KeyCode::Esc => {
+                unsafe { write_save(&mut gb.assume_init()) };
+                break;
+            }
+            KeyCode::Char('r') => {
+                unsafe { gb_reset(gb.as_mut_ptr()) };
+                continue;
+            }
+            KeyCode::Tab => JOYPAD_START as u8,
+            KeyCode::Del => JOYPAD_SELECT as u8,
+            KeyCode::Enter => JOYPAD_A as u8,
+            KeyCode::Backspace => JOYPAD_B as u8,
+            KeyCode::Up => JOYPAD_UP as u8,
+            KeyCode::Down => JOYPAD_DOWN as u8,
+            KeyCode::Left => JOYPAD_LEFT as u8,
+            KeyCode::Right => JOYPAD_RIGHT as u8,
+            _ => 0,
+        };
+
+        if button != 0 {
+            unsafe {
+                // bindgen incorrectly generates direct so manual manipulation is required :(
+                let direct_ptr = &mut gb.assume_init().direct as *mut _ as *mut u8;
+                let joypad_ptr = direct_ptr.add(2); // this is the joypad bitfield byte
+
+                if let KeyState::Pressed = event.state {
+                    *joypad_ptr &= !button;
+                } else if let KeyState::Released = event.state {
+                    *joypad_ptr |= button;
+                }
+
+                println!("joypad: {:b}", *joypad_ptr);
+            }
+        }
+
+        unsafe {
+            gb_run_frame(gb.as_mut_ptr());
+        }
+    }
+}
+
+unsafe fn load_save(gb: &mut gb_s) {
+    let mut buf = [0; 16];
+
+    unsafe {
+        gb_get_rom_name(gb, buf.as_mut_ptr());
+
+        let save_size = gb_get_save_size(gb);
+
+        if save_size > 0 {
+            read_file(
+                &format!(
+                    "{}/saves/{}.sav",
+                    GAME_PATH,
+                    str::from_utf8(&buf).expect("bad rom name")
+                ),
+                0,
+                &mut RAM,
+            );
+        }
+    }
+}
+
+unsafe fn write_save(gb: &mut gb_s) {
+    let mut buf = [0; 16];
+
+    unsafe {
+        gb_get_rom_name(gb, buf.as_mut_ptr());
+
+        let save_size = gb_get_save_size(gb);
+
+        if save_size > 0 {
+            write_file(
+                &format!(
+                    "{}/saves/{}.sav",
+                    GAME_PATH,
+                    str::from_utf8(&buf).expect("bad rom name")
+                ),
+                0,
+                &mut RAM,
+            );
+        }
+    }
+}

user-apps/gboy/src/peanut.rs

@@ -0,0 +1,102 @@
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+
+use crate::{DISPLAY, GAME_ROM, RAM};
+
+#[allow(unused)]
+include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
+
+use abi::{display::Pixel565, println};
+use embedded_graphics::{Drawable, pixelcolor::Rgb565, prelude::Point};
+
+pub const GBOY_WIDTH: usize = 160;
+pub const GBOY_HEIGHT: usize = 144;
+
+pub unsafe extern "C" fn gb_rom_read(_gb: *mut gb_s, addr: u32) -> u8 {
+    unsafe { GAME_ROM.as_ref().unwrap()[addr as usize] }
+}
+
+pub unsafe extern "C" fn gb_cart_ram_read(_gb: *mut gb_s, addr: u32) -> u8 {
+    unsafe { RAM[addr as usize] }
+}
+
+pub unsafe extern "C" fn gb_cart_ram_write(_gb: *mut gb_s, addr: u32, val: u8) {
+    unsafe { RAM[addr as usize] = val }
+}
+
+pub unsafe extern "C" fn gb_error(_gb: *mut gb_s, err: gb_error_e, addr: u16) {
+    let e = match err {
+        0 => "UNKNOWN ERROR",
+        1 => "INVALID OPCODE",
+        2 => "INVALID READ",
+        3 => "INVALID WRITE",
+        4 => "HALT FOREVER",
+        5 => "INVALID MAX",
+        _ => unreachable!(),
+    };
+
+    println!("PeanutGB error: {}, addr: {}", e, addr);
+}
+
+const NUM_PALETTES: usize = 3;
+const SHADES_PER_PALETTE: usize = 4;
+
+const PALETTES: [[Rgb565; SHADES_PER_PALETTE]; NUM_PALETTES] = [
+    [
+        Rgb565::new(8, 24, 32),
+        Rgb565::new(52, 104, 86),
+        Rgb565::new(136, 192, 112),
+        Rgb565::new(224, 248, 208),
+    ], // BG
+    [
+        Rgb565::new(8, 24, 32),
+        Rgb565::new(52, 104, 86),
+        Rgb565::new(136, 192, 112),
+        Rgb565::new(224, 248, 208),
+    ], // OBJ0
+    [
+        Rgb565::new(8, 24, 32),
+        Rgb565::new(52, 104, 86),
+        Rgb565::new(136, 192, 112),
+        Rgb565::new(224, 248, 208),
+    ], // OBJ1
+];
+
+pub unsafe extern "C" fn lcd_draw_line(_gb: *mut gb_s, pixels: *const u8, line: u8) {
+    if line < GBOY_HEIGHT as u8 {
+        let pixels = unsafe { core::slice::from_raw_parts(pixels, GBOY_WIDTH) };
+        let y = line as u16;
+
+        for (x, &p) in pixels.iter().enumerate() {
+            let palette_idx = ((p & 0xF0) >> 4) as usize;
+            let shade_idx = (p & 0x03) as usize;
+
+            let color = PALETTES
+                .get(palette_idx)
+                .and_then(|pal| pal.get(shade_idx))
+                .copied()
+                .unwrap_or(Rgb565::new(0, 0, 0));
+
+            // let sx = (x as u16) * 2;
+            // let sy = y * 2;
+
+            // draw_color(color, sx, sy);
+            // draw_color(color, sx + 1, sy);
+            // draw_color(color, sx, sy + 1);
+            // draw_color(color, sx + 1, sy + 1);
+            //
+            draw_color(color, x as u16, y as u16);
+        }
+    }
+}
+
+fn draw_color(color: Rgb565, x: u16, y: u16) {
+    let mut pixel = Pixel565::default();
+    pixel.0 = Point::new(x.into(), y.into());
+    pixel.1 = color;
+
+    unsafe {
+        pixel.draw(&mut *DISPLAY).unwrap();
+    }
+}

user-apps/gif/Cargo.toml

@@ -5,5 +5,6 @@ edition = "2024"
 
 [dependencies]
 abi = { path = "../../abi" }
+selection_ui = { path = "../../selection_ui" }
 embedded-graphics = "0.8.1"
-tinygif = "0.0.4"
+tinygif = { git = "https://github.com/LegitCamper/tinygif" }

user-apps/gif/src/main.rs

@@ -3,20 +3,27 @@
 
 extern crate alloc;
 use abi::{
-    display::Display,
-    fs::{file_len, read_file},
+    display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH},
+    fs::{Entries, file_len, list_dir, read_file},
     get_key, get_ms,
     keyboard::{KeyCode, KeyState},
-    print, sleep,
+    println, sleep,
 };
-use alloc::vec;
+use alloc::{format, vec, vec::Vec};
 use core::panic::PanicInfo;
-use embedded_graphics::{image::ImageDrawable, pixelcolor::Rgb565};
+use embedded_graphics::{
+    image::ImageDrawable,
+    mono_font::{MonoTextStyle, ascii::FONT_6X10},
+    pixelcolor::Rgb565,
+    prelude::{Point, RgbColor},
+    transform::Transform,
+};
+use selection_ui::{SelectionUi, SelectionUiError, draw_text_center};
 use tinygif::Gif;
 
 #[panic_handler]
 fn panic(info: &PanicInfo) -> ! {
-    print!("user panic: {} @ {:?}", info.message(), info.location(),);
+    println!("user panic: {} @ {:?}", info.message(), info.location(),);
     loop {}
 }
 
@@ -26,30 +33,66 @@ pub extern "Rust" fn _start() {
 }
 
 pub fn main() {
-    print!("Starting Gif app");
-    let mut display = Display;
+    println!("Starting Gif app");
+    let mut display = Display::take().unwrap();
 
-    let size = file_len("/gifs/bad_apple.gif");
+    let mut entries = Entries::new();
+    list_dir("/gifs", &mut entries);
+
+    let mut files = entries.entries();
+    files.retain(|e| e.extension().unwrap_or("") == "gif");
+    let mut gifs = files.iter().map(|e| e.full_name()).collect::<Vec<&str>>();
+    gifs.sort();
+
+    let mut selection_ui = SelectionUi::new(&mut gifs);
+    let selection = match selection_ui.run_selection_ui(&mut display) {
+        Ok(maybe_sel) => maybe_sel,
+        Err(e) => match e {
+            SelectionUiError::SelectionListEmpty => {
+                draw_text_center(
+                    &mut display,
+                    "No Gifs were found in /gifs",
+                    MonoTextStyle::new(&FONT_6X10, Rgb565::RED),
+                )
+                .expect("Display Error");
+                None
+            }
+            SelectionUiError::DisplayError(_) => panic!("Display Error"),
+        },
+    };
+
+    assert!(selection.is_some());
+
+    let file_name = format!("/gifs/{}", gifs[selection.unwrap()]);
+    let size = file_len(&file_name);
     let mut buf = vec![0_u8; size];
-    let read = read_file("/gifs/bad_apple.gif", 0, &mut buf);
-    print!("read: {}, file size: {}", read, size);
+    let read = read_file(&file_name, 0, &mut buf);
+    println!("read: {}, file size: {}", read, size);
     assert!(read == size);
 
-    let gif = Gif::<Rgb565>::from_slice(&buf).unwrap();
+    let gif = Gif::<Rgb565>::from_slice(&buf).expect("Failed to parse gif");
+
+    let translation = Point::new(
+        (SCREEN_WIDTH as i32 - gif.width() as i32) / 2,
+        (SCREEN_HEIGHT as i32 - gif.height() as i32) / 2,
+    );
 
     let mut frame_num = 0;
     loop {
-        for frame in gif.frames() {
+        for mut frame in gif.frames() {
             let start = get_ms();
 
-            frame.draw(&mut display).unwrap();
+            frame.translate_mut(translation).draw(&mut display).unwrap();
             frame_num += 1;
 
-            if frame_num % 100 == 0 {
+            if frame_num % 5 == 0 {
                 let event = get_key();
                 if event.state != KeyState::Idle {
                     match event.key {
-                        KeyCode::Esc => return,
+                        KeyCode::Esc => {
+                            drop(buf);
+                            return;
+                        }
                         _ => (),
                     };
                 };

user-apps/snake/src/main.rs

@@ -7,7 +7,7 @@ use abi::{
     display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH},
     get_key,
     keyboard::{KeyCode, KeyState},
-    print, sleep,
+    println, sleep,
 };
 use core::panic::PanicInfo;
 use embedded_graphics::{pixelcolor::Rgb565, prelude::RgbColor};
@@ -15,7 +15,7 @@ use embedded_snake::{Direction, SnakeGame};
 
 #[panic_handler]
 fn panic(info: &PanicInfo) -> ! {
-    print!("user panic: {} @ {:?}", info.message(), info.location(),);
+    println!("user panic: {} @ {:?}", info.message(), info.location(),);
     loop {}
 }
 
@@ -27,8 +27,8 @@ pub extern "Rust" fn _start() {
 const CELL_SIZE: usize = 8;
 
 pub fn main() {
-    print!("Starting Snake app");
-    let mut display = Display;
+    println!("Starting Snake app");
+    let mut display = Display::take().unwrap();
 
     let mut game = SnakeGame::<100, Rgb565, Rng>::new(
         SCREEN_WIDTH as u16,