Neo8085

A modern 8085 microprocessor simulator with an integrated development environment

Features Installation Usage Documentation Screenshots Contributing

Overview

Neo8085 is a comprehensive 8085 microprocessor simulator designed for educational and development purposes. It provides a modern, feature-rich environment for writing, debugging, and executing 8085 assembly language programs with real-time visualization of processor state and memory.

✨ Features

Integrated Development Environment

  • Syntax highlighting for 8085 assembly language
  • Line numbers and breakpoint management
  • File operations (Open, Save, Save As)
  • Modern UI with light theme

Powerful Assembler

  • Partial 8085 instruction set support
  • Symbol and label resolution
  • EQU directive with arithmetic expression support
  • Comprehensive error reporting
  • Support for DS directive for reserving memory bytes

Execution and Debugging

  • Step-by-step execution
  • Continuous execution with breakpoints
  • Real-time register and flag visualization
  • Memory viewer and editor

Advanced Tools

  • Number format converter (Hex, Decimal, Binary, ASCII)
  • Memory editor for direct manipulation
  • Execution statistics tracking
  • Detailed execution log

Feature Highlights

Code Editor

Powerful Code Editor

Write 8085 assembly code efficiently with our feature-rich editor designed specifically for assembly language development.

  • Syntax highlighting for 8085 assembly
  • Line numbering for easy reference
  • Breakpoint integration for debugging
Simulator Operations

Easy Simulator Controls

Easily interact and control the simulator with these advanced options

  • Assemble and load the program to memory in one go
  • Step-by-step run the program
  • Execute and run the program continuously
  • Stop the simulator at any time for effienct analysis
  • Reset the simulator (CPU and Memory) in click
  • Simulator's CPU status indicator with error reporting
Register and Flags View

Detailed Registers and Flags View

Evaluate CPU's register and flags state during execution in real-time

    Registers:

  • A (Accumulator)
  • B-C Register pair
  • D-E Register pair
  • H-L Register pair
  • Stack Pointer (SP)
  • Program Counter (PC)
  • PSW register

    • Flags:

  • Sign, Zero, Auxiliary Carry, Parity, and Carry
Register and Flags View

Numeric Value Converter and Memory Editor

Convert values easily and edit memory with a breeze

  • Convert between Hexadecimal, Decimal, Binary, and ASCII formats
  • Directly edit memory values using memory editor (supports both decimal and hexadecimal values)
Register and Flags View

Keep track of every event

Execution log helps in deeper analysis of working of a program

  • States different kinds of error be it assembler or CPU related
  • Logs upto last 500 exection related messages
Memory Viewer

Interactive Memory Viewer

Examine and modify memory contents in real-time with our intuitive memory viewing and editing tools.

  • Organized memory value display in hexadecimal format
  • View memory address in both hexadecimal and decimal values
  • Change memory view for a specific memory address
  • Automatic scrolling to follow program execution
Debugging Tools

Advanced Debugging Tools

Debug your assembly programs with precision using our comprehensive suite of debugging tools.

  • Step-by-step execution visualization
  • Register and flag state monitoring
  • Execution history and statistics
  • Breakpoints for closer analysis

🛠ī¸ Installation

Prerequisites

  • Python 3.13+
  • PySide6 (Qt for Python)

Installing from Source

1. Clone the repository:

git clone https://github.com/rusty-jar/Neo8085.git
cd Neo8085

2. Install dependencies:

pip install -r requirements.txt

3. Run the application:

python src/main.py

📝 Usage

Writing Assembly Code

Use the built-in editor with syntax highlighting, line numbers, and breakpoint support.

Assembling and Execution

  • Assemble: Click "Assemble" or press Ctrl+B
  • Step Execution: Click "Step" or press F10
  • Continuous Execution: Click "Run" or press F5
  • Fast Execution: Use "Run without Highlighting" or press Ctrl+Shift+F5
  • Debugging: Set breakpoints by clicking line numbers or pressing F9

Memory Manipulation

  • Use the Memory Editor to write values directly
  • View memory contents in the Memory View table
  • Enable Follow PC to track the Program Counter automatically

📚 Documentation

Supported Instructions

Data Transfer: MOV, MVI, LXI, LDA, STA, XCHG
Arithmetic: ADD, ADI, SUB, INR, DCR, DAD
Logical: CPI
Branching: JMP, JZ, JNZ, JC, JNC, JP, JM, JPE, JPO
Stack: PUSH, POP
Subroutines: CALL, RET
Machine Control: HLT

Assembler Directives

  • ORG: Set starting address
  • EQU: Define constants (supports arithmetic)
  • DS: Reserve memory space
  • END: Mark the end of the program (currently just a placeholder)

Keyboard Shortcuts

Shortcut Action
Ctrl+N New File
Ctrl+O Open Program
Ctrl+S Save
Ctrl+Shift+S Save As
Ctrl+B Assemble
F10 Step
F5 Run
Ctrl+Shift+F5 Run without Highlighting
F8 Stop
Ctrl+R Reset
F9 Add Breakpoint

📸 Screenshots

Neo8085 Interface

Neo8085 on startup showing the clean user interface
Neo8085 in action
Neo8085 Interface showing the simulator in action with registers and memory view
Debugging session
Debugging session with breakpoints and highlighted code execution

🤝 Contributing

We welcome contributions to Neo8085! Here's how to get started:

  1. Fork the repository
  2. Create a new branch:
    git checkout -b feature-name
  3. Make your changes and commit:
    git commit -m "Describe your changes"
  4. Push to your fork:
    git push origin feature-name
  5. Open a Pull Request

Contribution Guidelines

  • Follow existing code style and structure
  • Write clear, descriptive commit messages
  • Comment complex logic
  • Update documentation and add tests for new features

License

This project is licensed under the GNU General Public License v3.0. See the LICENSE file for details.

Acknowledgements

↑ Back to Top
× Enlarged view