Visual6502 Remix | Hacker News Reader

Visual6502 Remix

floooh.github.io

205 pointsingve35 comments

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

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/

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

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

https://github.com/floooh/sokol

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

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.

Going the other way: https://c74project.com/ or even https://monster6502.com/

Edit: Western Design Center manufactures a pin-compatible DIP-packaged 6502. https://www.mouser.com/ProductDetail/Western-Design-Center-W... I couldn't find any pictures or info about what's inside though.

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

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.

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.

Some of us have reflow ovens, stencils, and past. It's not that hard with SMD. Through hole is where it gets time cosuming.

I love this.

Doubtful - the 6502 had something like one poly and one metal routing layer. It was hand routed by a human; balancing the use of poly, metal and diffusion is pretty tricky and requires bending a few rules that would otherwise constrain an autorouter in order to get everything to fit.

> It was hand routed by a human

And let's be clear, it was hand routed in both senses of the word. The layout engineers cut the mask by hand, crawling around on the table sized photomask.

Terminator 1 has it.

I'm not sure if why you're being voted down. I still remember sitting in the theater realizing that was 6502 assembler scrolling across the screen.

Can someone explain what we're looking at?

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

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

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

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, 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".

Here's a nice talk video covering the story from the origins of the 6502 to the Visual 6502 (but not the wasm Remix): https://www.youtube.com/watch?v=fWqBmmPQP40 .

To add a bit of anecdotal context to how significant the performance boost is, I didn't even have to look at the source code to know that this runs far, far faster than the original.

Sure! It's a 6502 CPU [0]. The visualization is showing the signals traveling through the components, as laid out in the die, which looks like this [1]. It looks like it's using the CMOS interpretation which is a layer below typical logic gates. The simulator is running a simple loop and you can step through and see all the registers, ALU, and whatnot running.

[0] https://en.wikipedia.org/wiki/MOS_Technology_6502 [1] https://commons.wikimedia.org/wiki/File:MOS_6502_die.jpg

https://www.pagetable.com/?p=517

"Here is the video recording of [this person's] presentation “Reverse Engineering the MOS 6502 CPU” given at 27C3, on the low cost CPU that arguably launched the home computer revolution."

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... ?

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

Question: what is the code for/from?

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

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

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...

I just took the original testing code from 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...

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

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

No, you can just make it in your language of choice. If you'd like to emulate it then you'll probably need to learn it.

Nice, is it about ~6 times faster?

It's about ~6 times cheaper.

Reply on news.ycombinator.com