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.
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.
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.
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.
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".
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.
"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."
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
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).
https://eater.net/6502