Emulate 6502-based microcomputer systems in Python
Go to file
Mike Naberezny 74e2576894 Back to .dev0 until next release 2024-04-12 14:03:26 -07:00
.github/workflows Fix interactive assembly on Python 3 2024-04-12 12:25:12 -07:00
docs Back to .dev0 until next release 2024-04-12 14:03:26 -07:00
examples Remove blocking_getc at $f005 2014-01-31 15:07:51 -08:00
py65 Fix interactive assembly on Python 3 2024-04-12 12:25:12 -07:00
.gitignore Ignore coverage files 2014-03-16 12:30:29 -07:00
CHANGES.rst Back to .dev0 until next release 2024-04-12 14:03:26 -07:00
LICENSE.txt Update copyright year to 2024 2024-04-12 11:11:16 -07:00
MANIFEST.in Rename CHANGES.txt to CHANGES.rst for GitHub rendering 2021-12-27 14:11:15 -08:00
README.rst Test with Python 3.12 on CI 2023-11-18 16:43:21 -08:00
setup.cfg Mark this package as a universal wheel 2015-03-31 12:06:48 -07:00
setup.py Back to .dev0 until next release 2024-04-12 14:03:26 -07:00



Py65 provides tools for simulating hardware based on 6502-like
microprocessors.  It has the following goals:

- Focus on ease of use and modularity rather than performance.  Py65 is
  written in the Python programming language for productivity, while
  similar programs are written in C for performance.

- Enable simulations to be created for systems where it might have
  otherwise not been practical, such as homebuilt computers.

- Rigorously unit test all of the components.  While the tools provided
  by Py65 may not always be perfect, their behavior is verified through
  tests so unexpected results are minimized.


Py65 packages are `available <http://pypi.python.org/pypi/py65>`_ on the
Python Package Index (PyPI).  You download them from there or you can
use ``pip`` to install Py65::

    $ pip install setuptools py65


The following devices are simulated at this time:

- ``mpu6502`` simulates the original NMOS 6502 microprocessor from MOS
  Technology, later known as Commodore Semiconductor Group (CSG). At this
  time, all of the documented opcodes are supported.  Support for the
  illegal opcodes is planned for the future.

- ``mpu65c02`` simulates a generic CMOS 65C02 microprocessor. There were
  several 65C02 versions from various manufacturers, some with more
  opcodes than others. This simulation is based on the W65C02S from the
  Western Design Center (WDC).

- ``mpu65org16`` simulates the 65Org16, a 6502-like microprocessor with a
  16-bit data bus and 32-bit address bus.  This microprocessor is a project
  of the `6502.org community <http://forum.6502.org/viewtopic.php?t=1824>`_
  and a `Verilog core <https://github.com/BigEd/verilog-6502/wiki>`_ for it
  has been implemented.


Py65 includes a console-based machine language monitor (sometimes also called
a debugger).  This program, ``py65mon``, allows you to interact with the
simulations that you build.  Its features include:

- Commands that are largely compatible with those used in the monitor of
  the popular VICE emulator for Commodore computers.

- Ability to load, dump, and fill memory.

- Simple assemble and disassemble capability, including support for labels
  and labels with offsets.


These people are responsible for Py65:

- `Mike Naberezny <https://github.com/mnaberez>`_ is the original author of
  Py65 and is the primary maintainer.

- `Oscar Lindberg <https://github.com/offe>`_ started the 65C02 simulation
  module and contributed greatly to its implementation.

- `Ed Spittles <https://github.com/biged>`_ wrote the 65Org16 simulation
  module and provided many useful issue reports and patches.

- `David Beazley <https://github.com/dabeaz>`_ did the initial port of Py65
  to Python 3.

- `Alessandro Gatti <https://github.com/agatti>`_ added support for
  breakpoints in the monitor.

- `Mario Keller <https://github.com/mkeller0815>`_ added support for
  configuring ``getc``/``putc`` and fixed bugs in command line option parsing.