An 8-bit minicomputer with a fully custom architecture. Hardware schematics, software (firmware), and an emulator for testing.
8-bit data width. 16-bit address space (with banking). 8 general purpose registers (5 normal, 2 indirect addressing, 1 flag), 16 instruction RISC instruction set, port mapped I/O.
The Selfie Project provides an educational platform for teaching undergraduate and graduate students the design and implementation of programming languages and runtime systems. The focus is on the construction of compilers, libraries, operating systems, and virtual machine monitors. The common theme is to identify and resolve self-reference in systems code which is seen as the key challenge when teaching systems engineering, hence the name.
Selfie is a self-contained 64-bit, 11-KLOC C implementation of:
- a self-compiling compiler called starc that compiles a tiny but still fast subset of C called C Star (C*) to a tiny and easy-to-teach subset of RISC-V called RISC-U,
- a self-executing emulator called mipster that executes RISC-U code including itself when compiled with starc,
- a self-hosting hypervisor called hypster that provides RISC-U virtual machines that can host all of selfie, that is, starc, mipster, and hypster itself, and
- a tiny C* library called libcstar utilized by selfie.
Selfie generates ELF binaries that run on real RISC-V hardware as well as on QEMU and are compatible with the official RISC-V toolchain, in particular the spike emulator and the pk kernel.
CEmu is a GUI application that empowers users to write assembly and test it by compiling it to bytecode and executing it in an QEMU-based emulator. CEmu combines all the advantages of a basic assembly IDE, compilation and execution environment, by relying on the great libraries Keystone, Unicorn and Capstone engines in a Qt powered GUI. It allows you to test binary samples, check your shellcodes or even simply learn how to write assembly code, all of this for the following architectures:
- x86-32 / x86-64
- Arm / AArch64
- MIPS / MIPS64
- SPARC / SPARC64
- (more to come)
A portable, open-source 8086 PC emulator for bare metal Raspberry Pi. Boots as its own OS as you'd expect but emulates a MS-DOS machine from the silicon up. Emulates the 8086 and 80186 processor cores. Does CGA, EGA, and VGA graphics. Still in the early stages.
Advanced Mac Substitute is an API-level reimplementation of classic Mac OS. It runs 68K Mac applications in an emulator without an Apple ROM or system software. Unlike traditional emulators, Advanced Mac Substitute doesn’t emulate the hardware on which an operating system runs (except for the 680x0 processor), but actually replaces the OS — so it launches directly into an application, without a startup phase.
Header-only NES emulation library with an easy to use API. Include the header and instantiate the emulator with a handful of lines. Seems a fully featured NES emulator, capable of running even later games like SMB3. MIT licensed.
x86 virtualization in JavaScript, running in your browser and NodeJS.
Disk images to boot and run: https://copy.sh/v86/
A software modem that pretends to be an analog dialup modem from the old days, only for communications it uses the IAX protocol to connect to an Asterisk VoIP switch rather than the PSTN.
Software that emulates the guidance computer of the Apollo space capsules.
A wiki dedicated to the Commodore-64 home computer.
Unicorn is a super-CPU emulator which handles multiple common processor core architectures, from x86 to Arm. Based on QEMU, written in pure C for speed and portability. Has multiple API bindings for different languages. Does just-in-time (JIT) translation of opcodes. Designed from the ground up to be thread-safe.
Homepage of a kit that emulates an Altair 8080 system using an Arduino.
An /*duino/i shield which emulates an MOS 6581... the SID chip.
Cuckoo is a system emulator written in Python for analyzing malware. It automates much of the process of reverse engineering malware samples, such as tracing execution, snapshotting memorry, tracing API and function calls, and dumping network traffic. Generates reports at the end of execution. Modular design, so it's easily customizable.