py65 VS cc65

Here’s a working one already https://github.com/mnaberez/py65

I use the cc65 toolset to program my 65c02 projects and the py65 emulator to help debug them. I use a slightly modified version of da65, the cc65 disassembler, to create a complete listing of my code, something I find very useful for multi-file projects.

I've recommended py65, by Mike Naberezny, for 6502 development and have created several enhancements to it for my own builds (interrupt handling and debug window). Unfortunately, py65 doesn't support the 65C816. Luckily, it's open source and easy to modify, so I thought I'd try adding support for the 65C816.

I didn't understand Python enough at the time. I could probably figure it out now that I know more, but those commands aren't really useful to me for how I use the monitor. I added the continue command which does what I wanted. Interestingly, someone requested that a continue command be added to py65 back in 2019.

Py65, by Mike Naberezny, is a great simulator for the 6502. I recommend checking it out, especially as your 6502 build and code get more advanced. Py65 doesn't handle interrupts though, so if your build uses them, you either need to create a version of your code to simulate or modify py65 to handle your hardware binary. The former is the best option for most people, but the latter might be attractive to folks who don't want to deal with two versions of their code.

Thanks for all of the info. It looks very interesting. I'll have to resist getting sidetracked. Not easy to do. I'm currently on another sidetrack adding interrupt capability to the py65 simulator. Not really needed, but it means I don't need to maintain a separate code base for the simulator. It has the added benefit of letting me work with Python.

I recommend cc65 as well and might as well mention the py65 emulator. Both are great tools that have aided my development.

Luckily there is a nice 6502 emulator, py65, that makes development easier. Without that I don't think I would have every attempted this. Once I got it running on the emulator it was fairly straight forward getting it to run on the breadboard 6502. Working on the actual hardware did provide some unique challenges though.

Thanks. I've been using py65 for my development.

I'll probably be working to get a version of this running in my ANSIish Forth in py65, a simulation of the 6502 in python. Py65 runs fine with terminal escape codes running in a compatible terminal program. I've tried it with Conway's Game of Life which works similarly.

True. The code generated by https://cc65.github.io/ is pretty decent but there are a few places where hand-rolled assembler will perform much better when you need it. Although I've made things for 6502-based systems in C with this handy compiler (thanks cc65 contributors!).

Is there something intrinsic to how C handles addressing that makes segmented architectures more painful than they ought to be? Or maybe is there a language where segmented addressing is easier?

I hadn't really thought about it in a while. :)

cc65

There's tools like cc65 that let you write C code for the NES.

You can use any text editor for coding and the tutorial uses cc65 for compiling assembly to machine code.

You can use cc65 https://cc65.github.io/ but because you are compiling it in a limit hardware the cc65 has its rules and recommendations to follow in order to get the most optimal binaries, and more specifically I read this when I made the "Pong" game for NES as a practice long time ago https://nesdoug.com/ , I hope it helps, happy coding!

What assembler/tools did you use anyways? Personally I'd recommend ca65 from the cc65 C compiler utility. It's very powerful, open source, and kept updated (unlike a lot of ancient 6502 tools, like WDC's)

It really is a cool project. https://github.com/cc65/cc65

It provides some template configuration files describing different memory layouts. And provides common libraries for input/output.

There's also a LLVM fork for MOS: https://github.com/llvm-mos/llvm-mos

They've got some interesting hacks with ZeroPage memory and register allocation: https://llvm-mos.org/wiki/Code_generation_overview

Interesting if you geek out on that kind of research.