NES Emulator in Common Lisp (2016)

I think if you've never written any sort of lower level code before it's somewhat more daunting. I did spend a little time trying to get this emulator to run but ran into too many issues and gave up -- it's either a problem with some optimizations no longer being valid and raising type errors by default now (e.g. specifying a type as string does not, like other languages, implicitly mean it's either string or null¹) or something about the sdl2 bindings has changed (it's not the most stable of library binds unfortunately and has some misleading docs/examples out there, and the with- macros are not good and best avoided).

The assembler project I linked on the other hand works, though as you say having multiple asdf files is annoying, and the dollhouse.lisp demo makes an unfortunate choice of setting its *path* to #.*compile-file-pathname* Here's what I did to run it without changing that line (which would be better), translate to your flavor of editor+slime for convenience:

    $ git clone https://github.com/ahefner/asm6502
    $ cd asm6502/
    $ sbcl
    * (asdf-here)
    ; my own function I have in ~/.sbclrc, it is just:
    ;(defun asdf-here ()
    ;  (push (uiop:getcwd) asdf:*central-registry*))
    * (asdf:load-system "ichr")
    T
    * (defpackage :dollhouse-demo)
    #<PACKAGE "DOLLHOUSE-DEMO">
    * (defvar dollhouse-demo::*path* "hacks/")
    DOLLHOUSE-DEMO::*PATH*
    * (load "hacks/dollhouse.lisp")
    ; ...output
    ;
    ;(:NUM-UNIQUE 458) 
    ;Empty space begins at F600
    ;Created "/tmp/dollhouse.nes"
    T
    * ^D
    $ fceux /tmp/dollhouse.nes 

¹Example of SBCL raising a type error:

    (let ((x 3))
      (declare (type integer x))
      x)
    ; -> 3
    
    (let ((x nil))
      (declare (type integer x))
      x)
    ; in: LET ((X NIL))
    ;     (LET ((X NIL))
    ;       (DECLARE (TYPE INTEGER X))
    ;       X)
    ; 
    ; caught WARNING:
    ;   Constant NIL conflicts with its asserted type INTEGER.
    ;   See also:
    ;     The SBCL Manual, Node "Handling of Types"
    ; 
    ; compilation unit finished
    ;   caught 1 WARNING condition
    
    debugger invoked on a SIMPLE-TYPE-ERROR in thread
    #<THREAD tid=9761 "main thread" RUNNING {1001750003}>:
      Value of NIL in
      (LET ((X NIL))
      (DECLARE (TYPE INTEGER X))
      X)
    
      is
        NIL,
      not a
        INTEGER.

That's funny considering one of the comments in the README:

> TODO: Write more idiomatic Lisp

Perhaps it's readable because it's not idiomatic :D

Further testing and basically two kind of err code for the 6 rom I tested, example here:

;(nes:setup-and-emulate "1943.nes") #| The value NIL is not of type 6502-CPU::INSTRUCTION when binding 6502-CPU::INST |#

;(nes:setup-and-emulate "DKJU.nes") #| invalid number of arguments: 6 |#

I test both Rom using fcuex64.exe and both worked. Hence, I guess it is not usable. Sadly as the source code is very readable, unlike well python one.

Sadly it does not work

The 6502 bit is fun, but the NES PPU not so much! I never got past that part, maybe one day ...

Just for fun and learning, after writing a CHIP-8 emulator, what would be a good first emulator for a real device to tackle?

NES or Gameboy are my two main ideas, but I'm curious if there are other suggestions.

Yeah a stale repo isn't bad as long as there aren't outstanding issues to be worked. It is still a bad sign in evolving tooling environments like java c++ or rust, but lisp is pretty stable at this point too...

NES is a little unusual in this respect because the vast majority of cartridges have "mapper" hardware that must be emulated, and there has been a more-or-less continuous trickle of unlicensed cartridges over the years, some of which have unique mappers. If memory serves you can get to something like 95% compatibility with the few dozen most common mappers, but then there's a pile of oddball mappers that are each used by 1 or 2 games (many of which are just pirate hacks of a licensed game).

Thanks! I did that and all is good now