HN Explorer

Ask HN: Books to learn 6502 ASM and the Apple II

102 points by abkt ↗ HN
I want to learn Assembly to make games on the Apple II. What are the old books to learn 6502 Assembly and the Apple II itself (memory, screen management) ? And is it absolutely necessary to learn BASIC before Assembly ?

39 comments

[ 2.0 ms ] story [ 70.0 ms ] thread
aa-jv
Pretty much the best resource available:

https://6502.org/

Check the books section and find something that compels you.

Also, don't forget the HUGE number of resources for 6502 assembly programming that are available in the https://archive.org/ magazine and book sections:

https://archive.org/search?query=6502

Rodney Zaks' books are great - I like especially "6502 Games", which taught me a lot back in the day:

https://archive.org/download/6502g/6502Games.pdf

I'm also especially fond of the easy6502 emulator - its a very handy tool to have while studying 6502 techniques:

https://skilldrick.github.io/easy6502/

Its not absolutely necessary to learn BASIC before Assembly, but it will definitely help you understand the resources of the machine better if you can debug BASIC ROM code. My personal 6502 platform of choice, the Oric-1/Atmos machines, has a pretty great ROM disassembly available, from which a lot of great knowledge can be obtained - but it does of course first require an undersanding of BASIC.

In case you're curious, the Oric-1 ROM Disassembly:

https://library.defence-force.org/books/content/oric_advance...

(You can get an Oric emulator named Oricutron, or you can access a virtual Oric here: https://oric.games/ ..)

Good luck!

einr
I believe one of the "standard works" to learn 6502 back in the day was Programming the 6502 by Rodnay Zaks. It's out of print, but it was printed in a lot of copies so you should be able to find one second-hand.
i_don_t_know
I'm seconding the recommendation to look at Rodnay Zack's books. For example, I really enjoyed Advanced 6502 Programming. It's a project-based tutorial for a custom 6502 machine. The design and schematics are in the book.

https://archive.org/details/Advanced_6502_Programming/mode/2...

c64cryptoboy
WRT advanced 6502 programming texts, allow me plug my (free) book "EOR #$FF: 6502 Ponderables and Befuddlements". It's 64 assembly snippets to ponder, with explanations for each in the 2nd-half of the book: https://archive.org/details/eor6502
christkv
I remember looking at the way graphics work on the Apple II and it looked pretty crazy lol with how memory layout worked to generate pixels.
asdefghyk
The answer would depend on what programming experience you have? Do you have any assembly language experience ? with other targets? ie have you used an assembler ( and maybe linker ) before. Are you familiar with hex? bytes, bits etc , You will learn this and much more ...

Id look for a book that targets Assembly programming on a Apple 2, ie not a book on general 6502 programming.

   Such a book Id expect to discuss things like Apple 2 memory map , Apple 2 hardware and how they are used in assembler language.
Hopefully the book would also provide guidance using a particular assembler ( hopefully still available)

I googled phrase Apple 2 assembly language programming for beginners?

and lots of very good looking links popped up.

You aim is a challenging task. Much to learn. Good luck. However entirely do able these days.

My background is electronics engineer, embedded programing on in assembler (some Motorola processors and others) and C for a few years before moving on to other things ....

The book Assembly Lines: The Complete Book available as a FREE PDF download from .... site https://ct6502.org/product/assembly-lines-the-complete-book/

INCLUDES All 33 of Roger Wagner’s Assembly Lines articles from Softalk magazine, plus appendices, in one complete volume.

ksherlock
For Apple-II specific info, consider

The Assembly Lines book -- https://archive.org/details/AssemblyLinesCompleteWagner

Understanding the Apple IIe -- https://archive.org/details/understandingapp0000sath

Understanding the Apple II -- https://archive.org/details/understanding_the_apple_ii

dmezzetti
Have you considered using something like claude code / opencode?
justin66
Learning BASIC isn't essential, but the thing is, you might as well just do it. It's not complicated, and you're not under any obligation to develop a big piece of software with it. Have fun!
neomantra
My running joke after showing off some amazing LLM-driven work is...

if you think this is impressive, I once opened a modal dialog on an Apple IIGS in 65C816 assembly

I don't think you need to learn BASIC, if you know concepts like conditionals and looping and indexing. It is interesting to compare the higher-level language of the time with its companion assembly. And you might find yourself writing BASIC programs to complement your assembly, if you stick to that platform.

<lore> A friend dropped me a BASIC program that ran and wrote text to the Apple IIGS border. He asked me to figure it out, because it wasn't obvious what was going on. OG hacker puzzle... it was a BASIC program that jumped to hidden assembly after the apparent end of the text file (hidden chars maybe, I forget) and the assembly was changing the border at appropriate rate to "draw" on it. Those were the days... trying to find some reference to this and am failing. </lore>

I certainly credit my stack-frame debugging capability to dealing with that stuff so long ago. Oddly enough, I didn't really find it helpful for computer architecture class. Just because you know registers exists and how to manipulate them, doesn't exactly map architecting modern hardware system. But being fluent in logic operations and bit-twiddling and indexing does help a lot.

jlmcgraw
There is "Apple Machine Language for Beginners" by Richard Mansfield https://archive.org/details/Apple_Machine_Language_for_Begin...

I have fond memories from the late 1980s of trying to get the assembler contained within this book working, typing line after line of the MLX listing in. Unfortunately I never did finish it back then.

A week or so ago I got the urge to complete this project and I literally just finished getting the source in it to a point where it can be compiled online and then within an emulator: https://github.com/jlmcgraw/LADS_DOS33

WillAdams
No, you don't need to learn BASIC before assembly, but many books of the time went that route, e.g.,

https://www.goodreads.com/en/book/show/5011686-apple-machine...

Here is an interesting article on porting a BASIC game for the Apple II to GW BASIC:

https://nanochess.org/akalabeth.html

and it includes a link to the documented source code for Akalabeth (also known as Ultima 0)

Somewhere, there's an article discussing the assembly-language like bit-blitting used to draw the high-res graphics in a timely fashion and the variable/memory management techniques needed to drive that which I'm sure a bit of searching will turn up (or one can derive it from the source).

EvanAnderson
They screen memory layout on the Apple II was a clever hardware hack but makes programming the machine more difficult. I think you'd be better off using a "trainer", like a KIM-1 simulator [0] to get your feet wet. (The KIM-1 was made by MOS Technologies, manufacturers of the 6502, as a demonstration and prototyping platform for the CPU.)

If you can do simple exercises on a machine like that and get comfortable with simple operations (loops, memory addressing modes) I think you'd have a better time grokking something more feature-filled.

[0] http://retro.hansotten.nl/6502-sbc/kim-1-manuals-and-softwar...

wang_li
If you aren't doing hires graphics, you don't have to mess with the screen memory directly. You can just call the ROM routines which has the nice side effect of working with 40- or 80-columns automatically. If you are doing hires graphics you are going to use a lookup table regardless as doing the multiplication to get the base address of a particular scanline is far too slow. You can, one time, either make a table manually, which you can use forever, or you can write a short routine that counts from 0 to 191, stick 0 in X and the scanline number in A and JSR $F411. It'll leave the base address of the scanline in $36 and $37. Which you can stick in your table.

As in other comments, if you are specifically interested in the Apple II line, the Assembly Lines books by Roger Wagner is fantastic.

Also, if you can find it Sandy Mossberg's Disassembly Lines articles in Nibble magazine were great too. Start with Assembly Lines, then read the Disassembly Lines and you'll be quite expert.

ThinkingGuy
This one worked for me: Apple II 6502 Assembly Language Tutor (1983) Richard E Haskell
andreybaskov
Original Apple II manuals written by Chris Espinosa and Jef Raskin are a treat to read. Would highly recommend, just to get a sense of what it was like to get onboarded on Apple II back in the day.

And then obviously Programming the 6502 by Rodnay Zaks.

jacquesm
Lance Leventhal's CPU books are pretty comprehensive and make it easy to switch from one architecture to another. Learning BASIC is definitely not a requirement.
dehrmann
There are a few distinct things here. Learning 6502 assembly is straightforward, and you'd be better learning about simple (not modern) assembly languages at a high level--opcodes, registers, noop, branch, jump, compare, accumulators, program counters, and clock cycles. From there, start writing 6502 in an emulator and seeing what happens. That's where you're going to learn, and the feedback will be a lot faster. Programming for an Apple II will be more about learning how to interact with devices through memory.
alnwlsn
You don't need to learn BASIC first but it might be helpful for bootstrapping at the beginning. Since it's included in the computer you can PEEK and POKE memory locations from BASIC and get a feel for how memory and machine code works without needing to understand the whole entire hardware, bootloading process, etc. first.

In my opinion BASIC, with its line numbers and GOTO / GOSUB feels assembly-ish anyway - you'll be doing a lot of JMP / JSR to control program flow which is different to how modern high levels are normally written.

runjake
6502 Assembly Language Programming by Leventhal.

This is how I learned. This book is great. I have the worn paper copy sitting 6 feet behind me as I type this. It's worth getting a paper copy if that is still possible.

https://archive.org/details/6502-assembly-language-programmi...

musicale
Looks like a nice book, and it appears that he wrote books on other microprocessors (8080/8085, 8086, Z-80, Z8000, 6800, 6809, 68000... even SPARC apparently) as well. I'd like to find a full version of the 68000 book, which archive.org only seems to offer a preview of.
ajross
Honestly if you want to learn retro stuff for retro reasons... maybe consider using the retro materials? Here's the MOS programming manual for the original parts, it's what Woz would have used when hand-assembling Integer BASIC:

https://archive.org/details/mos_microcomputers_programming_m...

And it's really not so complicated! The chip is simple, so the docs are simple. There's more to read about the history to come later, but there's also something to be said for understanding it in the context its designers presented it.

sloaken
For learning basic, the question is: do you already know how to program?

Only reason I can think to learn basic is if you do not know any programming language. And even then there are better choices.

Do they make an C compiler for the AppleII?