RPCEmu RV32IM
A 32-bit RISC-V core with integer multiply and divide, and up to 64MB, which is the one to reach for if you want room to work.
Second processor
The slot Acorn built and almost nobody used
The Risc PC had an interface for a second processor sharing the machine's memory and devices. Acorn documented it in 1994, very little was ever made for it, and it is emulated here with a card offering a choice of seven processors.
What is in the slot
Seven processors, each with its own memory
Fit one card per machine and choose what is on it. Each core has memory of its own, configurable up to what that processor can actually address.
6502 and 65C02
The processor of the BBC Micro and the Electron, and its CMOS successor, with 64K each.
Z80 and 8080
The other half of the eight-bit world, for anyone whose interest runs that way.
6809 and 6800
Motorola's eight-bit line. The 6809 is not a superset of the 6800 and they are separate cores here, because pretending otherwise gets the details wrong.
What you can do with it
Seventeen calls, and no software
A RISC OS module gives you the interface: load a program, start it, and run the machine a frame at a time.
Describe the address space
Tell the card in a single call what lives where, so a program running on the second processor sees the memory map you intend.
Watch what it writes
Be told what the program wrote and when, which is how you build a display or a device on top of it.
Answer what it reads
Present values when it reads, so an emulated peripheral can live in your RISC OS program.
Interrupt it, and step it
Raise an interrupt, or run it for a frame and stop, which is what makes writing an emulator on top of it practical.
No card like this was ever made, so there is no software for it. That is the appeal: what runs on it is what you write.
The history
Acorn documented it, then almost nobody used it
The Risc PC was Acorn's first ARM platform to support more than one bus master. The technical reference manual of September 1994 describes an interface for connecting a second processor that shares the machine's memory and devices with the native one.
Very little came of it. The interface existed, the slot existed, and the market for a second processor card in a machine that was already fast enough did not. That leaves an odd gap in the hardware: a documented, usable expansion route with essentially nothing ever built for it.
Emulating it costs little and opens something genuinely unusual. You can build the card that was never made, and because the emulator provides the processor, the part you write is the interesting half: the memory map, the devices and the software.
Getting started with it
A stub card to prove the wiring
Something that answers
A minimal card is included so the interface can be exercised before you write anything: fit it, ask it what it is, and get an answer back.
Fit it while the machine runs
A card can be added to a running machine rather than only at startup, which shortens the loop when you are developing against it.
One card per machine
The slot takes one, as the real interface does. Different machines can carry different processors, so comparing two is a matter of starting both.