diff --git a/Cargo.lock b/Cargo.lock
index a0c534e2fc..9848284378 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -32,6 +32,7 @@ version = "0.0.0"
 dependencies = [
  "hashbrown",
  "linked_list_allocator",
+ "log",
  "plain",
  "redox-initfs",
  "redox-path",
diff --git a/Cargo.toml b/Cargo.toml
index 2f6308d655..4b2536203d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,6 +15,7 @@ hashbrown = { version = "0.15", default-features = false, features = [
     "default-hasher",
 ] }
 linked_list_allocator = "0.10"
+log = { version = "0.4", default-features = false }
 plain = "0.2"
 redox-initfs = { git = "https://gitlab.redox-os.org/redox-os/redox-initfs.git", default-features = false }
 redox_syscall = { version = "0.5.4", default-features = false }
diff --git a/src/exec.rs b/src/exec.rs
index 825e4003bf..a82b006ff3 100644
--- a/src/exec.rs
+++ b/src/exec.rs
@@ -6,6 +6,21 @@ use syscall::{Error, EINTR};
 
 use redox_rt::proc::*;
 
+struct Logger;
+
+impl log::Log for Logger {
+    fn enabled(&self, metadata: &log::Metadata) -> bool {
+        metadata.level() <= log::max_level()
+    }
+    fn log(&self, record: &log::Record) {
+        let module = record.module_path().unwrap_or("");
+        let level = record.level();
+        let msg = record.args();
+        let _ = syscall::write(1, alloc::format!("[{module} {level}] {msg}\n").as_bytes());
+    }
+    fn flush(&self) {}
+}
+
 pub fn main() -> ! {
     let auth = FdGuard::new(
         syscall::open("/scheme/kernel.proc/authority", O_CLOEXEC)
@@ -15,6 +30,9 @@ pub fn main() -> ! {
         FdGuard::new(syscall::dup(*auth, b"cur-context").expect("failed to open open_via_dup"));
     let this_thr_fd = unsafe { redox_rt::initialize_freestanding(this_thr_fd) };
 
+    log::set_max_level(log::LevelFilter::Trace);
+    let _ = log::set_logger(&Logger);
+
     let envs = {
         let mut env = [0_u8; 4096];
 
diff --git a/src/procmgr.rs b/src/procmgr.rs
index bd75e7885d..25639d7e8f 100644
--- a/src/procmgr.rs
+++ b/src/procmgr.rs
@@ -44,7 +44,7 @@ pub fn run(write_fd: usize, auth: &FdGuard) {
 
     let mut scheme = ProcScheme::new(auth, &queue);
 
-    let _ = syscall::write(1, b"process manager started\n").unwrap();
+    log::info!("process manager started");
     let _ = syscall::write(write_fd, &[0]);
     let _ = syscall::close(write_fd);
 
@@ -53,15 +53,14 @@ pub fn run(write_fd: usize, auth: &FdGuard) {
     let mut new_awoken = VecDeque::new();
 
     'outer: loop {
-        let _ = syscall::write(1, alloc::format!("\n{awoken:#?}\n").as_bytes());
+        log::trace!("{awoken:#?}");
         while !awoken.is_empty() || !new_awoken.is_empty() {
             awoken.append(&mut new_awoken);
             for awoken in awoken.drain(..) {
-                //let _ = syscall::write(1, alloc::format!("\nALL STATES {states:#?}, AWOKEN {awoken:#?}\n").as_bytes());
+                //log::trace!("ALL STATES {states:#?}, AWOKEN {awoken:#?}");
                 let Entry::Occupied(state) = states.entry(awoken) else {
                     continue;
                 };
-                //let _ = syscall::write(1, alloc::format!("\nSTATE {state:#?}\n").as_bytes());
                 match scheme.work_on(state, &mut new_awoken) {
                     Ready(resp) => {
                         loop {
@@ -111,10 +110,7 @@ pub fn run(write_fd: usize, auth: &FdGuard) {
             }
         } else if let Some(thread) = scheme.thread_lookup.get(&event.data) {
             let Some(thread_rc) = thread.upgrade() else {
-                let _ = syscall::write(
-                    1,
-                    alloc::format!("\nDEAD THREAD EVENT FROM {}\n", event.data).as_bytes(),
-                );
+                log::trace!("DEAD THREAD EVENT FROM {}", event.data,);
                 continue;
             };
             let thread = thread_rc.borrow();
@@ -122,16 +118,12 @@ pub fn run(write_fd: usize, auth: &FdGuard) {
                 // TODO?
                 continue;
             };
-            let _ = syscall::write(
-                1,
-                alloc::format!("\nTHREAD EVENT FROM {}, {}, \n", event.data, thread.pid.0)
-                    .as_bytes(),
-            );
+            log::trace!("THREAD EVENT FROM {}, {}", event.data, thread.pid.0);
             let mut buf = 0_usize.to_ne_bytes();
             let _ = syscall::read(*thread.status_hndl, &mut buf).unwrap();
             let status = usize::from_ne_bytes(buf);
 
-            let _ = syscall::write(1, alloc::format!("\nSTATUS {status}\n",).as_bytes());
+            log::trace!("STATUS {status}");
 
             if status != ContextStatus::Dead as usize {
                 // spurious event
@@ -139,13 +131,10 @@ pub fn run(write_fd: usize, auth: &FdGuard) {
             }
             scheme.thread_lookup.remove(&event.data);
             proc.threads.retain(|rc| !Rc::ptr_eq(rc, &thread_rc));
-            let _ = syscall::write(
-                1,
-                alloc::format!("\nAWAITING {}\n", proc.awaiting_threads_term.len()).as_bytes(),
-            );
+            log::trace!("AWAITING {}", proc.awaiting_threads_term.len(),);
             awoken.extend(proc.awaiting_threads_term.drain(..)); // TODO: inefficient
         } else {
-            let _ = syscall::write(1, b"\nTODO: UNKNOWN EVENT\n");
+            log::debug!("TODO: UNKNOWN EVENT");
         }
     }
 
@@ -186,7 +175,7 @@ fn handle_scheme<'a>(
                     awoken,
                 ),
                 _ => {
-                    let _ = syscall::write(1, alloc::format!("\nUNKNOWN: {op:?}\n").as_bytes());
+                    log::trace!("UNKNOWN: {op:?}");
                     Ready(Response::new(Err(Error::new(ENOSYS)), op))
                 }
             }
@@ -583,6 +572,7 @@ impl<'a> ProcScheme<'a> {
         match self.handles[old_id] {
             Handle::Proc(pid) => match buf {
                 b"fork" => {
+                    log::trace!("Forking {pid:?}");
                     let child_pid = self.fork(pid)?;
                     Ok(OpenResult::ThisScheme {
                         number: self.handles.insert(Handle::Proc(child_pid)),
@@ -702,7 +692,7 @@ impl<'a> ProcScheme<'a> {
                 }
             }
 
-            let _ = syscall::write(1, b"\nEXIT PENDING\n");
+            log::trace!("EXIT PENDING");
             //self.debug();
             // TODO: check?
             process.awaiting_threads_term.push(*state.key());
@@ -731,7 +721,7 @@ impl<'a> ProcScheme<'a> {
         }
 
         let proc = self.processes.get_mut(&this_pid).ok_or(Error::new(ESRCH))?;
-        let _ = syscall::write(1, b"\nWAITPID\n");
+        log::trace!("WAITPID");
 
         let recv_nonblock = |waitpid: &mut BTreeMap<WaitpidKey, (ProcessId, WaitpidStatus)>,
                              key: &WaitpidKey|
@@ -940,7 +930,7 @@ impl<'a> ProcScheme<'a> {
                     return Response::ready_err(ESRCH, tag);
                 };
                 if proc.threads.is_empty() {
-                    let _ = syscall::write(1, b"\nWORKING ON AWAIT TERM\n");
+                    log::trace!("WORKING ON AWAIT TERM");
                     let (signal, status) = match proc.status {
                         ProcessStatus::Exiting { signal, status } => (signal, status),
                         ProcessStatus::Exited { .. } => return Response::ready_ok(0, tag),
@@ -960,13 +950,13 @@ impl<'a> ProcScheme<'a> {
                             },
                             (current_pid, WaitpidStatus::Terminated { signal, status }),
                         );
-                        //let _ = syscall::write(1, alloc::format!("\nAWAKING WAITPID {:?}\n", parent.waitpid_waiting).as_bytes());
+                        //log::trace!("AWAKING WAITPID {:?}", parent.waitpid_waiting);
                         // TODO: inefficient
                         awoken.extend(parent.waitpid_waiting.drain(..));
                     }
                     Ready(Response::new(Ok(0), tag))
                 } else {
-                    let _ = syscall::write(1, b"\nWAITING AGAIN\n");
+                    log::trace!("WAITING AGAIN");
                     proc.awaiting_threads_term.push(req_id);
                     *state = PendingState::AwaitingThreadsTermination(current_pid, tag);
                     Pending
@@ -978,7 +968,7 @@ impl<'a> ProcScheme<'a> {
                 flags,
                 mut op,
             } => {
-                let _ = syscall::write(1, b"\nWORKING ON AWAIT STS CHANGE\n");
+                log::trace!("WORKING ON AWAIT STS CHANGE");
 
                 match self.on_waitpid(waiter, target, flags, req_id) {
                     Ready(Ok((pid, status))) => {
@@ -1002,13 +992,7 @@ impl<'a> ProcScheme<'a> {
         }
     }
     fn debug(&self) {
-        let _ = syscall::write(
-            1,
-            alloc::format!("PROCESSES\n\n{:#?}\n\n", self.processes).as_bytes(),
-        );
-        let _ = syscall::write(
-            1,
-            alloc::format!("HANDLES\n\n{:#?}\n\n", self.handles).as_bytes(),
-        );
+        log::trace!("PROCESSES\n{:#?}", self.processes,);
+        log::trace!("HANDLES\n{:#?}", self.handles,);
     }
 }