This project is a minimal, educational Chip-8 emulator written in C# targeting .NET 8. It demonstrates the core architecture and instruction cycle of a Chip-8 system, and is designed for clarity, simplicity, and easy extension.
- Minimal implementation: Only the essential components (CPU, memory, and a simple coordinator) are included.
- Core instruction cycle: Implements fetch-decode-execute for a subset of Chip-8 opcodes (6XNN, 7XNN, 8XY4).
- Demonstration program: Runs a hardcoded test program to show register and CPU state changes.
- Separation of concerns: Memory and CPU logic are cleanly separated.
- Ready for extension: The codebase is structured for easy addition of more opcodes, input, graphics, timers, and other Chip-8 features.
Program.cs: Entry point. Loads a test program, runs the CPU, and prints register state.Chip8Cpu.cs: Implements the CPU, registers, and instruction cycle.Chip8Memory.cs: Handles 4KB Chip-8 memory, with safe read/write and program loading.Chip8Emulator.cs: (Optional) Coordinator class for future expansion.
- Test Program:
- Loads values into V0 and V1, then adds them (V0 = V0 + V1).
- Demonstrates opcode handling and register changes.
- Execution:
- The emulator fetches, decodes, and executes each instruction, printing state after each step.
- Final register values are printed for verification.
Initial: V0=0, V1=0, VF=0, PC=0x200
Executing 0x6005 at PC=0x200
After: V0=5, V1=0, VF=0, PC=0x202
Executing 0x6107 at PC=0x202
After: V0=5, V1=7, VF=0, PC=0x204
Executing 0x8014 at PC=0x204
After: V0=12, V1=7, VF=0, PC=0x206
Final: V0=12, V1=7, VF=0, PC=0x206
Demo complete. Emulator ready for extension (add more opcodes, input, graphics, etc.).
- Clone the repository.
- Build the project:
dotnet build
- Run the emulator:
dotnet run
This project is intentionally minimal. You can extend it by:
- Implementing more Chip-8 opcodes in
Chip8Cpu.cs. - Adding input handling, graphics, and sound.
- Loading external ROM files.
- Implementing timers and more advanced features.
Here are detailed features that could be implemented to extend this emulator:
- Complete the instruction set: Implement all standard CHIP-8 opcodes:
0NNN: Execute machine language subroutine00E0: Clear the screen00EE: Return from subroutine1NNN: Jump to address NNN2NNN: Execute subroutine at NNN3XNN: Skip if VX equals NN4XNN: Skip if VX doesn't equal NN5XY0: Skip if VX equals VY8XY0: Set VX to VY8XY1: Set VX to VX OR VY8XY2: Set VX to VX AND VY8XY3: Set VX to VX XOR VY8XY5: Subtract VY from VX8XY6: Right shift VX8XY7: Set VX to VY minus VX8XYE: Left shift VX9XY0: Skip if VX doesn't equal VYANNN: Set index register IBNNN: Jump to address NNN + V0CXNN: Set VX to random number AND NNDXYN: Display/drawEX9E: Skip if key VX pressedEXA1: Skip if key VX not pressedFX07: Set VX to delay timerFX0A: Wait for key pressFX15: Set delay timer to VXFX18: Set sound timer to VXFX1E: Add VX to IFX29: Set I to font sprite for character VXFX33: Store BCD representation of VXFX55: Store V0...VX in memory at IFX65: Fill V0...VX from memory at I
- Implement the 64x32 monochrome pixel display
- Create a rendering system using a modern graphics library
- Add support for sprite drawing and collision detection
- Implement the font set (0-F hexadecimal characters)
- Add optional upscaling for better visibility on modern displays
- Implement configurable color schemes
- Support for the 16-key hexadecimal keypad (0-9 and A-F)
- Configurable keyboard mapping
- Optional gamepad/controller support
- Key event handling for real-time input
- Implement the 60Hz delay timer for timing game events
- Add the 60Hz sound timer for audio control
- Implement a basic sound system for the buzzer tone
- Add volume control and mute options
- Ensure consistent timing across different hardware
- Implement the stack for subroutine calls (typically 12-16 levels deep)
- Add memory viewer/editor for debugging
- Implement memory protection for reserved areas (0x000-0x1FF)
- Add support for loading external ROM files
- Implement a ROM browser/selector
- Add ROM information display (size, CRC, etc.)
- Support for saving and loading emulator state
- Create a proper GUI with menus and controls
- Add pause/resume functionality
- Implement step-by-step execution for debugging
- Add speed control (faster/slower than original)
- Display register values and memory state in real-time
- Implement a disassembler to view program code
- Add breakpoint support
- Provide register and memory inspection
- Add logging of opcode execution
- Visualization of the stack and program flow
- Support for Super CHIP-8 instructions
- XO-CHIP enhancements
- Custom instruction sets or extensions
- High-resolution graphics modes
- Multiple color support
- Additional sound capabilities
- Configuration saving/loading
- Performance optimizations
- Screenshot and recording capabilities
- Integration with CHIP-8 program repositories
- Automated testing framework for opcodes
- Developed using both OpenAI Deep Research and GitHub Copilot for code generation, research, and best practices.
This project is provided for educational purposes. See LICENSE for details.