I'm a Windows 10 user, but all of my programming (work and play) I do on Linux. At work I use Linux x86 development machines for MIPS32 firmware work (with simulators when needed) and at home I run a Linux virtual machine under VMWARE Player on Windows.

Tools wise, I use vi and make to build. When tinkering with 6502 I'll use ca65 (from the cc65 suite) to assemble, with a pieced together 6502 emulator taken from the MAME distribution (http://www.mamedev.org). I use ca65 just because it was there and I needed something trivial. I might use atasm or similar if I wanted to write something significant.

Some questions for active 65xx developers:

What operating system do you develop on? Any particular reason for the choice?

What's your edit/assemble environment (e.g. IDE+F5, vi+make, other)?

What assembler do you use? Have you tried others? Why/how did you make your choice?

Do you use an emulator? If so, which one? Does it include device models?

Are there 65xx software tools that you wish you had that as yet haven't existed?

Linux, I've not used anything else for 15+ years.



emacs, make, bash



xa, haven't tried any others. No frills, does what's needed.



VICE, I develop for the VIC-20. It supports most Commodore variants.



No, but if there were I'd just lash them up in Python, bash, etc.

Hi,


Linux (Ubuntu). The Unix stuff is handy and it's actually easier to cross-compile a Windows binary from Linux anyway.


VIM and Make.


I wrote the 6502 and 65816 modules for naken_asm, so I use that. I prefer a newer syntax style (0xBEEF vs $BEEF), but I'm almost done supporting the older syntax also.


I currently use SXB boards to test routines against the real hardware, which is even easier than using an emulator. They are expensive, though.

FWIW, in another thread porcupine noted that the W65C265SXB is available for $99, about half what a W65C816SXB (eg) costs.

_________________
In 1988 my 65C02 got six new registers and 44 new full-speed instructions!
https://laughtonelectronics.com/Arcana/ ... mmary.html

Yeah, I have the '265 and '134 boards. It's nice to have both the 6502 and 65816 in hardware form. I'm more of an analog electronics and software guy, so the cheaper microcontroller boards are plenty enough for me. Still trying to come up with a good project, maybe a music synth or something.

Win 7, and am a big fan. I like it that so many great tools are available and easy to use.


Notepad++ for the editor and build, and the 64tass assembler, which handles all 65x cpu versions flawlessly. Using these two tools I can automatically and easily create any type of binary, complete with any amount of syntax highlighting I may need, mix it in with x86 assembly if need be (using GoAsm or Fasm) and get something fast and with what I feel is a very standard syntax. You didn't ask, but I also use IDA w/ the 65816 plugin for disassembling and figuring out binaries. Here again, da65 (from the cc65 suite) is a super-solid product, but there are just too many arcane hoops required (for me at least) to want to use it regularly.


64tass for 65x, mainly GoAsm for x86, and I have tried just about all of 'em over the years, both native and cross. Some, like ca65 or even Merlin, while popular with some, use syntax and long-way methods that I find too much work to become familiar and comfortable with. Staying within the comfort zone I guess...

VICE for both c64 and SuperCPU. It's awesome. I have emulators for virtually all the major 8/16-bit systems and do use them all occasionally, but tend to stick with Commodore. For me it's the most fun.
Haven't thought about it much, but at present I don't think so. Maybe a better ml monitor. Working on porting the old Warpspeed cartridge monitor to 'C02/816 now.

All good questions, by the way.

I use C64ASM.EXE to assemble my 6502 code. This is a DOS program which I run in DOSBOX on my Linux system. A MAKE.BAT file makes it easy to do the necessary assembling without having to remember the switches each time.

For small editing purposes, I will use MSDOS's EDIT program or another DOS program like VI or VDE. For larger jobs I will use a Linux based editor like leafpad or geany.

I also use VICE as my emulator of choice when running my programs.

I use either my own 'Dev65' cross platform (Java based) assembler or the WDC tools with a Makefile and some batch files under Windows (XP, Vista and 7)

_________________
Andrew Jacobs
6502 & PIC Stuff - http://www.obelisk.me.uk/
Cross-Platform 6502/65C02/65816 Macro Assembler - http://www.obelisk.me.uk/dev65/
Open Source Projects - https://github.com/andrew-jacobs

I mostly use emacs, make and cc65, usually on Linux and sometimes on OS X. For specific projects, I'll use the appropriate assembler: Dev65, HXA, AS65 and so on. I also use the assembler inside easy6502. For emulation, I'll use easy6502, visual6502, jsBeeb, lib6502 or others depending on what I'm trying to do. I do have a BBC Master hooked up with a serial cable for when I want to run on hardware, and a BBC nearby similarly.

Windows 7, pending upgrade to Windows 10.

PSPad

Kingswood AS65. I made the coice based on the best readable output listing and features for my needs. There is a lot of assemblers around with crappy output listings.

Rarely Kowalski. No device models. Most of the time I test on the target system which has sufficient debugging features.

No

_________________
6502 sources on GitHub: https://github.com/Klaus2m5

I use Windows 7, although I switched to Linux during the Vista debacle. I switched back to Windows 7 because of web cam, sound, video card, and WiFi drivers. Linux is great for pure software development, but you need to be careful about hardware vendors not porting their closed source driver blobs to newer kernel versions. In my experience laptops can be especially problematic because you can't pick and choose components that only have open source drivers like you can on a desktop machine.

Windows 8 and 10 are making me think about braving the driver issue again.



Emacs and Git Bash. I use either shell scripts or make.



I borrow code from other people and mash it up into what I want. So I'll use whatever assembler the original author used. The one I use the most is Tass.



No and that might be easier than burning eeproms as often as I need to.

Currently on Windows XP SP3 running against Samba on Linux. My development environment is Windows-only, so that's what I use.


The Kowalski assembler/simulator, with macros to synthesize 65C02/65C816 instructions that Kowalski doesn't natively support.


The Kowalski assembler or my custom UNIX-based assembler. I've tried some others, but often found them cumbersome or deficient in some way. The closest I have come to switching assemblers was Andrew's Java-based assembler.


No.


No.

_________________
x86?  We ain't got no x86.  We don't NEED no stinking x86!

Thanks for the responses.

OSes: DOSBox(Linux), Linux, MacOSX, Windows XP, Windows 7, Windows 10
Editors: edit, emacs, feany, leafpad, Notepad++, pspad, vim
Build: make
Assemblers: 64tass, as65, c64asm, ca65, dev65, Kowalski, naken_asm, xa,
Emulators: custom, Kowalski,none, VICE

Tools are a very personal choice, so it's no surprise there's a wide selection, although I expected there to be a front-runner for the assembler. Perhaps within cliques (e.g. Atari programmers vs. C64 programmers) there are more preferred tools, but this group appears diverse. VICE was mentioned 3 times, so gets a special mention.

For those of you who bypass emulation and go straight to target, how do you load the code onto the target?

I guess it depends on what was available at the time you sought out an assembler (C64ASM came out in the 90s though I can't remember when I downloaded it). If it works for you then there is little incentive to change to a different type - no matter how highly recommended the new one is.

The assembler that I wrote for my Forth system if far more powerful and I may switch to using that permanently once my Forth is completed.

OS: DOS, LInux. I can develop with my handheld HP computers from the 1980's also, but it's not very practical.

Assemblers: Used 2500AD (now distributed by Avocet Systems) 65(c)02 assembler from '86 to '93, then C32 (Cross-32) from Universal Cross Assemblers in Canada (now distributed by Data Sync Engineering). The latter is able to assemble for dozens of processors, including for the 65(c)02 and '816. Both are great macro assemblers. For PICs, I use MPASM. For the workbench computer, my own Forth kernel with onboard assembler.

• If for (E)EPROM, I use the Needham's PB-10 programmer that's plugged into a slot in the PC.
  
  
• For PICs, I send the Intel Hex file to the 65c02 workbench computer which controls my home-made PIC programmer.
  
  
• If it's something to run on the workbench computer itself, I just mark a block in the source code in the text editor on the PC and "print" the block on the RS-232 port as if to a serial line printer. The PC thinks it's just printing; but the workbench computer takes that text and compiles, assembles, or interprets on the fly, as appropriate. For short additions, turn-around time is virtually instant, from writing a piece of code to adding it to the system on the workbench to actually watching it run. In the Forth system, it is not necessary to re-compile the whole application, only the little piece you're working on. If I crash it, the reset routine gives me the option to start new, or to pick up where I left off instead of having to re-compile everything (since most crashes just get stuck in a loop with no way out and they're not writing trash all over the dictionary), or do the latter and even run a specified routine again to set things up and get a process going again. This way, a crash may cost less than five seconds' time. I've even changed interrupt-service routines between timer interrupts, without pausing interrupts that are hitting at tens of thousands of times per second. How do you do that? By assembling the new one, then watching for when the interrupt was just processed, then when you know you have enough time before the next one, quickly swap out the vector, so the next interrupt gets serviced by the new routine. It's instant, without a simulator, emulator, debugger, etc.. The few times I've shown people, they've had a hard time believing there wasn't a TSR or some other hidden software on the PC.

At the moment, I'm trying to get a Displaytech graphic LCD going, and it has been rough, as Displaytech's documentation seems to be a mess and their website is not helpful. They have a forum to ask your questions, but most questions go unanswered, or their answer just refers you to a particular data sheet, and the sheet obviously does not match my display even though the model number is exactly the same. [Edit, several months later: I got it going. I had one bit wrong in one of the LCD's set-up instructions. Here's a few seconds of demo video done for experiment purposes, using a random number generator to produce sets of 25 random segments then displaying the screen memory: http://wilsonminesco.com/6502primer/Dis ... 8Ademo.mp4 ] There's no problem sending it commands with the workbench computer, and writing the code to do what I want is a trivial time-taker in my system. What I'm lacking is an understanding of what the code needs to do to get the results I want. How would a simulator or even an emulator help with that? It wouldn't. But that's my life as far as the little computers go. It's about interfacing to hardware, sometimes to make sure I correctly understand how to interface to a new IC to use in a product (or in this case, a graphic LCD). It is trivial to try things in Forth, on the actual hardware. Once I have a collection of routines working for it, I can translate it to PIC assembly or other language where development would have been much slower if I hadn't first been able to use the workbench computer with Forth.

_________________
http://WilsonMinesCo.com/ lots of 6502 resources
The "second front page" is http://wilsonminesco.com/links.html .
What's an additional VIA among friends, anyhow?