diff --git a/app/src/dprintf.rs b/app/src/dprintf.rs
index c9c75e0..e4aa62e 100644
--- a/app/src/dprintf.rs
+++ b/app/src/dprintf.rs
@@ -21,8 +21,8 @@
     if cur.write_fmt(args).is_ok() {
         let pos = cur.position();
         drop(cur);
-        let allow = syscalls::allow(DRIVER_NUM_DEBUG_UART, 0, &mut uart_buf);
-        let _result = syscalls::command(DRIVER_NUM_DEBUG_UART, 0, pos as usize, 0);
+        let allow = syscalls::allow(CAPSULE_DPRINTF, 0, &mut uart_buf);
+        let _result = syscalls::command(CAPSULE_DPRINTF, CMD_DPRINTF_PRINT, pos as usize, 0);
         drop(allow);
     }
 }
diff --git a/app/src/main.rs b/app/src/main.rs
index dd4d4cb..f06d653 100644
--- a/app/src/main.rs
+++ b/app/src/main.rs
@@ -15,7 +15,7 @@
     dprintf!("sw/matcha/app/src/main.rs::main()\n");
 
     dprintf!("Booting sel4 from TockOS app!\n");
-    let _result = syscalls::command(DRIVER_NUM_ELF_LOADER, CMD_ELF_LOADER_BOOT_SEL4, 0, 0);
+    let _result = syscalls::command(CAPSULE_ELFLOADER, CMD_ELFLOADER_BOOT_SEL4, 0, 0);
     dprintf!("Booting sel4 from TockOS app done!\n");
 
     Ok(())
diff --git a/capsules/src/debug_uart.rs b/capsules/src/dprintf_capsule.rs
similarity index 91%
rename from capsules/src/debug_uart.rs
rename to capsules/src/dprintf_capsule.rs
index f1e18f3..0026cbc 100644
--- a/capsules/src/debug_uart.rs
+++ b/capsules/src/dprintf_capsule.rs
@@ -19,11 +19,11 @@
     pub buffer: Option<AppSlice<Shared, u8>>,
 }
 
-pub struct DebugUartCapsule {
+pub struct DprintfCapsule {
     pub app_data_grant: Grant<AppData>,
 }
 
-impl Driver for DebugUartCapsule {
+impl Driver for DprintfCapsule {
     fn subscribe(&self, _: usize, _: Option<Callback>, _: AppId) -> ReturnCode {
         ReturnCode::EINVAL
     }
@@ -35,7 +35,7 @@
 
         let _ = self.app_data_grant.enter(app_id, |app_data, _| {
             if let Some(buf) = &app_data.buffer {
-                matcha_hal::debug_uart::send_sync(buf.as_ref(), r2);
+                matcha_hal::dprintf_hal::send_sync(buf.as_ref(), r2);
             }
         });
         return ReturnCode::SUCCESS;
diff --git a/capsules/src/elf_loader.rs b/capsules/src/elfloader_capsule.rs
similarity index 91%
rename from capsules/src/elf_loader.rs
rename to capsules/src/elfloader_capsule.rs
index 84d9fc3..393fec5 100644
--- a/capsules/src/elf_loader.rs
+++ b/capsules/src/elfloader_capsule.rs
@@ -13,7 +13,7 @@
     fn command(&self, minor_num: usize, _r2: usize, _r3: usize, _app_id: AppId) -> ReturnCode {
         dprintf!("ElfLoaderCapsule::command()\n");
 
-        if minor_num == matcha_config::CMD_ELF_LOADER_BOOT_SEL4 {
+        if minor_num == matcha_config::CMD_ELFLOADER_BOOT_SEL4 {
             matcha_utils::load_sel4();
             return ReturnCode::SUCCESS;
         }
diff --git a/capsules/src/lib.rs b/capsules/src/lib.rs
index bd4ff3f..1b59b4a 100644
--- a/capsules/src/lib.rs
+++ b/capsules/src/lib.rs
@@ -1,7 +1,7 @@
 #![forbid(unsafe_code)]
 #![no_std]
 
-pub mod debug_uart;
-pub mod elf_loader;
-pub mod mailbox;
-pub mod storage_manager;
+pub mod dprintf_capsule;
+pub mod elfloader_capsule;
+pub mod mailbox_capsule;
+pub mod storage_capsule;
diff --git a/capsules/src/mailbox.rs b/capsules/src/mailbox_capsule.rs
similarity index 92%
rename from capsules/src/mailbox.rs
rename to capsules/src/mailbox_capsule.rs
index 4f9676f..1b93b0d 100644
--- a/capsules/src/mailbox.rs
+++ b/capsules/src/mailbox_capsule.rs
@@ -7,11 +7,11 @@
     pub buffer: Option<AppSlice<Shared, u8>>,
 }
 
-pub struct Mailbox {
+pub struct MailboxCapsule {
     pub app_data_grant: Grant<AppData>,
 }
 
-impl Driver for Mailbox {
+impl Driver for MailboxCapsule {
     fn subscribe(&self, _: usize, _: Option<Callback>, _: AppId) -> ReturnCode {
         ReturnCode::EINVAL
     }
diff --git a/capsules/src/storage_manager.rs b/capsules/src/storage_capsule.rs
similarity index 77%
rename from capsules/src/storage_manager.rs
rename to capsules/src/storage_capsule.rs
index ab26383..be6f049 100644
--- a/capsules/src/storage_manager.rs
+++ b/capsules/src/storage_capsule.rs
@@ -12,14 +12,14 @@
     pub arg3: usize,
 }
 
-pub struct StorageManagerCapsule {
+pub struct StorageCapsule {
     app_data_grant: Grant<AppData>,
 }
 
-impl StorageManagerCapsule {
+impl StorageCapsule {
     pub fn new(app_data_grant: Grant<AppData>) -> Self {
-        dprintf!("StorageManager::new()");
-        return StorageManagerCapsule {
+        dprintf!("StorageManager::new()\n");
+        return StorageCapsule {
             app_data_grant: app_data_grant,
         };
     }
@@ -32,7 +32,7 @@
         arg3: usize,
     ) -> ReturnCode {
         dprintf!(
-            "StorageManagerCapsule::handle_command({}, {}, {})",
+            "StorageCapsule::handle_command({}, {}, {})",
             minor_num,
             arg2,
             arg3
@@ -44,12 +44,12 @@
             0 => ReturnCode::SUCCESS,
             1 => {
                 if let Some(mut callback) = app_data.callback {
-                    dprintf!("StorageManagerCapsule::handle_command : Calling callback!");
+                    dprintf!("StorageCapsule::handle_command : Calling callback!");
                     callback.schedule(1, 2, 3);
                     app_data.callback = Some(callback);
                     ReturnCode::SUCCESS
                 } else {
-                    dprintf!("StorageManagerCapsule::handle_command : No callback!");
+                    dprintf!("StorageCapsule::handle_command : No callback!");
                     ReturnCode::EINVAL
                 }
             }
@@ -63,11 +63,11 @@
         minor_num: usize,
         callback: Option<Callback>,
     ) -> ReturnCode {
-        dprintf!("StorageManagerCapsule::handle_subscribe({})", minor_num);
+        dprintf!("StorageCapsule::handle_subscribe({})", minor_num);
         if callback.is_some() {
-            dprintf!("StorageManagerCapsule::handle_subscribe got Some callback");
+            dprintf!("StorageCapsule::handle_subscribe got Some callback");
         } else {
-            dprintf!("StorageManagerCapsule::handle_subscribe got None callback");
+            dprintf!("StorageCapsule::handle_subscribe got None callback");
         }
         app_data.callback = callback;
         return ReturnCode::SUCCESS;
@@ -80,18 +80,18 @@
         slice: Option<AppSlice<Shared, u8>>,
     ) -> ReturnCode {
         if let Some(slice) = slice {
-            dprintf!("StorageManagerCapsule::handle_allow({})", slice.len());
+            dprintf!("StorageCapsule::handle_allow({})", slice.len());
             app_data.buffer = Some(slice);
         } else {
-            dprintf!("StorageManagerCapsule::handle_allow(None)");
+            dprintf!("StorageCapsule::handle_allow(None)");
         }
         return ReturnCode::SUCCESS;
     }
 }
 
-/// Driver impl just enters the app_data grant and delegates to StorageManagerCapsule.
+/// Driver impl just enters the app_data grant and delegates to StorageCapsule.
 
-impl Driver for StorageManagerCapsule {
+impl Driver for StorageCapsule {
     fn subscribe(&self, minor_num: usize, callback: Option<Callback>, app_id: AppId) -> ReturnCode {
         self.app_data_grant
             .enter(app_id, |app_data, _| {
diff --git a/config/src/lib.rs b/config/src/lib.rs
index 49d782c..08f6eaf 100644
--- a/config/src/lib.rs
+++ b/config/src/lib.rs
@@ -7,10 +7,14 @@
 // right now due to some sort of toolchain mismatch that we need to figure out
 // later.
 
-pub const DRIVER_NUM_ALARM: usize = 0x00000;
-pub const DRIVER_NUM_CONSOLE: usize = 0x00001;
-pub const DRIVER_NUM_DEBUG_UART: usize = 0x00009;
-pub const DRIVER_NUM_STORAGE_MANAGER: usize = 0x50003;
-pub const DRIVER_NUM_ELF_LOADER: usize = 0x50004;
+pub const CAPSULE_ALARM: usize = 0x00000;
+pub const CAPSULE_CONSOLE: usize = 0x00001;
+pub const CAPSULE_LLDB: usize = 0x00008;
+pub const CAPSULE_DPRINTF: usize = 0x00009;
+pub const CAPSULE_STORAGE: usize = 0x50003;
+pub const CAPSULE_ELFLOADER: usize = 0x50004;
+pub const CAPSULE_MAILBOX: usize = 0x50005;
 
-pub const CMD_ELF_LOADER_BOOT_SEL4: usize = 10;
+pub const CMD_ELFLOADER_BOOT_SEL4: usize = 10;
+
+pub const CMD_DPRINTF_PRINT: usize = 0;
diff --git a/hal/src/debug_uart.rs b/hal/src/dprintf_hal.rs
similarity index 86%
rename from hal/src/debug_uart.rs
rename to hal/src/dprintf_hal.rs
index 9dcc161..d6e5ffb 100644
--- a/hal/src/debug_uart.rs
+++ b/hal/src/dprintf_hal.rs
@@ -27,9 +27,9 @@
 #[macro_export]
 macro_rules! dprintf {
     ($msg:expr) => ({
-        $crate::debug_uart::vdprintf(format_args!($msg))
+        $crate::dprintf_hal::vdprintf(format_args!($msg))
     });
     ($fmt:expr, $($arg:tt)+) => ({
-        $crate::debug_uart::vdprintf(format_args!($fmt, $($arg)+))
+        $crate::dprintf_hal::vdprintf(format_args!($fmt, $($arg)+))
     });
 }
diff --git a/hal/src/lib.rs b/hal/src/lib.rs
index bc607a6..6a929e7 100644
--- a/hal/src/lib.rs
+++ b/hal/src/lib.rs
@@ -4,9 +4,9 @@
 #![no_std]
 #![feature(asm)]
 
-pub mod debug_uart;
-pub mod mailbox;
-pub mod plic;
+pub mod dprintf_hal;
+pub mod mailbox_hal;
+pub mod plic_hal;
 pub mod plic_constants;
 
 // Software interrupt enable bits in MIE
diff --git a/hal/src/mailbox.rs b/hal/src/mailbox_hal.rs
similarity index 95%
rename from hal/src/mailbox.rs
rename to hal/src/mailbox_hal.rs
index d4acf4b..cff310d 100644
--- a/hal/src/mailbox.rs
+++ b/hal/src/mailbox_hal.rs
@@ -46,14 +46,14 @@
     }
 }
 
-pub struct Mailbox {
+pub struct MailboxHAL {
     regs: StaticRef<MailboxRegisters>,
     plic_wtirq: u32,
     plic_rtirq: u32,
     plic_eirq: u32,
 }
 
-pub const MAILBOX: Mailbox = Mailbox {
+pub const MAILBOX: MailboxHAL = MailboxHAL {
     regs: unsafe { StaticRef::new(MAILBOX_BASE as *mut MailboxRegisters) },
     plic_wtirq: MAILBOX_WTIRQ,
     plic_rtirq: MAILBOX_RTIRQ,
@@ -76,7 +76,7 @@
     buf.offset(bit_index >> 5).write_volatile(bits);
 }
 
-impl Mailbox {
+impl MailboxHAL {
     // Synchronously send a message. Blocks the caller if there's no room in the
     // outbox.
     pub fn send_message_sync(&self, message: &[u32]) {
@@ -101,7 +101,7 @@
         self.regs.reg_intr_enable.set(INTR_ENABLE_BIT_RTIRQ);
 
         unsafe {
-            set_bit(plic::PLIC_EN0, self.plic_rtirq as isize);
+            set_bit(plic_hal::PLIC_EN0, self.plic_rtirq as isize);
         }
 
         // Wait for the read interrupt to fire.
@@ -116,7 +116,7 @@
 
         // Turn the interrupt and IRQ line back off.
         unsafe {
-            clear_bit(plic::PLIC_EN0, self.plic_rtirq as isize);
+            clear_bit(plic_hal::PLIC_EN0, self.plic_rtirq as isize);
         }
         self.regs.reg_intr_enable.set(0);
 
diff --git a/hal/src/plic.rs b/hal/src/plic_hal.rs
similarity index 100%
rename from hal/src/plic.rs
rename to hal/src/plic_hal.rs
diff --git a/platform/src/chip.rs b/platform/src/chip.rs
index b063c46..dd37838 100644
--- a/platform/src/chip.rs
+++ b/platform/src/chip.rs
@@ -11,7 +11,7 @@
 
 use crate::timer;
 use crate::uart;
-use matcha_hal::plic;
+use matcha_hal::plic_hal;
 
 PMPConfigMacro!(4);
 
@@ -39,18 +39,18 @@
     }
 
     pub unsafe fn enable_plic_interrupts(&self) {
-        plic::disable_all();
-        plic::clear_all_pending();
-        plic::enable_all();
+        plic_hal::disable_all();
+        plic_hal::clear_all_pending();
+        plic_hal::enable_all();
     }
 
     unsafe fn handle_plic_interrupts(&self) {
-        while let Some(interrupt) = plic::next_pending() {
+        while let Some(interrupt) = plic_hal::next_pending() {
             match interrupt {
                 UART0_TX_WATERMARK..=UART0_RX_PARITY_ERR => uart::UART0.handle_interrupt(),
                 _ => debug!("Pidx {}", interrupt),
             }
-            plic::complete(interrupt);
+            plic_hal::complete(interrupt);
         }
     }
 }
diff --git a/platform/src/main.rs b/platform/src/main.rs
index 7d67cdf..9a811b2 100644
--- a/platform/src/main.rs
+++ b/platform/src/main.rs
@@ -16,9 +16,9 @@
 use kernel::Chip;
 use kernel::Platform;
 use kernel::{create_capability, debug, static_init};
-use matcha_capsules::debug_uart::DebugUartCapsule;
-use matcha_capsules::elf_loader::ElfLoaderCapsule;
-use matcha_capsules::storage_manager::StorageManagerCapsule;
+use matcha_capsules::dprintf_capsule::DprintfCapsule;
+use matcha_capsules::elfloader_capsule::ElfLoaderCapsule;
+use matcha_capsules::storage_capsule::StorageCapsule;
 use matcha_config::*;
 use matcha_hal::dprintf;
 use rv32i::csr;
@@ -62,15 +62,15 @@
 /// A structure representing this platform that holds references to all
 /// capsules for this platform. We've included an alarm and console.
 struct MatchaPlatform {
-    console: &'static capsules::console::Console<'static>,
-    alarm: &'static capsules::alarm::AlarmDriver<
+    console_capsule: &'static capsules::console::Console<'static>,
+    alarm_capsule: &'static capsules::alarm::AlarmDriver<
         'static,
         VirtualMuxAlarm<'static, crate::timer::RvTimer<'static>>,
     >,
-    debug_uart: &'static DebugUartCapsule,
-    storage_manager: &'static StorageManagerCapsule,
-    elf_loader: &'static ElfLoaderCapsule,
-    lldb: &'static capsules::low_level_debug::LowLevelDebug<
+    dprintf_capsule: &'static DprintfCapsule,
+    storage_capsule: &'static StorageCapsule,
+    elfloader_capsule: &'static ElfLoaderCapsule,
+    lldb_capsule: &'static capsules::low_level_debug::LowLevelDebug<
         'static,
         capsules::virtual_uart::UartDevice<'static>,
     >,
@@ -83,12 +83,12 @@
         F: FnOnce(Option<&dyn kernel::Driver>) -> R,
     {
         match driver_num {
-            DRIVER_NUM_CONSOLE => f(Some(self.console)),
-            DRIVER_NUM_ALARM => f(Some(self.alarm)),
-            DRIVER_NUM_DEBUG_UART => f(Some(self.debug_uart)),
-            DRIVER_NUM_STORAGE_MANAGER => f(Some(self.storage_manager)),
-            DRIVER_NUM_ELF_LOADER => f(Some(self.elf_loader)),
-            capsules::low_level_debug::DRIVER_NUM => f(Some(self.lldb)),
+            CAPSULE_CONSOLE => f(Some(self.console_capsule)),
+            CAPSULE_ALARM => f(Some(self.alarm_capsule)),
+            CAPSULE_DPRINTF => f(Some(self.dprintf_capsule)),
+            CAPSULE_STORAGE => f(Some(self.storage_capsule)),
+            CAPSULE_ELFLOADER => f(Some(self.elfloader_capsule)),
+            CAPSULE_LLDB => f(Some(self.lldb_capsule)),
             _ => f(None),
         }
     }
@@ -151,14 +151,14 @@
         VirtualMuxAlarm<'static, crate::timer::RvTimer>,
         VirtualMuxAlarm::new(mux_alarm)
     );
-    let alarm = static_init!(
+    let alarm_capsule = static_init!(
         capsules::alarm::AlarmDriver<'static, VirtualMuxAlarm<'static, crate::timer::RvTimer>>,
         capsules::alarm::AlarmDriver::new(
             virtual_alarm_user,
             board_kernel.create_grant(&memory_allocation_cap)
         )
     );
-    hil::time::Alarm::set_alarm_client(virtual_alarm_user, alarm);
+    hil::time::Alarm::set_alarm_client(virtual_alarm_user, alarm_capsule);
 
     let chip = static_init!(
         crate::chip::Matcha<VirtualMuxAlarm<'static, crate::timer::RvTimer>>,
@@ -175,38 +175,40 @@
     csr::CSR.mstatus.modify(csr::mstatus::mstatus::mie::SET);
 
     // Setup the console.
-    let console = components::console::ConsoleComponent::new(board_kernel, uart_mux).finalize(());
+    let console_capsule =
+        components::console::ConsoleComponent::new(board_kernel, uart_mux).finalize(());
     // Create the debugger object that handles calls to `debug!()`.
     components::debug_writer::DebugWriterComponent::new(uart_mux).finalize(());
 
-    let lldb = components::lldb::LowLevelDebugComponent::new(board_kernel, uart_mux).finalize(());
+    let lldb_capsule =
+        components::lldb::LowLevelDebugComponent::new(board_kernel, uart_mux).finalize(());
 
-    let debug_uart_capsule = static_init!(
-        DebugUartCapsule,
-        DebugUartCapsule {
+    let dprintf_capsule = static_init!(
+        DprintfCapsule,
+        DprintfCapsule {
             app_data_grant: board_kernel.create_grant(&memory_allocation_cap)
         }
     );
 
-    let storage_manager = static_init!(
-        matcha_capsules::storage_manager::StorageManagerCapsule,
-        matcha_capsules::storage_manager::StorageManagerCapsule::new(
+    let storage_capsule = static_init!(
+        matcha_capsules::storage_capsule::StorageCapsule,
+        matcha_capsules::storage_capsule::StorageCapsule::new(
             board_kernel.create_grant(&memory_allocation_cap)
         )
     );
 
-    let elf_loader = static_init!(
-        matcha_capsules::elf_loader::ElfLoaderCapsule,
-        matcha_capsules::elf_loader::ElfLoaderCapsule {}
+    let elfloader_capsule = static_init!(
+        matcha_capsules::elfloader_capsule::ElfLoaderCapsule,
+        matcha_capsules::elfloader_capsule::ElfLoaderCapsule {}
     );
 
     let platform = MatchaPlatform {
-        console: console,
-        alarm: alarm,
-        debug_uart: debug_uart_capsule,
-        storage_manager: storage_manager,
-        elf_loader: elf_loader,
-        lldb: lldb,
+        console_capsule: console_capsule,
+        alarm_capsule: alarm_capsule,
+        dprintf_capsule: dprintf_capsule,
+        storage_capsule: storage_capsule,
+        elfloader_capsule: elfloader_capsule,
+        lldb_capsule: lldb_capsule,
     };
 
     kernel::procs::load_processes(
diff --git a/utils/src/lib.rs b/utils/src/lib.rs
index c18295b..03c45c6 100644
--- a/utils/src/lib.rs
+++ b/utils/src/lib.rs
@@ -62,7 +62,7 @@
             transmute(sel4_pend - elf_loader::elf_phys_min(capdl_segments)),
             transmute((*capdl_elf).e_entry),
         ];
-        matcha_hal::mailbox::MAILBOX.send_message_sync(&message);
+        matcha_hal::mailbox_hal::MAILBOX.send_message_sync(&message);
         dprintf!("seL4 boot message posted\n");
 
         SMC_CONTROL_BLOCK.write_volatile(entry_point);
@@ -70,7 +70,7 @@
         dprintf!("SMC started, waiting on ACK\n");
 
         let mut reply : [u32;1] = [0];
-        matcha_hal::mailbox::MAILBOX.recv_message_sync(&mut reply);
+        matcha_hal::mailbox_hal::MAILBOX.recv_message_sync(&mut reply);
 
         dprintf!("ACK = 0x{:08X} received.\n", reply[0]);