
Visual6502 Remix - ingve
https://floooh.github.io/visual6502remix/
======
jah
For those interested in the 6502, Ben Eater is starting a new YouTube series
in which he builds a computer around a 6502 chip.

[https://eater.net/6502](https://eater.net/6502)

~~~
matheusmoreira
An up-scaled replica of the 6502 with a lot of LEDs to visualize the state of
the processor while it works:

[https://monster6502.com/](https://monster6502.com/)

~~~
colordrops
Love it. Would be willing to purchase one of these to use as a teaching tool.

------
rlp
The author of this also created the excellent Sokol cross-platform
graphics/sound library, which is being used here.

[https://github.com/floooh/sokol](https://github.com/floooh/sokol)

~~~
FraKtus
Thank you for posting this. sokol_gfx.h looks really handy!

------
microcolonel
Really great performance, buttery-smooth. Excellent job!

Looking at the 6502, I've got to wonder if today's most powerful Place 'n
Route tools could make any significant improvement to it.

~~~
sp332
Going the other way: [https://c74project.com/](https://c74project.com/) or
even [https://monster6502.com/](https://monster6502.com/)

Edit: Western Design Center manufactures a pin-compatible DIP-packaged 6502.
[https://www.mouser.com/ProductDetail/Western-Design-
Center-W...](https://www.mouser.com/ProductDetail/Western-Design-Center-
WDC/W65C02S6TPG-14/?qs=sGAEpiMZZMvu0Nwh4cA1wSNu7hWmGrIdvYIw7nZ2DMI=) I
couldn't find any pictures or info about what's inside though.

~~~
deelowe
I wish they'd release the monster6502 as a kit or at least release the brd
files so others can make/improve on it.

~~~
duskwuff
With 4,769 surface-mount components and somewhere on the order of 16,000
solder joints, it's well outside the realm of what you can assemble at home.

~~~
monocasa
IDK, it's meticulous work I'll give it that, but more impressive computers
have been built component by component. Just take your time, test each piece
as you go, and don't develop an ego and you'll be fine.

------
hombre_fatal
Can someone explain what we're looking at?

~~~
NobodyNada
The MOS 6502 [0] was an 8-bit CPU that powered many systems from the 70’s and
80’s, including the Atari game consoles, Commodore 64, Nintendo Entertainment
System, and early Apple computers. It could also be considered the ancestor of
the ARM architecture.

Visual 6502 [1] is a transistor-level simulation of the 6502, written in
JavaScript. It allows you to investigate how the real hardware behaves in
response to some input, and it makes it possible to investigate the circuitry
responsible for this behavior. It has proven an invaluable resource in recent
years for developers and emulator authors to nail down and document all the
weird quirks of their 6502-based hardware. The simulator core is also very
useful for modeling other 80’s hardware, such as the NES’s video and audio
systems.

Looking at this project’s GitHub [2], it appears this is a rewrite of Visual
6502 that compiles into WebAssembly, resulting in _vastly_ improved
performance compared to the original JS implementation.

[0]:
[https://en.wikipedia.org/wiki/MOS_Technology_6502](https://en.wikipedia.org/wiki/MOS_Technology_6502)

[1]:
[http://www.visual6502.org/JSSim/index.html](http://www.visual6502.org/JSSim/index.html)

[2]:[https://github.com/floooh/v6502r](https://github.com/floooh/v6502r)

~~~
flohofwoe
TBH, the main factor for the smoother performance is that rendering the chip
visualization is handled very differently than the original visual6502.org.
Instead of using 2D canvas, the "remix" uses WebGL and offline-precomputed
static vertex buffers.

The actual simulation is most likely also faster than the original JS
implementation, but I haven't measured that. This is done by
[https://github.com/mist64/perfect6502](https://github.com/mist64/perfect6502),
which is a rewrite of the original JS simulation code to C. but there's only
at most one CPU half-cycle running per 60Hz frame, so the actual CPU
performance for the simulation is hard to compare with visual6502.org which I
think is running "unthrottled".

------
integricho
Off topic: can already assembled 6502 kits (i.e. single board computers) be
bought anywhere, just like this one for z80 [https://shop.mcjohn.it/en/diy-
kit/22-33-kit-z80-mbc2.html#/1...](https://shop.mcjohn.it/en/diy-
kit/22-33-kit-z80-mbc2.html#/13-kit-assembled) ?

~~~
Keyframe
Bring your own chip(s) [https://icomp.de/shop-icomp/en/produkt-
details/product/c64-r...](https://icomp.de/shop-icomp/en/produkt-
details/product/c64-reloaded-mk2.html) or get and old one. It’s 6510, which is
the same thing.

------
saagarjha
Question: what is the code for/from?

~~~
NobodyNada
If you're referring to the code that's loaded into memory location $00 and run
when the simulator starts up: it doesn't look like it's anything particularly
interesting, just a simple loop to exercise the simulator:

    
    
          LDA #$00    ; A=0
        loop:
          JSR sub     ; call subroutine
          JMP loop    ; infinite loop
        sub:
          INX         ; increment X register
          DEY         ; decrement Y register
          INC $0F     ; increment memory location $0F
          SEC         ; set carry flag
          ADC #$02    ; A += 3 (add 2, with carry)
          RTS         ; return from subroutine

~~~
saagarjha
Yeah, it didn't look like it was doing anything useful so I was curious if it
was a reference to something…

~~~
NobodyNada
I very much doubt it's a reference to anything. It doesn't appear to have a
useful purpose besides demonstrating/exercising a few of the important
components of the processor: it performs operations using the registers, the
stack (JSR/RTS), memory (INC), and the ALU (ADC).

A quick search through GitHub shows that this code is unchanged since the
initial commit of the original Visual6502:
[https://github.com/trebonian/visual6502/blob/4d8da5b680216dc...](https://github.com/trebonian/visual6502/blob/4d8da5b680216dcbe5705ecb831821cd6b81e479/macros.js#L2)

~~~
flohofwoe
I just took the original testing code from
[http://visual6502.org/JSSim/index.html](http://visual6502.org/JSSim/index.html),
also to confirm whether the simulation and visualization works.

I don't think it has any significance except testing a few things like memory
read/write access, whether the stack works etc...

------
mrcactu5
if all I want to to is build a Super Mario clone is the knowledge of the 6502
assembly language still necessary ?

~~~
monocasa
It'd be helpful, but not strictly necessary.

Here's an extremely well commented disassembly of Super Mario Bros.

[https://gist.github.com/1wErt3r/4048722](https://gist.github.com/1wErt3r/4048722)

------
djmips
Nice, is it about ~6 times faster?

~~~
airstrike
It's about ~6 times cheaper.

