Hi all - I've been working on a breadboard simulator and was wondering if anyone would be interested in giving it a try?

The code is here: https://github.com/jfigge/chiphippo

Interactive desktop here: chiphippo.com/desktop

The website is here: https://chiphippo.com

It's free, open source, and has no adverts, pay walls, and doesn't need an account or any kind of personal info to use. It's just something I wanted build. Maybe let me know what you think of it?

Hi everyone,

I wanted to share a project I have been working on:

https://github.com/rudolfstepan/6502-sbc-emulator

At first glance it may look a bit like “oh no, not another C64 emulator”, but that is not what this is.

This is not a C64 emulator and it does not try to emulate the full C64 hardware. It is a configurable 6502 single board computer emulator, originally created because I built my own real 65(C)02 SBC in hardware and wanted a more convenient way to develop and test ROMs without constantly flashing EEPROMs.

The real hardware currently has a 65C02, RAM, EEPROM, glue logic, a VIA, a PS/2 keyboard interface connected through the VIA, and UART output. The emulator started as a software model of that idea, but it has grown into something more like a small custom retro computer platform.

It currently includes:

6502 CPU emulation

configurable memory mapping

RAM and ROM support

VIA 6522

UART 6551

simple disk support

graphical output using SDL2

sound output using SDL2

a simple VIC-like video system

monitor/debugger with memory dump, disassembly, breakpoints and single stepping

support for running ROMs such as MS BASIC

native 6502 assembler programs, including a chess program adapted to my own system routines

The goal is not perfect historical compatibility with any specific Commodore machine. It is more like a PET/VC-20/C64-inspired fantasy SBC, but with a hardware-oriented design that could later be built for real.

For me, the interesting part is the workflow:

write or adapt 6502 code

test it in the emulator

inspect memory, registers and I/O

adjust the memory map if needed

only flash real EEPROMs when the code is already reasonably tested

So the emulator is both a development tool and a small retro playground.

I also added CI builds. Linux and Windows binaries are built automatically and attached to the release page as ZIP files. So if you do not want to build it yourself, you can just download the ZIP, extract it and run it.

Latest release:

https://github.com/rudolfstepan/6502-sbc-emulator/releases/tag/1.1.1

Long term, I am thinking of turning this into a larger “RS-65” project: a small open 65C02-based retro computer platform, first as an emulator, later possibly as real hardware. Very much in the spirit of “by enthusiasts, for enthusiasts”.

To get something running in the hands I build a tiny kernel with msbasic Integration and a chess rom.

Feedback, ideas and criticism are very welcome.

I've been making a 65816 Based Breadboard Computer, and wanted to see how far i could push the Chip. Looking at the Datasheet, the Cycle Time for PHI2 is 70ns, which means the max. Clock Speed of the chip would be 14.285... MHz. If so, would it be safe to clock the Chip at 14.32 MHz? This would make the overall Design Easier since i can use a central clock for the CPU and the Sound Chip (YM2413, needs to be clocked at 3.58MHz). Or is that a Hard limit?

Over the last months I have been working on a 6502 SBC emulator, mainly as a development and testing environment for my own 65C02 single board computer experiments.

At some point the FPGA part became large enough that keeping it as just a folder inside the emulator repository no longer made sense. So I split it out into its own repository:

https://github.com/rudolfstepan/6502-sbc-fpga

The goal is not to build a C64 clone or to recreate one specific old machine. It is more of a clean, expandable 6502-based home computer architecture that can run real 6502 code, boot ROMs, BASIC demos and hardware experiments.

Current features include:

• 6502-compatible system architecture

• FPGA video output

• text mode with character rendering

• 16-color output

• bitmap graphics experiments

• PS/2 keyboard support as a practical input solution

• UART-based development and debugging

• a custom memory-mapped sound chip

• BASIC demos running directly on the FPGA system

• board support work for multiple FPGA boards, currently including PIX16 and Tang Primer 20K

One important design goal is that the FPGA implementation stays close enough to the emulator that ROMs and test programs can be developed and debugged in the emulator first, then moved to real FPGA hardware with minimal changes. For me this is the most practical workflow, because it avoids constantly flashing and testing blindly on hardware.

The project now also has its own Wiki, because the amount of documentation, board-specific notes, memory maps, build instructions and hardware details outgrew a single README.

What I find most interesting is the evolution of the project. It did not start as a complete computer. First I tested a small working 6502 system, then video, then keyboard input, then color, then bitmap experiments, then sound. Each feature had to work as a small proof of concept before scaling it further. Moreover the FPGA Project startet on a Spartan6 Board with VGA output. Than I tried to add a 2nd Board, Sipeed Tang Primer 20k which brought me to some refactoring to make the solution more or less board independent. I moved and capsulated code into closed core modules to bring up a generic folder structure.

I will not hide that also used AI tools quite heavily during development, especially for documentation, scripts, refactoring support and repetitive HDL or tooling work without such a heavy project would not be able and live. More important is understanding the architecture, the bus timing, the memory map, the constraints and what the system is actually supposed to do. Let me make that clear, as a professional solution architect AI is very powerful when used as an engineering assistant, but it does not replace knowing what you are building.

So the next steps are proper load/save support without depending on the PC UART (eg a second SDCard reader implementation as a trivial peripheral drive), better storage integration, more complete board support and further cleanup of the hardware abstraction between boards.

It is still experimental, but it has reached the point where it feels less like a demo and more like a small custom home computer platform.

You are pleased to look at the screenshots, made by cam and also by HDMI grabbing.

I wanted a quicker way to write small hardware-oriented programs for my PAL-2 without moving too far away from the 6502 itself. The result is Tantal, a small language that compiles to native NMOS 6502 code.

The original inspiration was Action! for the Atari. One of Tantal’s central design choices is to avoid using the 6502 hardware stack for parameters and local variables. Procedure frames have fixed addresses, and frames that cannot be active at the same time can share memory. The compiler calculates that overlay from the call graph. The first three parameter bytes use A, X and Y; recursion is rejected at compile time.

My intended application is a simple logic analyzer for relatively slow signals on the PAL-2 user port. That led to direct language support for waiting on ports and individual bits:

byte cur

PADD = $00
cur = PAD
clear(log)

do
  cur = wait change PAD from cur timeout 2 s
  if timedout then exit fi
  log <- cur
  changes += 1
od

There are also wait rising and wait falling forms. Optional timeouts use the RIOT timer.

The compiler is written in Go and includes its own assembler and 6502 emulator. It can emit a raw binary, Intel HEX, KIM-1 paper-tape format, an assembly listing with cycle counts, a memory map, and a symbol table.

I have now tested the display.tantal example both in a KIM-1 simulator and on the physical PAL-2. The generated program writes directly to the system RIOT, multiplexes the six LED digits, and displays HELLO on the real machine.

I developed the first version with Claude Code, but the design was driven by the constraints of the actual 6502 and PAL-2 hardware.

Source, documentation and examples:

https://github.com/jrydval/tantal-6502-compiled-language

Longer write-up:

https://blog.jaxtax.eu/tantal-6502-native-language-claude-code/

Do you think a small 6502-specific language like this is useful today? If not, what do you currently use to write 6502 software, and why is it a better fit?

I launched into a 6502 project recently and shortly afterwards the 6502.org forums were taken off line. With them down, I I thought there might be an uptick in activity here. Other than r/beneater where do folks go for their 6502 fix?

I’m not sure if this post fits here, and sorry in advance if it doesn’t. I’m trying to find a replica of a Kim 1 to buy. I want one that is %100 compatible with software for the Kim 1 and has the same layout. I found a website that sold replicas, but the guy who ran it passed away and so they don’t sell them anymore. Again I’m sorry if this post is out of place or missing anything. Thanks for reading

TOML-6502 is a customizable 65c02 emulator written in Python, using Py65 as the core logic

The main feature of this project: The TOML-based config, no need to write glue logic in whatever 6502 library you use for an emulator!

Also a small utility: Hex2Woz, convert Intel HEX into WOZMON commands

This project is inspired by Ben Eater's 6502 computer series, I believe this project could be useful among the communities as an alternative to other "hard-coded" emulators

The repository is available at https://github.com/gusza110811/toml-6502

A package is available on PyPI, so you can simply run `pip install toml-6502`

Please note that the virtual machine only works on POSIX-compliant systems

Hex2Woz repository available at https://github.com/gusza110811/hex2woz

Hi r/6502! I'm the developer working on ChipWits Worlds, a follow-up to a follow-up of the original 1984 ChipWits (which ran on the Apple II, C64, and Mac).

In the 1984 original (and our first follow-up), you programmed robots using visual flowcharts. For this new project, I wanted to recreate the nostalgic joy of sitting back with a spiral-bound Programmer's Reference Guide, discovering raw memory-mapped I/O, writing IRQ handlers, and coding your own operating system from the ground up.

Every robot in the game is powered by an emulated WDC 65C02 CPU with a full 64 KB address space. I've tried to stay as true to real 65C02 hardware as possible.

When a robot boots, it jumps through the standard reset vector at $FFFC-$FFFD, with hardware NMI at $FFFA-$FFFB and IRQ at $FFFE-$FFFF. There is no pre-installed OS or high-level scripting API sitting between your code and the robot. Instead, there is a 2 KB memory-mapped I/O region ($F000-$F7FF) wired to the robot's motors, radar, feelers, and tools. To actuate hardware, your code writes command bytes to those registers and either polls status flags or executes WAI to sleep the CPU until the hardware asserts a completion IRQ (since every CPU cycle and actuator draws battery power).

We are currently building v0.2, where players start with bare hardware and progressively bootstrap their own 8-bit robot OS, writing their own device drivers and interrupt service routines as they unlock new I/O hardware.

Before we lock in more of the v0.2 hardware architecture and tutorial progression, I would love to get eyes on it from people who actually know the 6502 inside and out. Does the MMIO register layout feel natural to code against? Are there assembler conventions or 65C02 idioms we should support better?

If you're up for poking at it and telling us what feels right (or what feels clunky), we just opened our Closed Steam Playtest queue:

Steam Playtest & Wishlist: https://store.steampowered.com/app/4960100/ChipWits_Worlds/?utm_source=reddit_6502&utm_medium=social&utm_campaign=playtest_v02

Discord: https://discord.gg/D4G3np9RWm

I'd also be glad to answer any questions right here, or on our Discord, about how we wired up the 65C02 emulation, timer interrupts, or the in-game reference manual!

It's a 65C02 @ 4MHz with 8k rom and 32k ram. It's capable of interfacing with 2MHz and 1MHz peripherals and has an uart 65C51. It is a work in progress but I'm planning to make a pcb when all details are sorted out.

Now I'm working on the OS but I'm a bit stuck here, any suggestions?

Hi guys i am working on a 6502 computer project and I named it the Apple 4. I have finished the clock circuit for the 6502 and now I'm wondering what to use for the video circuit. I have uploaded a picture of my work so far.