# minix-8086-rs

minix-8086-rs is a Rust-based toolchain for analyzing and emulating 16-bit MINIX binaries. It includes:
- 📦 a.out Parser: Parses legacy MINIX executables.
- 🛠 8086 Disassembler: Converts 16-bit instructions into an IR.
- 💻 MINIX Emulator: Interprets and executes 8086 MINIX binaries in a simulated environment.

## Usage

To compile and run the tool, use Cargo:
```
cargo build --release
```

Or run it directly:
```
cargo run -- --help
```

CLI Options:
```
$ cargo run -- --help
Simple prgram to diasm and interpret Minix binaries                    
                                                                       
Usage: minix-8086-rs [OPTIONS] <COMMAND>                               
                                                                       
Commands:                                                              
  disasm     Disassemble the binary into 8086 instructions             
  interpret  Interpret the binary as 8086 Minix                        
  help       Print this message or the help of the given subcommand(s) 
                                                                       
Options:                                                               
  -p, --path <PATH>  Path of the binary                                
  -h, --help         Print help                                        
  -V, --version      Print version                                     
```

## Examples

Disassemble a binary:

```
cargo run -- disasm -p ./a.out
```

Interpret a binary:
```
cargo run -- interpret -p ./a.out
```

## Status

This project is under active development and primarily used by me to explore some Intel disassembly and learn some more Rust. 
Expect bugs and some missing features.


## Documentation

For the implementation of all instructions I used the Intel "8086 16-BIT HMOS MICROPROCESSOR" Spec, as well as [this](http://www.mlsite.net/8086/8086_table.txt) overview of all Opcode variants used in conjunction with [this](http://www.mlsite.net/8086/) decoding matrix.