add dsx clone command

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

.gitignore

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

.zed/tasks.json

@@ -19,11 +19,20 @@
     "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",

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]

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().expect("assembler failed.");
-
-    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)
-    }
-}

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,12 +0,0 @@
-use crate::model::{CompilerError, Program};
-
-mod codegen;
-mod instruction;
-mod registers;
-mod scope;
-mod variable;
-
-pub fn generate_code(ast: &Program) -> Result<String, CompilerError> {
-    let mut codegen = codegen::CodeGenerator::new(ast.clone());
-    codegen.generate()
-}

compiler/src/backend/dsa/scope.rs

@@ -1,287 +0,0 @@
-use std::{cell::RefCell, collections::HashMap, ops::Deref, rc::Rc};
-
-use uuid::Uuid;
-
-use crate::{
-    backend::dsa::{
-        instruction::{InsBlock, Instruction},
-        registers::{Register, RegisterAllocator},
-        variable::Variable,
-    },
-    model::CompilerError,
-};
-
-pub struct Allocator {
-    stack_offset: i32,
-    in_use: [(Register, bool); 16],
-}
-
-pub struct TempReg(Register);
-pub struct AssignedReg(Register);
-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
-    }
-}
-
-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_assigned(&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 read_var(&mut self, var: &mut Variable) -> Result<InsBlock, CompilerError> {
-        if let Some(slot) = &mut var.stack_slot {
-            if var.register.is_none() {
-                var.register = Some(self.allocate_var()?);
-            }
-
-            if let Some(reg) = &var.register {
-                return Ok(InsBlock::from(Instruction::ldw_reg_offset(
-                    **reg,
-                    Register::Spr,
-                    **slot - self.stack_offset,
-                )));
-            }
-
-            unreachable!()
-        }
-
-        Err(CompilerError::Generic(format!(
-            "Tried to write var {} to stack but var was not assigned a reg and/or stack slot",
-            var.name
-        )))
-    }
-
-    pub fn write_var(&mut self, var: &mut Variable) -> Result<InsBlock, CompilerError> {
-        if let Some(slot) = &var.stack_slot {
-            if let Some(reg) = &var.register {
-                return Ok(InsBlock::from(Instruction::stw_reg_offset(
-                    **reg,
-                    Register::Spr,
-                    **slot - self.stack_offset,
-                )));
-            }
-        }
-
-        Err(CompilerError::Generic(format!(
-            "Tried to write var {} to stack but var was not assigned a reg and/or stack slot",
-            var.name
-        )))
-    }
-
-    pub fn spill_var(&mut self, var: &mut Variable) -> Result<InsBlock, CompilerError> {
-        if let Some(slot) = &var.stack_slot {
-            let block = self.write_var(var)?;
-            if let Some(reg) = &var.register {
-                self.free_assigned(reg);
-                var.register = None;
-            }
-
-            return Ok(block);
-        }
-
-        // var doesn't have a stack slot so we need to create one
-        if let Some(reg) = &var.register {
-            let slot = self.allocate_stack_slot(var.size);
-            let block = InsBlock::from(Instruction::push(**reg));
-
-            self.free_assigned(reg);
-            var.register = None;
-            var.stack_slot = Some(slot);
-            return Ok(block);
-        }
-
-        return Err(CompilerError::Generic(
-            "spill_var called on a variable without a register".to_string(),
-        ));
-    }
-
-    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;
-    }
-
-    fn free_assigned(&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
-            }
-        })
-    }
-}
-
-pub struct FunctionContext {
-    name: String,
-    allocator: RefCell<Allocator>,
-}
-
-impl FunctionContext {
-    pub fn new(name: String) -> Self {
-        Self {
-            name,
-            allocator: RefCell::new(Allocator::new()),
-        }
-    }
-
-    pub fn get_stack_offset(&self) -> i32 {
-        self.allocator.borrow().get_stack_offset()
-    }
-}
-
-/// scope object
-pub struct Scope<'a> {
-    /// outer scope, for a function this will be the global scope.
-    parent: Option<&'a mut Scope<'a>>,
-
-    context: Rc<FunctionContext>,
-
-    /// 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<Uuid, Variable>,
-
-    entry_stack_offset: i32,
-}
-
-impl<'a> Scope<'a> {
-    pub fn new(parent: &'a mut Scope<'a>, r#type: ScopeType) -> Scope<'a> {
-        Self {
-            entry_stack_offset: parent.context.get_stack_offset(),
-            context: Rc::clone(&parent.context),
-            parent: Some(parent),
-            r#type,
-            variables: HashMap::new(),
-        }
-    }
-
-    pub fn close(&mut self) -> Result<(), CompilerError> {
-        // closing a scope means we need to drop all variables in scope and free
-        // registers.
-        for (name, var) in self.variables.iter() {
-            todo!()
-            // if let Some(reg) = var.allocated_register {}
-
-            // if let Some(offset) = var.bpr_offset {
-            //     self.stack_offset -= offset;
-            // }
-        }
-
-        Ok(())
-    }
-
-    pub fn alloc_temp_reg(&mut self) -> Result<(Register, InsBlock), CompilerError> {
-        todo!()
-    }
-
-    pub fn alloc_var_reg(&mut self) -> Result<(Register, InsBlock), CompilerError> {
-        todo!()
-    }
-
-    pub fn alloc_var_stack(&mut self) -> Result<(Register, InsBlock), CompilerError> {
-        todo!()
-    }
-
-    pub fn free_var_stack(&mut self) -> Result<(Register, InsBlock), CompilerError> {
-        todo!()
-    }
-
-    pub fn free_temp_reg(&mut self) -> Result<(Register, InsBlock), CompilerError> {
-        todo!()
-    }
-}
-
-#[derive(PartialEq, Copy, Clone, Debug)]
-pub enum ScopeType {
-    Function,
-    IfBlock,
-    LoopBlock,
-}

compiler/src/backend/dsa/variable.rs

@@ -1,93 +0,0 @@
-use std::{collections::HashMap, hash::Hash, rc::Rc};
-
-use uuid::Uuid;
-
-use crate::{
-    backend::dsa::{
-        instruction::InsBlock,
-        registers::Register,
-        scope::{AssignedReg, FunctionContext, Scope, StackSlot},
-    },
-    model::{CompilerError, TypeId},
-};
-
-pub struct Variable {
-    pub name: String,
-    pub uuid: Uuid,
-
-    /// 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_uninit(name: String, r#type: TypeId) -> Self {
-        Self {
-            name,
-            uuid: Uuid::new_v4(),
-            size: r#type.size(),
-            r#type,
-            stack_slot: None,
-            register: None,
-        }
-    }
-
-    pub fn new(
-        name: String,
-        r#type: TypeId,
-        scope: &'_ mut Scope,
-    ) -> Result<Self, CompilerError> {
-        let mut var = Self::new_uninit(name, r#type);
-        var.alloc_default(scope);
-
-        Ok(var)
-    }
-
-    fn alloc_default(&mut self, scope: &'_ mut Scope) {
-        if self.size > 4 {
-            self.alloc_stack(scope).unwrap();
-        } else {
-            self.alloc_register(scope).unwrap();
-        }
-    }
-
-    fn alloc_register(
-        &mut self,
-        scope: &'_ mut Scope,
-    ) -> Result<Register, CompilerError> {
-        if self.size > 4 {
-            return Err(CompilerError::Generic(format!(
-                "Type {} cannot be allocated a register as it has a size of {} bytes",
-                self.r#type, self.size
-            )));
-        }
-
-        todo!("integrate with register alloc logic")
-
-        // self.allocated_register = Some(...)
-    }
-
-    fn alloc_stack(&mut self, scope: &'_ mut Scope) -> Result<usize, CompilerError> {
-        todo!("integrate with stack alloc logic")
-
-        // self.bpr_offset = Some(...)
-    }
-
-    pub fn load(&mut self, scope: &'_ mut Scope) -> Result<Register, CompilerError> {
-        todo!("load var from stack to reg (if possible)")
-    }
-
-    pub fn drop(&mut self, scope: &'_ mut Scope) -> Result<(), CompilerError> {
-        Ok(())
-    }
-
-    pub fn spill(&mut self, scope: &'_ mut Scope) -> Result<(), CompilerError> {
-        todo!()
-    }
-}

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,19 +0,0 @@
-use std::path::Path;
-
-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"
+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/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/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,7 +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/codegen.rs

@@ -20,10 +20,11 @@ pub struct CodeGenerator {
     functions: Vec<IB>,
     symbols: Vec<String>,
     allocator: RegisterAllocator,
+    is_library: bool,
 }
 
 impl CodeGenerator {
-    pub fn new(ast: Program) -> Self {
+    pub fn new(ast: Program, is_lib: bool) -> Self {
         CodeGenerator {
             ast,
             imports: HashMap::new(),
@@ -31,6 +32,7 @@ impl CodeGenerator {
             functions: Vec::new(),
             symbols: Vec::new(),
             allocator: RegisterAllocator::new(),
+            is_library: is_lib,
         }
     }
 
@@ -46,7 +48,9 @@ impl CodeGenerator {
 
     pub fn generate(&mut self) -> Result<String, CompilerError> {
         // always include the print library for debugging!
-        self.include("print", "./lib/io/print.dsa");
+        if !self.is_library {
+            self.include("print", "./lib/print.dsa");
+        }
 
         for block in self.ast.clone().declarations {
             match block {
@@ -101,25 +105,30 @@ impl CodeGenerator {
 
         block.extend(self.globals.values().cloned().collect::<Vec<_>>());
 
+        if !self.is_library {
+            block.extend(vec![
+                I::Newline,
+                I::global_comment("Entry Point"),
+                I::db_word("stack", 0x10000),
+                I::db_string("message", "Process Exited with code:"),
+                // init function for stack setup.
+                I::label("_init"),
+                I::ldw_label("stack", Register::Bpr),
+                I::mov(Register::Bpr, Register::Spr),
+                I::push(Register::Zero),
+                I::call("main"),
+                I::call("print::print_newline"),
+                I::lwi_label("message", Register::Rg0),
+                I::push(Register::Rg0),
+                I::call("print::print"),
+                I::pop(Register::Zero),
+                I::call("print::print_hex_word"),
+                I::pop(Register::Zero),
+                I::Hlt,
+            ]);
+        }
+
         block.extend(vec![
-            I::Newline,
-            I::global_comment("Entry Point"),
-            I::db_word("stack", 0x10000),
-            I::db_string("message", "Process Exited with code:"),
-            // init function for stack setup.
-            I::label("_init"),
-            I::ldw_label("stack", Register::Bpr),
-            I::mov(Register::Bpr, Register::Spr),
-            I::push(Register::Zero),
-            I::call("main"),
-            I::call("print::print_newline"),
-            I::lwi_label("message", Register::Rg0),
-            I::push(Register::Rg0),
-            I::call("print::print"),
-            I::pop(Register::Zero),
-            I::call("print::print_hex_word"),
-            I::pop(Register::Zero),
-            I::Hlt,
             I::Newline,
             // default return block boilerplate
             I::global_comment("Return"),

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/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/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

@@ -722,37 +722,42 @@ impl Parser {
 
                 // 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() {
+                // if !expect_tt!(self.peek_next()?, LeftBrace).accepted() {
-                    return ParseResult::Accept(Expression::Variable {
+                //     return ParseResult::Accept(Expression::Variable {
-                        name,
+                //         name,
-                        expr_type: None,
+                //         expr_type: None,
-                    });
+                //     });
-                }
+                // }
-
+                //
-                let _ = self.next()?;
+                ParseResult::Accept(Expression::Variable {
-
-                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,
+                    expr_type: None,
-                    type_id: 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 '['
@@ -800,8 +805,6 @@ impl Parser {
     }
 
     fn parse_type(&mut self) -> ParseResult<TypeId, CompilerError> {
-        println!("yes {:?}", self.peek_next()?);
-
         // parse primitive or named type
         if expect_tt!(self.peek_next()?, Identifier).accepted() {
             return self.parse_type_identifier();

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,6 +16,12 @@ 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,

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/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)
+    }
+}

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)
+}

dsx/dsx_server/templates/artifact_detail.html.tera

@@ -0,0 +1,360 @@
+{% extends "base" %}
+
+{% block title %}#{{ artifact.id }} · {{ package.name }}{% endblock %}
+
+{% block extra_head %}
+<style>
+    /* ── Artifact layout ────────────────────────── */
+    .artifact-layout {
+        display: grid;
+        grid-template-columns: 1fr 220px;
+        gap: 24px;
+        align-items: start;
+    }
+    @media (max-width: 768px) {
+        .artifact-layout { grid-template-columns: 1fr; }
+        .artifact-sidebar { order: -1; }
+    }
+
+    /* ── Artifact header ────────────────────────── */
+    .artifact-header {
+        margin-bottom: 20px;
+    }
+    .artifact-header h1 {
+        font-family: var(--mono);
+        font-size: 20px;
+        font-weight: 500;
+        margin: 0 0 6px;
+        display: flex;
+        align-items: center;
+        gap: 10px;
+        flex-wrap: wrap;
+    }
+    .artifact-trigger-line {
+        font-size: 13px;
+        color: var(--text-dim);
+    }
+
+    /* ── Steps list ─────────────────────────────── */
+    .steps-list {
+        display: flex;
+        flex-direction: column;
+        gap: 8px;
+    }
+
+    .step-card { overflow: hidden; }
+
+    .step-header {
+        display: flex;
+        align-items: center;
+        gap: 10px;
+        padding: 10px 14px;
+        cursor: pointer;
+        background: var(--surface);
+        border-radius: var(--radius);
+        transition: background .1s;
+        user-select: none;
+    }
+    .step-card.open .step-header {
+        border-radius: var(--radius) var(--radius) 0 0;
+        background: var(--surface2);
+        border-bottom: 1px solid var(--border);
+    }
+    .step-header:hover { background: var(--surface2); }
+
+    .step-name {
+        flex: 1;
+        font-family: var(--mono);
+        font-size: 13px;
+    }
+    .step-duration {
+        font-family: var(--mono);
+        font-size: 11px;
+        color: var(--muted);
+    }
+    .step-chevron {
+        color: var(--muted);
+        transition: transform .2s;
+        flex-shrink: 0;
+    }
+    .step-card.open .step-chevron { transform: rotate(90deg); }
+
+    /* ── Log output ─────────────────────────────── */
+    .step-log {
+        display: none;
+        background: #080808;
+        border: 1px solid var(--border);
+        border-top: none;
+        border-radius: 0 0 var(--radius) var(--radius);
+        overflow: hidden;
+    }
+    .step-card.open .step-log { display: block; }
+
+    .log-line {
+        display: flex;
+        gap: 0;
+        font-family: var(--mono);
+        font-size: 12px;
+        line-height: 1.7;
+    }
+    .log-line:hover { background: rgba(255,255,255,.03); }
+    .log-num {
+        min-width: 48px;
+        padding: 0 12px;
+        text-align: right;
+        color: var(--muted);
+        user-select: none;
+        border-right: 1px solid #1a1a1a;
+        flex-shrink: 0;
+    }
+    .log-text {
+        padding: 0 16px;
+        white-space: pre-wrap;
+        word-break: break-all;
+        flex: 1;
+    }
+    .log-text.err { color: var(--red); }
+    .log-text.warn { color: var(--yellow); }
+
+    /* ── Sidebar ────────────────────────────────── */
+    .sidebar-card { overflow: hidden; margin-bottom: 12px; }
+    .sidebar-card-title {
+        font-size: 11px;
+        font-family: var(--mono);
+        text-transform: uppercase;
+        letter-spacing: .8px;
+        color: var(--muted);
+        padding: 10px 14px 8px;
+        border-bottom: 1px solid var(--border);
+        background: var(--surface2);
+    }
+    .sidebar-card-body { padding: 12px 14px; }
+    .sidebar-stat {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        padding: 4px 0;
+        font-size: 13px;
+    }
+    .sidebar-stat-label { color: var(--text-dim); }
+    .sidebar-stat-value { font-family: var(--mono); font-size: 12px; }
+
+    /* ── Navigation between artifacts ──────────── */
+    .artifact-nav {
+        display: flex;
+        gap: 8px;
+        margin-top: 20px;
+    }
+    .artifact-nav a {
+        font-family: var(--mono);
+        font-size: 12px;
+        padding: 5px 12px;
+        background: var(--surface);
+        border: 1px solid var(--border);
+        border-radius: var(--radius);
+        color: var(--text-dim);
+        transition: border-color .15s, color .15s;
+    }
+    .artifact-nav a:hover { color: var(--text); border-color: #3a3a3a; text-decoration: none; }
+</style>
+{% endblock %}
+
+{% block content %}
+<div class="container">
+
+    <div class="breadcrumb">
+        <a href="/packages/">packages</a>
+        <span class="breadcrumb-sep">/</span>
+        <a href="/packages/{{ package.name }}">{{ package.name }}</a>
+        <span class="breadcrumb-sep">/</span>
+        <a href="/packages/{{ package.name }}/~artifact/">artifacts</a>
+        <span class="breadcrumb-sep">/</span>
+        <span>#{{ artifact.id }}</span>
+    </div>
+
+    <div class="artifact-header">
+        <h1>
+            #{{ artifact.id }}
+            {% if artifact.status == "success" %}
+                <span class="badge badge-success"><span class="dot"></span>passed</span>
+            {% elif artifact.status == "failure" %}
+                <span class="badge badge-failure"><span class="dot"></span>failed</span>
+            {% elif artifact.status == "running" %}
+                <span class="badge badge-running"><span class="dot dot-pulse"></span>running</span>
+            {% elif artifact.status == "pending" %}
+                <span class="badge badge-pending"><span class="dot"></span>queued</span>
+            {% else %}
+                <span class="badge badge-unknown"><span class="dot"></span>{{ artifact.status }}</span>
+            {% endif %}
+        </h1>
+        <p class="artifact-trigger-line">
+            {{ artifact.trigger | default(value="Triggered manually") }}
+            {% if artifact.commit_sha %} · <span class="mono" style="font-size:12px">{{ artifact.commit_sha }}</span>{% endif %}
+            {% if artifact.branch %} on <strong>{{ artifact.branch }}</strong>{% endif %}
+        </p>
+    </div>
+
+    <div class="artifact-layout">
+
+        <!-- Steps + logs -->
+        <div>
+            {% if artifact.steps and artifact.steps | length > 0 %}
+            <p class="section-title">Steps</p>
+            <div class="steps-list">
+                {% for step in artifact.steps %}
+                <div class="card step-card {% if step.status == 'failure' or loop.first %}open{% endif %}" id="step-{{ loop.index }}">
+                    <div class="step-header" onclick="toggleStep(this)">
+                        <span class="step-status">
+                            {% if step.status == "success" %}
+                                <span style="color:var(--green)">
+                                    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><polyline points="20 6 9 17 4 12"/></svg>
+                                </span>
+                            {% elif step.status == "failure" %}
+                                <span style="color:var(--red)">
+                                    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>
+                                </span>
+                            {% elif step.status == "running" %}
+                                <span style="color:var(--accent)" class="dot-pulse">
+                                    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><polyline points="12 6 12 12 16 14"/></svg>
+                                </span>
+                            {% elif step.status == "skipped" %}
+                                <span style="color:var(--muted)">
+                                    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="5" y1="12" x2="19" y2="12"/></svg>
+                                </span>
+                            {% else %}
+                                <span style="color:var(--muted)">
+                                    <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/></svg>
+                                </span>
+                            {% endif %}
+                        </span>
+                        <span class="step-name">{{ step.name }}</span>
+                        {% if step.duration %}<span class="step-duration">{{ step.duration }}</span>{% endif %}
+                        <svg class="step-chevron" width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="9 18 15 12 9 6"/></svg>
+                    </div>
+                    <div class="step-log">
+                        {% if step.log_lines and step.log_lines | length > 0 %}
+                            {% for line in step.log_lines %}
+                            <div class="log-line">
+                                <span class="log-num">{{ loop.index }}</span>
+                                <span class="log-text {% if line.level == 'error' %}err{% elif line.level == 'warn' %}warn{% endif %}">{{ line.text | default(value=line) | escape }}</span>
+                            </div>
+                            {% endfor %}
+                        {% elif step.log %}
+                            {% for raw_line in step.log | split(pat="\n") %}
+                            <div class="log-line">
+                                <span class="log-num">{{ loop.index }}</span>
+                                <span class="log-text">{{ raw_line | escape }}</span>
+                            </div>
+                            {% endfor %}
+                        {% else %}
+                            <div class="log-line">
+                                <span class="log-num">1</span>
+                                <span class="log-text dim">No output.</span>
+                            </div>
+                        {% endif %}
+                    </div>
+                </div>
+                {% endfor %}
+            </div>
+            {% else %}
+            <div class="card" style="padding:32px;text-align:center;color:var(--text-dim);font-size:13px">
+                No steps recorded for this artifact.
+            </div>
+            {% endif %}
+
+            <div class="artifact-nav">
+                {% if artifact.prev_id %}
+                <a href="/packages/{{ package.name }}/~artifact/{{ artifact.prev_id }}">← #{{ artifact.prev_id }}</a>
+                {% endif %}
+                {% if artifact.next_id %}
+                <a href="/packages/{{ package.name }}/~artifact/{{ artifact.next_id }}">#{{ artifact.next_id }} →</a>
+                {% endif %}
+            </div>
+        </div>
+
+        <!-- Sidebar -->
+        <aside class="artifact-sidebar">
+
+            <div class="card sidebar-card">
+                <div class="sidebar-card-title">Summary</div>
+                <div class="sidebar-card-body">
+                    <div class="sidebar-stat">
+                        <span class="sidebar-stat-label">Status</span>
+                        <span>
+                            {% if artifact.status == "success" %}
+                                <span class="badge badge-success"><span class="dot"></span>passed</span>
+                            {% elif artifact.status == "failure" %}
+                                <span class="badge badge-failure"><span class="dot"></span>failed</span>
+                            {% elif artifact.status == "running" %}
+                                <span class="badge badge-running"><span class="dot dot-pulse"></span>running</span>
+                            {% else %}
+                                <span class="badge badge-unknown">{{ artifact.status }}</span>
+                            {% endif %}
+                        </span>
+                    </div>
+                    {% if artifact.duration %}
+                    <div class="sidebar-stat">
+                        <span class="sidebar-stat-label">Duration</span>
+                        <span class="sidebar-stat-value">{{ artifact.duration }}</span>
+                    </div>
+                    {% endif %}
+                    {% if artifact.created_at %}
+                    <div class="sidebar-stat">
+                        <span class="sidebar-stat-label">Started</span>
+                        <span class="sidebar-stat-value">{{ artifact.created_at }}</span>
+                    </div>
+                    {% endif %}
+                    {% if artifact.finished_at %}
+                    <div class="sidebar-stat">
+                        <span class="sidebar-stat-label">Finished</span>
+                        <span class="sidebar-stat-value">{{ artifact.finished_at }}</span>
+                    </div>
+                    {% endif %}
+                    {% if artifact.steps %}
+                    <div class="sidebar-stat">
+                        <span class="sidebar-stat-label">Steps</span>
+                        <span class="sidebar-stat-value">{{ artifact.steps | length }}</span>
+                    </div>
+                    {% endif %}
+                </div>
+            </div>
+
+            {% if artifact.commit_sha or artifact.branch %}
+            <div class="card sidebar-card">
+                <div class="sidebar-card-title">Commit</div>
+                <div class="sidebar-card-body">
+                    {% if artifact.branch %}
+                    <div class="sidebar-stat">
+                        <span class="sidebar-stat-label">Branch</span>
+                        <span class="sidebar-stat-value">{{ artifact.branch }}</span>
+                    </div>
+                    {% endif %}
+                    {% if artifact.commit_sha %}
+                    <div class="sidebar-stat">
+                        <span class="sidebar-stat-label">SHA</span>
+                        <span class="sidebar-stat-value">{{ artifact.commit_sha | truncate(length=8, end="") }}</span>
+                    </div>
+                    {% endif %}
+                    {% if artifact.commit_message %}
+                    <div style="font-size:12px;color:var(--text-dim);margin-top:8px;line-height:1.5">{{ artifact.commit_message }}</div>
+                    {% endif %}
+                </div>
+            </div>
+            {% endif %}
+
+            <div style="margin-top:4px">
+                <a href="/packages/{{ package.name }}/~artifact/" style="font-size:12px;font-family:var(--mono)">← all artifacts</a>
+            </div>
+
+        </aside>
+    </div>
+
+</div>
+
+<script>
+function toggleStep(header) {
+    const card = header.closest('.step-card');
+    card.classList.toggle('open');
+}
+</script>
+{% endblock %}

dsx/dsx_server/templates/artifact_list.html.tera

@@ -0,0 +1,189 @@
+{% extends "base" %}
+
+{% block title %}Artifacts · {{ package.name }}{% endblock %}
+
+{% block extra_head %}
+<style>
+    .artifacts-header {
+        display: flex;
+        align-items: baseline;
+        justify-content: space-between;
+        margin-bottom: 20px;
+        flex-wrap: wrap;
+        gap: 8px;
+    }
+    .artifacts-header h1 {
+        font-size: 20px;
+        font-weight: 500;
+        margin: 0;
+        font-family: var(--mono);
+    }
+
+    .artifact-list {
+        display: flex;
+        flex-direction: column;
+        gap: 8px;
+    }
+
+    .artifact-row {
+        display: flex;
+        align-items: center;
+        gap: 14px;
+        padding: 12px 16px;
+        text-decoration: none;
+        color: var(--text);
+        transition: border-color .15s, background .15s;
+    }
+    .artifact-row:hover {
+        background: var(--surface2);
+        border-color: #3a3a3a;
+        text-decoration: none;
+    }
+
+    .artifact-id {
+        font-family: var(--mono);
+        font-size: 13px;
+        color: var(--accent);
+        flex-shrink: 0;
+        min-width: 48px;
+    }
+
+    .artifact-info { flex: 1; min-width: 0; }
+    .artifact-trigger {
+        font-size: 13px;
+        white-space: nowrap;
+        overflow: hidden;
+        text-overflow: ellipsis;
+    }
+    .artifact-meta {
+        font-size: 11px;
+        color: var(--text-dim);
+        font-family: var(--mono);
+        margin-top: 2px;
+    }
+
+    .artifact-status { flex-shrink: 0; }
+    .artifact-duration {
+        font-family: var(--mono);
+        font-size: 11px;
+        color: var(--muted);
+        flex-shrink: 0;
+        min-width: 48px;
+        text-align: right;
+    }
+    .artifact-date {
+        font-size: 11px;
+        color: var(--muted);
+        font-family: var(--mono);
+        flex-shrink: 0;
+        min-width: 90px;
+        text-align: right;
+    }
+
+    .empty-state {
+        text-align: center;
+        padding: 64px 0;
+        color: var(--text-dim);
+        font-size: 13px;
+    }
+
+    /* Stats strip at top */
+    .stats-strip {
+        display: flex;
+        gap: 8px;
+        margin-bottom: 20px;
+        flex-wrap: wrap;
+    }
+    .stat-chip {
+        background: var(--surface);
+        border: 1px solid var(--border);
+        border-radius: var(--radius);
+        padding: 8px 14px;
+        font-size: 12px;
+        display: flex;
+        flex-direction: column;
+        gap: 2px;
+    }
+    .stat-chip-val {
+        font-family: var(--mono);
+        font-size: 18px;
+        font-weight: 500;
+    }
+    .stat-chip-label { color: var(--text-dim); }
+</style>
+{% endblock %}
+
+{% block content %}
+<div class="container">
+
+    <div class="breadcrumb">
+        <a href="/packages/">packages</a>
+        <span class="breadcrumb-sep">/</span>
+        <a href="/packages/{{ package.name }}">{{ package.name }}</a>
+        <span class="breadcrumb-sep">/</span>
+        <span>artifacts</span>
+    </div>
+
+    <div class="artifacts-header">
+        <h1>{{ package.name }} / artifacts</h1>
+    </div>
+
+    {% if stats is defined %}
+    <div class="stats-strip">
+        <div class="stat-chip">
+            <span class="stat-chip-val">{{ stats.total | default(value=0) }}</span>
+            <span class="stat-chip-label">Total</span>
+        </div>
+        <div class="stat-chip">
+            <span class="stat-chip-val" style="color:var(--green)">{{ stats.success | default(value=0) }}</span>
+            <span class="stat-chip-label">Passed</span>
+        </div>
+        <div class="stat-chip">
+            <span class="stat-chip-val" style="color:var(--red)">{{ stats.failure | default(value=0) }}</span>
+            <span class="stat-chip-label">Failed</span>
+        </div>
+        {% if stats.avg_duration is defined %}
+        <div class="stat-chip">
+            <span class="stat-chip-val">{{ stats.avg_duration }}</span>
+            <span class="stat-chip-label">Avg duration</span>
+        </div>
+        {% endif %}
+    </div>
+    {% endif %}
+
+    {% if artifacts and artifacts | length > 0 %}
+    <div class="artifact-list">
+        {% for artifact in artifacts %}
+        <a class="card artifact-row" href="/packages/{{ package.name }}/~artifact/{{ artifact.id }}">
+            <span class="artifact-id">#{{ artifact.id }}</span>
+            <div class="artifact-info">
+                <div class="artifact-trigger">{{ artifact.trigger | default(value="manual") }}</div>
+                <div class="artifact-meta">{{ artifact.commit_sha | default(value="") }}{% if artifact.branch %} on {{ artifact.branch }}{% endif %}</div>
+            </div>
+            <span class="artifact-status">
+                {% if artifact.status == "success" %}
+                    <span class="badge badge-success"><span class="dot"></span>passed</span>
+                {% elif artifact.status == "failure" %}
+                    <span class="badge badge-failure"><span class="dot"></span>failed</span>
+                {% elif artifact.status == "running" %}
+                    <span class="badge badge-running"><span class="dot dot-pulse"></span>running</span>
+                {% elif artifact.status == "pending" %}
+                    <span class="badge badge-pending"><span class="dot"></span>queued</span>
+                {% else %}
+                    <span class="badge badge-unknown"><span class="dot"></span>{{ artifact.status }}</span>
+                {% endif %}
+            </span>
+            {% if artifact.duration %}<span class="artifact-duration">{{ artifact.duration }}</span>{% endif %}
+            <span class="artifact-date">{{ artifact.created_at | default(value="") }}</span>
+        </a>
+        {% endfor %}
+    </div>
+    {% else %}
+    <div class="empty-state">
+        <svg width="32" height="32" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" style="color:var(--border)"><circle cx="12" cy="12" r="10"/><polyline points="12 6 12 12 16 14"/></svg>
+        <p style="margin-top:10px">No artifacts yet.</p>
+    </div>
+    {% endif %}
+
+</div>
+{% endblock %}

dsx/dsx_server/templates/base.html.tera

@@ -0,0 +1,198 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{% block title %}Packages{% endblock %} · depot</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link href="https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@400;500&family=IBM+Plex+Sans:wght@300;400;500&display=swap" rel="stylesheet">
+    <style>
+        :root {
+            --bg:       #0d0d0d;
+            --surface:  #161616;
+            --surface2: #1f1f1f;
+            --border:   #2a2a2a;
+            --muted:    #555;
+            --text:     #ddd;
+            --text-dim: #888;
+            --accent:   #4f8ef7;
+            --green:    #3ecf6a;
+            --yellow:   #f0b429;
+            --red:      #f25c5c;
+            --radius:   6px;
+            --mono:     'IBM Plex Mono', monospace;
+            --sans:     'IBM Plex Sans', sans-serif;
+        }
+
+        *, *::before, *::after { box-sizing: border-box; }
+
+        body {
+            margin: 0;
+            font-family: var(--sans);
+            font-size: 14px;
+            background: var(--bg);
+            color: var(--text);
+            line-height: 1.5;
+        }
+
+        a { color: var(--accent); text-decoration: none; }
+        a:hover { text-decoration: underline; }
+
+        /* ── Top nav ─────────────────────────────── */
+        .topbar {
+            position: fixed;
+            top: 0; left: 0;
+            width: 100%;
+            height: 52px;
+            background: var(--surface);
+            border-bottom: 1px solid var(--border);
+            display: flex;
+            align-items: center;
+            gap: 16px;
+            padding: 0 24px;
+            z-index: 1000;
+        }
+
+        .topbar-logo {
+            font-family: var(--mono);
+            font-size: 15px;
+            font-weight: 500;
+            color: var(--text);
+            letter-spacing: -0.5px;
+            flex-shrink: 0;
+        }
+        .topbar-logo span { color: var(--accent); }
+
+        .topbar-search {
+            flex: 1;
+            max-width: 420px;
+            position: relative;
+        }
+        .topbar-search input {
+            width: 100%;
+            padding: 6px 12px 6px 32px;
+            background: var(--surface2);
+            border: 1px solid var(--border);
+            border-radius: var(--radius);
+            color: var(--text);
+            font-family: var(--sans);
+            font-size: 13px;
+            outline: none;
+            transition: border-color .15s;
+        }
+        .topbar-search input:focus { border-color: var(--accent); }
+        .topbar-search input::placeholder { color: var(--muted); }
+        .topbar-search-icon {
+            position: absolute;
+            left: 10px;
+            top: 50%;
+            transform: translateY(-50%);
+            color: var(--muted);
+            pointer-events: none;
+        }
+
+        /* ── Page wrapper ───────────────────────── */
+        .page {
+            padding-top: 52px;
+            min-height: 100vh;
+        }
+
+        .container {
+            max-width: 1100px;
+            margin: 0 auto;
+            padding: 32px 24px;
+            width: 100%;
+        }
+
+        /* ── Breadcrumb ─────────────────────────── */
+        .breadcrumb {
+            font-family: var(--mono);
+            font-size: 12px;
+            color: var(--text-dim);
+            margin-bottom: 20px;
+            display: flex;
+            align-items: center;
+            gap: 6px;
+            flex-wrap: wrap;
+        }
+        .breadcrumb a { color: var(--text-dim); }
+        .breadcrumb a:hover { color: var(--text); text-decoration: none; }
+        .breadcrumb-sep { color: var(--border); }
+
+        /* ── Status badges ──────────────────────── */
+        .badge {
+            display: inline-flex;
+            align-items: center;
+            gap: 5px;
+            padding: 2px 8px;
+            border-radius: 20px;
+            font-family: var(--mono);
+            font-size: 11px;
+            font-weight: 500;
+            text-transform: uppercase;
+            letter-spacing: .4px;
+        }
+        .badge-success { background: rgba(62,207,106,.12); color: var(--green); }
+        .badge-failure { background: rgba(242,92,92,.12);  color: var(--red); }
+        .badge-running { background: rgba(79,142,247,.12); color: var(--accent); }
+        .badge-pending { background: rgba(240,180,41,.12); color: var(--yellow); }
+        .badge-unknown { background: rgba(136,136,136,.12); color: var(--muted); }
+
+        .dot {
+            width: 6px; height: 6px;
+            border-radius: 50%;
+            background: currentColor;
+            flex-shrink: 0;
+        }
+        .dot-pulse {
+            animation: pulse 1.4s ease-in-out infinite;
+        }
+        @keyframes pulse {
+            0%,100% { opacity: 1; }
+            50%      { opacity: .3; }
+        }
+
+        /* ── Generic card ───────────────────────── */
+        .card {
+            background: var(--surface);
+            border: 1px solid var(--border);
+            border-radius: var(--radius);
+        }
+
+        /* ── Section heading ────────────────────── */
+        .section-title {
+            font-size: 11px;
+            font-family: var(--mono);
+            text-transform: uppercase;
+            letter-spacing: .8px;
+            color: var(--muted);
+            margin: 0 0 12px;
+        }
+
+        /* ── Utility ────────────────────────────── */
+        .mono  { font-family: var(--mono); }
+        .dim   { color: var(--text-dim); }
+        .small { font-size: 12px; }
+    </style>
+    {% block extra_head %}{% endblock %}
+</head>
+<body>
+<div class="page">
+
+    <nav class="topbar">
+        <a class="topbar-logo" href="/packages/"><span>//</span>DSA Packages</a>
+        <div class="topbar-search">
+            <svg class="topbar-search-icon" width="13" height="13" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg>
+            <form method="get" action="/packages/">
+                <input type="text" name="q" placeholder="Search packages…" value="{{ query | default(value='') }}">
+            </form>
+        </div>
+    </nav>
+
+    <div class="page">
+        {% block content %}{% endblock %}
+    </div>
+
+</div>
+</body>
+</html>

dsx/dsx_server/templates/components/file.html.tera

@@ -0,0 +1,16 @@
+{% macro file_view(package, file) %}
+<div class="file-row">
+    <span class="file-icon">
+        {% if file.is_dir %}
+        <svg width="14" height="14" viewBox="0 0 24 24" fill="currentColor" style="color:#4f8ef7" ><path d="M3 7a2 2 0 012-2h4l2 2h8a2 2 0 012 2v9a2 2 0 01-2 2H5a2 2 0 01-2-2V7z"/></svg>
+        {% else %}
+        <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M14 2H6a2 2 0 00-2 2v16a2 2 0 002 2h12a2 2 0 002-2V8z"/><polyline points="14 2 14 8 20 8"/></svg>
+        {% endif %}
+    </span>
+    <span class="file-name">
+        <a href="/packages/{{ package }}/~repo/{{ file.path }}">{{ file.name }}</a>
+    </span>
+    <!--<span class="file-commit">{{ file.last_commit_message | default(value="") }}</span>
+    <span class="file-age">{{ file.last_modified | default(value="") }}</span>-->
+</div>
+{% endmacro %}

dsx/dsx_server/templates/components/file_tree.html.tera

@@ -0,0 +1,34 @@
+ <!-- File tree -->
+ <div class="pkg-main">
+     <div class="file-tree">
+         <div class="file-toolbar">
+             <div class="file-toolbar-search">
+                 <svg class="file-toolbar-search-icon" width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg>
+                 <form method="get" action="/packages/{{ meta.id }}/~repo">
+                     <input type="text" name="q" placeholder="Filter files…" value="{{ query | default(value='') }}">
+                 </form>
+             </div>
+             <span class="dim small mono">{{ current_path | default(value="/") }}</span>
+         </div>
+
+         {% if files and files | length > 0 %}
+             <div class="file-tree-body">
+                 {% if current_path %}
+                 <a class="file-row" href="/packages/{{ meta.id }}/~repo/{{ parent_path | default(value='') }}">
+                     <span class="file-icon">
+                         <svg width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M3 9l9-7 9 7v11a2 2 0 01-2 2H5a2 2 0 01-2-2z"/></svg>
+                     </span>
+                     <span class="file-name" style="color:var(--text-dim)">..</span>
+                 </a>
+                 {% endif %}
+
+
+                 {% for file in files %}
+                     {{ files::file_view(package = meta.id, file = file) }}
+                 {% endfor %}
+             </div>
+         {% else %}
+             <div class="file-tree-empty">No files found.</div>
+         {% endif %}
+     </div>
+ </div>