I guess its a working execution loop?

src/core.rs

@@ -1,5 +1,7 @@
 use crate::{
     consts::{Addr, RegId, RegValue},
+    decode::Instruction,
+    instructions::find_runner,
     mem::MemConfig,
 };
 
@@ -27,6 +29,46 @@ impl Core {
         }
     }
 
+    pub fn run(&mut self) {
+        loop {
+            let page = (self.pc / 4096) as usize;
+            let offset = (self.pc / 4) as u16;
+            if !self.pc.is_multiple_of(4) {
+                //replace eprint with logging, replace break with exception
+                eprintln!("PC not aligned");
+                break;
+            }
+
+            let instr = match self.mem.read_word(page, offset) {
+                Ok(i) => i,
+                Err(_) => {
+                    eprintln!("Memory access fault while fetching instruction");
+                    break;
+                }
+            };
+
+            let instr = Instruction(instr);
+
+            let runner = find_runner(instr);
+
+            if let Some(runner) = runner {
+                let res = runner(self, instr);
+
+                match res {
+                    InstructionResult::Normal => {}
+                    InstructionResult::Exception(_e) => {
+                        eprintln!("Exception from instruction");
+                        break;
+                    }
+                    InstructionResult::Pause => {
+                        eprintln!("Instruction asked for pause");
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
     pub fn reset(&mut self, pc: Addr) {
         self.pc = pc;
     }

src/decode.rs

@@ -2,6 +2,7 @@ use crate::consts::{DWord, RegId, Word};
 
 const MASK_REGISTER: Word = 0x1f;
 
+#[derive(Debug, Clone, Copy)]
 pub struct Instruction(pub Word);
 
 impl Instruction {

src/instructions.rs

@@ -12,7 +12,7 @@ use crate::{
     decode::Instruction,
 };
 
-type Runner = fn(&mut Core, Instruction) -> Result<(), InstructionResult>;
+type Runner = fn(&mut Core, Instruction) -> InstructionResult;
 
 #[derive(Clone, Copy)]
 struct InstructionHandler {