add dsx clone command

- added is_lib arg for compiler to produce non-main assembly outputs
- updated templates to use include_str

.cargo/config.toml

@@ -5,3 +5,7 @@ rustc-wrapper = "sccache"
 
 [future-incompat-report]
 frequency = "always"
+
+[profile.profiling]
+inherits = "release"
+debug = true

.gitignore

@@ -1,3 +1,5 @@
 /target
 **/*.env
 Cargo.lock
+.test/
+pkg

.vscode/settings.json

@@ -8,4 +8,8 @@
   "files.trimTrailingWhitespace": true,
   "gitea.owner": "LowLevelDevs",
   "gitea.repo": "damn_simple_architecture",
+  "[markdown]": {
+    "editor.formatOnSave": true,
+    "editor.formatOnPaste": true
+  }
 }

.zed/settings.json

@@ -0,0 +1,15 @@
+// Folder-specific settings
+//
+// For a full list of overridable settings, and general information on folder-specific settings,
+// see the documentation: https://zed.dev/docs/configuring-zed#settings-files
+{
+  "lsp": {
+    "rust-analyzer": {
+      "initialization_options": {
+        "check": {
+          "command": "clippy", // rust-analyzer.check.command (default: "check")
+        },
+      },
+    },
+  },
+}

.zed/tasks.json

@@ -0,0 +1,46 @@
+[
+  {
+    "label": "Run Emulator",
+    "command": "cargo run --bin emulator",
+    "use_new_terminal": true,
+  },
+  {
+    "label": "Run Compiler",
+    "command": "cargo run --bin compiler",
+    "use_new_terminal": true,
+  },
+  {
+    "label": "Run Assembler",
+    "command": "cargo run --bin assembler",
+    "use_new_terminal": true,
+  },
+  {
+    "label": "Run Build System (dsx-build)",
+    "command": "cargo run --bin dsx-build",
+    "use_new_terminal": true,
+  },
+  {
+    "label": "Check All",
+    "command": "cargo clippy --all-targets",
+    "use_new_terminal": false,
+  },
+  {
+    "label": "Build All (Release)",
+    "command": "cargo build --release",
+    "use_new_terminal": false,
+  },
+  {
+    "label": "Publish Arch Package",
+    "command": "sh resources/publish.sh",
+  },
+  {
+    "label": "Run Tests",
+    "command": "cargo test",
+    "use_new_terminal": true,
+  },
+  {
+    "label": "Profile Emulator with perf",
+    "command": "cargo build --profile profiling; perf record -g -F 999 target/profiling/emulator; perf script -F +pid | save test.perf",
+    "use_new_terminal": true,
+  },
+]

Cargo.toml

@@ -1,7 +1,11 @@
 cargo-features = ["codegen-backend"]
 
 [workspace]
-members = ["emulator", "common", "assembler", "dsa_editor", "compiler", "dsx-build"]
+members = [
+    "core/dsa_common", "core/assembler", "core/compiler",
+    "emulator", "emulator/dsa_editor",
+    "dsx/dsx_server", "dsx/dsx_common", "dsx/dsx"
+]
 resolver = "3"
 
 [workspace.package]
@@ -11,7 +15,11 @@ authors = ["zxq5", "nullndvoid"]
 
 [profile.dev]
 codegen-backend = "cranelift"
-panic = "abort" # Cranelift does not support stack unwinds.
+panic = "abort"               # Cranelift does not support stack unwinds.
 lto = false
 debug = true
-incremental = false # sccache does not support caching incremental crates.
+incremental = false           # sccache does not support caching incremental crates.
+
+[profile.release]
+debug = true
+lto = "fat"

PKGBUILD

@@ -0,0 +1,59 @@
+# Maintainer: zxq5 <zxq5@proton.me>
+pkgbase='damn-simple-architecture'
+pkgname=('dsa' 'dsx' 'dsa-tools' 'dsx-server')
+pkgver=0.1.1
+pkgrel=1
+startdir='.'
+pkgdesc="Damn Simple Architecture"
+arch=('x86_64')
+url="https://git.zxq5.dev/zxq5/damn-simple-architecture"
+license=('MIT')
+makedepends=('rust' 'cargo' 'sed')
+
+build() {
+    cargo build --release \
+        --bin dsa \
+        --bin dsx \
+        --bin dsa-a \
+        --bin dsa-c \
+        --bin dsx-server
+}
+
+package_dsa() {
+    pkgdesc="DSA core binary"
+    depends=()
+
+    install -Dm755 "$startdir/target/release/dsa" "$pkgdir/usr/bin/dsa"
+    install -Dm644 "$startdir/resources/dsa.desktop" \
+        "$pkgdir/usr/share/applications/dsa.desktop"
+    install -Dm644 "$startdir/resources/dsa.png" \
+        "$pkgdir/usr/share/icons/hicolor/256x256/apps/dsa.png"
+}
+
+package_dsx() {
+    pkgdesc="DSX client"
+    depends=('dsa')
+
+    install -Dm755 "$startdir/target/release/dsx" "$pkgdir/usr/bin/dsx"
+}
+
+package_dsa-tools() {
+    pkgdesc="DSA assembler and compiler tools"
+    depends=()
+
+    install -Dm755 "$startdir/target/release/dsa-a" "$pkgdir/usr/bin/dsa-a"
+    install -Dm755 "$startdir/target/release/dsa-c" "$pkgdir/usr/bin/dsa-c"
+}
+
+package_dsx-server() {
+    pkgdesc="DSX server"
+    depends=()
+
+    install -Dm755 "$startdir/target/release/dsx-server" "$pkgdir/usr/bin/dsx-server"
+
+    # Example sed usage — patch config paths for system install
+    sed -i 's|./templates|/usr/share/dsx-server/templates|g' \
+        "target/release/dsx-server" 2>/dev/null || true
+
+    install -Dm644 "$startdir/dsx_server/templates" "$pkgdir/usr/share/dsx-server/templates" 2>/dev/null || true
+}

assembler/src/lib.rs

@@ -1,50 +0,0 @@
-#![deny(
-    clippy::unwrap_used,
-    clippy::nursery,
-    clippy::perf,
-    clippy::pedantic,
-    clippy::complexity
-)]
-#![allow(
-    clippy::cast_possible_truncation,
-    clippy::missing_panics_doc,
-    clippy::missing_errors_doc,
-    clippy::match_wildcard_for_single_variants
-)]
-
-pub mod assembler;
-pub mod image_builder;
-pub mod tooling;
-mod util;
-
-pub mod prelude {
-    pub use crate::assembler::CompilerEngine;
-    pub use crate::image_builder;
-    pub use crate::tooling::brainf;
-    pub use crate::tooling::project;
-}
-
-use std::{fs, path::Path};
-
-use num_cpus as _;
-use threadpool as _;
-
-use crate::prelude::CompilerEngine;
-
-pub fn assemble_file(input: &str, output: &str) -> Result<(), std::io::Error> {
-    let mut engine = CompilerEngine::new();
-    engine.start_compilation(Path::new(input));
-    let result = engine.wait_for_result().unwrap();
-
-    let buffer: Vec<u8> = result
-        .iter()
-        .flat_map(|instruction| instruction.encode().to_be_bytes())
-        .collect();
-
-    if let Err(e) = fs::write(output, buffer) {
-        eprintln!("Failed to write to output file: {e}");
-        std::process::exit(1);
-    }
-
-    Ok(())
-}

assembler/src/util/logging.rs

@@ -1,108 +0,0 @@
-#![allow(dead_code)]
-#![allow(unused)]
-use std::{fmt, sync::mpsc::Sender};
-
-pub struct Logger {}
-
-impl Logger {
-    pub const fn new() -> Self {
-        Self {}
-    }
-
-    pub fn log(&self, message: &str) {
-        _ = self;
-        println!("\x1b[32mINFO:\x1b[0m {message}");
-    }
-}
-
-// #[derive(Debug)]=
-// pub struct Logger {
-//     pub sender: Sender<Entry>,
-// }
-
-// impl Logger {
-//     pub fn new(sender: Sender<Entry>) -> Self {
-//         Self { sender }
-//     }
-
-//     pub fn debug<T: fmt::Display>(&self, message: T) {
-//         self.sender
-//             .send(Entry {
-//                 etype: EntryType::Debug,
-//                 message: message.to_string(),
-//             })
-//             .unwrap();
-//     }
-
-//     pub fn info<T: fmt::Display>(&self, message: T) {
-//         self.sender
-//             .send(Entry {
-//                 etype: EntryType::Info,
-//                 message: message.to_string(),
-//             })
-//             .unwrap();
-//     }
-
-//     pub fn warn<T: fmt::Display>(&self, message: T) {
-//         self.sender
-//             .send(Entry {
-//                 etype: EntryType::Warn,
-//                 message: message.to_string(),
-//             })
-//             .unwrap();
-//     }
-
-//     pub fn error<T: fmt::Display>(&self, message: T) {
-//         self.sender
-//             .send(Entry {
-//                 etype: EntryType::Error,
-//                 message: message.to_string(),
-//             })
-//             .unwrap();
-//     }
-
-//     pub fn fatal<T: fmt::Display>(&self, message: T) {
-//         self.sender
-//             .send(Entry {
-//                 etype: EntryType::Fatal,
-//                 message: message.to_string(),
-//             })
-//             .unwrap();
-//     }
-// }
-
-pub struct Entry {
-    etype: EntryType,
-    pub message: String,
-}
-
-#[derive(Copy, Clone, Eq, PartialEq)]
-enum EntryType {
-    Debug,
-    Info,
-    Warn,
-    Error,
-    Fatal,
-}
-
-impl fmt::Display for EntryType {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "{:<5}",
-            match self {
-                Self::Debug => "DEBUG",
-                Self::Info => "INFO",
-                Self::Warn => "WARN",
-                Self::Error => "ERROR",
-                Self::Fatal => "FATAL",
-            }
-        )
-    }
-}
-
-impl fmt::Display for Entry {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}: {}", self.etype, self.message)
-    }
-}

clippy.toml

@@ -0,0 +1 @@
+disallowed-types = ["std::collections::HashMap", "std::collections::HashSet"]

common/src/logging.rs

@@ -1,4 +0,0 @@
-// TODO: Use an actual logging or tracing library for pretty (scoped) output.
-pub fn log(message: &str) {
-    println!("\x1b[32mINFO:\x1b[0m {message}");
-}

compiler/src/backend/dsa/mod.rs

@@ -1,9 +0,0 @@
-use crate::model::{CompilerError, Program};
-
-mod codegen;
-mod registers;
-
-pub fn generate_code(ast: &Program) -> Result<String, CompilerError> {
-    let mut codegen = codegen::CodeGenerator::new(ast.clone());
-    codegen.generate()
-}

compiler/src/lib.rs

@@ -1,72 +0,0 @@
-#![feature(try_trait_v2)]
-
-use std::path::Path;
-
-use common::logging::log;
-
-use crate::specialised::build_specialised;
-
-mod backend;
-mod frontend;
-mod model;
-mod specialised;
-
-pub fn compile_file(
-    input_path: &Path,
-    output_path: &Path,
-) -> Result<(), Box<dyn std::error::Error>> {
-    let input = std::fs::read_to_string(input_path).expect("Failed to read input file");
-
-    let input_ext = input_path
-        .extension()
-        .and_then(|s| s.to_str())
-        .unwrap_or("");
-
-    // check if we're using a specialised compiler
-    if let Some(output) = build_specialised(input_ext, &input) {
-        let result = match output {
-            Ok(output) => output,
-            Err(err) => return Err(format!("Compilation failed: {err:?}").into()),
-        };
-
-        std::fs::write(output_path, &result).expect("Failed to write output");
-
-        log(&format!(
-            "Compilation Successful ✅ \n\tSource: {}\n\tOutput: {}\n",
-            input_path.display(),
-            output_path.display(),
-        ));
-
-        return Ok(());
-    }
-
-    // Parse the input using the frontend, providing the file extension and data.
-    let ast = match frontend::compiler_frontend(input_ext, &input) {
-        Ok(ast) => ast,
-        Err(err) => return Err(format!("Compilation failed: {err:?}").into()),
-    };
-
-    println!("Parsed AST: {:#?}", ast);
-
-    let output_ext = output_path
-        .extension()
-        .and_then(|s| s.to_str())
-        .unwrap_or("");
-
-    // Generate the output using the backend with the parsed result.
-    let result = match backend::compiler_backend(output_ext, &ast) {
-        Ok(result) => result,
-        Err(err) => return Err(format!("Compilation failed: {err:?}").into()),
-    };
-
-    // println!("{result}");
-    std::fs::write(output_path, &result).expect("Failed to write output");
-
-    log(&format!(
-        "Compilation Successful ✅ \n\tSource: {}\n\tOutput: {}\n",
-        input_path.display(),
-        output_path.display(),
-    ));
-
-    Ok(())
-}

compiler/src/main.rs

@@ -1,21 +0,0 @@
-use std::path::Path;
-
-use compiler;
-
-fn main() {
-    // read from input file: syntax "c_compiler <src.c> [output.dsa]"
-    let args: Vec<String> = std::env::args().collect();
-    if args.len() < 2 {
-        eprintln!("Usage: c_compiler <src.dsc> [output.dsa]");
-        return;
-    }
-
-    let input_file = &args[1];
-    let output_file = if args.len() > 2 {
-        &args[2]
-    } else {
-        "output.dsa"
-    };
-
-    compiler::compile_file(Path::new(input_file), Path::new(output_file)).unwrap();
-}

core/assembler/Cargo.toml

@@ -5,7 +5,7 @@ edition.workspace = true
 authors.workspace = true
 
 [[bin]]
-name = "assembler_runner"
+name = "dsa-a"
 path = "src/main.rs"
 
 [lib]
@@ -13,6 +13,6 @@ name = "assembler"
 path = "src/lib.rs"
 
 [dependencies]
-common = { path = "../common" }
+common = { path = "../dsa_common" }
 num_cpus = "1.17.0"
 threadpool = "1.8.1"

core/assembler/src/assembler/assembler.rs

@@ -8,7 +8,7 @@ use std::{
 
 use crate::assembler::{AssembleError, Token, expand_pseudo_ops, lexer, quick_hash};
 use crate::assembler::{Node, Parser, resolve_dependencies};
-use crate::util::logging::Logger;
+// use crate::util::logging::Logger;
 
 // pub fn new_assemble(path: &Path) {
 //     let program = Program::new();
@@ -144,7 +144,8 @@ impl Module {
     }
 
     pub fn build(path: PathBuf, program: ProgramRef) -> Result<Task, AssembleError> {
-        // Spawn a thread that creates the main function and executes the lexer and parser.
+        // Spawn a thread that creates the main function and executes the lexer and
+        // parser.
         let handle = thread::spawn(move || {
             let mut module =
                 Self::new(path.clone(), quick_hash(&path), Vec::new(), program.clone());

core/assembler/src/assembler/macros.rs

@@ -4,7 +4,8 @@ use crate::assembler::model::{Node, Opcode, Symbol, Token};
 /// Parse DSA assembly code with optional formatting
 ///
 /// # Examples
-/// ```
+/// ```rs
+/// use assembler::macros::dsa;
 /// // With formatting:
 /// let nodes = dsa!(hash, "mov r1, {}", 42)?;
 ///

core/assembler/src/assembler/mod.rs

@@ -5,19 +5,25 @@ use std::{
     fmt, fs,
     hash::{DefaultHasher, Hash, Hasher},
     path::{Path, PathBuf},
-    sync::{Arc, Mutex, mpsc},
+    sync::{
+        Arc, Mutex,
+        mpsc::{self, Receiver, Sender},
+    },
     thread,
 };
 
-pub use common::logging::log;
+use common::{
-use common::prelude::Instruction;
+    build::{BuildError, Builder},
+    logging::{LogReceiver, Logger},
+    prelude::Instruction,
+};
 
 // Module declarations
 #[macro_use]
 pub mod macros;
 
 #[allow(clippy::module_inception)]
-pub mod assembler;
+// pub mod assembler;
 pub mod codegen;
 pub mod expand;
 pub mod lexer;
@@ -35,45 +41,68 @@ pub use self::{
     resolver::{create_sections, resolve_dependencies, resolve_symbols},
 };
 
-use crate::util::logging::{Entry, Logger};
+pub struct Assembler {
-
+    src_path: PathBuf,
-pub struct CompilerEngine {
+    result_tx: mpsc::Sender<Result<Vec<u8>, AssembleError>>,
-    result_tx: mpsc::Sender<Result<Vec<Instruction>, AssembleError>>,
+    result_rx: Option<mpsc::Receiver<Result<Vec<u8>, AssembleError>>>,
-    result_rx: Option<mpsc::Receiver<Result<Vec<Instruction>, AssembleError>>>,
     is_running: bool,
+
+    logs_rx: LogReceiver,
 }
 
-impl CompilerEngine {
+impl From<AssembleError> for BuildError {
+    fn from(err: AssembleError) -> Self {
+        Self::Generic(err.to_string())
+    }
+}
+
+impl Builder for Assembler {
+    type Output = Vec<u8>;
+    type Args = ();
+
+    fn logs(&self) -> Vec<String> {
+        self.logs_rx.logs()
+    }
+
     #[must_use]
-    pub fn new() -> Self {
+    fn new(src_path: impl Into<PathBuf>) -> Self {
         let (tx, rx) = mpsc::channel();
         Self {
+            src_path: src_path.into(),
             result_tx: tx,
             result_rx: Some(rx),
             is_running: false,
+
+            // for logging
+            logs_rx: LogReceiver::new(true),
         }
     }
 
     /// Start the compilation process in a separate thread
-    pub fn start_compilation(&mut self, src: &Path) {
+    fn start(&mut self, args: ()) {
         if self.is_running {
             return;
         }
 
-        let src = src.to_path_buf();
+        let src = self.src_path.clone();
         let tx = self.result_tx.clone();
+        let logger = self.logs_rx.logger();
 
         thread::spawn(move || {
-            let result = assemble(&src);
+            if let Ok(res) = assemble(&src, &logger) {
-            tx.send(result)
+                let buffer: Vec<u8> = res
-                .expect("Failed to send compilation result from worker thread");
+                    .iter()
+                    .flat_map(|instruction| instruction.encode().to_be_bytes())
+                    .collect();
+                tx.send(Ok(buffer))
+                    .expect("Failed to send compilation result from worker thread");
+            }
         });
 
         self.is_running = true;
     }
 
-    /// Check if compilation is complete and get the result
+    fn poll(&mut self) -> Option<Result<Self::Output, common::build::BuildError>> {
-    pub fn try_get_result(&mut self) -> Option<Result<Vec<Instruction>, AssembleError>> {
         if !self.is_running {
             return None;
         }
@@ -86,22 +115,20 @@ impl CompilerEngine {
         {
             Ok(result) => {
                 self.is_running = false;
-                Some(result)
+                Some(result.map_err(std::convert::Into::into))
             }
             Err(mpsc::TryRecvError::Empty) => None,
             Err(mpsc::TryRecvError::Disconnected) => {
                 self.is_running = false;
-                Some(Err(AssembleError::Generic))
+                Some(Err(BuildError::Generic(String::from(
+                    "Compilation terminated before a result was returned",
+                ))))
             }
         }
     }
 
     /// Block until compilation is complete and return the result
-    pub fn wait_for_result(&mut self) -> Result<Vec<Instruction>, AssembleError> {
+    fn output(&mut self) -> Result<Self::Output, common::build::BuildError> {
-        if !self.is_running {
-            return Err(AssembleError::Generic);
-        }
-
         if let Ok(result) = self
             .result_rx
             .take()
@@ -109,15 +136,19 @@ impl CompilerEngine {
             .recv()
         {
             self.is_running = false;
-            result
+            result.map_err(std::convert::Into::into)
         } else {
             self.is_running = false;
-            Err(AssembleError::Generic)
+            Err(BuildError::Generic(String::from(
+                "Compilation terminated before a result was returned",
+            )))
         }
     }
 }
 
-fn assemble(src: &Path) -> Result<Vec<Instruction>, AssembleError> {
+impl Assembler {}
+
+fn assemble(src: &Path, logger: &Logger) -> Result<Vec<Instruction>, AssembleError> {
     let mut modules = HashSet::new();
     let mut program = Program::new();
 
@@ -127,31 +158,26 @@ fn assemble(src: &Path) -> Result<Vec<Instruction>, AssembleError> {
         return Ok(vec![]);
     }
 
-    prepare_dependency(src, &mut modules, &mut program)?;
+    prepare_dependency(src, &mut modules, &mut program, &logger)?;
 
     let mut nodes = program.nodes.clone();
 
     create_sections(&mut nodes)?;
     resolve_symbols(&mut nodes)?;
 
-    log("Generating assembly output...");
+    logger.info("Generating assembly output...");
 
     let instructions = codegen(nodes)?;
 
-    log("Compilation Successful");
+    logger.info("Compilation Successful");
     Ok(instructions)
 }
 
-impl Default for CompilerEngine {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 fn prepare_dependency(
     path: &Path,
     modules: &mut HashSet<u64>,
     program: &mut Program,
+    logger: &Logger,
 ) -> Result<(), AssembleError> {
     let filename = path
         .file_name()
@@ -159,7 +185,7 @@ fn prepare_dependency(
         .expect("Failed to get file name from path");
 
     if let Ok(path) = path.canonicalize() {
-        log(&format!(
+        logger.info(&format!(
             "{:20} {:20} [{}]",
             "Building",
             filename,
@@ -171,13 +197,13 @@ fn prepare_dependency(
         .map_err(|_| AssembleError::InvalidFile(path.to_path_buf()))?;
     let file_hash = quick_hash(path);
 
-    log(&format!("{:20} {:20}", "Tokenising", filename));
+    logger.info(&format!("{:20} {:20}", "Tokenising", filename));
     let tokens = lexer::lexer(src, file_hash)?;
 
-    log(&format!("{:20} {:20}", "Parsing", filename));
+    logger.info(&format!("{:20} {:20}", "Parsing", filename));
     let parsed = Parser::parse_nodes(tokens)?;
 
-    log(&format!("{:20} {:20}", "Resolving Deps", filename));
+    logger.info(&format!("{:20} {:20}", "Resolving Deps", filename));
     // Get the parent directory of the source file to use as the base directory
     let base_dir = path
         .parent()
@@ -187,7 +213,7 @@ fn prepare_dependency(
 
     let deps = Parser::get_dependencies(&nodes, path)?;
 
-    log(&format!("{:20} {:20}", "Expanding Pseudo-ops", filename));
+    logger.info(&format!("{:20} {:20}", "Expanding Pseudo-ops", filename));
 
     // add a section instruction
     nodes.insert(
@@ -202,7 +228,7 @@ fn prepare_dependency(
     program.add_module(nodes);
 
     for dep in deps {
-        log(&format!(
+        logger.info(&format!(
             "{:20} {:20}",
             "Including",
             dep.file_name()
@@ -212,7 +238,7 @@ fn prepare_dependency(
 
         let dep_hash = quick_hash(&dep);
         if modules.insert(dep_hash) {
-            prepare_dependency(dep.as_path(), modules, program)?;
+            prepare_dependency(dep.as_path(), modules, program, logger)?;
         }
     }
 

core/assembler/src/assembler/model.rs

@@ -184,11 +184,11 @@ pub enum Token {
 impl fmt::Display for Token {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::Symbol(symbol) => write!(f, "{}", symbol),
+            Self::Symbol(symbol) => write!(f, "{symbol}"),
-            Self::Register(register) => write!(f, "{}", register),
+            Self::Register(register) => write!(f, "{register}",),
-            Self::Immediate(immediate) => write!(f, "{}", immediate),
+            Self::Immediate(immediate) => write!(f, "{immediate}",),
-            Self::StringLit(string_lit) => write!(f, "{}", string_lit),
+            Self::StringLit(string_lit) => write!(f, "{string_lit}",),
-            Self::Opcode(opcode) => write!(f, "{}", opcode),
+            Self::Opcode(opcode) => write!(f, "{opcode}",),
         }
     }
 }

core/assembler/src/assembler/parser.rs

@@ -101,6 +101,7 @@ impl Parser {
         let opcode = expect_token!(self.next()?, Opcode)?;
         let args: Vec<Token>;
 
+        #[allow(clippy::match_same_arms)]
         match opcode {
             // R-type instructions
             Opcode::Mov | Opcode::Movs => {
@@ -113,24 +114,25 @@ impl Parser {
                 let base = expect_type!(self.next()?, Register, Symbol)?;
                 let dest = expect_type!(self.next()?, Register)?;
 
-                let mut offset = Token::Immediate(0);
+                let offset = match self.peek_next() {
-                if let Ok(next) = self.peek_next()
+                    Ok(next) if expect_type!(next.clone(), Immediate).is_ok() => {
-                    && expect_type!(next, Immediate).is_ok()
+                        self.next()?
-                {
+                    }
-                    offset = self.next()?;
+                    _ => Token::Immediate(0),
-                }
+                };
 
                 args = vec![base, dest, offset];
             }
             Opcode::Stb | Opcode::Sth | Opcode::Stw => {
                 let base = expect_type!(self.next()?, Register)?;
                 let dest = expect_type!(self.next()?, Register, Symbol)?;
-                let mut offset = Token::Immediate(0);
+
-                if let Ok(next) = self.peek_next()
+                let offset = match self.peek_next() {
-                    && expect_type!(next, Immediate).is_ok()
+                    Ok(next) if expect_type!(next.clone(), Immediate).is_ok() => {
-                {
+                        self.next()?
-                    offset = self.next()?;
+                    }
-                }
+                    _ => Token::Immediate(0),
+                };
                 args = vec![base, dest, offset];
             }
 

core/assembler/src/assembler/resolver.rs

@@ -6,11 +6,8 @@ use std::{
 
 use common::prelude::Register;
 
+use crate::assembler::model::{Module, Node, Opcode, Symbol, Token};
 use crate::assembler::quick_hash;
-use crate::assembler::{
-    log,
-    model::{Module, Node, Opcode, Symbol, Token},
-};
 use crate::{assembler::AssembleError, node};
 
 pub fn resolve_symbols(nodes: &mut [Node]) -> Result<(), AssembleError> {

core/assembler/src/lib.rs

@@ -0,0 +1,25 @@
+#![deny(
+    clippy::unwrap_used,
+    clippy::nursery,
+    clippy::perf,
+    clippy::pedantic,
+    clippy::complexity
+)]
+#![allow(
+    clippy::cast_possible_truncation,
+    clippy::missing_panics_doc,
+    clippy::missing_errors_doc,
+    clippy::match_wildcard_for_single_variants
+)]
+
+pub mod assembler;
+pub mod image_builder;
+pub mod tooling;
+mod util;
+
+pub mod prelude {
+    pub use crate::assembler::Assembler;
+    pub use crate::image_builder;
+    pub use crate::tooling::brainf;
+    pub use crate::tooling::project;
+}

core/assembler/src/main.rs

@@ -1,9 +1,6 @@
-use common as _;
+use common::{self as _, build::Builder};
-use num_cpus as _;
-use threadpool as _;
 
 use assembler::{
-    assemble_file,
     prelude::*,
     tooling::{brainf, project},
 };
@@ -47,5 +44,13 @@ fn main() {
 
     let input_path = &args[2];
     let output_path = &args[4];
-    assemble_file(input_path, output_path).unwrap();
+
+    let mut engine = Assembler::new(PathBuf::from(input_path));
+    engine.start(());
+    let result = engine.output().expect("assembler failed.");
+
+    if let Err(e) = fs::write(output_path, result) {
+        eprintln!("Failed to write to output file: {e}");
+        std::process::exit(1);
+    }
 }

core/assembler/src/util/logging.rs

@@ -0,0 +1,39 @@
+#![allow(dead_code)]
+#![allow(unused)]
+use std::{fmt, sync::mpsc::Sender};
+
+// pub struct Entry {
+//     etype: EntryType,
+//     pub message: String,
+// }
+
+// #[derive(Copy, Clone, Eq, PartialEq)]
+// enum EntryType {
+//     Debug,
+//     Info,
+//     Warn,
+//     Error,
+//     Fatal,
+// }
+
+// impl fmt::Display for EntryType {
+//     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+//         write!(
+//             f,
+//             "{:<5}",
+//             match self {
+//                 Self::Debug => "DEBUG",
+//                 Self::Info => "INFO",
+//                 Self::Warn => "WARN",
+//                 Self::Error => "ERROR",
+//                 Self::Fatal => "FATAL",
+//             }
+//         )
+//     }
+// }
+
+// impl fmt::Display for Entry {
+//     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+//         write!(f, "{}: {}", self.etype, self.message)
+//     }
+// }

core/compiler/Cargo.toml

@@ -4,6 +4,12 @@ version.workspace = true
 edition.workspace = true
 authors.workspace = true
 
+
+[[bin]]
+name = "dsa-c"
+path = "src/main.rs"
+
 [dependencies]
 chrono = "0.4.43"
-common = { path = "../common" }
+common = { path = "../dsa_common" }
+uuid = { version = "1.20.0", features = ["v4"] }

core/compiler/src/backend/dsa/instruction.rs

@@ -0,0 +1,797 @@
+use std::fmt;
+
+use crate::backend::dsa::registers::Register;
+
+pub struct InsBlock {
+    instructions: Vec<Instruction>,
+}
+
+impl InsBlock {
+    pub fn new() -> Self {
+        Self {
+            instructions: vec![],
+        }
+    }
+
+    pub fn insert(&mut self, index: usize, instr: Instruction) {
+        self.instructions.insert(index, instr);
+    }
+
+    pub fn push(&mut self, instr: Instruction) {
+        self.instructions.push(instr);
+    }
+
+    pub fn append(&mut self, mut other: Self) {
+        self.instructions.append(&mut other.instructions);
+    }
+
+    pub fn extend(&mut self, instrs: impl IntoIterator<Item = Instruction>) {
+        self.instructions.extend(instrs);
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.instructions.is_empty()
+    }
+
+    pub fn len(&self) -> usize {
+        self.instructions.len()
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = &Instruction> {
+        self.instructions.iter()
+    }
+}
+
+impl From<Vec<Instruction>> for InsBlock {
+    fn from(instructions: Vec<Instruction>) -> Self {
+        Self { instructions }
+    }
+}
+
+impl From<Instruction> for InsBlock {
+    fn from(instr: Instruction) -> Self {
+        Self {
+            instructions: vec![instr],
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum Instruction {
+    // Labels and comments
+    Label(Label),
+    Comment {
+        text: String,
+        top_level: bool,
+    },
+    Newline,
+
+    // Data Directives
+    Db {
+        label: String,
+        data: Vec<u8>,
+    },
+    Dh {
+        label: String,
+        data: Vec<u16>,
+    },
+    Dw {
+        label: String,
+        data: Vec<u32>,
+    },
+    DString {
+        // alias for db.
+        label: String,
+        data: String,
+    },
+
+    Resx {
+        label: String,
+        size: u32,
+    },
+
+    // Include
+    Include {
+        name: String,
+        path: String,
+    },
+
+    // Data movement
+    Mov {
+        src: Register,
+        dest: Register,
+    },
+    Movs {
+        src: Register,
+        dest: Register,
+    },
+
+    // Memory operations
+    Ldb {
+        src: MemOperand,
+        dest: Register,
+    },
+    Ldh {
+        src: MemOperand,
+        dest: Register,
+    },
+    Ldw {
+        src: MemOperand,
+        dest: Register,
+    },
+    Stb {
+        src: Register,
+        dest: MemOperand,
+    },
+    Sth {
+        src: Register,
+        dest: MemOperand,
+    },
+    Stw {
+        src: Register,
+        dest: MemOperand,
+    },
+
+    // Immediate loads
+    Lli {
+        imm: Imm,
+        dest: Register,
+    },
+    Lui {
+        imm: Imm,
+        dest: Register,
+    },
+    Lwi {
+        imm: Imm,
+        dest: Register,
+    },
+    LwiLabel {
+        label: String,
+        dest: Register,
+    },
+
+    // Arithmetic
+    Add {
+        src1: Register,
+        src2: Register,
+        dest: Register,
+    },
+    Sub {
+        src1: Register,
+        src2: Register,
+        dest: Register,
+    },
+    IAdd {
+        src: Register,
+        imm: Imm,
+        dest: Option<Register>,
+    },
+    ISub {
+        src: Register,
+        imm: Imm,
+        dest: Option<Register>,
+    },
+    Inc {
+        reg: Register,
+    },
+    Dec {
+        reg: Register,
+    },
+
+    // Bitwise
+    And {
+        src1: Register,
+        src2: Register,
+        dest: Register,
+    },
+    Or {
+        src1: Register,
+        src2: Register,
+        dest: Register,
+    },
+    Xor {
+        src1: Register,
+        src2: Register,
+        dest: Register,
+    },
+    Not {
+        src: Register,
+        dest: Register,
+    },
+    Nand {
+        src1: Register,
+        src2: Register,
+        dest: Register,
+    },
+    Nor {
+        src1: Register,
+        src2: Register,
+        dest: Register,
+    },
+    Xnor {
+        src1: Register,
+        src2: Register,
+        dest: Register,
+    },
+
+    // Shifts
+    Shl {
+        src1: Register,
+        r_shamt: Register,
+        i_shamt: u16,
+        dest: Register,
+    },
+    Shr {
+        src1: Register,
+        r_shamt: Register,
+        i_shamt: u16,
+        dest: Register,
+    },
+
+    // Comparison
+    Cmp {
+        reg1: Register,
+        reg2: Register,
+    },
+
+    // Jumps
+    Jmp {
+        target: Label,
+    },
+    Jeq {
+        target: Label,
+    },
+    Jne {
+        target: Label,
+    },
+    Jgt {
+        target: Label,
+    },
+    Jge {
+        target: Label,
+    },
+    Jlt {
+        target: Label,
+    },
+    Jle {
+        target: Label,
+    },
+
+    // Stack
+    Push {
+        reg: Register,
+    },
+    Pop {
+        reg: Register,
+    },
+
+    // Function calls
+    Call {
+        target: String,
+    }, // namespace::function
+    Return,
+
+    // System
+    Hlt,
+    Nop,
+    Int {
+        code: u8,
+    },
+}
+
+pub enum DataDirective {
+    U8(Vec<u8>),
+    U16(Vec<u16>),
+    U32(Vec<u32>),
+    String(String),
+    Char(char),
+}
+
+impl fmt::Display for Instruction {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::Label(l) => write!(f, "{}:", l),
+            Self::Newline => write!(f, ""), /* empty string as newlines are inserted */
+            // automatically.
+            Self::Comment { text, top_level } => write!(
+                f,
+                "{}",
+                text.lines()
+                    .map(|line| format!(
+                        "{}// {}",
+                        if *top_level { "" } else { "    " },
+                        line.trim(),
+                    ))
+                    .collect::<Vec<String>>()
+                    .join("\n")
+            ),
+
+            Self::Include { name, path } => write!(f, "include {name}: \"{}\"", path),
+
+            Self::Db { label, data } => write!(
+                f,
+                "db {}: {}",
+                label,
+                data.iter()
+                    .map(|&b| format!("{:#04X}", b))
+                    .collect::<Vec<String>>()
+                    .join(", ")
+            ),
+            Self::Dh { label, data } => write!(
+                f,
+                "dh {}: {}",
+                label,
+                data.iter()
+                    .map(|&b| format!("{:#06X}", b))
+                    .collect::<Vec<String>>()
+                    .join(", ")
+            ),
+            Self::Dw { label, data } => write!(
+                f,
+                "dw {}: {}",
+                label,
+                data.iter()
+                    .map(|&b| format!("{:#08X}", b))
+                    .collect::<Vec<String>>()
+                    .join(", ")
+            ),
+            Self::DString { label, data } => write!(f, "db {}: \"{}\"", label, data),
+
+            Self::Resx { label, size } => write!(f, "resx {}: {}", label, size),
+
+            Self::Mov { src, dest } => write!(f, "    mov {}, {}", src, dest),
+            Self::Movs { src, dest } => write!(f, "    movs {}, {}", src, dest),
+
+            Self::Ldb { src: addr, dest } => {
+                let (reg, offset) = reg_and_offset(addr);
+                write!(f, "    ldb {}, {}, {}", reg, dest, offset)
+            }
+            Self::Ldh { src: addr, dest } => {
+                let (reg, offset) = reg_and_offset(addr);
+                write!(f, "    ldh {}, {}, {}", reg, dest, offset)
+            }
+            Self::Ldw { src, dest } => {
+                let (reg, offset) = reg_and_offset(src);
+                write!(f, "    ldw {}, {}, {}", reg, dest, offset)
+            }
+            // Self::Ldbs { addr, dest } => {
+            //     write!(f, "    ldbs {}, {}", format_mem_operand(addr), dest)
+            // }
+            // Self::Ldhs { addr, dest } => {
+            //     write!(f, "    ldhs {}, {}", format_mem_operand(addr), dest)
+            // }
+            // Self::Ldws { addr, dest } => {
+            //     write!(f, "    ldws {}, {}", format_mem_operand(addr), dest)
+            // }
+            Self::Stb { src, dest: addr } => {
+                let (reg, offset) = reg_and_offset(addr);
+                write!(f, "    stb {}, {}, {}", src, reg, offset)
+            }
+            Self::Sth { src, dest: addr } => {
+                let (reg, offset) = reg_and_offset(addr);
+                write!(f, "    sth {}, {}, {}", src, reg, offset)
+            }
+            Self::Stw { src, dest: addr } => {
+                let (reg, offset) = reg_and_offset(addr);
+                write!(f, "    stw {}, {}, {}", src, reg, offset)
+            }
+
+            Self::Lli { imm, dest } => write!(f, "    lli {}, {}", imm, dest),
+            Self::Lui { imm, dest } => write!(f, "    lui {}, {}", imm, dest),
+            Self::Lwi { imm, dest } => write!(f, "    lwi {}, {}", imm, dest),
+            Self::LwiLabel { label, dest } => write!(f, "    lwi {}, {}", label, dest),
+
+            // arithmetic
+            Self::Add { src1, src2, dest } => {
+                write!(f, "    add {}, {}, {}", src1, src2, dest)
+            }
+            Self::Sub { src1, src2, dest } => {
+                write!(f, "    sub {}, {}, {}", src1, src2, dest)
+            }
+            Self::And { src1, src2, dest } => {
+                write!(f, "    and {}, {}, {}", src1, src2, dest)
+            }
+            Self::Or { src1, src2, dest } => {
+                write!(f, "    or {}, {}, {}", src1, src2, dest)
+            }
+            Self::Nand { src1, src2, dest } => {
+                write!(f, "    nand {}, {}, {}", src1, src2, dest)
+            }
+            Self::Xor { src1, src2, dest } => {
+                write!(f, "    xor {}, {}, {}", src1, src2, dest)
+            }
+            Self::Nor { src1, src2, dest } => {
+                write!(f, "    nor {}, {}, {}", src1, src2, dest)
+            }
+            Self::Not { src, dest } => {
+                write!(f, "    not {} {}", src, dest)
+            }
+            Self::Xnor { src1, src2, dest } => {
+                write!(f, "    xnor {}, {}, {}", src1, src2, dest)
+            }
+            Self::IAdd { src, imm, dest } => {
+                if let Some(d) = dest {
+                    write!(f, "    addi {}, {}, {}", src, imm, d)
+                } else {
+                    write!(f, "    addi {}, {}", src, imm)
+                }
+            }
+            Self::ISub { src, imm, dest } => {
+                if let Some(d) = dest {
+                    write!(f, "    subi {}, {}, {}", src, imm, d)
+                } else {
+                    write!(f, "    subi {}, {}", src, imm)
+                }
+            }
+
+            // shift instructions
+            Self::Shl {
+                src1,
+                r_shamt,
+                i_shamt,
+                dest,
+            } => {
+                write!(f, "    shl {}, {}, {}, {}", src1, r_shamt, i_shamt, dest)
+            }
+            Self::Shr {
+                src1,
+                r_shamt,
+                i_shamt,
+                dest,
+            } => {
+                write!(f, "    shl {}, {}, {}, {}", src1, r_shamt, i_shamt, dest)
+            }
+
+            // increment instructions
+            Self::Inc { reg } => write!(f, "    inc {}", reg),
+            Self::Dec { reg } => write!(f, "    dec {}", reg),
+
+            Self::Cmp { reg1, reg2 } => write!(f, "    cmp {}, {}", reg1, reg2),
+
+            // jump instructions
+            Self::Jmp { target } => write!(f, "    jmp {}", target),
+            Self::Jeq { target } => write!(f, "    jeq {}", target),
+            Self::Jne { target } => write!(f, "    jne {}", target),
+            Self::Jgt { target } => write!(f, "    jgt {}", target),
+            Self::Jge { target } => write!(f, "    jge {}", target),
+            Self::Jlt { target } => write!(f, "    jlt {}", target),
+            Self::Jle { target } => write!(f, "    jle {}", target),
+
+            // stack pseudoinstructions
+            Self::Push { reg } => write!(f, "    push {}", reg),
+            Self::Pop { reg } => write!(f, "    pop {}", reg),
+
+            // call & return pseudoinstructions
+            Self::Call { target } => write!(f, "    call {}", target),
+            Self::Return => write!(f, "    return"),
+
+            // misc instructions
+            Self::Int { code } => write!(f, "    int {}", code),
+            Self::Hlt => write!(f, "    hlt"),
+            Self::Nop => write!(f, "    nop"),
+        }
+    }
+}
+
+impl Instruction {
+    // data directives
+    pub fn db_string(label: impl Into<String>, data: impl Into<String>) -> Self {
+        Self::DString {
+            label: label.into(),
+            data: data.into(),
+        }
+    }
+
+    pub fn db_word(label: impl Into<String>, data: u32) -> Self {
+        Self::Dw {
+            label: label.into(),
+            data: vec![data],
+        }
+    }
+
+    pub fn db_bytes(label: impl Into<String>, data: &[u8]) -> Self {
+        Self::Db {
+            label: label.into(),
+            data: data.to_vec(),
+        }
+    }
+
+    // Movement
+    pub fn mov<R1, R2>(src: R1, dest: R2) -> Self
+    where
+        R1: Into<Register>,
+        R2: Into<Register>,
+    {
+        Self::Mov {
+            src: src.into(),
+            dest: dest.into(),
+        }
+    }
+
+    // Memory loads
+    pub fn ldw_reg<R>(base: R, dest: Register) -> Self
+    where
+        R: Into<Register>,
+    {
+        Self::Ldw {
+            src: MemOperand::RegIndirect(base.into()),
+            dest,
+        }
+    }
+
+    pub fn ldw_reg_offset<R>(base: R, dest: Register, offset: i32) -> Self
+    where
+        R: Into<Register>,
+    {
+        Self::Ldw {
+            src: MemOperand::RegOffset(base.into(), offset),
+            dest,
+        }
+    }
+
+    pub fn ldw_label(label: impl Into<Label>, dest: Register) -> Self {
+        Self::Ldw {
+            src: MemOperand::Label(label.into()),
+            dest,
+        }
+    }
+
+    // Memory stores
+    pub fn stw_reg<R>(src: Register, base: R) -> Self
+    where
+        R: Into<Register>,
+    {
+        Self::Stw {
+            src,
+            dest: MemOperand::RegIndirect(base.into()),
+        }
+    }
+
+    pub fn stw_reg_offset<R>(src: Register, base: R, offset: i32) -> Self
+    where
+        R: Into<Register>,
+    {
+        Self::Stw {
+            src,
+            dest: MemOperand::RegOffset(base.into(), offset),
+        }
+    }
+
+    pub fn stw_label(src: Register, label: impl Into<Label>) -> Self {
+        Self::Stw {
+            src,
+            dest: MemOperand::Label(label.into()),
+        }
+    }
+
+    // Arithmetic
+    pub fn add(src1: Register, src2: Register, dest: Register) -> Self {
+        Self::Add { src1, src2, dest }
+    }
+
+    pub fn sub(src1: Register, src2: Register, dest: Register) -> Self {
+        Self::Sub { src1, src2, dest }
+    }
+
+    pub fn and(src1: Register, src2: Register, dest: Register) -> Self {
+        Self::And { src1, src2, dest }
+    }
+
+    pub fn or(src1: Register, src2: Register, dest: Register) -> Self {
+        Self::Or { src1, src2, dest }
+    }
+
+    pub fn xor(src1: Register, src2: Register, dest: Register) -> Self {
+        Self::Xor { src1, src2, dest }
+    }
+
+    pub fn not(src: Register, dest: Register) -> Self {
+        Self::Not { src, dest }
+    }
+
+    pub fn shl(src1: Register, r_shamt: Register, i_shamt: u16, dest: Register) -> Self {
+        Self::Shl {
+            src1,
+            r_shamt,
+            i_shamt,
+            dest,
+        }
+    }
+
+    pub fn shr(src1: Register, r_shamt: Register, i_shamt: u16, dest: Register) -> Self {
+        Self::Shr {
+            src1,
+            r_shamt,
+            i_shamt,
+            dest,
+        }
+    }
+
+    pub fn iadd(src: Register, value: i64) -> Self {
+        let imm = Imm(value.unsigned_abs() as u32);
+
+        if value < 0 {
+            Self::ISub {
+                src,
+                imm,
+                dest: None,
+            }
+        } else {
+            Self::IAdd {
+                src,
+                imm,
+                dest: None,
+            }
+        }
+    }
+
+    pub fn iadd_dest(src: Register, value: i32, dest: Register) -> Self {
+        let imm = Imm(value.unsigned_abs());
+
+        if value < 0 {
+            Self::ISub {
+                src,
+                imm,
+                dest: Some(dest),
+            }
+        } else {
+            Self::IAdd {
+                src,
+                imm,
+                dest: Some(dest),
+            }
+        }
+    }
+
+    pub fn inc(reg: Register) -> Self {
+        Self::Inc { reg }
+    }
+
+    pub fn dec(reg: Register) -> Self {
+        Self::Dec { reg }
+    }
+
+    // Immediate loads
+    pub fn lwi(value: u32, dest: Register) -> Self {
+        if value > 0xFFFF {
+            Self::Lwi {
+                imm: Imm(value),
+                dest,
+            }
+        } else {
+            Self::Lli {
+                imm: Imm(value),
+                dest,
+            }
+        }
+    }
+
+    pub fn lwi_label(label: impl Into<String>, dest: Register) -> Self {
+        Self::LwiLabel {
+            label: label.into(),
+            dest,
+        }
+    }
+
+    // Control flow
+    pub fn label(name: impl Into<String>) -> Self {
+        Self::Label(Label(name.into()))
+    }
+
+    pub fn jmp(target: impl Into<Label>) -> Self {
+        Self::Jmp {
+            target: target.into(),
+        }
+    }
+
+    pub fn jeq(target: impl Into<Label>) -> Self {
+        Self::Jeq {
+            target: target.into(),
+        }
+    }
+
+    pub fn cmp(reg1: Register, reg2: Register) -> Self {
+        Self::Cmp { reg1, reg2 }
+    }
+
+    // Stack
+    pub fn push(reg: Register) -> Self {
+        Self::Push { reg }
+    }
+
+    pub fn pop(reg: Register) -> Self {
+        Self::Pop { reg }
+    }
+
+    // Functions
+    pub fn call(target: impl Into<String>) -> Self {
+        Self::Call {
+            target: target.into(),
+        }
+    }
+
+    pub fn int(code: u8) -> Self {
+        Self::Int { code }
+    }
+
+    pub fn ret() -> Self {
+        Self::Return
+    }
+
+    // Utilities
+    pub fn comment(text: impl Into<String>) -> Self {
+        Self::Comment {
+            text: text.into(),
+            top_level: false,
+        }
+    }
+
+    pub fn global_comment(text: impl Into<String>) -> Self {
+        Self::Comment {
+            text: text.into(),
+            top_level: true,
+        }
+    }
+
+    pub fn include(name: impl Into<String>, path: impl Into<String>) -> Self {
+        Self::Include {
+            name: name.into(),
+            path: path.into(),
+        }
+    }
+}
+
+// Convenience trait for Label conversion
+impl From<String> for Label {
+    fn from(s: String) -> Self {
+        Label(s)
+    }
+}
+
+impl From<&str> for Label {
+    fn from(s: &str) -> Self {
+        Label(s.to_string())
+    }
+}
+
+fn reg_and_offset(op: &MemOperand) -> (String, i32) {
+    match op {
+        MemOperand::RegIndirect(reg) => (reg.to_string(), 0),
+        MemOperand::RegOffset(reg, offset) => (reg.to_string(), *offset),
+        MemOperand::Label(label) => (label.to_string(), 0),
+        MemOperand::LabelOffset(label, offset) => (label.to_string(), *offset),
+    }
+}
+
+/// Memory operand for loads/stores
+#[derive(Debug, Clone)]
+pub enum MemOperand {
+    /// Register indirect: [reg]
+    RegIndirect(Register),
+    /// Register with offset: [reg + offset]
+    RegOffset(Register, i32),
+    /// Label: [label]
+    Label(Label),
+    /// Label with offset: [label + offset]
+    LabelOffset(Label, i32),
+}
+
+/// Immediate value (16-bit or 32-bit)
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Imm(pub u32);
+
+impl fmt::Display for Imm {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+/// Label reference
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Label(pub String);
+
+impl fmt::Display for Label {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}

core/compiler/src/backend/dsa/mod.rs

@@ -0,0 +1,11 @@
+use crate::model::{CompilerError, Program};
+
+mod codegen;
+mod instruction;
+mod registers;
+mod scope;
+
+pub fn generate_code(ast: &Program, is_lib: bool) -> Result<String, CompilerError> {
+    let mut codegen = codegen::CodeGenerator::new(ast.clone(), is_lib);
+    codegen.generate()
+}

core/compiler/src/backend/dsa/registers.rs

@@ -1,12 +1,14 @@
 use std::{collections::HashMap, fmt};
 
-use crate::model::CompilerError;
+use crate::{
+    backend::dsa::instruction::{InsBlock, Instruction},
+    model::CompilerError,
+};
 
 /// Register allocator for DSA assembly generation
 /// Manages general-purpose registers (rg0-rgf) and handles stack spilling
 pub struct RegisterAllocator {
     /// Available general-purpose registers
-
     /// Maps variable names to their current location (register or stack offset)
     variable_locations: HashMap<String, Location>,
 
@@ -18,7 +20,7 @@ pub struct RegisterAllocator {
     stack_offset: i32,
 
     /// Track which registers are currently in use
-    in_use: HashMap<Register, bool>,
+    in_use: Vec<(Register, bool)>,
 }
 
 #[derive(Debug, Clone)]
@@ -79,14 +81,14 @@ impl RegisterAllocator {
 
     /// Allocate a temporary register for expression evaluation
     /// Returns the register name and optionally assembly code to save it
-    pub fn alloc_temp(&mut self) -> Result<(Register, Vec<String>), CompilerError> {
+    pub fn alloc_temp(&mut self) -> Result<(Register, InsBlock), CompilerError> {
         // Try to find an unused register
 
         // println!("finding! {:#?}", self.in_use);
 
         if let Some(reg) = self.find_free_register() {
-            self.in_use.insert(reg, true);
+            self.in_use[reg as usize].1 = true;
-            return Ok((reg, Vec::new()));
+            return Ok((reg, InsBlock::new()));
         }
 
         // All registers in use - need to spill one
@@ -133,7 +135,7 @@ impl RegisterAllocator {
 
         // This is a true temporary - safe to free
         if !matches!(reg, Register::Zero | Register::Null) {
-            self.in_use.insert(reg, false);
+            self.in_use[reg as usize].1 = false;
         }
     }
 
@@ -144,7 +146,7 @@ impl RegisterAllocator {
                 && !matches!(reg, Register::Zero | Register::Null)
             {
                 self.register_contents.remove(&reg);
-                self.in_use.insert(reg, false);
+                self.in_use[reg as usize].1 = false;
             }
 
             self.variable_locations.remove(var);
@@ -156,11 +158,11 @@ impl RegisterAllocator {
     pub fn alloc_var(
         &mut self,
         var_name: &str,
-    ) -> Result<(Register, Vec<String>), CompilerError> {
+    ) -> Result<(Register, InsBlock), CompilerError> {
         if let Some(mut location) = self.variable_locations.get(var_name).cloned() {
             // if the var is in a register we can use it already.
             if let Some(reg) = location.register {
-                return Ok((reg, Vec::new()));
+                return Ok((reg, InsBlock::new()));
             }
 
             // if the variable is on the stack only, we need to get it in a register.
@@ -174,19 +176,17 @@ impl RegisterAllocator {
 
                 // Load from bpr + offset (offset is negative)
                 // code.push(format!("\tsubi bpr {} {}", -(offset + 4), reg));
-                code.push(format!(
+
-                    "\tldw spr, {}, {} // spr+{}: {}",
+                code.push(Instruction::ldw_reg_offset(
+                    Register::Spr,
                     reg,
                     offset - self.stack_offset,
-                    offset - self.stack_offset,
-                    var_name
                 ));
 
                 // Update location to register
                 self.variable_locations
                     .insert(var_name.to_string(), location);
-                self.register_contents
+                self.register_contents.insert(reg, var_name.to_string());
-                    .insert(reg.clone(), var_name.to_string());
 
                 return Ok((reg, code));
             }
@@ -196,8 +196,7 @@ impl RegisterAllocator {
         let (reg, code) = self.alloc_temp()?;
         self.variable_locations
             .insert(var_name.to_string(), Location::register(reg));
-        self.register_contents
+        self.register_contents.insert(reg, var_name.to_string());
-            .insert(reg.clone(), var_name.to_string());
 
         Ok((reg, code))
     }
@@ -212,34 +211,34 @@ impl RegisterAllocator {
     pub fn load_var(
         &mut self,
         var_name: &str,
-    ) -> Result<(Register, Vec<String>), CompilerError> {
+    ) -> Result<(Register, InsBlock), CompilerError> {
         self.alloc_var(var_name)
     }
 
     /// Store a value from a register into a variable
     /// Updates tracking and returns any necessary assembly code
-    pub fn store_var(&mut self, var_name: &str, source_reg: &Register) -> Vec<String> {
+    pub fn store_var(&mut self, var_name: &str, source_reg: &Register) -> InsBlock {
+        let mut block = InsBlock::new();
+
         // Check if variable already has a location
         if let Some(location) = self.variable_locations.get(var_name) {
             // if the variable exists in a register we write to that.
-            if let Some(reg) = location.register {
+            match location.register {
-                if reg == *source_reg {
+                Some(reg) if reg == *source_reg => {
-                    return vec![format!(
+                    block.push(Instruction::mov(*source_reg, reg));
-                        "\tmov {}, {} // save var:{} reg:{}",
+                    return block;
-                        source_reg, reg, var_name, reg
-                    )];
                 }
+                _ => (),
             }
 
             // if the variable exists on the stack but not a register we write here.
             if let Some(offset) = location.stack {
-                return vec![format!(
+                block.push(Instruction::stw_reg_offset(
-                    "\tstw {}, spr, {} // save var:{} offset:{}",
+                    *source_reg,
-                    source_reg,
+                    Register::Spr,
                     offset - self.stack_offset,
-                    var_name,
+                ));
-                    offset
+                return block;
-                )];
             }
         }
 
@@ -252,9 +251,9 @@ impl RegisterAllocator {
                 .insert(var_name.to_string(), Location::register(*source_reg));
             self.register_contents
                 .insert(*source_reg, var_name.to_string());
-            self.in_use.insert(*source_reg, true);
+            self.in_use[*source_reg as usize].1 = true;
 
-            return Vec::new();
+            return block;
         }
 
         // if current register isn't free, (eg is another variable) we assign somewhere
@@ -263,10 +262,11 @@ impl RegisterAllocator {
             self.variable_locations
                 .insert(var_name.to_string(), Location::register(free_reg));
             self.register_contents
-                .insert(free_reg.clone(), var_name.to_string());
+                .insert(free_reg, var_name.to_string());
-            self.in_use.insert(free_reg, true);
+            self.in_use[free_reg as usize].1 = true;
 
-            return vec![format!("\tmov {}, {}", source_reg, free_reg)];
+            block.push(Instruction::mov(*source_reg, free_reg));
+            return block;
         }
 
         // No free registers - allocate on stack
@@ -280,11 +280,8 @@ impl RegisterAllocator {
 
     /// spill a register to the stack (WITHOUT FREEING)
     /// DO NOT USE this if it's for a pointer!!!!
-    pub fn _spill_register(
+    pub fn _spill_register(&mut self, reg: &Register) -> Result<InsBlock, CompilerError> {
-        &mut self,
+        let mut code = InsBlock::new();
-        reg: &Register,
-    ) -> Result<Vec<String>, CompilerError> {
-        let mut code = Vec::new();
 
         // check if the variable is declared.
         if let Some(var_name) = self.register_contents.get(reg).cloned()
@@ -292,13 +289,10 @@ impl RegisterAllocator {
         {
             // check if var is on the stack
             if let Some(offset) = location.stack {
-                // ensure stack value is up to date with register value.
+                code.push(Instruction::stw_reg_offset(
-                code.push(format!(
+                    *reg,
-                    "\tstw {}, spr, {} // save var:{} offset:{}",
+                    Register::Spr,
-                    reg,
                     offset - self.stack_offset,
-                    var_name,
-                    offset
                 ));
                 return Ok(code);
             }
@@ -309,10 +303,7 @@ impl RegisterAllocator {
             // if the variable is not on the stack:
             // push register to stack (spr decrements automatically)
             let offset = self.stack_offset;
-            code.push(format!(
+            code.push(Instruction::push(*reg));
-                "\tpush {} // free var:{} offset:{}",
-                reg, var_name, offset
-            ));
 
             // Update variable location - it's now at current spr
             // Note: We track offset from bpr for consistency
@@ -332,9 +323,7 @@ impl RegisterAllocator {
     pub fn free_register(
         &mut self,
         reg: &Register,
-    ) -> Result<(i32, Vec<String>), CompilerError> {
+    ) -> Result<(i32, Instruction), CompilerError> {
-        let mut code = Vec::new();
-
         // check if the variable is declared.
         if let Some(var_name) = self.register_contents.get(reg).cloned()
             && let Some(location) = self.variable_locations.get_mut(&var_name)
@@ -342,13 +331,11 @@ impl RegisterAllocator {
             // check if var name is on the stack
             if let Some(offset) = location.stack {
                 // store current register value in stack location
-                code.push(format!(
+                let code = Instruction::stw_reg_offset(
-                    "\tstw {}, spr, {} // save var:{} offset:{}",
+                    *reg,
-                    reg,
+                    Register::Spr,
                     offset - self.stack_offset,
-                    var_name,
+                );
-                    offset
-                ));
 
                 // free the register.
                 location.register = None;
@@ -360,10 +347,7 @@ impl RegisterAllocator {
             self.stack_offset -= 4;
 
             let offset = self.stack_offset;
-            code.push(format!(
+            let code = Instruction::push(*reg);
-                "\tpush {} // free var:{} offset:{}",
-                reg, var_name, offset
-            ));
 
             // Update variable location
             // Note: We track offset from bpr for consistency
@@ -390,15 +374,15 @@ impl RegisterAllocator {
     }
 
     /// Spill all registers to stack (useful before function calls)
-    pub fn _spill_all(&mut self) -> Vec<String> {
+    pub fn _spill_all(&mut self) -> InsBlock {
-        let mut code = Vec::new();
+        let mut code = InsBlock::new();
 
         let regs_to_spill: Vec<Register> =
             self.register_contents.keys().cloned().collect();
 
         for reg in regs_to_spill {
             if let Ok(spill_code) = self.free_register(&reg) {
-                code.extend(spill_code.1);
+                code.push(spill_code.1);
             }
         }
 
@@ -443,59 +427,25 @@ impl RegisterAllocator {
         .collect();
     }
 
-    /// Mark a variable as dead (no longer needed)
-    /// Frees its register if it's in one
-    // pub fn _free_var(&mut self, var_name: &str) {
-    //     if let Some(Location::Register(reg)) = self.variable_locations.get(var_name) {
-    //         let reg = reg.clone();
-    //         self.register_contents.remove(&reg);
-    //         self.in_use.insert(reg, false);
-    //     }
-    //     self.variable_locations.remove(var_name);
-    // }
-
     /// Get list of registers that contain variables and are in use
     /// These need to be saved before function calls
     pub fn get_caller_saved_registers(&self) -> Vec<Register> {
         self.register_contents
             .iter()
-            .filter(|(reg, _)| *self.in_use.get(*reg).unwrap_or(&false))
+            .filter(|(reg, _)| {
-            .map(|(reg, _)| reg.clone())
+                self.in_use
+                    .get(**reg as usize)
+                    .unwrap_or(&(Register::Null, false))
+                    .1
+            })
+            .map(|(reg, _)| *reg)
             .collect()
     }
-
-    /// Save caller-saved registers before a function call
-    /// Returns assembly code to save them
-    pub fn _save_caller_saved(&mut self) -> Vec<String> {
-        let mut code = Vec::new();
-
-        // For simplicity, save all currently used registers
-        // In a more sophisticated compiler, you'd only save registers that are live
-        for (reg, _) in self.register_contents.clone() {
-            if *self.in_use.get(&reg).unwrap_or(&false) {
-                code.push(format!("\tpush {}", reg));
-            }
-        }
-
-        code
-    }
-
-    /// Restore caller-saved registers after a function call
-    /// Returns assembly code to restore them
-    pub fn _restore_caller_saved(&mut self, saved_regs: &[String]) -> Vec<String> {
-        let mut code = Vec::new();
-
-        // Restore in reverse order (LIFO)
-        for reg in saved_regs.iter().rev() {
-            code.push(format!("\tpop {}", reg));
-        }
-
-        code
-    }
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub enum Register {
+    // general purpose
     Rg0 = 0,
     Rg1 = 1,
     Rg2 = 2,
@@ -512,8 +462,68 @@ pub enum Register {
     Rgd = 13,
     Rge = 14,
     Rgf = 15,
-    Zero = 16,
+
-    Null = 17,
+    // special
+    Bpr,
+    Spr,
+    Ret,
+    Acc,
+
+    // read only
+    Pcx,
+    Zero,
+
+    // null
+    Null,
+}
+
+impl Register {
+    pub fn get_gp() -> [Register; 16] {
+        [
+            Register::Rg0,
+            Register::Rg1,
+            Register::Rg2,
+            Register::Rg3,
+            Register::Rg4,
+            Register::Rg5,
+            Register::Rg6,
+            Register::Rg7,
+            Register::Rg8,
+            Register::Rg9,
+            Register::Rga,
+            Register::Rgb,
+            Register::Rgc,
+            Register::Rgd,
+            Register::Rge,
+            Register::Rgf,
+        ]
+    }
+
+    pub fn is_gp(&self) -> bool {
+        (*self as u8) < 16
+    }
+
+    pub fn from_index(idx: usize) -> Register {
+        match idx {
+            0 => Register::Rg0,
+            1 => Register::Rg1,
+            2 => Register::Rg2,
+            3 => Register::Rg3,
+            4 => Register::Rg4,
+            5 => Register::Rg5,
+            6 => Register::Rg6,
+            7 => Register::Rg7,
+            8 => Register::Rg8,
+            9 => Register::Rg9,
+            10 => Register::Rga,
+            11 => Register::Rgb,
+            12 => Register::Rgc,
+            13 => Register::Rgd,
+            14 => Register::Rge,
+            15 => Register::Rgf,
+            _ => unreachable!("this function shouldn't ever be called with idx>15"),
+        }
+    }
 }
 
 impl fmt::Display for Register {
@@ -535,7 +545,15 @@ impl fmt::Display for Register {
             Self::Rgd => write!(f, "rgd"),
             Self::Rge => write!(f, "rge"),
             Self::Rgf => write!(f, "rgf"),
+
+            Self::Acc => write!(f, "acc"),
+            Self::Ret => write!(f, "ret"),
+            Self::Bpr => write!(f, "bpr"),
+            Self::Spr => write!(f, "spr"),
+
             Self::Zero => write!(f, "zero"),
+            Self::Pcx => write!(f, "pcx"),
+
             Self::Null => write!(f, "null"),
         }
     }

core/compiler/src/backend/dsa/scope.rs

@@ -0,0 +1,394 @@
+use std::{cell::RefCell, collections::HashMap, ops::Deref, rc::Rc};
+
+use crate::{
+    backend::dsa::{
+        instruction::{InsBlock, Instruction},
+        registers::{Register, RegisterAllocator},
+    },
+    error,
+    model::{CompilerError, Name, TypeId},
+};
+
+/// scope object
+pub struct Scope<'a> {
+    /// outer scope, for a function this will be the global scope.
+    parent: Option<&'a mut Scope<'a>>,
+    alloc: Rc<RefCell<Allocator>>,
+
+    /// is the scope a function body or just a loop?
+    /// depending on the type, ending a scope will have different behaviour
+    r#type: ScopeType,
+
+    /// variables
+    variables: HashMap<String, Variable>,
+
+    entry_stack_offset: i32,
+}
+
+impl<'a> Scope<'a> {
+    pub fn new() -> Scope<'a> {
+        let alloc = Rc::new(RefCell::new(Allocator::new()));
+        let entry_stack_offset = alloc.borrow().get_stack_offset();
+
+        Self {
+            alloc,
+            entry_stack_offset,
+            parent: None,
+            r#type: ScopeType::Function,
+            variables: HashMap::new(),
+        }
+    }
+
+    pub fn new_from(parent: &'a mut Scope<'a>, r#type: ScopeType) -> Scope<'a> {
+        let alloc = Rc::clone(&parent.alloc);
+        let entry_stack_offset = alloc.borrow().get_stack_offset();
+
+        Self {
+            alloc,
+            entry_stack_offset,
+            parent: Some(parent),
+            r#type,
+            variables: HashMap::new(),
+        }
+    }
+
+    pub fn create_var(
+        &mut self,
+        name: String,
+        r#type: TypeId,
+    ) -> Result<(), CompilerError> {
+        let mut var = Variable::new(name, r#type.clone());
+
+        if r#type.size() > 4 {
+            let slot = self.alloc.borrow_mut().allocate_stack_slot(r#type.size());
+            var.stack_slot = Some(slot);
+        } else {
+            let reg = self.alloc.borrow_mut().allocate_var()?;
+            var.register = Some(reg);
+        }
+
+        self.variables.insert(var.name.clone(), var);
+        Ok(())
+    }
+
+    pub fn alloc_temp(&mut self) -> Result<TempReg, CompilerError> {
+        self.alloc.borrow_mut().allocate_temp()
+    }
+
+    pub fn free_temp(&mut self, temp: &TempReg) {
+        self.alloc.borrow_mut().free_temp(temp)
+    }
+
+    pub fn free_var(&mut self, reg: &AssignedReg) {
+        self.alloc.borrow_mut().free_var(reg);
+    }
+
+    pub fn close(&mut self) {
+        // tell the allocator that this scope is closing
+        // this reverts the stack offset to what it was before this scope was created.
+        self.alloc.clone().borrow_mut().destroy_scope(self);
+
+        for var in self.variables.clone().values() {
+            if let Some(reg) = var.register {
+                self.free_var(&reg);
+            }
+        }
+    }
+
+    fn get_var(&mut self, var: &str) -> Option<&mut Variable> {
+        self.variables.get_mut(var)
+    }
+
+    pub fn offset_read(
+        &mut self,
+        var: &str,
+        offset: i32,
+    ) -> Result<(TempReg, Instruction), CompilerError> {
+        if let Some(var) = self.get_var(var) {
+            let slot = var.stack_slot.ok_or_else(|| {
+                error("Attempt to read from a var without a stack slot!")
+            })?;
+
+            return self.alloc.borrow_mut().offset_read(&slot, offset);
+        }
+
+        Err(CompilerError::Undefined(Name::new(var, None)))
+    }
+
+    pub fn offset_write(
+        &mut self,
+        reg: &TempReg,
+        var: &str,
+        offset: i32,
+    ) -> Result<Instruction, CompilerError> {
+        if let Some(var) = self.get_var(var) {
+            let slot = var.stack_slot.ok_or_else(|| {
+                error("Attempt to write to a var without a stack slot!")
+            })?;
+
+            return Ok(self.alloc.borrow_mut().offset_write(reg, &slot, offset));
+        }
+
+        Err(CompilerError::Undefined(Name::new(var, None)))
+    }
+
+    pub fn load_var(
+        &mut self,
+        var: &str,
+    ) -> Result<(AssignedReg, Instruction), CompilerError> {
+        if let Some(v) = self.get_var(var).cloned()
+            && let Some(slot) = v.stack_slot
+        {
+            let res = self.alloc.borrow_mut().load_var(&slot)?;
+            self.get_var(var).unwrap().register = Some(res.0);
+            return Ok(res);
+        }
+
+        panic!("e")
+    }
+
+    pub fn spill_var(&mut self, var: &str) -> Result<Instruction, CompilerError> {
+        if let Some(v) = self.get_var(var).cloned()
+            && let Some(rg) = v.register
+        {
+            let mut slot = v.stack_slot;
+            let res = self.alloc.borrow_mut().spill_var(&rg, &mut slot);
+            self.get_var(var).unwrap().stack_slot = slot;
+            return res;
+        }
+
+        Err(CompilerError::Undefined(Name::new(var, None)))
+    }
+}
+
+impl Drop for Scope<'_> {
+    fn drop(&mut self) {
+        self.close()
+    }
+}
+
+#[derive(PartialEq, Copy, Clone, Debug)]
+pub enum ScopeType {
+    Function,
+    IfBlock,
+    LoopBlock,
+}
+
+#[derive(Clone)]
+pub struct Variable {
+    pub name: String,
+
+    /// the type of the variable.
+    r#type: TypeId,
+
+    /// size taken up in bytes.
+    /// if size > 4, value must be stored on the stack.
+    pub size: usize,
+
+    pub stack_slot: Option<StackSlot>,
+    pub register: Option<AssignedReg>,
+}
+
+impl Variable {
+    pub fn new(name: String, r#type: TypeId) -> Self {
+        Self {
+            name,
+            size: r#type.size(),
+            r#type,
+            stack_slot: None,
+            register: None,
+        }
+    }
+}
+
+pub struct Allocator {
+    stack_offset: i32,
+    in_use: [(Register, bool); 16],
+}
+
+impl Allocator {
+    pub fn new() -> Self {
+        let mut in_use = [(Register::Null, false); 16];
+        in_use.copy_from_slice(&Register::get_gp().map(|r| (r, false))[0..16]);
+
+        Self {
+            stack_offset: 0,
+            in_use,
+        }
+    }
+
+    pub fn get_stack_offset(&self) -> i32 {
+        self.stack_offset
+    }
+
+    pub fn destroy_scope(&mut self, scope: &mut Scope) {
+        self.stack_offset = scope.entry_stack_offset;
+
+        for var in scope.variables.drain() {
+            if let Some(assigned) = var.1.register {
+                self.free_var(&assigned);
+            }
+        }
+    }
+
+    // what we need:
+
+    // - create var in register from temporary register. free temp and use it.
+    //
+    // - create var on stack from struct/array literal. return stack offset to write to.
+    //
+    // - spill var from register to stack. return stack offset to write to.
+    //
+    // - read/write var from stack+offset into register to use while preserving the stack
+    //   slot.
+    //
+    // - read / write bytes from the stack+offset in a larger variable into a register.
+
+    pub fn offset_read(
+        &mut self,
+        slot: &StackSlot,
+        offset: i32,
+    ) -> Result<(TempReg, Instruction), CompilerError> {
+        let register = self.allocate_temp()?;
+
+        // instruction: reg = *(&var + offset)
+        Ok((
+            register.clone(),
+            Instruction::ldw_reg_offset(
+                Register::Spr,
+                *register,
+                (**slot + offset) - self.stack_offset,
+            ),
+        ))
+    }
+
+    pub fn offset_write(
+        &mut self,
+        reg: &TempReg,
+        slot: &StackSlot,
+        offset: i32,
+    ) -> Instruction {
+        // instruction: *(&var + offset) = reg
+        Instruction::stw_reg_offset(
+            **reg,
+            Register::Spr,
+            (**slot + offset) - self.stack_offset,
+        )
+    }
+
+    pub fn load_var(
+        &mut self,
+        slot: &StackSlot,
+    ) -> Result<(AssignedReg, Instruction), CompilerError> {
+        let reg = self.allocate_var()?;
+
+        Ok((
+            reg.clone(),
+            Instruction::ldw_reg_offset(Register::Spr, *reg, **slot - self.stack_offset),
+        ))
+    }
+
+    pub fn spill_var(
+        &mut self,
+        reg: &AssignedReg,
+        slot: &mut Option<StackSlot>,
+        // var: &mut Variable,
+    ) -> Result<Instruction, CompilerError> {
+        if let Some(slot) = &slot {
+            let block = Instruction::stw_reg_offset(
+                **reg,
+                Register::Spr,
+                **slot - self.stack_offset,
+            );
+
+            self.free_var(reg);
+            return Ok(block);
+        }
+
+        // var doesn't have a stack slot so we need to create one
+        let new_slot = self.allocate_stack_slot(4); // alloc 4 bytes for reg value.
+        let block = Instruction::push(**reg);
+
+        self.free_var(reg);
+        *slot = Some(new_slot);
+        Ok(block)
+    }
+
+    pub fn allocate_stack_slot(&mut self, size: usize) -> StackSlot {
+        self.stack_offset -= size as i32;
+        let offset = self.stack_offset;
+        StackSlot(offset)
+    }
+
+    pub fn allocate_var(&mut self) -> Result<AssignedReg, CompilerError> {
+        if let Some(reg) = self.find_free_register() {
+            Ok(AssignedReg(reg))
+        } else {
+            Err(CompilerError::Generic(
+                "No free registers available".to_string(),
+            ))
+        }
+    }
+
+    pub fn allocate_temp(&mut self) -> Result<TempReg, CompilerError> {
+        // allocates a temporary register
+        if let Some(reg) = self.find_free_register() {
+            Ok(TempReg(reg))
+        } else {
+            todo!("an efficient stack spilling algorithm. needs scope awareness.");
+        }
+    }
+
+    pub fn free_temp(&mut self, temp: &TempReg) {
+        // frees a temporary register.
+        self.in_use[**temp as usize].1 = false;
+    }
+
+    pub fn free_var(&mut self, reg: &AssignedReg) {
+        // frees a register.
+        self.in_use[**reg as usize].1 = false;
+    }
+
+    // if we have register(s) free, return the first one.
+    fn find_free_register(&mut self) -> Option<Register> {
+        self.in_use.iter_mut().find_map(|(reg, used)| {
+            if !*used {
+                *used = true;
+                Some(*reg)
+            } else {
+                None
+            }
+        })
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct TempReg(Register);
+#[derive(Clone, Copy, Debug)]
+pub struct AssignedReg(Register);
+#[derive(Clone, Copy, Debug)]
+pub struct StackSlot(i32);
+
+impl Deref for TempReg {
+    type Target = Register;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl Deref for AssignedReg {
+    type Target = Register;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl Deref for StackSlot {
+    type Target = i32;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}

core/compiler/src/backend/mod.rs

@@ -2,9 +2,13 @@ use crate::model::{CompilerError, Program};
 
 mod dsa;
 
-pub fn compiler_backend(ext: &str, ast: &Program) -> Result<String, CompilerError> {
+pub fn compiler_backend(
+    ext: &str,
+    ast: &Program,
+    is_lib: bool,
+) -> Result<String, CompilerError> {
     match ext {
-        "dsa" => Ok(dsa::generate_code(ast)?),
+        "dsa" => Ok(dsa::generate_code(ast, is_lib)?),
         _ => Err(CompilerError::Generic(format!(
             "File type {} not supported",
             ext

core/compiler/src/frontend/dsc/lexer.rs

@@ -18,12 +18,14 @@ pub enum Token {
     Const,
     As,
     SizeOf,
+    Struct,
 
     // Identifiers and literals
     Identifier(Name),
     String(String),
-    Integer(u64),
     Char(char),
+    SignedInt(i32, Option<TypeId>),
+    UnsignedInt(u32, Option<TypeId>),
 
     // Delimiters
     LeftParen,    // (
@@ -85,7 +87,7 @@ pub enum Token {
     Eof,
 }
 
-use crate::model::Name;
+use crate::model::{Name, TypeId};
 use std::fmt;
 
 impl fmt::Display for Name {
@@ -104,6 +106,7 @@ impl Token {
             Token::Const => "Const",
             Token::Static => "Static",
             Token::Include => "Include",
+            Token::Struct => "Struct",
             Token::Fn => "Fn",
             Token::If => "If",
             Token::Let => "Let",
@@ -116,7 +119,8 @@ impl Token {
             Token::As => "As",
             Token::Identifier(_) => "Identifier",
             Token::String(_) => "String",
-            Token::Integer(_) => "UnsignedInt",
+            Token::UnsignedInt(_, _) => "UnsignedInt",
+            Token::SignedInt(_, _) => "SignedInt",
             Token::Char(_) => "Char",
             Token::LeftParen => "LeftParen",
             Token::RightParen => "RightParen",
@@ -376,6 +380,7 @@ impl<'a> Lexer<'a> {
             "static" => Some(Token::Static),
             "as" => Some(Token::As),
             "sizeof" => Some(Token::SizeOf),
+            "struct" => Some(Token::Struct),
             _ => None,
         }
     }
@@ -385,8 +390,126 @@ impl<'a> Lexer<'a> {
     // ========================================================================
 
     fn scan_number(&mut self) -> Token {
+        // Check if number is negative
+        let is_negative = self.current == Some('-');
+        if is_negative {
+            self.advance(); // consume '-'
+        }
+
         match self.read_number() {
-            Ok(num) => Token::Integer(num),
+            Ok((value, type_suffix)) => {
+                // Validate and construct appropriate token
+                if let Some(type_id) = type_suffix {
+                    match type_id {
+                        TypeId::I8 => {
+                            let signed_val = if is_negative {
+                                -(value as i32)
+                            } else {
+                                value as i32
+                            };
+                            if signed_val < i8::MIN as i32 || signed_val > i8::MAX as i32
+                            {
+                                self.error(&format!(
+                                    "Value {} out of range for i8",
+                                    signed_val
+                                ));
+                                return Token::SignedInt(0, Some(TypeId::I8));
+                            }
+                            Token::SignedInt(signed_val, Some(TypeId::I8))
+                        }
+                        TypeId::I16 => {
+                            let signed_val = if is_negative {
+                                -(value as i32)
+                            } else {
+                                value as i32
+                            };
+                            if signed_val < i16::MIN as i32
+                                || signed_val > i16::MAX as i32
+                            {
+                                self.error(&format!(
+                                    "Value {} out of range for i16",
+                                    signed_val
+                                ));
+                                return Token::SignedInt(0, Some(TypeId::I16));
+                            }
+                            Token::SignedInt(signed_val, Some(TypeId::I16))
+                        }
+                        TypeId::I32 => {
+                            let signed_val = if is_negative {
+                                if value > i32::MAX as u64 + 1 {
+                                    self.error(&format!(
+                                        "Value -{} out of range for i32",
+                                        value
+                                    ));
+                                    return Token::SignedInt(0, Some(TypeId::I32));
+                                }
+                                -(value as i32)
+                            } else {
+                                if value > i32::MAX as u64 {
+                                    self.error(&format!(
+                                        "Value {} out of range for i32",
+                                        value
+                                    ));
+                                    return Token::SignedInt(0, Some(TypeId::I32));
+                                }
+                                value as i32
+                            };
+                            Token::SignedInt(signed_val, Some(TypeId::I32))
+                        }
+                        TypeId::U8 => {
+                            if is_negative {
+                                self.error("Unsigned type u8 cannot be negative");
+                                return Token::UnsignedInt(0, Some(TypeId::U8));
+                            }
+                            if value > u8::MAX as u64 {
+                                self.error(&format!(
+                                    "Value {} out of range for u8",
+                                    value
+                                ));
+                                return Token::UnsignedInt(0, Some(TypeId::U8));
+                            }
+                            Token::UnsignedInt(value as u32, Some(TypeId::U8))
+                        }
+                        TypeId::U16 => {
+                            if is_negative {
+                                self.error("Unsigned type u16 cannot be negative");
+                                return Token::UnsignedInt(0, Some(TypeId::U16));
+                            }
+                            if value > u16::MAX as u64 {
+                                self.error(&format!(
+                                    "Value {} out of range for u16",
+                                    value
+                                ));
+                                return Token::UnsignedInt(0, Some(TypeId::U16));
+                            }
+                            Token::UnsignedInt(value as u32, Some(TypeId::U16))
+                        }
+                        TypeId::U32 => {
+                            if is_negative {
+                                self.error("Unsigned type u32 cannot be negative");
+                                return Token::UnsignedInt(0, Some(TypeId::U32));
+                            }
+                            if value > u32::MAX as u64 {
+                                self.error(&format!(
+                                    "Value {} out of range for u32",
+                                    value
+                                ));
+                                return Token::UnsignedInt(0, Some(TypeId::U32));
+                            }
+                            Token::UnsignedInt(value as u32, Some(TypeId::U32))
+                        }
+                        _ => unreachable!(),
+                    }
+                } else {
+                    // No type suffix - decide based on sign
+                    if is_negative {
+                        let signed_val = -(value as i32);
+                        Token::SignedInt(signed_val, None)
+                    } else {
+                        Token::UnsignedInt(value as u32, None)
+                    }
+                }
+            }
             Err(e) => {
                 self.error(&e);
                 // Skip the invalid number
@@ -396,31 +519,66 @@ impl<'a> Lexer<'a> {
                     }
                     self.advance();
                 }
-                Token::Integer(0)
+                Token::SignedInt(0, None)
             }
         }
     }
 
-    fn read_number(&mut self) -> Result<u64, String> {
+    fn read_number(&mut self) -> Result<(u64, Option<TypeId>), String> {
         // Check for hex (0x) or binary (0b) prefix
         if self.current == Some('0') {
             match self.peek() {
                 Some('x') | Some('X') => {
                     self.advance(); // consume '0'
                     self.advance(); // consume 'x'
-                    return self.read_hex_number();
+                    let value = self.read_hex_number()?;
+                    let type_suffix = self.read_type_suffix()?;
+                    return Ok((value, type_suffix));
                 }
                 Some('b') | Some('B') => {
                     self.advance(); // consume '0'
                     self.advance(); // consume 'b'
-                    return self.read_binary_number();
+                    let value = self.read_binary_number()?;
+                    let type_suffix = self.read_type_suffix()?;
+                    return Ok((value, type_suffix));
                 }
                 _ => {}
             }
         }
 
         // Read decimal number
-        self.read_decimal_number()
+        let value = self.read_decimal_number()?;
+        let type_suffix = self.read_type_suffix()?;
+        Ok((value, type_suffix))
+    }
+
+    fn read_type_suffix(&mut self) -> Result<Option<TypeId>, String> {
+        // Check for type suffix like _i32, _u8, etc.
+        if self.peek() == Some('_') {
+            self.advance(); // consume '_'
+
+            let mut suffix = String::new();
+            while let Some(c) = self.peek() {
+                if c.is_ascii_alphanumeric() {
+                    self.advance();
+                    suffix.push(c);
+                } else {
+                    break;
+                }
+            }
+
+            match suffix.as_str() {
+                "i8" => Ok(Some(TypeId::I8)),
+                "i16" => Ok(Some(TypeId::I16)),
+                "i32" => Ok(Some(TypeId::I32)),
+                "u8" => Ok(Some(TypeId::U8)),
+                "u16" => Ok(Some(TypeId::U16)),
+                "u32" => Ok(Some(TypeId::U32)),
+                _ => Err(format!("Invalid type suffix: {}", suffix)),
+            }
+        } else {
+            Ok(None)
+        }
     }
 
     fn read_decimal_number(&mut self) -> Result<u64, String> {
@@ -434,8 +592,9 @@ impl<'a> Lexer<'a> {
             if c.is_ascii_digit() {
                 self.advance();
                 num_str.push(c);
-            } else if c == '_' {
+            } else if c == '_' && self.peek_second().is_some_and(|ch| ch.is_ascii_digit())
-                // Allow underscores as separators (like Rust)
+            {
+                // Allow underscores as separators only between digits
                 self.advance();
             } else {
                 break;
@@ -451,10 +610,11 @@ impl<'a> Lexer<'a> {
         let mut num_str = String::new();
 
         // Read the first hex digit (current character)
-        if let Some(c) = self.current {
+        match self.current {
-            if c.is_ascii_hexdigit() {
+            Some(c) if c.is_ascii_hexdigit() => {
                 num_str.push(c);
             }
+            _ => (),
         }
 
         while let Some(c) = self.peek() {
@@ -480,10 +640,11 @@ impl<'a> Lexer<'a> {
         let mut num_str = String::new();
 
         // Read the first binary digit (current character)
-        if let Some(c) = self.current {
+        match self.current {
-            if c == '0' || c == '1' {
+            Some(c) if c == '0' || c == '1' => {
                 num_str.push(c);
             }
+            _ => (),
         }
 
         while let Some(c) = self.peek() {
@@ -880,17 +1041,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_numbers() {
-        let input = "42 0x2A 0b101010 123_456";
-        let mut lexer = Lexer::new(input);
-
-        assert_eq!(lexer.next_token(), Token::Integer(42));
-        assert_eq!(lexer.next_token(), Token::Integer(42));
-        assert_eq!(lexer.next_token(), Token::Integer(42));
-        assert_eq!(lexer.next_token(), Token::Integer(123456));
-    }
-
     #[test]
     fn test_namespaced_identifier() {
         let input = "print::println std::io::read";

core/compiler/src/frontend/dsc/mod.rs

@@ -1,6 +1,5 @@
-use common::logging::log;
-
 use crate::model::{CompilerError, Program};
+use common::logging::Logger;
 use parser::{ParseResult, Parser};
 // use semantic_analyser::Analyser;
 
@@ -8,14 +7,15 @@ pub mod lexer;
 pub mod parser;
 // pub mod semantic_analyser;
 
-pub fn generate_ast(input: &str) -> Result<Program, CompilerError> {
+pub fn generate_ast(input: &str, logger: &Logger) -> Result<Program, CompilerError> {
-    log("Tokenising Input...");
+    logger.info("Tokenising Input...");
 
     let lexer = lexer::Lexer::new(&input);
     let tokens = lexer.collect::<Vec<_>>();
-    // println!("{tokens:?}");
 
-    log(&format!("Parsing {} Tokens...", tokens.len()));
+    // println!("{tokens:#?}");
+
+    logger.info(&format!("Parsing {} Tokens...", tokens.len()));
 
     let mut parser = Parser::new(tokens);
     let ast = match parser.parse() {
@@ -27,12 +27,12 @@ pub fn generate_ast(input: &str) -> Result<Program, CompilerError> {
     };
     // println!("{ast:#?}");
 
-    log("Analyzing AST...");
+    logger.info("Analyzing AST...");
-    log("Checking Type Information...");
+    logger.info("Checking Type Information...");
 
     // let mut analyser = Analyser::new();
     // analyser.analyse(ast.clone()).unwrap();
 
-    log("Type Checking Complete...");
+    logger.info("Type Checking Complete...");
     Ok(ast)
 }

core/compiler/src/frontend/dsc/parser.rs

@@ -1,8 +1,8 @@
 use super::lexer::Token;
 use crate::model::{
     AssignmentOperator, BinaryOperator, Block, Call, CompilerError, ConstExpr,
-    Declaration, Dependency, Expression, Program, Statement, TypeId, UnaryOperator,
+    Declaration, Dependency, Expression, Number, Program, Statement, TypeId,
-    Variable,
+    UnaryOperator, Variable,
 };
 use crate::{expect_tt, expect_value};
 use std::ops::{ControlFlow, FromResidual, Try};
@@ -39,6 +39,10 @@ impl Parser {
             return self.parse_func();
         }
 
+        if expect_tt!(self.peek_next()?, Struct).accepted() {
+            return self.parse_struct();
+        }
+
         if expect_tt!(self.peek_next()?, Include).accepted() {
             // expect include keyword
             let _ = self.next();
@@ -79,7 +83,8 @@ impl Parser {
             let value = self.next()?;
             let init = match value {
                 Token::String(x) => Some(ConstExpr::String(x)),
-                Token::Integer(x) => Some(ConstExpr::Number(x as i32)),
+                Token::SignedInt(x, _) => Some(ConstExpr::Number(x)),
+                Token::UnsignedInt(x, _) => Some(ConstExpr::Number(x as i32)),
                 _ => {
                     return ParseResult::Reject(CompilerError::UnexpectedToken(
                         value.tt().to_string(),
@@ -99,6 +104,28 @@ impl Parser {
         ParseResult::Reject(CompilerError::UnexpectedEndOfInput)
     }
 
+    fn parse_struct(&mut self) -> ParseResult<Declaration, CompilerError> {
+        let _ = expect_tt!(self.next()?, Struct)?;
+        let name = expect_value!(self.next()?, Identifier)?;
+
+        let _ = expect_tt!(self.next()?, LeftBrace)?;
+
+        let mut fields = Vec::new();
+        while expect_tt!(self.peek_next()?, Identifier).accepted() {
+            let arg = self.parse_var_decl()?;
+            fields.push(arg);
+
+            if expect_tt!(self.peek_next()?, Comma).accepted() {
+                self.next()?;
+            } else {
+                break;
+            }
+        }
+
+        let _ = expect_tt!(self.next()?, RightBrace)?;
+        ParseResult::Accept(Declaration::Struct { name, fields })
+    }
+
     fn parse_func(&mut self) -> ParseResult<Declaration, CompilerError> {
         // expect function keyword
         let _ = expect_tt!(self.next()?, Fn);
@@ -318,18 +345,28 @@ impl Parser {
             });
         }
 
-        // handle assignment without "let"
+        // handle an in-place function call
-        let name = expect_value!(self.peek_next()?, Identifier);
+        if let ParseResult::Accept(name) = expect_value!(self.peek_next()?, Identifier)
-        if name.accepted() {
+            && let ParseResult::Accept(operator) = expect_tt!(
-            let varname = name?;
+                self.peek(1)?,
-            if expect_tt!(self.peek(1)?, LeftParen).accepted() {
+                Assign,
-                let expr = self.parse_expression()?; // a function call expr
+                PlusEqual,
-                let _ = expect_tt!(self.next()?, Semicolon)?;
+                MinusEqual,
-                return ParseResult::Accept(Statement::Expression { expr });
+                StarEqual,
-            }
+                SlashEqual,
-
+                PercentEqual,
+                AndEqual,
+                OrEqual,
+                XorEqual,
+                ShlEqual,
+                ShrEqual
+            )
+        {
+            // consume name token
             self.next()?;
-            let operator = match self.peek_next()? {
+
+            // pattern match to find operator
+            let operator = match operator {
                 Token::Assign => AssignmentOperator::Assign,
                 Token::PlusEqual => AssignmentOperator::AddAssign,
                 Token::MinusEqual => AssignmentOperator::SubAssign,
@@ -348,6 +385,7 @@ impl Parser {
                 }
             };
 
+            // consume operator token
             self.next()?;
 
             let value = self.parse_expression()?;
@@ -355,15 +393,17 @@ impl Parser {
             let _ = expect_tt!(self.next()?, Semicolon);
 
             return ParseResult::Accept(Statement::Assign {
-                varname: varname.name,
+                varname: name.name,
                 operator,
                 value,
             });
         }
 
-        ParseResult::Reject(CompilerError::UnexpectedToken(
+        // parse an expression and a semicolon
-            self.peek_next()?.tt().to_string(),
+        let expr = self.parse_expression()?;
-        ))
+        let _ = expect_tt!(self.next()?, Semicolon)?;
+
+        ParseResult::Accept(Statement::Expression { expr })
     }
 
     fn parse_expression(&mut self) -> ParseResult<Expression, CompilerError> {
@@ -374,7 +414,7 @@ impl Parser {
         let left = self.parse_logical_and()?;
 
         let op = match self.peek_next()? {
-            Token::Ampersand => BinaryOperator::LogicalOr,
+            Token::LogicalOr => BinaryOperator::LogicalOr,
             _ => return ParseResult::Accept(left),
         };
 
@@ -391,7 +431,7 @@ impl Parser {
         let left = self.parse_bitwise_or()?;
 
         let op = match self.peek_next()? {
-            Token::Ampersand => BinaryOperator::LogicalAnd,
+            Token::LogicalAnd => BinaryOperator::LogicalAnd,
             _ => return ParseResult::Accept(left),
         };
 
@@ -408,7 +448,7 @@ impl Parser {
         let left = self.parse_bitwise_xor()?;
 
         let op = match self.peek_next()? {
-            Token::Ampersand => BinaryOperator::BitwiseOr,
+            Token::Pipe => BinaryOperator::BitwiseOr,
             _ => return ParseResult::Accept(left),
         };
 
@@ -425,7 +465,7 @@ impl Parser {
         let left = self.parse_bitwise_and()?;
 
         let op = match self.peek_next()? {
-            Token::Ampersand => BinaryOperator::BitwiseXor,
+            Token::Caret => BinaryOperator::BitwiseXor,
             _ => return ParseResult::Accept(left),
         };
 
@@ -660,12 +700,13 @@ impl Parser {
 
     fn parse_primary(&mut self) -> ParseResult<Expression, CompilerError> {
         match self.peek_next()? {
-            Token::Integer(value) => {
+            Token::UnsignedInt(value, type_id) => {
                 self.next()?;
-                ParseResult::Accept(Expression::Number {
+                ParseResult::Accept(Expression::Number(Number::Unsigned(value, type_id)))
-                    value: value as isize,
+            }
-                    type_id: None,
+            Token::SignedInt(value, type_id) => {
-                })
+                self.next()?;
+                ParseResult::Accept(Expression::Number(Number::Signed(value, type_id)))
             }
             Token::String(value) => {
                 self.next()?;
@@ -678,10 +719,45 @@ impl Parser {
 
             Token::Identifier(name) => {
                 self.next()?;
+
+                // if the next token isn't the beginning of a struct literal this is just
+                // an identifier.
+                // if !expect_tt!(self.peek_next()?, LeftBrace).accepted() {
+                //     return ParseResult::Accept(Expression::Variable {
+                //         name,
+                //         expr_type: None,
+                //     });
+                // }
+                //
                 ParseResult::Accept(Expression::Variable {
                     name,
                     expr_type: None,
                 })
+
+                // let _ = self.next()?;
+
+                // let mut fields = Vec::new();
+                // while !expect_tt!(self.peek_next()?, RightBrace).accepted() {
+                //     let name = expect_value!(self.next()?, Identifier)?;
+                //     let _ = expect_tt!(self.next()?, Colon)?;
+                //     let expr = self.parse_expression()?;
+
+                //     fields.push((name, expr));
+
+                //     if expect_tt!(self.peek_next()?, Comma).accepted() {
+                //         self.next()?;
+                //     } else {
+                //         break;
+                //     }
+                // }
+
+                // let _ = expect_tt!(self.next()?, RightBrace)?;
+
+                // ParseResult::Accept(Expression::StructLiteral {
+                //     name,
+                //     fields,
+                //     type_id: None,
+                // })
             }
             Token::LeftBracket => {
                 self.next()?; // consume '['
@@ -729,21 +805,86 @@ impl Parser {
     }
 
     fn parse_type(&mut self) -> ParseResult<TypeId, CompilerError> {
-        // get the type name incl namespace
+        // parse primitive or named type
-        let typename = expect_value!(self.next()?, Identifier)?;
+        if expect_tt!(self.peek_next()?, Identifier).accepted() {
-
+            return self.parse_type_identifier();
-        match typename.name.as_str() {
-            "u32" => ParseResult::Accept(TypeId::U32),
-            "u16" => ParseResult::Accept(TypeId::U16),
-            "u8" => ParseResult::Accept(TypeId::U8),
-            "i32" => ParseResult::Accept(TypeId::I32),
-            "i16" => ParseResult::Accept(TypeId::I16),
-            "i8" => ParseResult::Accept(TypeId::I8),
-            "void" => ParseResult::Accept(TypeId::Void),
-            "char" => ParseResult::Accept(TypeId::Char),
-            "str" => ParseResult::Accept(TypeId::Ptr(Box::new(TypeId::Char))),
-            _ => todo!("Implement parsing for other types!!"),
         }
+
+        // parse array type
+        if expect_tt!(self.peek_next()?, LeftBracket).accepted() {
+            let _ = self.next()?;
+
+            let internal_type = self.parse_type()?;
+            let _ = expect_tt!(self.next()?, Semicolon)?;
+
+            let size = expect_value!(self.next()?, UnsignedInt)?;
+
+            let _ = expect_tt!(self.next()?, RightBracket)?;
+
+            return ParseResult::Accept(TypeId::Array {
+                r#type: Box::new(internal_type),
+                size: size as usize,
+            });
+        }
+
+        // parse tuple type
+        if expect_tt!(self.peek_next()?, LeftParen).accepted() {
+            let _ = self.next()?;
+
+            let mut types = Vec::new();
+            while !expect_tt!(self.peek_next()?, RightParen).accepted() {
+                types.push(self.parse_type()?);
+                if !expect_tt!(self.peek_next()?, Comma).accepted() {
+                    break;
+                }
+                let _ = self.next()?;
+            }
+            let _ = expect_tt!(self.next()?, RightParen)?;
+
+            return ParseResult::Accept(TypeId::Tuple(types));
+        }
+
+        ParseResult::Reject(CompilerError::Generic(format!(
+            "Parsing type but no valid type was detected: {:?}",
+            self.peek_next()?
+        )))
+    }
+
+    fn parse_type_identifier(&mut self) -> ParseResult<TypeId, CompilerError> {
+        // get the type name incl namespace
+        let name = expect_value!(self.next()?, Identifier)?;
+
+        let type_id = match name.name.as_str() {
+            "u32" => TypeId::U32,
+            "u16" => TypeId::U16,
+            "u8" => TypeId::U8,
+            "i32" => TypeId::I32,
+            "i16" => TypeId::I16,
+            "i8" => TypeId::I8,
+            "void" => TypeId::Void,
+            "char" => TypeId::Char,
+            "str" => TypeId::Ptr(Box::new(TypeId::Char)),
+            _ => {
+                let mut generics = Vec::new();
+                if expect_tt!(self.peek_next()?, Less).accepted() {
+                    let _ = self.next()?;
+
+                    // loop until we find the closing '>'
+                    while !expect_tt!(self.peek_next()?, Greater).accepted() {
+                        generics.push(self.parse_type()?);
+                        if !expect_tt!(self.peek_next()?, Comma).accepted() {
+                            break;
+                        }
+                        let _ = self.next()?;
+                    }
+                    let _ = expect_tt!(self.next()?, Greater)?;
+                }
+
+                TypeId::UnknownCustom { name, generics }
+            }
+        };
+
+        ParseResult::Accept(type_id)
     }
 
     fn next(&mut self) -> ParseResult<Token, CompilerError> {
@@ -840,7 +981,7 @@ macro_rules! expect_value {
     ($expr:expr, $variant:ident) => {{
         let tok = $expr;
         match tok.clone() {
-            Token::$variant(value) => ParseResult::Accept(value),
+            Token::$variant(first, ..) => ParseResult::Accept(first),
             _ => {
                 ParseResult::Reject(CompilerError::UnexpectedToken(tok.tt().to_string()))
             }

core/compiler/src/frontend/mod.rs

@@ -1,11 +1,17 @@
+use common::logging::Logger;
+
 use crate::model::{CompilerError, Program};
 
 // mod c;
 mod dsc;
 
-pub fn compiler_frontend(ext: &str, data: &str) -> Result<Program, CompilerError> {
+pub fn compiler_frontend(
+    ext: &str,
+    data: &str,
+    logger: &Logger,
+) -> Result<Program, CompilerError> {
     match ext {
-        "dsc" => Ok(dsc::generate_ast(&data)?),
+        "dsc" => Ok(dsc::generate_ast(&data, &logger)?),
         // "c" => Ok(c::generate_ast(&data)?),
         _ => Err(CompilerError::Generic(format!(
             "File type {} not supported",

core/compiler/src/lib.rs

@@ -0,0 +1,94 @@
+#![feature(try_trait_v2)]
+
+use std::path::{Path, PathBuf};
+
+use common::{
+    build::{BuildError, Builder},
+    logging::LogReceiver,
+};
+
+use crate::{model::CompilerError, specialised::build_specialised};
+
+mod backend;
+mod frontend;
+mod model;
+mod specialised;
+
+pub struct Compiler {
+    src_path: PathBuf,
+    result: Option<Result<String, BuildError>>,
+    logger: LogReceiver,
+}
+
+impl Compiler {
+    fn build(&mut self, is_lib: bool) -> Result<String, Box<dyn std::error::Error>> {
+        let input =
+            std::fs::read_to_string(&self.src_path).expect("Failed to read input file");
+
+        let input_ext = self
+            .src_path
+            .extension()
+            .and_then(|s| s.to_str())
+            .unwrap_or("");
+
+        // check if we're using a specialised compiler
+        if let Some(output) = build_specialised(input_ext, &input) {
+            return output.map_err(|err| format!("Compilation failed: {err:?}").into());
+        }
+
+        // Parse the input using the frontend, providing the file extension and data.
+        let ast =
+            match frontend::compiler_frontend(input_ext, &input, &self.logger.logger()) {
+                Ok(ast) => ast,
+                Err(err) => return Err(format!("Compilation failed: {err:?}").into()),
+            };
+
+        // println!("Parsed AST: {:#?}", ast);
+
+        // Generate the output using the backend with the parsed result.
+        let result = match backend::compiler_backend("dsa", &ast, is_lib) {
+            Ok(result) => result,
+            Err(err) => return Err(format!("Compilation failed: {err:?}").into()),
+        };
+
+        Ok(result)
+    }
+}
+
+impl Builder for Compiler {
+    type Output = String;
+    type Args = bool;
+
+    fn new(src_path: impl Into<PathBuf>) -> Self {
+        Self {
+            src_path: src_path.into(),
+            result: None,
+            logger: LogReceiver::new(true),
+        }
+    }
+
+    fn start(&mut self, args: bool) {
+        match self.build(args) {
+            Ok(x) => self.result = Some(Ok(x)),
+            Err(err) => self.result = Some(Err(err.into())),
+        }
+    }
+
+    fn poll(&mut self) -> Option<Result<Self::Output, BuildError>> {
+        self.result.take()
+    }
+
+    fn output(&mut self) -> Result<Self::Output, BuildError> {
+        self.result.clone().ok_or(BuildError::Generic(String::from(
+            "Compiler was never started",
+        )))?
+    }
+
+    fn logs(&self) -> Vec<String> {
+        todo!()
+    }
+}
+
+pub fn error(msg: impl Into<String>) -> CompilerError {
+    CompilerError::Generic(msg.into())
+}

core/compiler/src/main.rs

@@ -0,0 +1,35 @@
+use std::path::{Path, PathBuf};
+
+use common::{build::Builder, logging::info};
+use compiler::Compiler;
+
+fn main() {
+    // read from input file: syntax "c_compiler <src.c> [output.dsa]"
+    let args: Vec<String> = std::env::args().collect();
+    if args.len() < 2 {
+        eprintln!("Usage: c_compiler [--lib | --bin] <src.dsc> [output.dsa]");
+        return;
+    }
+
+    let input_file = &args[1];
+    let output_file = if args.len() > 2 {
+        &args[2]
+    } else {
+        "output.dsa"
+    };
+
+    {
+        let is_lib = args.contains(&"--lib".to_string());
+
+        let mut builder = Compiler::new(PathBuf::from(input_file));
+        builder.start(is_lib);
+        let result = builder.output().unwrap();
+
+        std::fs::write(output_file, &result).expect("Failed to write output");
+
+        info(&format!(
+            "Compilation Successful ✅ \n\tSource: {}\n\tOutput: {}\n",
+            input_file, output_file,
+        ));
+    }
+}

core/compiler/src/model.rs

@@ -1,5 +1,7 @@
 use core::fmt;
 
+use common::build::BuildError;
+
 #[allow(unused)]
 #[derive(Debug, Clone)]
 pub enum CompilerError {
@@ -14,11 +16,25 @@ pub enum CompilerError {
     Unimplemented(String),
 }
 
+impl From<CompilerError> for BuildError {
+    fn from(err: CompilerError) -> Self {
+        BuildError::Generic(format!("{:?}", err))
+    }
+}
+
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct Name {
     pub name: String,
     pub namespace: Option<String>,
 }
+impl Name {
+    pub fn new(name: impl Into<String>, namespace: Option<String>) -> Self {
+        Self {
+            name: name.into(),
+            namespace,
+        }
+    }
+}
 
 #[derive(Debug, Clone)]
 pub struct Program {
@@ -40,6 +56,10 @@ pub enum Declaration {
         is_const: bool,
     },
     Dependency(Dependency),
+    Struct {
+        name: Name,
+        fields: Vec<Variable>,
+    },
 }
 
 #[derive(Debug, Clone)]
@@ -62,8 +82,20 @@ pub enum TypeId {
     Void,
     Ptr(Box<TypeId>),
     Ref(Box<TypeId>),
-    Array(Box<TypeId>, usize),
+    Tuple(Vec<TypeId>),
-    Struct { name: Name, fields: Vec<TypeId> },
+    Array {
+        r#type: Box<TypeId>,
+        size: usize,
+    },
+    UnknownCustom {
+        name: Name,
+        generics: Vec<TypeId>,
+    },
+    Struct {
+        name: Name,
+        fields: Vec<TypeId>,
+        generics: Vec<TypeId>,
+    },
 }
 
 impl TypeId {
@@ -80,7 +112,10 @@ impl TypeId {
             Self::Void => 0,
             Self::Ptr(t) => t.size(),
             Self::Ref(t) => t.size(),
-            Self::Array(t, size) => t.size() * size,
+            Self::Tuple(types) => types.iter().map(|t| t.size()).sum(),
+            Self::Array { r#type, size } => r#type.size() * size,
+            Self::UnknownCustom { .. } => 1, /* TODO: calculate type size during */
+            // semantic analysis
             Self::Struct { fields, .. } => fields.iter().map(|t| t.size()).sum(),
         }
     }
@@ -100,14 +135,47 @@ impl fmt::Display for TypeId {
             Self::Void => write!(f, "void"),
             Self::Ptr(t) => write!(f, "*{}", t),
             Self::Ref(t) => write!(f, "&{}", t),
-            Self::Array(t, len) => write!(f, "[{}; {}]", t, len),
+            Self::Tuple(elems) => write!(
-            Self::Struct { name, fields } => {
+                f,
-                write!(f, "struct {} {{", name)?;
+                "({})",
-                for (i, field) in fields.iter().enumerate() {
+                elems
-                    write!(f, "{}: {}", i, field)?;
+                    .iter()
-                }
+                    .map(|t| t.to_string())
-                write!(f, "}}")
+                    .collect::<Vec<String>>()
+                    .join(", ")
+            ),
+            Self::Array { r#type, size } => write!(f, "[{}; {}]", r#type, size),
+            Self::UnknownCustom { name, generics } => {
+                write!(
+                    f,
+                    "{}<{}>",
+                    name,
+                    generics
+                        .iter()
+                        .map(|t| t.to_string())
+                        .collect::<Vec<String>>()
+                        .join(", ")
+                )
             }
+            Self::Struct {
+                name,
+                fields,
+                generics,
+            } => write!(
+                f,
+                "struct<{}> {} {{{}}}",
+                generics
+                    .iter()
+                    .map(|t| t.to_string())
+                    .collect::<Vec<String>>()
+                    .join(", "),
+                name,
+                fields
+                    .iter()
+                    .map(|t| t.to_string())
+                    .collect::<Vec<String>>()
+                    .join(", ")
+            ),
         }
     }
 }
@@ -229,18 +297,24 @@ pub enum Expression {
         // Post-Semantic Analysis
         type_id: Option<TypeId>,
     },
-    Number {
+    Number(Number),
-        value: isize,
-
-        // Post-Semantic Analysis
-        type_id: Option<TypeId>,
-    },
     StringLiteral(String),
     CharLiteral(char),
     ArrayLiteral {
         elements: Vec<Expression>,
         type_id: Option<TypeId>,
     },
+    StructLiteral {
+        name: Name,
+        fields: Vec<(Name, Expression)>,
+        type_id: Option<TypeId>,
+    },
+}
+
+#[derive(Debug, Clone)]
+pub enum Number {
+    Signed(i32, Option<TypeId>),
+    Unsigned(u32, Option<TypeId>),
 }
 
 #[derive(Debug, Clone)]
@@ -266,17 +340,20 @@ impl Expression {
                 expr.is_pure() && index.is_pure()
             }
             Expression::MemberAccess { expr, .. } => expr.is_pure(),
-            Expression::ArrayLiteral { elements, type_id } => {
+            Expression::ArrayLiteral { elements, .. } => {
                 elements.iter().all(|element| element.is_pure())
             }
+            Expression::StructLiteral { fields, .. } => {
+                fields.iter().all(|(_, expr)| expr.is_pure())
+            }
         }
     }
 
     pub fn type_id(&self) -> Result<TypeId, CompilerError> {
         match self {
-            Expression::Number { type_id, .. } => {
+            Expression::Number(
-                type_id.clone().ok_or(CompilerError::UnknownType)
+                Number::Signed(_, type_id) | Number::Unsigned(_, type_id),
-            }
+            ) => type_id.clone().ok_or(CompilerError::UnknownType),
             Expression::StringLiteral(_) => Ok(TypeId::Ptr(Box::new(TypeId::Char))),
             Expression::CharLiteral(_) => Ok(TypeId::Char),
             Expression::Call { type_id, .. } => {
@@ -304,7 +381,21 @@ impl Expression {
                 let element_type = elements
                     .first()
                     .map_or(TypeId::Void, |e| e.type_id().unwrap_or(TypeId::Void));
-                Ok(TypeId::Array(Box::new(element_type), elements.len()))
+                Ok(TypeId::Array {
+                    r#type: Box::new(element_type),
+                    size: elements.len(),
+                })
+            }
+            Expression::StructLiteral { name, fields, .. } => {
+                let fields = fields
+                    .iter()
+                    .map(|(_, expr)| expr.type_id())
+                    .collect::<Result<Vec<_>, _>>()?;
+                Ok(TypeId::Struct {
+                    name: name.clone(),
+                    fields,
+                    generics: Vec::new(),
+                })
             }
         }
     }

core/dsa_common/src/build.rs

@@ -0,0 +1,55 @@
+use std::{
+    fmt,
+    path::{Path, PathBuf},
+};
+
+#[derive(Debug, Clone)]
+pub enum BuildError {
+    IoError(String),
+    Generic(String),
+}
+
+impl From<std::io::Error> for BuildError {
+    fn from(err: std::io::Error) -> Self {
+        Self::IoError(err.to_string())
+    }
+}
+
+impl From<Box<dyn std::error::Error>> for BuildError {
+    fn from(err: Box<dyn std::error::Error>) -> Self {
+        Self::Generic(err.to_string())
+    }
+}
+
+impl fmt::Display for BuildError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::IoError(err) => write!(f, "IO Error: {err}"),
+            Self::Generic(err) => write!(f, "Generic Error: {err}"),
+        }
+    }
+}
+
+pub trait Builder {
+    type Output: Clone + std::convert::AsRef<[u8]>;
+    type Args: Clone;
+
+    fn new(src_path: impl Into<PathBuf>) -> Self;
+
+    // starts compilation
+    fn start(&mut self, args: Self::Args);
+
+    // non-blocking function, returns output if completed
+    fn poll(&mut self) -> Option<Result<Self::Output, BuildError>>;
+
+    // blocking function, returns output when completed.
+    fn output(&mut self) -> Result<Self::Output, BuildError>;
+
+    fn write_result(&mut self, path: impl AsRef<Path>) -> Result<(), BuildError> {
+        let output = self.output()?;
+        std::fs::write(path.as_ref(), output)
+            .map_err(|e| BuildError::IoError(e.to_string()))
+    }
+
+    fn logs(&self) -> Vec<String>;
+}

core/dsa_common/src/instructions.rs

@@ -40,7 +40,7 @@ pub enum InstructionType {
     Immediate,
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
 #[non_exhaustive]
 pub enum Register {
     // general purpose registers
@@ -69,6 +69,8 @@ pub enum Register {
     Idr,
     Mmr,
     Zero,
+
+    #[default]
     Null, // Invalid - Triggers a fault if accessed
 
     // system registers - can't be written to by instructions.
@@ -104,12 +106,6 @@ impl Register {
     }
 }
 
-impl Default for Register {
-    fn default() -> Self {
-        Self::Null
-    }
-}
-
 impl TryFrom<u8> for Register {
     type Error = RegisterParseError;
 

core/dsa_common/src/lib.rs

@@ -12,6 +12,7 @@
     clippy::match_wildcard_for_single_variants
 )]
 
+pub mod build;
 pub mod instructions;
 pub mod logging;
 

core/dsa_common/src/logging.rs

@@ -0,0 +1,65 @@
+use std::sync::{Arc, mpsc};
+
+pub fn info(message: &str) {
+    println!("\x1b[32mINFO:\x1b[0m {message}");
+}
+
+#[derive(Debug)]
+pub struct LogReceiver {
+    logs_rx: mpsc::Receiver<String>,
+    sender: Logger,
+    use_stdio: bool,
+}
+
+#[derive(Debug, Clone)]
+pub struct Logger {
+    use_stdio: bool,
+    logs_tx: Arc<mpsc::Sender<String>>,
+}
+
+impl Logger {
+    #[must_use]
+    pub fn new(logs_tx: mpsc::Sender<String>, use_stdio: bool) -> Self {
+        Self {
+            use_stdio,
+            logs_tx: Arc::new(logs_tx),
+        }
+    }
+
+    pub fn info(&self, message: &str) {
+        let res = format!("\x1b[32mINFO:\x1b[0m {message}");
+        if self.use_stdio {
+            println!("{res}");
+        }
+
+        self.logs_tx.send(res).expect("Failed to send log message");
+    }
+}
+
+impl LogReceiver {
+    #[must_use]
+    pub fn new(use_stdio: bool) -> Self {
+        let (logs_tx, logs_rx) = mpsc::channel();
+        Self {
+            use_stdio,
+            logs_rx,
+            sender: Logger::new(logs_tx, use_stdio),
+        }
+    }
+
+    #[must_use]
+    pub fn logs(&self) -> Vec<String> {
+        self.logs_rx.try_iter().collect()
+    }
+
+    #[must_use]
+    pub fn logger(&self) -> Logger {
+        self.sender.clone()
+    }
+}
+
+impl Default for LogReceiver {
+    fn default() -> Self {
+        Self::new(true)
+    }
+}

docs/ISA REVISION notes.md

@@ -0,0 +1,4 @@
+
+- we definitely need to be able to use registers for shift operations.
+- we need logical boolean operations in addition to the bitwise ones.
+- better conditionals.

docs/todo.md

@@ -0,0 +1,26 @@
+# General TODO's
+
+# Bugfixes
+- [x] [EASY] Investigate logical and operator not compiling - either a lexer or parser issue.
+  - **note**: this was a parser issue.
+
+# Missing features
+- [x] [MEDIUM] Get shift operations working correctly.
+- [ ] [MEDIUM] proper prefix/postfix inc/dec implementation. slightly more complex as we need to check for a variable and modify it in place
+- [ ] [EASY] Add multiply and divide operations to code generation
+  - **note**: very easy to do but our division algorithm is hopelessly slow so not worth doing for now.
+
+# Performance Improvements
+- [ ] [MEDIUM] implement a proper div/mod library that's not slow af.
+- [ ] [HARD] Immediate operations for values that support it (up to +/- u16::max for addi and subi respectively) 
+  - this requires significant complexity in code generation as we need to traverse down the tree when we come across these operations to prevent additional register allocations.
+
+# Compiler optimisations
+
+# Codegen improvements
+- [ ] [MEDIUM / time consuming] Add scoping to code generation
+- [ ] [MEDIUM / time consuming] Rewrite entire codegen to imrpove code quality and make the code more readable.
+  - [ ] type-safe instruction builder
+    - [ ] Instruction & Register enums
+    - [ ] Instruction builder helper fns eg `fn add(left: &Register, right: &Register, dest: &Register) -> Instruction`
+    - [ ] Instruction Block types.

dsx-build/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "dsx-build"
-version.workspace = true
-edition.workspace = true
-authors.workspace = true
-
-[dependencies]
-compiler = { path = "../compiler" }
-assembler = { path = "../assembler" }
-chrono = "0.4.43"

dsx-build/src/main.rs

@@ -1,200 +0,0 @@
-use std::process::{Command, Stdio};
-use std::{
-    env, fs,
-    path::{Path, PathBuf},
-};
-
-use crate::templates::{Dsa, Dsc, Template};
-
-mod templates;
-
-/// Run a command and exit on failure.
-fn run(cmd: &mut Command) {
-    let status = cmd.status().expect("failed to execute command");
-    if !status.success() {
-        std::process::exit(1);
-    }
-}
-
-fn main() {
-    // Very small CLI – only three sub‑commands.
-    let args: Vec<String> = env::args().collect();
-    if args.len() < 2 {
-        eprintln!("Usage: dsx-build <new|build|package> [options]");
-        std::process::exit(1);
-    }
-    match args[1].as_str() {
-        "new" => cmd_new(&args[2..]),
-        "build" => cmd_build(),
-        "package" => todo!("Package manager stub – not implemented yet."),
-        _ => {
-            eprintln!("Unknown command: {}", args[1]);
-            std::process::exit(1);
-        }
-    }
-}
-
-// ----------  new project ----------------------------------------------------
-fn cmd_new(args: &[String]) {
-    let mut lang = "dsa";
-    for i in 0..args.len() {
-        if args[i] == "--lang" && i + 1 < args.len() {
-            lang = &args[i + 1];
-        }
-    }
-
-    let lib = args.contains(&"--lib".to_string());
-
-    // Determine project root: a subdirectory named after the supplied --name argument.
-    let mut name_opt = None;
-    for i in 0..args.len() {
-        if args[i] == "--name" && i + 1 < args.len() {
-            name_opt = Some(&args[i + 1]);
-            break;
-        }
-    }
-
-    let project_name = match name_opt {
-        Some(name) => name.to_string(),
-        None => {
-            eprintln!("Error: --name argument required");
-            std::process::exit(1);
-        }
-    };
-
-    let cwd = env::current_dir().unwrap();
-    let src_path = cwd.join(&project_name).join("src");
-    fs::create_dir_all(&src_path).expect("Failed to create project directory");
-
-    match lang {
-        "dsa" => {
-            // Minimal DSA binary template.
-            let path = src_path.join(format!("main.dsa"));
-
-            let template = Dsa::create(&project_name, lib);
-
-            fs::write(path, template).expect("Unable to write DSA file");
-        }
-        "dsc" => {
-            let path = src_path.join(format!("main.dsc"));
-
-            let template = Dsc::create(&project_name, lib);
-
-            fs::write(path, template).expect("Unable to write DSC file");
-        }
-        _ => {
-            eprintln!("Unsupported language: {}", lang);
-            std::process::exit(1);
-        }
-    }
-
-    fs::create_dir_all(src_path.join("lib")).expect("Failed to create lib directory");
-    fs::write(
-        src_path.join("lib/print.dsa"),
-        templates::create_print_lib(),
-    )
-    .expect("Failed to create print.dsa");
-    fs::write(
-        src_path.join("lib/maths.dsa"),
-        templates::create_maths_lib(),
-    )
-    .expect("Failed to create maths.dsa");
-
-    println!(
-        "Created new {} project in {}.",
-        lang,
-        src_path.parent().unwrap().display()
-    );
-}
-
-// ----------  build ----------------------------------------------------------
-fn cmd_build() {
-    let cwd = env::current_dir().unwrap();
-
-    // Detect .dsc or .dsa files in current directory.
-    let mut has_dsc = false;
-    let mut has_dsa = false;
-    for entry in fs::read_dir(&cwd.join("src")).expect("unable to read dir") {
-        if let Ok(entry) = entry {
-            let path = entry.path();
-            if path.extension().and_then(|s| s.to_str()) == Some("dsc") {
-                has_dsc = true;
-            } else if path.extension().and_then(|s| s.to_str()) == Some("dsa") {
-                has_dsa = true;
-            }
-        }
-    }
-
-    if !has_dsc && !has_dsa {
-        eprintln!("No .dsc or .dsa source found in src directory.");
-        std::process::exit(1);
-    }
-
-    // Assemble main.dsa to a dsb binary.
-    println!("Assembling Project to a DSB binary...");
-    let build_dir = cwd.join("build");
-    fs::create_dir_all(&build_dir).expect("Failed to create build directory");
-
-    // Copy everything from `cwd/src` to the build directory.
-    fn copy_recursively(src: &Path, dst: &Path) {
-        if src.is_file() {
-            fs::create_dir_all(dst.parent().unwrap())
-                .expect("Failed to create parent directory");
-            fs::copy(src, dst).expect("Failed to copy file");
-        } else if src.is_dir() {
-            for entry in fs::read_dir(src).expect("Unable to read source dir") {
-                let entry = entry.expect("Failed to read entry");
-                let child_src = entry.path();
-                let child_dst = dst.join(entry.file_name());
-                copy_recursively(&child_src, &child_dst);
-            }
-        }
-    }
-
-    let src_dir = cwd.join("src");
-    if src_dir.exists() {
-        copy_recursively(&src_dir, &build_dir);
-    }
-
-    // Change current working directory to the build directory.
-    env::set_current_dir(&build_dir).expect("Failed to change to build directory");
-
-    if has_dsc {
-        println!("Compiling DSC to DSA...");
-        fn compile_recursive(path: &Path) {
-            if path.is_dir() {
-                for entry in fs::read_dir(path).expect("unable to read dir") {
-                    let entry = entry.expect("failed to read entry");
-                    compile_recursive(&entry.path());
-                }
-            } else if path.extension().and_then(|s| s.to_str()) == Some("dsc") {
-                let input_path = path;
-                let output_path = path.with_extension("dsa");
-                compiler::compile_file(&input_path, &output_path).unwrap_or_else(|e| {
-                    eprintln!("Failed to compile {:?}: {}", input_path, e);
-                    std::process::exit(1);
-                });
-            }
-        }
-        compile_recursive(&build_dir);
-    }
-
-    // Replace .dsc with .dsa only in include statements, recursively for each file.
-    let mut sed_cmd = Command::new("bash");
-    sed_cmd.args(&[
-        "-c",
-        &format!(
-            "find \"{}\" -type f -name '*.dsa' -exec sed -i '/^include/ s/\\.dsc/.dsa/g' {{}} +",
-            build_dir.display()
-        ),
-    ]);
-    run(&mut sed_cmd);
-
-    fs::create_dir_all(&cwd.join("artifacts")).expect("Failed to create build directory");
-    assembler::assemble_file("./main.dsa", "../artifacts/out.dsb").unwrap_or_else(|e| {
-        eprintln!("Failed to assemble {:?}: {}", "./main.dsa", e);
-        std::process::exit(1);
-    });
-
-    println!("Build finished. Binary at {}/main.dsb", build_dir.display());
-}

dsx/dsx/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "dsx"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+
+[[bin]]
+name = "dsx"
+path = "src/main.rs"
+
+[dependencies]
+compiler = { path = "../../core/compiler" }
+assembler = { path = "../../core/assembler" }
+common = { path = "../../core/dsa_common" }
+dsx_common = { path = "../dsx_common" }
+toml = "1.0.3"
+chrono = "0.4.44"
+reqwest = { version = "0.13.2", default-features = false, features = ["blocking", "native-tls"] }
+tar = "0.4.44"
+flate2 = "1.1.9"

dsx/dsx/src/main.rs

@@ -0,0 +1,120 @@
+use std::{env, fs, path::PathBuf, process::Command};
+
+use dsx_common::builder::{self, BuildContext};
+use reqwest::Url;
+
+pub mod new;
+pub mod repo;
+pub mod templates;
+
+fn main() {
+    // Very small CLI – only three sub‑commands.
+    let args: Vec<String> = env::args().collect();
+    if args.len() < 2 {
+        eprintln!("Usage: dsx-build <new|build|package> [options]");
+        std::process::exit(1);
+    }
+    match args[1].as_str() {
+        "new" => new::new_project(&args[2..]),
+        "build" => {
+            if let Some(dir) = find_project_root() {
+                let ctx = BuildContext {
+                    project_dir: dir.clone(),
+                    build_dir: dir.join("build"),
+                    artifact_dir: dir.join("artifacts"),
+                };
+
+                builder::build_project(ctx).expect("Build failed!");
+            } else {
+                eprintln!("No Dsx.toml found");
+                std::process::exit(1);
+            }
+        }
+        "clean" => {
+            if let Some(dir) = find_project_root() {
+                fs::remove_dir_all(dir.join("build"))
+                    .expect("failed to remove build dir");
+                println!("Build directory cleaned...");
+                fs::remove_dir_all(dir.join("artifacts"))
+                    .expect("failed to remove artifacts dir");
+                println!("Artifacts directory cleaned...");
+            } else {
+                eprintln!("No Dsx.toml found");
+                std::process::exit(1);
+            }
+        }
+        "run" => {
+            if let Some(dir) = find_project_root() {
+                let ctx = BuildContext {
+                    project_dir: dir.clone(),
+                    build_dir: dir.join("build"),
+                    artifact_dir: dir.join("artifacts"),
+                };
+
+                builder::build_project(ctx).expect("Run failed!");
+
+                // start process and call emulator
+                let mut child = Command::new("dsa")
+                    .arg("--cli")
+                    .arg("--bin")
+                    .arg(dir.join("./artifacts/out.dsb"))
+                    .spawn()
+                    .expect("Failed to start emulator");
+
+                // wait for emulator to finish
+                child.wait().expect("Failed to wait for emulator");
+            } else {
+                eprintln!("No Dsx.toml found");
+                std::process::exit(1);
+            }
+        }
+        "clone" => {
+            let url: Url = Url::parse(&args[2]).unwrap();
+            let name = url.path_segments().unwrap().next_back().unwrap();
+            let repo = env::current_dir().unwrap().join(name);
+
+            fs::create_dir_all(&repo).unwrap();
+            repo::clone(&repo, &url).expect("Failed to clone repository");
+        }
+        "push" => {
+            if let Some(dir) = find_project_root() {
+                repo::push(&dir).expect("Failed to push repository");
+            } else {
+                eprintln!("No Dsx.toml found");
+                std::process::exit(1);
+            }
+        }
+        "pull" => {
+            if let Some(dir) = find_project_root() {
+                repo::pull(&dir).expect("Failed to pull repository");
+            } else {
+                eprintln!("No Dsx.toml found");
+                std::process::exit(1);
+            }
+        }
+        "package" => todo!("Package manager stub – not implemented yet."),
+        _ => {
+            eprintln!("Unknown command: {}", args[1]);
+            std::process::exit(1);
+        }
+    }
+}
+
+fn find_project_root() -> Option<PathBuf> {
+    // check if current dir has Dsx.toml otherwise check parent dir recursively
+    let mut cwd = env::current_dir().unwrap();
+    loop {
+        let dsx_toml = cwd.join("Dsx.toml");
+        if dsx_toml.exists() {
+            return Some(cwd);
+        }
+
+        if let Some(parent) = cwd.parent() {
+            cwd = parent.to_path_buf();
+        } else {
+            break;
+        }
+    }
+
+    None
+}

dsx/dsx/src/new.rs

@@ -0,0 +1,107 @@
+use std::{env, fmt, fs};
+
+use dsx_common::config::DsxConfig;
+
+use crate::templates::{self, Dsa, Dsc, Template};
+
+// ----------  new project ----------------------------------------------------
+pub fn new_project(args: &[String]) {
+    // get project details from args.
+    let lang = Language::from_args(args);
+    let lib = args.contains(&"--lib".to_string());
+    let name = project_name(args).unwrap_or_else(|| {
+        eprintln!("Error: --name argument required");
+        std::process::exit(1);
+    });
+
+    let project_path = env::current_dir().unwrap().join(name);
+    let src_path = project_path.join("src");
+
+    fs::create_dir_all(&src_path).expect("Failed to create project directory");
+
+    let config_template = DsxConfig::new(name);
+    fs::write(
+        project_path.join("Dsx.toml"),
+        toml::to_string(&config_template).unwrap(),
+    )
+    .expect("Unable to write default config");
+
+    let (path, template) = match lang {
+        Language::Unknown | Language::Dsa => {
+            (src_path.join("main.dsa"), Dsa::create(name, lib))
+        }
+        Language::Dsc => (src_path.join("main.dsc"), Dsc::create(name, lib)),
+    };
+
+    fs::write(path, template).expect("Unable to write DSA file");
+
+    fs::create_dir_all(src_path.join("lib")).expect("Failed to create lib directory");
+    fs::write(
+        src_path.join("./lib/print.dsa"),
+        include_str!("../templates/dsa/print.dsa"),
+    )
+    .expect("Failed to create print.dsa");
+    fs::write(
+        src_path.join("./lib/maths.dsa"),
+        include_str!("../templates/dsa/maths.dsa"),
+    )
+    .expect("Failed to create maths.dsa");
+    fs::write(
+        src_path.join("./lib/serial.dsa"),
+        include_str!("../templates/dsa/serial.dsa"),
+    )
+    .expect("Failed to create maths.dsa");
+
+    println!(
+        "Created new {} project in {}.",
+        lang,
+        src_path.parent().unwrap().display()
+    );
+}
+
+// helpers
+
+enum Language {
+    Unknown,
+    Dsa,
+    Dsc,
+}
+
+impl Language {
+    fn from_args(args: &[String]) -> Self {
+        let mut lang = Language::Unknown;
+        for i in 0..args.len() {
+            if args[i] == "--lang" && i + 1 < args.len() {
+                match args[i + 1].as_str() {
+                    "dsa" => lang = Language::Dsa,
+                    "dsc" => lang = Language::Dsc,
+                    _ => {
+                        eprintln!("Error: Invalid language argument");
+                        std::process::exit(1);
+                    }
+                }
+            }
+        }
+        lang
+    }
+}
+
+impl fmt::Display for Language {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::Unknown => write!(f, "Unknown"),
+            Self::Dsa => write!(f, "Dsa"),
+            Self::Dsc => write!(f, "Dsc"),
+        }
+    }
+}
+
+pub fn project_name(args: &[String]) -> Option<&str> {
+    for i in 0..args.len() {
+        if args[i] == "--name" && i + 1 < args.len() {
+            return Some(&args[i + 1]);
+        }
+    }
+
+    None
+}

dsx/dsx/src/repo.rs

@@ -0,0 +1,145 @@
+use dsx_common::config::DsxConfig;
+use flate2::read::GzDecoder;
+use flate2::{Compression, write::GzEncoder};
+use reqwest::Url;
+use std::fs::{self, File};
+use std::path::Path;
+use tar::Builder;
+
+pub fn push(repo_dir: &Path) -> Result<(), DsxError> {
+    let config_file = fs::read_to_string(repo_dir.join("Dsx.toml"))?;
+    let config: DsxConfig = toml::from_str(&config_file).expect("Failed to parse config");
+
+    let mut repo_url =
+        Url::parse(&config.remote_url.expect(
+            "Repository URL is not set in Dsx.toml, set it with the key 'remote'",
+        ))
+        .unwrap();
+    repo_url.path_segments_mut().unwrap().push("push");
+
+    let client = reqwest::blocking::Client::new();
+    let response = client
+        .post(repo_url)
+        .body(pack_tarball(repo_dir)?)
+        .header("Content-Type", "application/octet-stream")
+        .send()
+        .map_err(|e| {
+            DsxError::with_context(
+                format!("failed to stream to client: {}", e),
+                ErrorType::IoError,
+            )
+        })?;
+
+    if response.status().is_success() {
+        Ok(())
+    } else {
+        Err(DsxError::with_context(
+            response.text().unwrap(),
+            ErrorType::IoError,
+        ))
+    }
+}
+
+pub fn pull(repo_dir: &Path) -> Result<(), DsxError> {
+    let config_file = fs::read_to_string(repo_dir.join("Dsx.toml"))?;
+    let config: DsxConfig = toml::from_str(&config_file).expect("Failed to parse config");
+
+    let repo_url =
+        Url::parse(&config.remote_url.expect(
+            "Repository URL is not set in Dsx.toml, set it with the key 'remote'",
+        ))
+        .unwrap();
+
+    clone(repo_dir, &repo_url)
+}
+
+pub fn clone(repo_dir: &Path, url: &Url) -> Result<(), DsxError> {
+    let mut url = url.clone();
+    url.path_segments_mut().unwrap().push("pull");
+
+    let client = reqwest::blocking::Client::new();
+    let response = client.get(url).send().map_err(|e| {
+        DsxError::with_context(
+            format!("failed to stream from client: {e}"),
+            ErrorType::IoError,
+        )
+    })?;
+
+    if !response.status().is_success() {
+        return Err(DsxError::with_context(
+            response.text().unwrap(),
+            ErrorType::IoError,
+        ));
+    }
+
+    let tmp_file = std::env::temp_dir().join("dsx-pull.tar.gz");
+    std::fs::write(&tmp_file, response.bytes().unwrap())
+        .map_err(|e| DsxError::with_context(e.to_string(), ErrorType::IoError))?;
+    unpack_tarball(&tmp_file, repo_dir)?;
+    fs::remove_file(tmp_file)?;
+    Ok(())
+}
+
+fn unpack_tarball(
+    archive: &std::path::Path,
+    dest: &std::path::Path,
+) -> Result<(), DsxError> {
+    let file = File::open(archive)
+        .map_err(|e| DsxError::with_context(e.to_string(), ErrorType::IoError))?;
+
+    fs::create_dir_all(dest)?;
+
+    let gz = GzDecoder::new(file);
+    let mut tar = tar::Archive::new(gz);
+    tar.unpack(dest)
+        .map_err(|e| DsxError::with_context(e.to_string(), ErrorType::TarError))?;
+
+    Ok(())
+}
+
+fn pack_tarball(src_dir: &std::path::Path) -> Result<Vec<u8>, DsxError> {
+    let buf = Vec::new();
+    let gz = GzEncoder::new(buf, Compression::default());
+    let mut tar = Builder::new(gz);
+    tar.append_dir_all(".", src_dir)?;
+    let gz = tar.into_inner()?;
+    Ok(gz.finish()?)
+}
+
+#[derive(Debug)]
+pub struct DsxError {
+    pub message: String,
+    pub r#type: ErrorType,
+}
+
+impl DsxError {
+    pub fn new(message: impl AsRef<str>) -> Self {
+        DsxError {
+            message: message.as_ref().to_string(),
+            r#type: ErrorType::Generic,
+        }
+    }
+
+    pub fn with_context(message: impl AsRef<str>, r#type: ErrorType) -> Self {
+        DsxError {
+            message: message.as_ref().to_string(),
+            r#type,
+        }
+    }
+}
+
+impl From<std::io::Error> for DsxError {
+    fn from(err: std::io::Error) -> Self {
+        Self::with_context(err.to_string(), ErrorType::IoError)
+    }
+}
+
+#[derive(Default, Debug)]
+pub enum ErrorType {
+    BuildFailed,
+    IoError,
+
+    #[default]
+    Generic,
+    TarError,
+}

dsx/dsx/src/templates.rs

@@ -0,0 +1,142 @@
+use std::path::PathBuf;
+
+pub trait Template {
+    fn lib(project: &str) -> String;
+    fn bin(project: &str) -> String;
+
+    fn create(project: &str, lib: bool) -> String {
+        if lib {
+            Self::lib(project)
+        } else {
+            Self::bin(project)
+        }
+    }
+}
+
+pub struct Dsa;
+pub struct Dsc;
+
+impl Template for Dsa {
+    fn lib(project: &str) -> String {
+        format!(
+            r#"//
+lib.dsa
+// usage:
+//
+// include {project} "<relative path>"
+//
+// usage for {project}_main:
+// push (arg1)
+// push (arg0)
+// call {project}::{project}_main
+// pop (arg0)
+// pop (arg1)
+
+// Example data declarations
+// dw example_data: 0x0000
+
+// Main function template
+{project}_main:
+    // the correct way to start a function as defined by the calling convention
+    push bpr
+    mov spr, bpr
+
+    // explanation of how to access args
+    ldw bpr, rg0, 8  // arg 0
+    ldw bpr, rg0, 12 // arg 1
+
+    // your code goes here
+    // Example: load example_data into rg1
+    // ldw example_data, rg1
+
+    // the correct way to end a function as defined by the calling convention
+    mov bpr, spr
+    pop bpr
+    return
+"#,
+        )
+    }
+
+    fn bin(project: &str) -> String {
+        format!(
+            r#"
+// GENERATED BY DSX-BUILD
+// Generated at: {timestamp}
+// Project name: {project}
+
+// Imports
+include print: "./lib/print.dsa"
+
+// Globals & Reserved Memory
+dw stack: 0x10000
+db message: "Process Exited with code:"
+
+// Entry Point
+_init:
+    ldw stack, bpr
+    mov bpr, spr
+    push zero
+    call main
+    call print::print_newline
+    lwi message, rg0
+    push rg0
+    call print::print
+    pop zero
+    call print::print_hex_word
+    pop zero
+    hlt
+
+main:
+    push bpr
+    mov spr, bpr
+
+    // Your code goes here
+
+    // Return zero
+    stw zero, bpr, 8
+
+    mov bpr, spr
+    pop bpr
+    return"#,
+            timestamp = chrono::Utc::now().format("%Y-%m-%d %H:%M:%S")
+        )
+    }
+}
+
+impl Template for Dsc {
+    fn lib(project: &str) -> String {
+        format!(
+            r#"
+// GENERATED BY DSX-BUILD
+// Generated at: {timestamp}
+// Project name: {project}
+
+// Imports
+include print: "./lib/print.dsa";
+
+// Main Function
+fn {project}_main() -> u32 {{
+    return 0;
+}}"#,
+            timestamp = chrono::Utc::now().format("%Y-%m-%d %H:%M:%S")
+        )
+    }
+
+    fn bin(project: &str) -> String {
+        format!(
+            r#"
+// GENERATED BY DSX-BUILD
+// Generated at: {timestamp}
+// Project name: {project}
+
+// Imports
+include print: "./lib/print.dsa";
+
+// Main Function
+fn main() -> u32 {{
+    return 0;
+}}"#,
+            timestamp = chrono::Utc::now().format("%Y-%m-%d %H:%M:%S")
+        )
+    }
+}

dsx/dsx/templates/dsa/maths.dsa

@@ -0,0 +1,104 @@
+// multiply.dsa
+// usage:
+//
+// include multiply "<relative path>"
+//
+// usage for multiply:
+// push (arg1)
+// push (arg0)
+// call multiply::multiply
+// pop (arg0)
+// pop (arg1)
+
+multiply:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8  // load op 2
+    ldw bpr, rg1, 12 // load op 1
+    lwi 0, rg2       // initialise rg2 to zero
+
+_multiply_loop:
+    add rg2, rg0, rg2
+    dec rg1
+
+    cmp rg1, zero
+    jgt _multiply_loop
+
+_multiply_end:
+    stw rg2, bpr, 8
+
+    mov bpr, spr
+    pop bpr
+    return
+
+divmod:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg1, 8  // load op 2
+    ldw bpr, rg0, 12 // load op 1
+
+    lli 0, rg3
+
+_divmod_loop:
+    cmp rg0, rg1
+    jlt _divmod_end
+
+    sub rg0, rg1, rg0
+    inc rg3
+
+    jmp _divmod_loop
+
+_divmod_end:
+    // store div in first arg
+    // store mod in second arg
+    stw rg3, bpr, 8
+    stw rg0, bpr, 12
+
+    mov bpr, spr
+    pop bpr
+    return
+
+// multiply.dsa - improved version
+// Multiplies two 32-bit numbers using shift-and-add
+//
+// Usage:
+// push operand2  (multiplier)
+// push operand1  (multiplicand)
+// call multiply::multiply
+// pop result
+// pop zero       (discard second argument)
+
+new_multiply:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8     // rg0 = multiplicand
+    ldw bpr, rg1, 12    // rg1 = multiplier
+
+    lli 0, rg2          // rg2 = result (accumulator)
+    lli 32, rg3         // rg3 = bit counter
+
+mult_loop:
+    // Check if lowest bit of multiplier is 1
+    lli 1, acc
+    and rg1, acc, acc   // acc = rg1 & 1
+    cmp acc, zero
+    jeq skip_add        // if (rg1 & 1) == 0, skip addition
+
+    // Add multiplicand to result
+    add rg2, rg0, rg2
+
+skip_add:
+    shl rg0, 1          // shift multiplicand left
+    shr rg1, 1          // shift multiplier right
+
+    dec rg3
+    cmp rg3, zero
+    jgt mult_loop
+
+    stw rg2, bpr, 8     // store result
+    mov bpr, spr
+    pop bpr
+    return

dsx/dsx/templates/dsa/print.dsa

@@ -0,0 +1,331 @@
+// lib:
+// print.dsa
+
+// usage:
+//
+// include print "<relative path>""
+//
+// usage for print:
+//      push (register containing address of string)
+//      push pcx
+//      jmp print::print
+//
+// usage for reset:
+//      push pcx
+//      jmp print::reset
+//
+// usage for clear:
+//      push pcx
+//      jmp print::clear
+//
+// usage for print_byte:
+//      push (register containing byte)
+//      push pcx
+//      jmp print::print_byte
+//
+// usage for print_word:
+//      push (register containing word)
+//      push pcx
+//      jmp print::print_word
+//
+// usage for print_num:
+//      push (register containing number to print in decimal)
+//      push pcx
+//      jmp print::print_num
+//
+
+include maths "./maths.dsa"
+
+dw display: 0x20000
+dw current: 0x20000
+
+// ------------------------------------------
+// prints the string at addr(arg[0]) to the screen. (no trailing whitespace unless explicitly provided)
+print:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    ldw current, rg1
+
+_print_loop:
+    ldb rg0, acc
+    cmp acc, zero
+    jeq _end
+    stb acc, rg1
+
+    addi rg0, 1
+    addi rg1, 1
+
+    jmp _print_loop
+
+// ------------------------------------------
+println:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    ldw current, rg1
+
+_println_loop:
+    ldb rg0, acc
+    cmp acc, zero
+    jeq _println_end
+    stb acc, rg1
+
+    addi rg0, 1
+    addi rg1, 1
+
+    jmp _println_loop
+
+_println_end:
+    call print_newline
+    jmp _end
+
+// ------------------------------------------
+// prints the value of arg[0] to the screen.
+print_word:
+    // initialise
+    push bpr
+    mov spr, bpr
+
+    // load byte into acc
+    ldw bpr, rg0, 8
+    ldw current, rg1
+
+    addi rg1, 3
+
+    stb rg0, rg1
+    subi rg1, 1
+    shr rg0, 8
+    stb rg0, rg1
+    subi rg1, 1
+    shr rg0, 8
+    stb rg0, rg1
+    subi rg1, 1
+    shr rg0, 8
+    stb rg0, rg1
+
+    addi rg1, 4
+    jmp _end
+
+// ------------------------------------------
+// prints the last byte of arg[0] to the screen.
+print_byte:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    ldw current, rg1
+
+    stb rg0, rg1
+    addi rg1, 1
+    jmp _end
+
+// ------------------------------------------
+// prints the value of arg[0] to the screen in hex.
+print_hex_word:
+    push bpr
+    mov spr, bpr
+
+    ldw current, rg1
+
+    ldb bpr, rg0, 8
+    push rg0
+    call _print_hex_byte
+    addi spr, 4
+
+    ldb bpr, rg0, 9
+    push rg0
+    call _print_hex_byte
+    addi spr, 4
+
+    ldb bpr, rg0, 10
+    push rg0
+    call _print_hex_byte
+    addi spr, 4
+
+    ldb bpr, rg0, 11
+    push rg0
+    call _print_hex_byte
+    addi spr, 4
+
+    jmp _end
+
+// ------------------------------------------
+// prints the last byte of arg[0] to the screen in hex.
+print_hex_byte:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    ldw current, rg1
+
+    call _print_hex_byte
+    jmp _end
+
+// function body
+_print_hex_byte:
+    // mask to get lower nibble
+    lli 0xF, rg2
+    // save rg0 state
+    push rg0
+
+    shr rg0, 4
+    and rg0, rg2, rg0
+    call _print_hex_nibble
+    pop rg0
+
+    and rg0, rg2, rg0
+    call _print_hex_nibble
+    return
+
+// print a hex digit
+_print_hex_nibble:
+    lli 10, rg3
+    cmp rg0, rg3
+    jlt _print_hex_nibble_number
+    addi rg0, 0x37, rg0
+    stb rg0, rg1
+    addi rg1, 1
+    return
+
+// helper function.
+_print_hex_nibble_number:
+    addi rg0, 0x30, rg0
+    stb rg0, rg1
+    addi rg1, 1
+    return
+
+// ------------------------------------------
+// print whitespace
+print_whitespace:
+    push bpr
+    mov spr, bpr
+
+    ldw current, rg1
+    lli 0x20, rg0
+    stb rg0, rg1
+    addi rg1, 1
+    jmp _end
+
+// ------------------------------------------
+// print newline
+print_newline:
+    push bpr
+    mov spr, bpr
+
+    // load variables into registers
+    ldw display, rg0
+    ldw current, rg1
+
+    // get the offset from the display base
+    sub rg1, rg0, rg0
+
+    lwi 80, rg2
+    pusha 3
+    push rg0
+    push rg2
+    call maths::divmod
+    pop zero  // result
+    pop rg3 // remainder
+    popa 3
+
+    sub rg1, rg3, rg2
+    addi rg2, 80, rg1
+
+    // _end saves the display state
+    jmp _end
+
+// ------------------------------------------
+// prints arg[0] as a decimal number to the screen.
+print_num:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8      // load number to print
+    lli 0, rg5           // rg5 = digit counter
+
+    // check if number is zero
+    cmp rg0, zero
+    jne _print_num_extract_digits
+
+    // special case: print '0' for zero
+    lli 0x30, rg6
+    push rg6             // push digit to stack buffer
+    lli 1, rg5           // we have 1 digit
+    jmp _print_num_output
+
+_print_num_extract_digits:
+    // divide by 10 repeatedly to get digits
+    cmp rg0, zero
+    jeq _print_num_output
+
+    // call divmod(rg0, 10)
+    push rg0             // dividend
+    lli 10, rg1
+    push rg1             // divisor (10)
+    call maths::divmod
+    pop rg0              // quotient (continue dividing this)
+    pop rg1              // remainder (the digit)
+
+    // convert digit to ASCII and push to stack buffer
+    addi rg1, 0x30, rg6  // convert to ASCII
+    push rg6             // push digit to stack
+    inc rg5              // increment digit counter
+
+    jmp _print_num_extract_digits
+
+_print_num_output:
+    // now print digits (pop them off in reverse order)
+    ldw current, rg1     // get display pointer
+
+_print_num_output_loop:
+    // check if we've printed all digits
+    cmp rg5, zero
+    jeq _print_num_done
+
+    // pop digit and print it
+    pop rg6
+    stb rg6, rg1
+    addi rg1, 1
+    dec rg5
+
+    jmp _print_num_output_loop
+
+_print_num_done:
+    jmp _end
+
+// ------------------------------------------
+// resets the cursor position on the screen to 0x20000. (0,0)
+reset:
+    push bpr
+    mov spr, bpr
+    ldw display, rg1
+    jmp _end
+
+// ------------------------------------------
+// clears the screen
+clear:
+    push bpr
+    mov spr, bpr
+    // display size = 2000 bytes / 500 words
+    lli 500 rg0
+    ldw display, rg1
+
+_clear_loop:
+    dec rg0
+    stw zero, rg1
+    addi rg1, 4
+    cmp rg0, zero
+    jgt _clear_loop
+    jmp _end
+
+// ------------------------------------------
+// return
+_end:
+    stw rg1, current
+
+    mov bpr, spr
+    pop bpr
+    return

dsx/dsx/templates/dsa/serial.dsa

@@ -0,0 +1,244 @@
+// lib:
+// print_serial.dsa
+
+// usage:
+//
+// include print_serial "<relative path>"
+//
+// usage for print:
+//      push (register containing address of string)
+//      push pcx
+//      jmp print_serial::print
+//
+// usage for print_byte:
+//      push (register containing byte)
+//      push pcx
+//      jmp print_serial::print_byte
+//
+// usage for print_word:
+//      push (register containing word)
+//      push pcx
+//      jmp print_serial::print_word
+//
+// usage for print_hex_byte:
+//      push (register containing byte)
+//      push pcx
+//      jmp print_serial::print_hex_byte
+//
+// usage for print_hex_word:
+//      push (register containing word)
+//      push pcx
+//      jmp print_serial::print_hex_word
+//
+// usage for print_num:
+//      push (register containing number to print in decimal)
+//      push pcx
+//      jmp print_serial::print_num
+//
+// usage for println:
+//      push (register containing address of string)
+//      push pcx
+//      jmp print_serial::println
+//
+
+include maths "../maths.dsa"
+
+dw serial: 0x207D0      // 0x20000 + 2000
+
+// ------------------------------------------
+// prints the string at addr(arg[0]) to the serial port.
+print:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    lwi 0x207D0, rg1
+
+_print_loop:
+    ldb rg0, acc
+    cmp acc, zero
+    jeq _end
+    stb acc, rg1
+
+    addi rg0, 1
+    jmp _print_loop
+
+// ------------------------------------------
+// prints the string at addr(arg[0]) followed by a newline to the serial port.
+println:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    lwi 0x207D0, rg1
+
+_println_loop:
+    ldb rg0, acc
+    cmp acc, zero
+    jeq _println_end
+    stb acc, rg1
+
+    addi rg0, 1
+    jmp _println_loop
+
+_println_end:
+    lli 0x0A, rg2       // newline character
+    stb rg2, rg1
+    jmp _end
+
+// ------------------------------------------
+// prints the word in arg[0] as 4 raw bytes to the serial port.
+print_word:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    lwi 0x207D0, rg1
+
+    stb rg0, rg1
+    shr rg0, 8
+    stb rg0, rg1
+    shr rg0, 8
+    stb rg0, rg1
+    shr rg0, 8
+    stb rg0, rg1
+    jmp _end
+
+// ------------------------------------------
+// prints the last byte of arg[0] to the serial port.
+print_byte:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    lwi 0x207D0, rg1
+
+    stb rg0, rg1
+    jmp _end
+
+// ------------------------------------------
+// prints the value of arg[0] to the serial port in hex.
+print_hex_word:
+    push bpr
+    mov spr, bpr
+
+    lwi 0x207D0, rg1
+
+    ldb bpr, rg0, 8
+    push rg0
+    call _print_hex_byte
+    addi spr, 4
+
+    ldb bpr, rg0, 9
+    push rg0
+    call _print_hex_byte
+    addi spr, 4
+
+    ldb bpr, rg0, 10
+    push rg0
+    call _print_hex_byte
+    addi spr, 4
+
+    ldb bpr, rg0, 11
+    push rg0
+    call _print_hex_byte
+    addi spr, 4
+
+    jmp _end
+
+// ------------------------------------------
+// prints the last byte of arg[0] to the serial port in hex.
+print_hex_byte:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    lwi 0x207D0, rg1
+
+    call _print_hex_byte
+    jmp _end
+
+// function body
+_print_hex_byte:
+    lli 0xF, rg2
+    push rg0
+
+    shr rg0, 4
+    and rg0, rg2, rg0
+    call _print_hex_nibble
+    pop rg0
+
+    and rg0, rg2, rg0
+    call _print_hex_nibble
+    return
+
+// print a hex digit
+_print_hex_nibble:
+    lli 10, rg3
+    cmp rg0, rg3
+    jlt _print_hex_nibble_number
+    addi rg0, 0x37, rg0
+    stb rg0, rg1
+    return
+
+_print_hex_nibble_number:
+    addi rg0, 0x30, rg0
+    stb rg0, rg1
+    return
+
+// ------------------------------------------
+// prints arg[0] as a decimal number to the serial port.
+print_num:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    lli 0, rg5
+
+    cmp rg0, zero
+    jne _print_num_extract_digits
+
+    lli 0x30, rg6
+    push rg6
+    lli 1, rg5
+    jmp _print_num_output
+
+_print_num_extract_digits:
+    cmp rg0, zero
+    jeq _print_num_output
+
+    push rg0
+    lli 10, rg1
+    push rg1
+    call maths::divmod
+    pop rg0
+    pop rg1
+
+    addi rg1, 0x30, rg6
+    push rg6
+    inc rg5
+
+    jmp _print_num_extract_digits
+
+_print_num_output:
+    lwi 0x207D0, rg1
+
+_print_num_output_loop:
+    cmp rg5, zero
+    jeq _print_num_done
+
+    pop rg6
+    stb rg6, rg1
+    dec rg5
+
+    jmp _print_num_output_loop
+
+_print_num_done:
+    jmp _end
+
+// ------------------------------------------
+// return
+_end:
+    mov bpr, spr
+    pop bpr
+    return

dsx/dsx_common/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "dsx_common"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+
+[dependencies]
+compiler = { path = "../../core/compiler" }
+assembler = { path = "../../core/assembler" }
+common = { path = "../../core/dsa_common" }
+
+chrono = "0.4.44"
+serde = { version = "1.0.228", features = ["derive"] }
+toml = "1.0.3"
+walkdir = "2.5.0"

dsx/dsx_common/src/builder.rs

@@ -0,0 +1,168 @@
+use std::{
+    env, fs, io,
+    path::{Path, PathBuf},
+    process::Command,
+};
+
+use crate::config::DsxConfig;
+
+use assembler::prelude::Assembler;
+use common::build::{BuildError, Builder};
+use compiler::Compiler;
+
+pub struct BuildContext {
+    pub project_dir: PathBuf,
+    pub build_dir: PathBuf,
+    pub artifact_dir: PathBuf,
+}
+
+// ----------  build ----------------------------------------------------------
+pub fn build_project(ctx: BuildContext) -> Result<(), BuildError> {
+    // variables
+    let binary_path = ctx.artifact_dir.join("out.dsb");
+    let main_path = ctx.build_dir.join("main.dsa");
+    let config_path = ctx.project_dir.join("Dsx.toml");
+
+    let src_dir = ctx.project_dir.join("src");
+
+    let config: DsxConfig =
+        toml::from_str(&fs::read_to_string(&config_path)?).map_err(|deser_err| {
+            io::Error::new(io::ErrorKind::InvalidData, deser_err.to_string())
+        })?;
+
+    if !src_dir.exists() {
+        return Err(BuildError::Generic(String::from(
+            "Source Directory does not exist",
+        )));
+    }
+
+    // make sure there's a main file to assemble later.
+    if !main_exists(&src_dir)? {
+        return Err(BuildError::Generic(String::from(
+            "No main.dsa or main.dsc file found in top level of src directory.",
+        )));
+    }
+
+    // detect src.
+    let (has_dsa, has_dsc) = detect_source_language(&src_dir);
+
+    // create a build dir and copy all files across
+    fs::create_dir_all(&ctx.build_dir)?;
+    copy_recursively(&src_dir, &ctx.build_dir)?;
+
+    if has_dsc {
+        build_all_dsc(&ctx.build_dir)?;
+    }
+
+    // Replace .dsc with .dsa only in include statements, recursively for each file.
+
+    let status = Command::new("bash").args([
+        "-c",
+        &format!(
+            "find \"{}\" -type f -name '*.dsa' -exec sed -i '/^include/ s/\\.dsc/.dsa/g' {{}} +",
+            ctx.build_dir.display()
+        ),
+    ]).status()?;
+
+    if !status.success() {
+        return Err(BuildError::IoError(String::from(
+            "Failed to execute build command command",
+        )));
+    }
+
+    // assemble result
+    {
+        fs::create_dir_all(&ctx.artifact_dir)?;
+        let mut asm = Assembler::new(&main_path);
+        asm.start(());
+        asm.write_result(&binary_path)?;
+    }
+
+    println!("Build finished. Binary at {}", binary_path.display());
+    Ok(())
+}
+
+// ----- Helpers -------------------------------
+
+struct BuildStep;
+impl BuildStep {
+    pub fn compiling(path: &Path) {
+        println!("Compiling {}", path.display());
+    }
+
+    pub fn assembling(path: &Path) {
+        println!("Assembling {}", path.display());
+    }
+}
+
+/// Checks what source languages are used in the project.
+fn detect_source_language(src_dir: &Path) -> (bool, bool) {
+    let mut contains_dsc = false;
+    let mut contains_dsa = false;
+
+    for entry in walkdir::WalkDir::new(src_dir).into_iter().flatten() {
+        match entry.path().extension().and_then(|s| s.to_str()) {
+            Some("dsc") => contains_dsc = true,
+            Some("dsa") => contains_dsa = true,
+            _ => {}
+        }
+    }
+    (contains_dsa, contains_dsc)
+}
+
+// Checks if either main.dsa or main.dsc exist in the source directory
+fn main_exists(src_dir: &Path) -> Result<bool, std::io::Error> {
+    for entry in fs::read_dir(src_dir).into_iter().flatten() {
+        match entry?.path().file_name().and_then(|s| s.to_str()) {
+            Some("main.dsc") => return Ok(true),
+            Some("main.dsa") => return Ok(true),
+            _ => {}
+        }
+    }
+
+    Ok(false)
+}
+
+// Copy contents of one directory to another
+fn copy_recursively(src: &Path, dst: &Path) -> Result<(), std::io::Error> {
+    if src.is_file() {
+        fs::create_dir_all(dst.parent().unwrap())?;
+        fs::copy(src, dst)?;
+        return Ok(());
+    }
+
+    if src.is_dir() {
+        for entry in fs::read_dir(src)? {
+            let entry = entry?;
+            let child_src = entry.path();
+            let child_dst = dst.join(entry.file_name());
+            copy_recursively(&child_src, &child_dst)?;
+        }
+    }
+
+    Ok(())
+}
+
+fn build_all_dsc(path: &Path) -> Result<(), BuildError> {
+    if path.is_dir() {
+        for entry in fs::read_dir(path)? {
+            let entry = entry?;
+            build_all_dsc(&entry.path())?;
+        }
+
+        return Ok(());
+    }
+
+    if path.extension().and_then(|s| s.to_str()) == Some("dsc") {
+        let input_path = path;
+        let output_path = path.with_extension("dsa");
+
+        let is_lib = !(input_path.file_stem().unwrap().to_str().unwrap() == "main");
+
+        let mut compiler = Compiler::new(input_path);
+        compiler.start(is_lib);
+        compiler.write_result(output_path.clone())?;
+    }
+
+    Ok(())
+}

dsx/dsx_common/src/common/templates.rs

@@ -140,7 +140,7 @@ fn main() -> u32 {{
 }
 
 pub fn create_print_lib() -> String {
-    format!(
+    String::from(
         r#"
 // lib:
 // print.dsa
@@ -473,12 +473,12 @@ _end:
     mov bpr, spr
     pop bpr
     return
-"#
+"#,
     )
 }
 
 pub fn create_maths_lib() -> String {
-    format!(
+    String::from(
         r#"
 // multiply.dsa
 // usage:
@@ -584,6 +584,6 @@ skip_add:
     mov bpr, spr
     pop bpr
     return
-"#
+"#,
     )
 }

dsx/dsx_common/src/config.rs

@@ -0,0 +1,45 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DsxConfig {
+    pub name: String,
+
+    #[serde(default)]
+    pub description: Option<String>,
+
+    #[serde(default)]
+    #[serde(rename = "remote")]
+    pub remote_url: Option<String>,
+
+    #[serde(default)]
+    pub binaries: Vec<Binary>,
+    // todo!
+    // #[serde(default)]
+    // pub libraries: Vec<Library>,
+}
+
+impl DsxConfig {
+    pub fn new(name: &str) -> Self {
+        Self {
+            name: name.to_string(),
+            description: None,
+            remote_url: None,
+            binaries: Vec::new(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Binary {
+    pub name: String,
+    pub path: String,
+}
+
+impl Binary {
+    pub fn new(name: &str, path: &str) -> Self {
+        Self {
+            name: name.to_string(),
+            path: path.to_string(),
+        }
+    }
+}

dsx/dsx_common/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod builder;
+pub mod config;

dsx/dsx_repo_data/repos/test/Package.toml

@@ -0,0 +1,4 @@
+id = "test"
+latest_build_date = "2026-02-25 14:39:49"
+latest_build_status = "success"
+latest_build_id = "test"

dsx/dsx_repo_data/repos/test/repo/Dsx.toml

@@ -0,0 +1,3 @@
+name = "test"
+binaries = []
+remote = "http://localhost:8000/api/pkg/test"

dsx/dsx_repo_data/repos/test/repo/src/lib/arena_alloc.dsc

@@ -0,0 +1,77 @@
+// Arena Allocator
+// Supports multiple arenas that can be destroyed independently
+// Much more practical than a simple bump allocator
+
+// Global heap management
+static heap_start: u32 = 0x30000;
+static heap_end: u32 = 0x40000;
+static heap_current: u32 = 0x30000;
+
+// Arena structure (stored at the start of each arena):
+// [0-3]: start_address (u32)
+// [4-7]: current_position (u32)
+// [8-11]: end_address (u32)
+// Total header size: 12 bytes
+
+// Create a new arena with given size
+// Returns pointer to arena handle (or 0 if failed)
+fn new(size: u32) -> u32 {
+    let total_size: u32 = size + 12;
+    let arena_ptr: u32 = heap_current;
+    let new_current: u32 = arena_ptr + total_size;
+
+    // Check if we have space
+    if new_current > heap_end {
+        return 0;
+    }
+
+    // Calculate arena data region
+    let data_start: u32 = arena_ptr + 12;
+    let data_end: u32 = arena_ptr + total_size;
+
+    // Initialize arena header
+    // Note: In real implementation, you'd use pointer writes here
+    // For now, using placeholder comments:
+    *arena_ptr = data_start;        // start_address
+    *(arena_ptr + 4) = data_start;  // current_position
+    *(arena_ptr + 8) = data_end;    // end_address
+
+    heap_current = new_current;
+
+    return arena_ptr;
+}
+
+// Allocate from an arena
+// Returns pointer to allocated memory (or 0 if failed)
+fn alloc(arena: u32, size: u32) -> u32 {
+    // Read current position from arena
+    let current: u32 = *(arena + 4);
+    let end: u32 = *(arena + 8);
+
+    let new_current: u32 = current + size;
+
+    // Check if arena has space
+    if new_current > end {
+        return 0;
+    }
+
+    // Update current position in arena
+    *(arena + 4) = new_current;
+
+    return current;
+}
+
+// Destroy an arena (in bump allocator, this is a no-op)
+// In a real allocator, you'd mark the memory as free
+fn destroy(arena: u32) {
+    // In a true allocator, mark memory as reusable
+    // For bump allocator, we can't reclaim memory
+    // unless we destroy ALL arenas and reset
+    return 0;
+}
+
+// Reset entire heap (destroys ALL arenas)
+fn reset_all() {
+    heap_current = heap_start;
+    return 0;
+}

dsx/dsx_repo_data/repos/test/repo/src/lib/maths.dsa

@@ -0,0 +1,104 @@
+// multiply.dsa
+// usage:
+//
+// include multiply "<relative path>"
+//
+// usage for multiply:
+// push (arg1)
+// push (arg0)
+// call multiply::multiply
+// pop (arg0)
+// pop (arg1)
+
+multiply:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8  // load op 2
+    ldw bpr, rg1, 12 // load op 1
+    lwi 0, rg2       // initialise rg2 to zero
+
+_multiply_loop:
+    add rg2, rg0, rg2
+    dec rg1
+
+    cmp rg1, zero
+    jgt _multiply_loop
+
+_multiply_end:
+    stw rg2, bpr, 8
+
+    mov bpr, spr
+    pop bpr
+    return
+
+divmod:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg1, 8  // load op 2
+    ldw bpr, rg0, 12 // load op 1
+
+    lli 0, rg3
+
+_divmod_loop:
+    cmp rg0, rg1
+    jlt _divmod_end
+
+    sub rg0, rg1, rg0
+    inc rg3
+
+    jmp _divmod_loop
+
+_divmod_end:
+    // store div in first arg
+    // store mod in second arg
+    stw rg3, bpr, 8
+    stw rg0, bpr, 12
+
+    mov bpr, spr
+    pop bpr
+    return
+
+// multiply.dsa - improved version
+// Multiplies two 32-bit numbers using shift-and-add
+//
+// Usage:
+// push operand2  (multiplier)
+// push operand1  (multiplicand)
+// call multiply::multiply
+// pop result
+// pop zero       (discard second argument)
+
+new_multiply:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8     // rg0 = multiplicand
+    ldw bpr, rg1, 12    // rg1 = multiplier
+
+    lli 0, rg2          // rg2 = result (accumulator)
+    lli 32, rg3         // rg3 = bit counter
+
+mult_loop:
+    // Check if lowest bit of multiplier is 1
+    lli 1, acc
+    and rg1, acc, acc   // acc = rg1 & 1
+    cmp acc, zero
+    jeq skip_add        // if (rg1 & 1) == 0, skip addition
+
+    // Add multiplicand to result
+    add rg2, rg0, rg2
+
+skip_add:
+    shl rg0, 1          // shift multiplicand left
+    shr rg1, 1          // shift multiplier right
+
+    dec rg3
+    cmp rg3, zero
+    jgt mult_loop
+
+    stw rg2, bpr, 8     // store result
+    mov bpr, spr
+    pop bpr
+    return

dsx/dsx_repo_data/repos/test/repo/src/lib/print.dsa

@@ -0,0 +1,331 @@
+// lib:
+// print.dsa
+
+// usage:
+//
+// include print "<relative path>""
+//
+// usage for print:
+//      push (register containing address of string)
+//      push pcx
+//      jmp print::print
+//
+// usage for reset:
+//      push pcx
+//      jmp print::reset
+//
+// usage for clear:
+//      push pcx
+//      jmp print::clear
+//
+// usage for print_byte:
+//      push (register containing byte)
+//      push pcx
+//      jmp print::print_byte
+//
+// usage for print_word:
+//      push (register containing word)
+//      push pcx
+//      jmp print::print_word
+//
+// usage for print_num:
+//      push (register containing number to print in decimal)
+//      push pcx
+//      jmp print::print_num
+//
+
+include maths "./maths.dsa"
+
+dw display: 0x20000
+dw current: 0x20000
+
+// ------------------------------------------
+// prints the string at addr(arg[0]) to the screen. (no trailing whitespace unless explicitly provided)
+print:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    ldw current, rg1
+
+_print_loop:
+    ldb rg0, acc
+    cmp acc, zero
+    jeq _end
+    stb acc, rg1
+
+    addi rg0, 1
+    addi rg1, 1
+
+    jmp _print_loop
+
+// ------------------------------------------
+println:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    ldw current, rg1
+
+_println_loop:
+    ldb rg0, acc
+    cmp acc, zero
+    jeq _println_end
+    stb acc, rg1
+
+    addi rg0, 1
+    addi rg1, 1
+
+    jmp _println_loop
+
+_println_end:
+    call print_newline
+    jmp _end
+
+// ------------------------------------------
+// prints the value of arg[0] to the screen.
+print_word:
+    // initialise
+    push bpr
+    mov spr, bpr
+
+    // load byte into acc
+    ldw bpr, rg0, 8
+    ldw current, rg1
+
+    addi rg1, 3
+
+    stb rg0, rg1
+    subi rg1, 1
+    shr rg0, 8
+    stb rg0, rg1
+    subi rg1, 1
+    shr rg0, 8
+    stb rg0, rg1
+    subi rg1, 1
+    shr rg0, 8
+    stb rg0, rg1
+
+    addi rg1, 4
+    jmp _end
+
+// ------------------------------------------
+// prints the last byte of arg[0] to the screen.
+print_byte:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    ldw current, rg1
+
+    stb rg0, rg1
+    addi rg1, 1
+    jmp _end
+
+// ------------------------------------------
+// prints the value of arg[0] to the screen in hex.
+print_hex_word:
+    push bpr
+    mov spr, bpr
+
+    ldw current, rg1
+
+    ldb bpr, rg0, 8
+    push rg0
+    call _print_hex_byte
+    addi spr, 4
+
+    ldb bpr, rg0, 9
+    push rg0
+    call _print_hex_byte
+    addi spr, 4
+
+    ldb bpr, rg0, 10
+    push rg0
+    call _print_hex_byte
+    addi spr, 4
+
+    ldb bpr, rg0, 11
+    push rg0
+    call _print_hex_byte
+    addi spr, 4
+
+    jmp _end
+
+// ------------------------------------------
+// prints the last byte of arg[0] to the screen in hex.
+print_hex_byte:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    ldw current, rg1
+
+    call _print_hex_byte
+    jmp _end
+
+// function body
+_print_hex_byte:
+    // mask to get lower nibble
+    lli 0xF, rg2
+    // save rg0 state
+    push rg0
+
+    shr rg0, 4
+    and rg0, rg2, rg0
+    call _print_hex_nibble
+    pop rg0
+
+    and rg0, rg2, rg0
+    call _print_hex_nibble
+    return
+
+// print a hex digit
+_print_hex_nibble:
+    lli 10, rg3
+    cmp rg0, rg3
+    jlt _print_hex_nibble_number
+    addi rg0, 0x37, rg0
+    stb rg0, rg1
+    addi rg1, 1
+    return
+
+// helper function.
+_print_hex_nibble_number:
+    addi rg0, 0x30, rg0
+    stb rg0, rg1
+    addi rg1, 1
+    return
+
+// ------------------------------------------
+// print whitespace
+print_whitespace:
+    push bpr
+    mov spr, bpr
+
+    ldw current, rg1
+    lli 0x20, rg0
+    stb rg0, rg1
+    addi rg1, 1
+    jmp _end
+
+// ------------------------------------------
+// print newline
+print_newline:
+    push bpr
+    mov spr, bpr
+
+    // load variables into registers
+    ldw display, rg0
+    ldw current, rg1
+
+    // get the offset from the display base
+    sub rg1, rg0, rg0
+
+    lwi 80, rg2
+    pusha 3
+    push rg0
+    push rg2
+    call maths::divmod
+    pop zero  // result
+    pop rg3 // remainder
+    popa 3
+
+    sub rg1, rg3, rg2
+    addi rg2, 80, rg1
+
+    // _end saves the display state
+    jmp _end
+
+// ------------------------------------------
+// prints arg[0] as a decimal number to the screen.
+print_num:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8      // load number to print
+    lli 0, rg5           // rg5 = digit counter
+
+    // check if number is zero
+    cmp rg0, zero
+    jne _print_num_extract_digits
+
+    // special case: print '0' for zero
+    lli 0x30, rg6
+    push rg6             // push digit to stack buffer
+    lli 1, rg5           // we have 1 digit
+    jmp _print_num_output
+
+_print_num_extract_digits:
+    // divide by 10 repeatedly to get digits
+    cmp rg0, zero
+    jeq _print_num_output
+
+    // call divmod(rg0, 10)
+    push rg0             // dividend
+    lli 10, rg1
+    push rg1             // divisor (10)
+    call maths::divmod
+    pop rg0              // quotient (continue dividing this)
+    pop rg1              // remainder (the digit)
+
+    // convert digit to ASCII and push to stack buffer
+    addi rg1, 0x30, rg6  // convert to ASCII
+    push rg6             // push digit to stack
+    inc rg5              // increment digit counter
+
+    jmp _print_num_extract_digits
+
+_print_num_output:
+    // now print digits (pop them off in reverse order)
+    ldw current, rg1     // get display pointer
+
+_print_num_output_loop:
+    // check if we've printed all digits
+    cmp rg5, zero
+    jeq _print_num_done
+
+    // pop digit and print it
+    pop rg6
+    stb rg6, rg1
+    addi rg1, 1
+    dec rg5
+
+    jmp _print_num_output_loop
+
+_print_num_done:
+    jmp _end
+
+// ------------------------------------------
+// resets the cursor position on the screen to 0x20000. (0,0)
+reset:
+    push bpr
+    mov spr, bpr
+    ldw display, rg1
+    jmp _end
+
+// ------------------------------------------
+// clears the screen
+clear:
+    push bpr
+    mov spr, bpr
+    // display size = 2000 bytes / 500 words
+    lli 500 rg0
+    ldw display, rg1
+
+_clear_loop:
+    dec rg0
+    stw zero, rg1
+    addi rg1, 4
+    cmp rg0, zero
+    jgt _clear_loop
+    jmp _end
+
+// ------------------------------------------
+// return
+_end:
+    stw rg1, current
+
+    mov bpr, spr
+    pop bpr
+    return

dsx/dsx_repo_data/repos/test/repo/src/lib/serial.dsa

@@ -0,0 +1,274 @@
+// lib:
+// print_serial.dsa
+
+// usage:
+//
+// include print_serial "<relative path>"
+//
+// usage for print:
+//      push (register containing address of string)
+//      push pcx
+//      jmp print_serial::print
+//
+// usage for print_byte:
+//      push (register containing byte)
+//      push pcx
+//      jmp print_serial::print_byte
+//
+// usage for print_word:
+//      push (register containing word)
+//      push pcx
+//      jmp print_serial::print_word
+//
+// usage for print_hex_byte:
+//      push (register containing byte)
+//      push pcx
+//      jmp print_serial::print_hex_byte
+//
+// usage for print_hex_word:
+//      push (register containing word)
+//      push pcx
+//      jmp print_serial::print_hex_word
+//
+// usage for print_whitespace:
+//      push pcx
+//      jmp print_serial::print_whitespace
+//
+// usage for print_newline:
+//      push pcx
+//      jmp print_serial::print_newline
+//
+// usage for print_num:
+//      push (register containing number to print in decimal)
+//      push pcx
+//      jmp print_serial::print_num
+//
+// usage for println:
+//      push (register containing address of string)
+//      push pcx
+//      jmp print_serial::println
+//
+
+include maths "./maths.dsa"
+
+dw serial: 0x207D0      // 0x20000 + 2000
+
+// ------------------------------------------
+// prints the string at addr(arg[0]) to the serial port.
+print:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    lwi 0x207D0, rg1
+
+_print_loop:
+    ldb rg0, acc
+    cmp acc, zero
+    jeq _end
+    stb acc, rg1
+
+    addi rg0, 1
+    jmp _print_loop
+
+// ------------------------------------------
+// prints the string at addr(arg[0]) followed by a newline to the serial port.
+println:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    lwi 0x207D0, rg1
+
+_println_loop:
+    ldb rg0, acc
+    cmp acc, zero
+    jeq _println_end
+    stb acc, rg1
+
+    addi rg0, 1
+    jmp _println_loop
+
+_println_end:
+    lli 0x0A, rg2       // newline character
+    stb rg2, rg1
+    jmp _end
+
+// ------------------------------------------
+// prints the word in arg[0] as 4 raw bytes to the serial port.
+print_word:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    lwi 0x207D0, rg1
+
+    stb rg0, rg1
+    shr rg0, 8
+    stb rg0, rg1
+    shr rg0, 8
+    stb rg0, rg1
+    shr rg0, 8
+    stb rg0, rg1
+    jmp _end
+
+// ------------------------------------------
+// prints the last byte of arg[0] to the serial port.
+print_byte:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    lwi 0x207D0, rg1
+
+    stb rg0, rg1
+    jmp _end
+
+// ------------------------------------------
+// prints the value of arg[0] to the serial port in hex.
+print_hex_word:
+    push bpr
+    mov spr, bpr
+
+    lwi 0x207D0, rg1
+
+    ldb bpr, rg0, 8
+    push rg0
+    call _print_hex_byte
+    addi spr, 4
+
+    ldb bpr, rg0, 9
+    push rg0
+    call _print_hex_byte
+    addi spr, 4
+
+    ldb bpr, rg0, 10
+    push rg0
+    call _print_hex_byte
+    addi spr, 4
+
+    ldb bpr, rg0, 11
+    push rg0
+    call _print_hex_byte
+    addi spr, 4
+
+    jmp _end
+
+// ------------------------------------------
+// prints the last byte of arg[0] to the serial port in hex.
+print_hex_byte:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    lwi 0x207D0, rg1
+
+    call _print_hex_byte
+    jmp _end
+
+// function body
+_print_hex_byte:
+    lli 0xF, rg2
+    push rg0
+
+    shr rg0, 4
+    and rg0, rg2, rg0
+    call _print_hex_nibble
+    pop rg0
+
+    and rg0, rg2, rg0
+    call _print_hex_nibble
+    return
+
+// print a hex digit
+_print_hex_nibble:
+    lli 10, rg3
+    cmp rg0, rg3
+    jlt _print_hex_nibble_number
+    addi rg0, 0x37, rg0
+    stb rg0, rg1
+    return
+
+_print_hex_nibble_number:
+    addi rg0, 0x30, rg0
+    stb rg0, rg1
+    return
+
+// print a single space
+print_whitespace:
+    push bpr
+    mov spr, bpr
+
+    lli 0x20, rg0
+    ldw serial, rg1
+    stb rg0, rg1
+
+    jmp _end
+
+// print a single space
+print_newline:
+    push bpr
+    mov spr, bpr
+
+    lli 0x0A, rg0
+    ldw serial, rg1
+    stb rg0, rg1
+
+    jmp _end
+
+// ------------------------------------------
+// prints arg[0] as a decimal number to the serial port.
+print_num:
+    push bpr
+    mov spr, bpr
+
+    ldw bpr, rg0, 8
+    lli 0, rg5
+
+    cmp rg0, zero
+    jne _print_num_extract_digits
+
+    lli 0x30, rg6
+    push rg6
+    lli 1, rg5
+    jmp _print_num_output
+
+_print_num_extract_digits:
+    cmp rg0, zero
+    jeq _print_num_output
+
+    push rg0
+    lli 10, rg1
+    push rg1
+    call maths::divmod
+    pop rg0
+    pop rg1
+
+    addi rg1, 0x30, rg6
+    push rg6
+    inc rg5
+
+    jmp _print_num_extract_digits
+
+_print_num_output:
+    lwi 0x207D0, rg1
+
+_print_num_output_loop:
+    cmp rg5, zero
+    jeq _print_num_done
+
+    pop rg6
+    stb rg6, rg1
+    dec rg5
+
+    jmp _print_num_output_loop
+
+_print_num_done:
+    jmp _end
+
+// ------------------------------------------
+// return
+_end:
+    mov bpr, spr
+    pop bpr
+    return

dsx/dsx_repo_data/repos/test/repo/src/main.dsc

@@ -0,0 +1,30 @@
+include serial: "./lib/serial.dsa";
+include print: "./lib/print.dsa";
+include arena: "./lib/arena_alloc.dsc";
+
+fn main() {
+    let x: u32 = 0;
+    let y: u32 = &x;
+
+    let alloc: u32 = arena::new(512);
+    let ptr1: u32 = arena::alloc(alloc, 32);
+    let ptr2: u32 = arena::alloc(alloc, 32);
+
+    serial::print_hex_word(alloc);
+    serial::print_newline();
+    serial::print_hex_word(ptr1);
+    serial::print_newline();
+    serial::print_hex_word(ptr2);
+    serial::print_newline();
+    serial::print_num(*ptr2);
+    serial::print_newline();
+    *ptr2 = 42;
+
+    serial::print_hex_word(ptr2);
+    serial::print_whitespace();
+    serial::print_num(*ptr2);
+    serial::print_newline();
+    serial::println("end");
+
+    return 0;
+}

dsx/dsx_server/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "dsx_server"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+
+[[bin]]
+name = "dsx-server"
+path = "src/main.rs"
+
+[dependencies]
+compiler = { path = "../../core/compiler" }
+assembler = { path = "../../core/assembler" }
+common = { path = "../../core/dsa_common" }
+dsx_common = { path = "../dsx_common" }
+
+dotenv = "0.15.0"
+rocket = { version = "0.5.1", features = ["json"] }
+rocket_dyn_templates = { version = "0.2.0", features = ["tera"] }
+serde = { version = "1.0.228", features = ["derive"] }
+toml = "1.0.3"
+tracing = "0.1.44"
+tracing-subscriber = { version = "0.3.22", features = ["env-filter"] }
+chrono = "0.4.43"
+tar = "0.4.44"
+flate2 = "1.1.9"
+walkdir = "2.5.0"
+tokio = { version = "1.49.0", features = ["rt"] }

dsx/dsx_server/bacon.toml

@@ -0,0 +1,106 @@
+default_job = "check"
+env.CARGO_TERM_COLOR = "always"
+
+[jobs.check]
+command = ["cargo", "check"]
+need_stdout = false
+
+[jobs.check-all]
+command = ["cargo", "check", "--all-targets"]
+need_stdout = false
+
+# Run clippy on the default target
+[jobs.clippy]
+command = ["cargo", "clippy"]
+need_stdout = false
+
+[jobs.clippy-all]
+command = ["cargo", "clippy", "--all-targets"]
+need_stdout = false
+
+# Run clippy in pedantic mode
+# The 'dismiss' feature may come handy
+[jobs.pedantic]
+command = [
+	"cargo", "clippy",
+	"--",
+	"-W", "clippy::pedantic",
+]
+need_stdout = false
+
+# This job lets you run
+# - all tests: bacon test
+# - a specific test: bacon test -- config::test_default_files
+# - the tests of a package: bacon test -- -- -p config
+[jobs.test]
+command = ["cargo", "test"]
+need_stdout = true
+
+[jobs.nextest]
+command = [
+    "cargo", "nextest", "run",
+    "--hide-progress-bar", "--failure-output", "final"
+]
+need_stdout = true
+analyzer = "nextest"
+
+[jobs.doc]
+command = ["cargo", "doc", "--no-deps"]
+need_stdout = false
+
+# If the doc compiles, then it opens in your browser and bacon switches
+# to the previous job
+[jobs.doc-open]
+command = ["cargo", "doc", "--no-deps", "--open"]
+need_stdout = false
+on_success = "back" # so that we don't open the browser at each change
+
+# You can run your application and have the result displayed in bacon,
+# if it makes sense for this crate.
+[jobs.run]
+command = [
+    "cargo", "run", "--bin", "dsx-server"
+    # put launch parameters for your program behind a `--` separator
+]
+need_stdout = true
+allow_warnings = true
+background = true
+
+# Run your long-running application (eg server) and have the result displayed in bacon.
+# For programs that never stop (eg a server), `background` is set to false
+# to have the cargo run output immediately displayed instead of waiting for
+# program's end.
+# 'on_change_strategy' is set to `kill_then_restart` to have your program restart
+# on every change (an alternative would be to use the 'F5' key manually in bacon).
+# If you often use this job, it makes sense to override the 'r' key by adding
+# a binding `r = job:run-long` at the end of this file .
+# A custom kill command such as the one suggested below is frequently needed to kill
+# long running programs (uncomment it if you need it)
+[jobs.run-long]
+command = [
+    "cargo", "run",
+    # put launch parameters for your program behind a `--` separator
+]
+need_stdout = true
+allow_warnings = true
+background = false
+on_change_strategy = "kill_then_restart"
+# kill = ["pkill", "-TERM", "-P"]
+
+# This parameterized job runs the example of your choice, as soon
+# as the code compiles.
+# Call it as
+#    bacon ex -- my-example
+[jobs.ex]
+command = ["cargo", "run", "--example"]
+need_stdout = true
+allow_warnings = true
+
+# You may define here keybindings that would be specific to
+# a project, for example a shortcut to launch a specific job.
+# Shortcuts to internal functions (scrolling, toggling, etc.)
+# should go in your personal global prefs.toml file instead.
+[keybindings]
+# alt-m = "job:my-job"
+c = "job:clippy-all" # comment this to have 'c' run clippy on only the default target
+p = "job:pedantic"

dsx/dsx_server/doc/endpoints.md

@@ -0,0 +1,20 @@
+
+# Endpoints
+
+let n be the repo name.
+
+## Web view
+GET  /packages/                       # home page listing packages - simple search bar.
+GET  /packages?q=<query>              # search for a package
+GET  /packages/<name>                 # main page for a repository, shows status, files, name etc.
+GET  /packages/<name>/~repo/<path>    # path for a file within a repo
+GET  /packages/<name>/~repo?q=<query> # search within a package's files
+GET  /packages/<name>/~artifact/      # page listing repo artifacts by date
+GET  /packages/<name>/~artifact/<id>  # page for a specific artifact and status/logs
+
+## API
+POST /api/pkg                         # create repo
+GET  /api/pkg/<name>                  # repo status/metadata
+POST /api/pkg/<name>/push             # upload source tarball
+GET  /api/pkg/<name>/pull             # download source tarball
+GET  /api/pkg/<name>/artifact         # download compiled binary

dsx/dsx_server/doc/structure.md

@@ -0,0 +1,15 @@
+# Folder structure
+
+data/
+  repos/
+    <repo_name>/
+      repo/
+        Dsx.toml
+        README.md
+        src/
+      artifacts/
+        <repo_name>.dsb
+        <repo_name-lib>.dsb
+      docs/
+        <repo_name-lib>.md
+  index/

dsx/dsx_server/src/error.rs

@@ -0,0 +1,82 @@
+use common::build::BuildError;
+use rocket::response::Responder;
+use serde::Serialize;
+
+#[derive(Debug, Serialize, Responder)]
+pub enum ApiError {
+    #[response(status = 404)]
+    NotFound(String),
+
+    #[response(status = 500)]
+    InternalServerError(()),
+
+    #[response(status = 500)]
+    ServerError(String),
+
+    #[response(status = 401)]
+    Unauthorized(String),
+    #[response(status = 403)]
+    Forbidden(String),
+
+    #[response(status = 400)]
+    BadRequest(String),
+}
+
+impl From<std::io::Error> for ApiError {
+    fn from(err: std::io::Error) -> Self {
+        ApiError::InternalServerError(())
+    }
+}
+
+impl From<BuildError> for ApiError {
+    fn from(err: BuildError) -> Self {
+        match err {
+            BuildError::IoError(err) => ApiError::ServerError(err.to_string()),
+            BuildError::Generic(err) => ApiError::ServerError(err),
+        }
+    }
+}
+
+impl From<DsxError> for ApiError {
+    fn from(err: DsxError) -> Self {
+        ApiError::ServerError(format!("{:?}: {}", err.r#type, err.message))
+    }
+}
+
+#[derive(Debug)]
+pub struct DsxError {
+    pub message: String,
+    pub r#type: ErrorType,
+}
+
+impl DsxError {
+    pub fn new(message: impl AsRef<str>) -> Self {
+        DsxError {
+            message: message.as_ref().to_string(),
+            r#type: ErrorType::Generic,
+        }
+    }
+
+    pub fn with_context(message: impl AsRef<str>, r#type: ErrorType) -> Self {
+        DsxError {
+            message: message.as_ref().to_string(),
+            r#type,
+        }
+    }
+}
+
+impl From<std::io::Error> for DsxError {
+    fn from(err: std::io::Error) -> Self {
+        Self::with_context(err.to_string(), ErrorType::IoError)
+    }
+}
+
+#[derive(Default, Debug)]
+pub enum ErrorType {
+    BuildFailed,
+    IoError,
+
+    #[default]
+    Generic,
+    TarError,
+}

dsx/dsx_server/src/main.rs

@@ -0,0 +1,82 @@
+#[macro_use]
+extern crate rocket;
+
+use std::fs;
+use std::path::PathBuf;
+use std::sync::LazyLock;
+
+use rocket::Data;
+use rocket::data::ToByteUnit;
+use rocket::serde::json::Json;
+use rocket::{fs::FileServer, serde::Deserialize};
+
+use rocket_dyn_templates::tera::{Function, Value};
+use rocket_dyn_templates::{Template, context, tera};
+
+use dotenv::dotenv;
+use serde::Serialize;
+use tracing::warn;
+
+use crate::error::ApiError;
+use crate::model::{Package, PackageMeta};
+use dsx_common::config::DsxConfig;
+
+mod error;
+mod model;
+
+mod routes;
+
+fn language_colour() -> impl Function {
+    Box::new(
+        move |args: &std::collections::HashMap<String, Value>| -> tera::Result<Value> {
+            match args.get("lang") {
+                Some(Value::String(lang)) => match lang.as_str() {
+                    // language syntax colour
+                    "dsc" => Ok(Value::String("#000000".to_string())),
+                    "dsa" => Ok(Value::String("#3776AB".to_string())),
+                    _ => Ok(Value::String("#FFFFFF".to_string())),
+                },
+                Some(_) => Err(tera::Error::msg("Invalid argument type")),
+                None => Ok(Value::String("#FFFFFF".to_string())),
+            }
+        },
+    )
+}
+
+#[launch]
+fn rocket() -> _ {
+    if dotenv().is_err() {
+        eprintln!("Failed to load .env file");
+    }
+
+    use routes::api;
+    use routes::pages;
+
+    rocket::build()
+        .mount(
+            "/packages",
+            routes![
+                pages::search_packages,
+                pages::package_main,
+                pages::repo_file,
+                pages::search_repo_files,
+                pages::list_artifacts,
+                pages::artifact_detail,
+            ],
+        )
+        .mount(
+            "/api",
+            routes![
+                api::create_repo,
+                api::get_pkg,
+                api::push_tarball,
+                api::pull_tarball,
+                api::download_artifact
+            ],
+        )
+        .attach(Template::custom(|tera| {
+            tera.tera
+                .register_function("language_colour", language_colour());
+        }))
+        .mount("/static", FileServer::from("./static"))
+}

dsx/dsx_server/src/model.rs

@@ -0,0 +1,316 @@
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::sync::LazyLock;
+
+use chrono::Utc;
+use dsx_common::builder::{self, BuildContext};
+use dsx_common::config::DsxConfig;
+use serde::{Deserialize, Serialize};
+use walkdir::WalkDir;
+
+pub static DATA_DIR: LazyLock<PathBuf> = LazyLock::new(|| {
+    PathBuf::from(std::env::var("DATA_DIR").unwrap_or("./data".to_string()))
+});
+
+use crate::error::{ApiError, DsxError, ErrorType};
+
+// stored as a Package.toml above the repository root.
+// not directly modifiable by the user/maintainer.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PackageMeta {
+    pub id: String,
+
+    #[serde(default)]
+    pub latest_build_date: Option<String>,
+    #[serde(default)]
+    pub latest_build_status: Option<String>,
+    #[serde(default)]
+    pub latest_build_id: Option<String>,
+
+    #[serde(default)]
+    pub detected_languages: Option<Vec<String>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Package {
+    pub config: DsxConfig,
+    pub language: String,
+    pub meta: PackageMeta,
+    pub files: Vec<FileObj>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FileObj {
+    pub name: String,
+    pub path: String,
+    pub is_dir: bool,
+    pub size: u64,
+    pub extension: String,
+}
+
+enum BuildStatus {
+    // if we don't know the build state, or no build has run before.
+    None,
+
+    // waiting for build
+    Pending,
+
+    // build
+    Building,
+
+    // build result
+    Success,
+    Failure,
+    Error,
+}
+
+pub struct PackageHandle {
+    // id of the package
+    pub package_id: String,
+
+    config: Option<DsxConfig>,
+    meta: Option<PackageMeta>,
+
+    // build info
+    build_state: BuildStatus,
+}
+
+impl PackageHandle {
+    const META_PATH: &'static str = "Package.toml";
+    const CONFIG_PATH: &'static str = "repo/Dsx.toml";
+    const ARTIFACTS_DIR: &'static str = "artifacts";
+
+    pub fn new(package_id: impl Into<String>) -> Self {
+        PackageHandle {
+            package_id: package_id.into(),
+            config: None,
+            meta: None,
+            build_state: BuildStatus::None,
+        }
+    }
+
+    pub fn load(&mut self) -> Result<&mut Self, DsxError> {
+        self.get_config()?;
+        self.get_meta()?;
+        Ok(self)
+    }
+
+    pub fn tarball(&self) -> Result<Vec<u8>, DsxError> {
+        let src_dir = self.path().join("repo");
+        pack_tarball(&src_dir)
+    }
+
+    pub fn unpack(&mut self, archive: &Path) -> Result<&mut Self, DsxError> {
+        let dest = DATA_DIR.join("repos").join(&self.package_id).join("repo");
+        unpack_tarball(archive, &dest)?;
+        self.load()
+    }
+
+    pub fn path(&self) -> PathBuf {
+        DATA_DIR.join("repos").join(&self.package_id)
+    }
+
+    pub fn build(&mut self) -> Result<&mut Self, DsxError> {
+        let ctx = BuildContext {
+            project_dir: self.path().join("repo"),
+            build_dir: self.path().join("build"),
+            artifact_dir: self.path().join("artifacts"),
+        };
+
+        self.build_state = BuildStatus::Building;
+
+        let id = self.package_id.clone();
+        tokio::task::spawn_blocking(move || {
+            let id = id;
+
+            let res = match builder::build_project(ctx) {
+                Ok(_) => "success",
+                Err(_) => "failure",
+            };
+
+            let mut handle = PackageHandle::new(&id);
+            let mut meta = handle.get_meta().unwrap();
+            meta.latest_build_date =
+                Some(Utc::now().format("%Y-%m-%d %H:%M:%S").to_string());
+            meta.latest_build_status = Some(res.to_string());
+            meta.latest_build_id = Some(id);
+            handle.set_meta(meta)
+        });
+
+        Ok(self)
+    }
+
+    pub fn get_config(&mut self) -> Result<DsxConfig, DsxError> {
+        let config_path = self.path().join(Self::CONFIG_PATH);
+
+        let config = fs::read_to_string(&config_path).map_err(|e| {
+            warn!("unable to read Dsx.toml, {e}");
+            DsxError::with_context("Unable to read Dsx.toml", ErrorType::IoError)
+        })?;
+
+        let config: DsxConfig = toml::from_str(&config).map_err(|e| {
+            warn!("unable to parse Dsx.toml: {e}");
+            DsxError::new("Unable to parse Dsx.toml")
+        })?;
+
+        self.config = Some(config.clone());
+        Ok(config)
+    }
+
+    pub fn get_meta(&mut self) -> Result<PackageMeta, DsxError> {
+        let meta_path = self.path().join(Self::META_PATH);
+
+        let meta = fs::read_to_string(&meta_path).map_err(|e| {
+            warn!("unable to read Package.toml, {e}");
+            DsxError::with_context("Unable to read Package.toml", ErrorType::IoError)
+        })?;
+
+        let meta: PackageMeta = toml::from_str(&meta).map_err(|e| {
+            warn!("unable to parse Package.toml: {e}");
+            DsxError::new("Unable to parse Package.toml")
+        })?;
+
+        self.meta = Some(meta.clone());
+        Ok(meta)
+    }
+
+    pub fn set_meta(&mut self, meta: PackageMeta) -> Result<(), DsxError> {
+        self.meta = Some(meta);
+        self.save_meta()
+    }
+
+    fn save_meta(&self) -> Result<(), DsxError> {
+        let meta_path = self.path().join(Self::META_PATH);
+        let str = toml::to_string(&self.meta.as_ref().unwrap()).unwrap();
+
+        fs::write(&meta_path, str).map_err(|e| {
+            warn!("unable to write Package.toml, {e}");
+            DsxError::with_context("Unable to write Package.toml", ErrorType::IoError)
+        })?;
+        Ok(())
+    }
+
+    pub fn get_languages(&mut self) -> Result<Vec<String>, DsxError> {
+        self.get_meta()?;
+
+        if let Some(languages) = &self.meta.as_ref().unwrap().detected_languages {
+            return Ok(languages.clone());
+        }
+
+        let mut langs = Vec::new();
+
+        for entry in WalkDir::new(self.path().join("repo/src"))
+            .into_iter()
+            .flatten()
+        {
+            if entry.file_type().is_file() {
+                let path = entry.path();
+                let extension = path.extension().and_then(|ext| ext.to_str());
+                if let Some(ext) = extension {
+                    match ext {
+                        "dsa" | "dsc" => langs.push(ext.to_string()),
+                        _ => {}
+                    }
+                }
+            }
+        }
+
+        self.meta.as_mut().unwrap().detected_languages = Some(langs.clone());
+
+        Ok(langs)
+    }
+
+    pub fn get_artifact(&self) -> Result<Vec<u8>, DsxError> {
+        println!(
+            "{}",
+            self.path()
+                .join(Self::ARTIFACTS_DIR)
+                .join("out.dsb")
+                .display()
+        );
+
+        let artifact_path = self.path().join(Self::ARTIFACTS_DIR).join("out.dsb");
+        fs::read(artifact_path).map_err(|e| {
+            warn!("unable to read artifact for repo: {e}");
+            DsxError::new("Unable to read artifact")
+        })
+    }
+
+    pub fn file_tree(&self, subpath: impl AsRef<Path>) -> Result<Vec<FileObj>, DsxError> {
+        let repo = self.path().join("repo").join(subpath);
+
+        let dir = fs::read_dir(repo).map_err(|e| {
+            warn!("unable to read files for repo, {e}");
+            DsxError::new("Unable to read files in repository")
+        })?;
+
+        let mut files = Vec::new();
+
+        // for entry in WalkDir::new(repo_path.join("repo")).max_depth(1) {
+        for entry in dir {
+            let entry = entry.map_err(|e| {
+                warn!("unable to read file entry for repo, {e}");
+                DsxError::new("Internal error")
+            })?;
+
+            // remove root of DATA_DIR/repos/<name>/repo
+            let path = entry.path();
+
+            let metadata = fs::metadata(&path).map_err(|e| {
+                warn!("unable to read file metadata for repo, {e}");
+                DsxError::new("Internal error")
+            })?;
+            let is_dir = metadata.is_dir();
+            let size = metadata.len();
+            let extension = path
+                .extension()
+                .map_or(String::new(), |ext| ext.to_string_lossy().to_string());
+            files.push(FileObj {
+                path: path
+                    .strip_prefix(self.path().join("repo"))
+                    .unwrap()
+                    .to_string_lossy()
+                    .to_string(),
+                name: path.file_name().unwrap().to_string_lossy().to_string(),
+                is_dir,
+                size,
+                extension,
+            });
+        }
+
+        Ok(files)
+    }
+}
+
+// ── Tar helpers ───────────────────────────────────────────────────────────────
+
+use flate2::read::GzDecoder;
+use flate2::{Compression, write::GzEncoder};
+use std::fs::File;
+use tar::Builder;
+
+fn unpack_tarball(
+    archive: &std::path::Path,
+    dest: &std::path::Path,
+) -> Result<(), DsxError> {
+    let file = File::open(archive)
+        .map_err(|e| DsxError::with_context(e.to_string(), ErrorType::IoError))?;
+
+    fs::create_dir_all(dest)?;
+
+    let gz = GzDecoder::new(file);
+    let mut tar = tar::Archive::new(gz);
+    tar.unpack(dest)
+        .map_err(|e| DsxError::with_context(e.to_string(), ErrorType::TarError))?;
+
+    Ok(())
+}
+
+fn pack_tarball(src_dir: &std::path::Path) -> Result<Vec<u8>, DsxError> {
+    let buf = Vec::new();
+    let gz = GzEncoder::new(buf, Compression::default());
+    let mut tar = Builder::new(gz);
+    tar.append_dir_all(".", src_dir)?;
+    let gz = tar.into_inner()?;
+    Ok(gz.finish()?)
+}

dsx/dsx_server/src/routes/api.rs

@@ -0,0 +1,119 @@
+use std::fs;
+
+use dsx_common::config::DsxConfig;
+use rocket::{Data, data::ToByteUnit, serde::json::Json};
+use serde::Deserialize;
+
+use crate::{
+    error::ApiError,
+    model::{DATA_DIR, PackageHandle, PackageMeta},
+};
+
+#[derive(Deserialize)]
+#[serde(crate = "rocket::serde")]
+pub struct NewRepo<'r> {
+    name: &'r str,
+}
+
+// Create repo
+#[post("/pkg", data = "<repo>")]
+pub fn create_repo(repo: Json<NewRepo<'_>>) -> Result<(), &'static str> {
+    let path = DATA_DIR.join("repos").join(repo.name);
+
+    if repo.name.is_empty() {
+        return Err("Repository name cannot be empty!");
+    }
+
+    if path.exists() {
+        tracing::info!(
+            "Attempt to create repository '{}' which already exists.",
+            repo.name
+        );
+        return Err("This repository already exists!");
+    }
+
+    if let Err(e) = fs::create_dir_all(path) {
+        tracing::error!(
+            "Attempted to create package with name {} - Error: {e},",
+            repo.name
+        );
+        return Err("Internal server error");
+    }
+
+    Ok(())
+}
+
+// Repo status/metadata
+#[get("/pkg/<id>")]
+pub fn get_pkg(id: &str) -> Result<Json<(PackageMeta, DsxConfig)>, ApiError> {
+    let mut handle = PackageHandle::new(id);
+    let meta = handle.get_meta()?;
+    let config = handle.get_config()?;
+    Ok(Json((meta, config)))
+}
+
+// Upload source tarball
+#[post("/pkg/<id>/push", data = "<data>")]
+pub async fn push_tarball(id: &str, data: Data<'_>) -> Result<(), ApiError> {
+    let mut handle = PackageHandle::new(id);
+    let repo = handle.path();
+
+    let tmp_path = repo.join("upload.tar.gz");
+    let stream = data
+        .open(256.mebibytes())
+        .into_file(&tmp_path)
+        .await
+        .map_err(|e| ApiError::ServerError(e.to_string()))?;
+
+    if !stream.is_complete() {
+        return Err(ApiError::BadRequest("Incomplete upload".to_string()));
+    }
+
+    // Unpack over the existing repo dir.
+    // if the repo is already deleted that's fine so ignore err
+    if handle.path().exists() {
+        let _ = fs::remove_dir_all(repo.join("repo"));
+    }
+
+    handle.unpack(&tmp_path)?;
+    fs::remove_file(&tmp_path).ok();
+
+    // we don't care if there's an error in the build.
+    let _ = handle.build();
+
+    Ok(())
+}
+
+// Download source tarball
+#[get("/pkg/<id>/pull")]
+pub fn pull_tarball(
+    id: &str,
+) -> Result<(rocket::http::ContentType, Vec<u8>), Json<ApiError>> {
+    if let Ok(tarball) = PackageHandle::new(id).tarball() {
+        Ok((
+            rocket::http::ContentType::new("application", "octet-stream"),
+            tarball,
+        ))
+    } else {
+        Err(Json(ApiError::NotFound(format!(
+            "repo with id {id} does not exist"
+        ))))
+    }
+}
+
+// Download compiled binary
+#[get("/pkg/<id>/artifact")]
+pub fn download_artifact(
+    id: &str,
+) -> Result<(rocket::http::ContentType, Vec<u8>), Json<ApiError>> {
+    if let Ok(artifact) = PackageHandle::new(id).get_artifact() {
+        Ok((
+            rocket::http::ContentType::new("application", "octet-stream"),
+            artifact,
+        ))
+    } else {
+        Err(Json(ApiError::NotFound(format!(
+            "repo with id {id} does not have a valid artifact"
+        ))))
+    }
+}

dsx/dsx_server/src/routes/mod.rs

@@ -0,0 +1,2 @@
+pub mod api;
+pub mod pages;

dsx/dsx_server/src/routes/pages.rs

@@ -0,0 +1,145 @@
+use std::{fs, path::Path};
+
+use dsx_common::config::DsxConfig;
+use rocket_dyn_templates::{Template, context};
+use serde::Serialize;
+
+use crate::{
+    error::ApiError,
+    model::{DATA_DIR, PackageHandle},
+};
+
+// Search for a package
+#[get("/?<q>")]
+pub fn search_packages(q: Option<String>) -> Result<Template, ApiError> {
+    #[derive(Serialize)]
+    struct Package {
+        name: String,
+        description: String,
+        updated_at: String,
+    }
+
+    let mut packages = Vec::new();
+
+    let dir = match fs::read_dir(DATA_DIR.join("repos")) {
+        Ok(dir) => dir,
+        Err(e) => {
+            warn!("failed to read repos directory: {}", e);
+            return Err(ApiError::InternalServerError(()));
+        }
+    };
+
+    for entry in dir {
+        let entry = entry.map_err(|e| {
+            warn!("failed to read entry: {}", e);
+            ApiError::InternalServerError(())
+        })?;
+
+        let config_path = entry.path().join("repo").join("Dsx.toml");
+        if config_path.exists() {
+            let text = fs::read_to_string(&config_path).map_err(|e| {
+                warn!("failed to read config file: {}", e);
+                ApiError::InternalServerError(())
+            })?;
+            let config: DsxConfig = toml::from_str(&text).map_err(|e| {
+                warn!("failed to parse config file: {}", e);
+                ApiError::InternalServerError(())
+            })?;
+
+            error!("{}", config.description.clone().unwrap_or_default());
+
+            // skip repo if it doesnt match query params
+            if let Some(query) = &q
+                && !(config.name.contains(query)
+                    || config
+                        .description
+                        .clone()
+                        .unwrap_or_default()
+                        .contains(query))
+            {
+                continue;
+            }
+
+            packages.push(Package {
+                name: config.name,
+                description: config.description.unwrap_or_default(),
+                updated_at: String::from("0:00"),
+            })
+        }
+    }
+
+    Ok(Template::render(
+        "packages",
+        context! {
+            packages,
+            query: q.clone().unwrap_or_default()
+        },
+    ))
+}
+
+// Main page for a repository, shows status, files, name etc.
+#[get("/<id>")]
+pub fn package_main(id: &str) -> Result<Template, ApiError> {
+    // get package info
+
+    let mut handle = PackageHandle::new(id);
+    let meta = handle.get_meta()?;
+    let config = handle.get_config()?;
+    let files = handle.file_tree("")?;
+
+    let parent_path: Option<String> = None;
+    let current_path: Option<String> = None;
+
+    Ok(Template::render(
+        "package_home",
+        context! {
+            parent_path,
+            current_path,
+            meta: meta,
+            config: config,
+            files: files,
+        },
+    ))
+}
+
+// Path for a file within a repo
+#[get("/<id>/~repo/<path..>", rank = 1)]
+pub fn repo_file(id: &str, path: std::path::PathBuf) -> Result<Template, ApiError> {
+    // get package info
+    let mut handle = PackageHandle::new(id);
+    let meta = handle.get_meta()?;
+    let config = handle.get_config()?;
+    let files = handle.file_tree(&path)?;
+
+    let parent_path = path.parent().unwrap_or(Path::new(""));
+    let current_path = &path;
+
+    Ok(Template::render(
+        "package_home",
+        context! {
+            parent_path,
+            current_path,
+            meta: meta,
+            config: config,
+            files: files,
+        },
+    ))
+}
+
+// Search within a package's files
+#[get("/<name>/~repo?<q>", rank = 2)]
+pub fn search_repo_files(name: &str, q: Option<String>) -> String {
+    format!("Search within {} for {:?}", name, q)
+}
+
+// Page listing repo artifacts by date
+#[get("/<name>/artifacts")]
+pub fn list_artifacts(name: &str) -> String {
+    format!("Artifacts for package {}", name)
+}
+
+// Page for a specific artifact and status/logs
+#[get("/<name>/artifacts/<id>")]
+pub fn artifact_detail(name: &str, id: u64) -> String {
+    format!("Artifact {} details for package {}", id, name)
+}