Lib.rs

agb

Game Boy Advance Development

firecracker-microvm/jailer

Process for starting Firecracker in production scenarios; applies a cgroup/namespace isolation barrier and then drops privileges

chd

File Format

virt

Rust bindings to the libvirt C library

nuttx-arm64-emulator

Emulate Apache NuttX RTOS for Arm64 with Unicorn Emulator (Avaota-A1 SBC)

qemu

QEMU binary installer

trapezoid

A PSX emulator, backed by vulkano for rendering

swf

Read and write the Adobe Flash SWF file format

tetanes

A cross-platform NES Emulator written in Rust using wgpu

libscemu

x86 32/64bits and system internals emulator, for securely emulating malware and other stuff

unicorn-engine

Rust bindings for the Unicorn emulator with utility functions

mos6502

A MOS 6502 Emulator

librashader

RetroArch shaders for all

risc0-circuit-rv32im

RISC Zero circuit for rv32im

iz80

Z80 and 8080 emulator

gameboy

emulator written in Rust and WebAssembly

yane

An N.E.S. emulator and emulation library.

netsblox-vm

running NetsBlox code with optional native extensions

qapi

QEMU QMP and Guest Agent API

enjoy

Play any game rom with associated emulator in RetroArch

ipl3checksum

calculate the IPL3 checksum for N64 ROMs

tdx-guest

The tdx-guest provides a Rust implementation of Intel® Trust Domain Extensions (Intel® TDX) Guest APIs, supporting for TDX Guest specific instructions, structures and functions

muvm

Run programs from your system in a microVM

armv4t_emu

An emulator for the ARMv4t instruction set

rtlola-interpreter

An interpreter for RTLola specifications

binfmt-dispatcher

Smart dispatcher for binfmt_misc

aranya-policy-vm

The Aranya Policy Virtual Machine

monistode-emulator-cli

A CLI for the Monistode emulator

risc-y

RISC-V Emulator

vhost-device-console

vhost console backend device

haybale

Symbolic execution of LLVM IR, written in Rust

rust_multistackvm

Stack-based virtual machine on top of rust_multistack crate

teletype

Altair 8800 / teletype emulator (via 88-SIO board) for my 8080 emulator

firecracker-microvm/vmm

Secure and fast microVMs for serverless computing

libslirp

High-level bindings & helper process for libslirp

resid-rs

Port of reSID, a MOS6581 SID emulator engine, to Rust

hecate-assembler

The assembler for the hecate vm

microvmi

A cross-platform, unified, low-level VM introspection API supporting multiple hypervisors

udbserver

Provide Unicorn emulator with a debug server

w65c816

WIP! An emulator for the WDC W65C816S, a 16-bit derivative of the 6502

rustzx-z80

Z80 CPU emulator library

z80emu

ZiLOG Z80 microprocessor emulation library

osiris-set-std

A standard operation set

xum1541

Rust driver to access Commodore disk drives using xum1541 USB device

r6502

MOS 6502 emulator

jchip8-rs

emulator for the Chip8 platform

playdate-simulator-utils

Cross-platform utils to deal with Playdate Simulator

zk-aluvm

AluVM extensions for zero knowledge, STARKs and SNARKs

agb-gbafix

CLI utility to convert ELF file to valid GBA ROM

swamp-vm-disasm

disassembler for the opcodes in the swamp vm

mizu

An accurate gameboy(DMG) and gameboy color emulator. Front-end for mizu-core

trust-80

TRS-80 Emulator

qook

Pure Rust unitaryfund/qrack Wrapper

hecate-packer

The packer for the hecate vm

boytacean-hashing

Hashing library for Boytacen

ruboy

A gameboy emulator for desktop, based on ruboy_lib

brainhug

brainf*ck translator

safeboy

Safe bindings for SameBoy, a free and accurate Game Boy emulator

emulator_6502

MOS 6502 emulator, intended to be a talking point during the interview process for my Winter 2020 co-op placement

virt-ic

virtual integrated circuits - an backend IC emulator

gabbro

A Game Boy emulator written in Rust

maurice

Thomson MO5 emulator

scriptful

A minimalist, no_std stack machine library for interpreting domain specific interpreted languages

squid

A RISC-V emulator with AOT compilation for fuzzing

vmw_backdoor

A pure-Rust library for VMware host-guest protocol ("VMXh backdoor")

runes

No-std NES emulator library and minimal emulator written purely in Rust

kaze

An HDL embedded in Rust

vines

NES emulator library

monistode-emulator

An emulator for the monistode set of ISA's

plastic

A NES emulator with GUI and TUI

manzana-uno-emu

Apple I emulator

nsm-nitro-enclave-utils

simplifies development for AWS Nitro Enclaves by enabling the reading and verifying of mocked attestation documents while in local development environments. Once your ready to go to production…

cpclib

Set of tools and libraries to ease demomaking on the Amstrad CPC platform. WIP

libafl_qemu_build

Builder for LibAFL QEMU

firecracker-microvm/firecracker

enables you to deploy workloads in lightweight virtual machines, called microVMs, which provide enhanced security and workload isolation over traditional VMs, while enabling the speed…

krata-xencall

direct interfacing to Xen privcmd for krata

rvemu

RISC-V emulator core implementation

qip

efficient quantum computing simulations

tudelft-nes-test

support library for the 'software fundamentals' project for the TU Delft

baby-emulator

An emulation library of the Manchester SSEM 'Baby'

librashader-runtime

RetroArch shaders for all

gameboyr

A Gameboy emulator written in Rust

gpcas_forwardcom

ForwardCom instruction set architecture (ISA) properties for use with the General Purpose Core Architecture Simulator (GPCAS)

sbrain

evaluating Semantic Brain, a minimalistic multiparadigm programming language optimized for genetic programming applications

tdx-tdcall

Constants, stuctures and wrappers to access TDCALL services

rvsim

A RISC-V simulator implementing RV32G[C]

sk-ctrl

Kubernetes controller for replaying traces in a simulated cluster

osiris-data

A data management package

hecate-turtle

A turtle implementation based on hecate vm

pica

virtual UWB Controller implementing the FiRa UCI specification

zilog_z80

Zilog Z80 Emulator

chip-ahoyto

A CHIP-8 emulator in Rust

bfc

An industrial-grade brainfuck compiler

rrs-lib

building RISC-V instruction set simulators

ashpaper-plus

Rust Inpterpreter for Esopo language AshPaper conceived by William Hicks

nes6502

An emulated NES version of the 6502

c8

🎮 CHIP-8 / S-CHIP / XO-CHIP tui toolkit featuring a virtual machine, debugger, and disassembler

lwk_ledger

Liquid Wallet Kit - Interact with Ledger Hardware Wallet

mos6502_model

MOS6502 hardware model

agb-debug

CLI utility to convert agb stack trace dumps into human readable stack traces

phakebit

A 6502 CPU emulator

avr

AVR emulator

gpcas_isa

Interface and utilities for GPCAS ISA implementations

riscv_emu_rust

RISC-V emulator written in Rust

z80

z80 emulator

desmume-sys

FFI for DeSmuME, the Nintendo DS emulator

gameboy_core

core library to be used for Gameboy emulation

dcpu16

DCPU-16 assembler, disassembler and emulator

spectrusty

building highly customizable emulators of the ZX Spectrum computer series and clones

chip_8

CHIP-8 virtual machine / emulator

lemurs-8080

An emulator for the Intel 8080 microprocessor

rysk-core

RISCV instruction decoding and execution

pros-simulator

Run PROS robot code without the need for real VEX V5 hardware

termin-8

CHIP-8 emulator that runs in your terminal

boytacean-common

Commons library for Boytacen

brubeck

A RISC-V REPL and emulation library ... a work in progress!

libmwemu

x86 32/64bits and system internals emulator, for securely emulating malware and other stuff

beam_bvm_interface

A direct interface to the Beam Virtual Machine functions and data structures

cranefack-cli

Commandline utility for the cranefack brainfuck compiler

vmadm

Administer virtual machines in local libvirt

intel8080

Intel 8080 Emulator

rustzx

ZX Spectrum emulator

librashader-runtime-gl

RetroArch shaders for all

nescore

NES emulator

pir-8-emu

pir-8 ISA

runestick

Runescript, a generic stack-based virtual machine for Rust

cpclib-z80emu

cpclib libraries related to snapshots

kaiju-core

Core module of modern assembly language toolset

qapi-codegen

QEMU QAPI codegen helper

mohanson/gameboy

Full featured Cross-platform GameBoy emulator by Rust. Forever boys!.

csx64

An Intel-style x64 assembler and executor

vm_translator

A VM translator for the hack machine (ref: The Element Of Compting System)

libafl_qemu_sys

C to Rust bindings for the LibAFL QEMU bridge

kondrak/rust64

Commodore 64 emulator written in Rust

bevm

Emulator of Basic EVM for itmo students

nes_rust

NES emulator written in Rust

ch8asm

Open-source Chip-8 assembler

zeerust

A Z80 CPU Emulator

krata-xengnt

Xen grant interfaces for krata

meru

Multi game console Emulator written in Rust

tinychip

CHIP-8 emulator/interpreter

psg

Fast and precise AY-3-8910 and YM2149 sound chip emulation

tetanes-web

A NES Emulator written in Rust and WebAssembly

smmdb

Super Mario Maker and Super Mario Maker 2 to read and manipulate game files

gekkio/mooneye-gb

A Game Boy research project and emulator written in Rust

lr35902

Gameboy emulator written in Rust and WebAssembly

osiris-process

A processor implementation

zinc64

Commodore 64 emulator app

aphelion-util

types and traits for Aphelion instruction set architecture

mupen64plus

High-level Rust bindings to the Mupen64Plus Core API

simias/rustation

A PlayStation emulator

rrs-succinct

building RISC-V instruction set simulators

esrtool

Port of the PS2 Homebrew ESRtool to Rust and modern platforms

melon

creating retro computing platforms

siso

IBM 5150 emulator

ruboy_binutils

A collection of utilities for working with Gameboy binaries, based on ruboy_lib

ttxcat

Show Teletext pages in the console

nanowasm

A small, stand-alone WebAssembly interpreter

emu6809

In development 6809 emulator

imperative-rs

Auto derivable trait to easily define instruction sets

libretro-proxy

Write libretro cores that act as a proxy to other cores

tis-100

An emulator for the TIS-100

intel-8080-emu

A small library to emulate an intel 8080

tudelft-nes-ppu

support library for the 'software fundamentals' project for the TU Delft

gameboy-rom

Gameboy ROM parser

ruxn

Uxn stack-machine written in Rust

rusty-boy-advance

A Gameboy Advance Emulator (WIP)

rudelctl

Commandline utility for rudelblinken

gbr

Game Boy emulator in Rust

mem_storage

Abstractions for readable and writable memory. Designed to be uesd in emulators.

tis-cli

TIS-100 emulator

feo3boy

Emulator core for the gameboy

rust8

A Chip-8 Emulator Library in Rust

vm-superio

Emulation for legacy devices

emu-runner

Command builder and executor for various emulators

rust-simple-stack-processor

stack processor emulator written in Rust

cpclib-cpr

cpclib libraries related to CPR handling

corewars

The classic programming battle game Core Wars

falcon-mos6502

Instruction decoding for MOS 6502

rusty_6502

6502 emulator

rustzx-utils

Additional helpers for rustzx-core based emulators

toyvm

The toylang CLI/Wrapper

qemu-plugin

High level bindings to the QEMU plugin API

dolphin-memory

that makes reading and writing memory of the Dolphin emulator easier

strawberryvm

A fantasy virtual machine with limits on resources

automachina

Lobana Abstract Computers

heliometer

A basic Brainfuck interpreter

svmap

parse SVMap, used to map memory for emulators

agb_tracker

playing tracker music. Designed for use with the agb library for the Game Boy Advance.

rustyboy

Gameboy emulator

chip8_db

Embed the CHIP-8 DB in your own CHIP-8 implementation

plastic_tui

A NES emulator with terminal interface (TUI)

femtos

a femtosecond-based representation of time, duration, and frequency, for the purpose of simulation

intcodeint

An intcode interpreter for Advent of Code 2019

krun

Run programs from your system in a microVM

olympia_cli

Olympia is a gameboy emulator and toolkit, intended to run as a native or web assembly application targeting a cycle count accurate emulation. olympia_cli contains tools to debug the olympia emulator and rom files.

mindjuice

brainfuck interpreter

yaxpeax-sm83

sm83 decoder for the yaxpeax project

kvm-ioctls

Safe wrappers over KVM ioctls

schip8

Interpreter backend for Chip-8 and Super-Chip

chip8_core

A CHIP-8 emulator core library

librashader-runtime-vk

RetroArch shaders for all

emul8

rust-based toolchain to interoperate and emulate the CHIP-8 architecture

flips

Rust bindings to Flips, the Floating IPS patcher

gsm

A very simple generic stack machine crate

deca

CHIP-8 interpreter backend

greenwasm-execution

execution section from the Webassembly spec

retronomicon

managing the retronomicon database, including uploading and downloading artifacts

vtx-bin

VTX sound format toolbox

brainpreter

easy to use brainfuck interpreter

evunit

A unit testing program for the Game Boy

zxbasic

Generates BASIC code for the Sinclar ZX Spectrum programmatically

gyms

Gym for Reinforcement Learning

petscii

String library for Commodore PETSCII

angrylion-rdp-plus

Angrylion+ in a Rust form

code-generation-example

lib with code generation example

gpcas_simulator

A simulator of highly configurable CPU models and multiple ISAs

gbas

An assembler for Game Boy

rustration

A toy Brainfuck compiler/interpreter

dgreid/tpm2

rusty-chip8

Chip8 emulator/interpreter

rust-libretro

libretro API abstractions

aluvm

Functional registry-based RISC virtual machine

cranelift-assembler-x64

A Cranelift-specific x64 assembler

retrobasic

A BASIC emulator with easy access to a libary of classic games

rgb-emu

Rust Game Boy emulator

gbsdiff

highlighting the differences in the execution of two GBS files

r8lib

CHIP-8 interpreters development

i8080

An Intel 8080 emulator

lookbusy

You are busy

wlvm

virtual machine with associated language written in Rust

teletext

Interpret Teletext page content

nestools

A set of Rust tools used to help make NES games, mostly used for tile compiling

cannonball

QEMU tracing framework

fast6502

WIP Fast and accurate 6502 emulator

lc3b-assembler

LC-3B assembler

daktilo-tray

brings the typewriter emulator daktilo to the tray

chipmunk-sdl2

CHIP8 Emulator built in Rust

librashader-runtime-wgpu

RetroArch shaders for all

ral1243

RAL 1243 is a fictional computer emulator for z80emu

rustasm6502

A 6502 assembler in macro_rules!

quil-py

Python bindings for quil-rs

tgbr

GameBoy emulator

gpcas_arschitek_zero

Arschitek_zero instruction set architecture (ISA) properties for use with the General Purpose Core Architecture Simulator (GPCAS)

fpgrars

Fast Pretty Good RISC-V Assembly Rendering System

dg6502

A 6502 emulator

ssemu

An emulation/asm command line tool of the Manchester SSEM 'Baby'

euphrates

emulating video game consoles, in particular the Sega Master System, Game Gear, and SG-1000

br4infuck

A brainfuck interpreter

chip_8_cpu_emulator

chip 8 cpu emulator written rust

m68000

A Motorola 68000 interpreter, disassembler and assembler (code emitter)

chip8_vm

Virtual machine for the CHIP-8 programming language

opl3-rs

Rust bindings for Nuked-OPL3, a Yamaha OPL3 FM-synthesis chip emulation library

cpclib-asm

cpclib libraries related to z80 assembling

olympia_engine

Olympia is a gameboy emulator and toolkit, intended to run as a native or web assembly application targeting a cycle count accurate emulation. olympia_engine is the reusable core for both native and wasm.

vjoy

Idiomatic and safe wrapper for vjoy-sys

micromarshal

(De)Serialisation between Rust values and binary byte objects

qapi-spec

QEMU QAPI common types

timi

A visual template instantiation machine interpreter to understand how lazy functional programming languages evaluate

hvctrl

A hypervisor controller library

trenchcoat

JavaScript-ish virtual machine for embedded, LEDs, hot code reload, etc

ruboy_lib

A easy-to-integrate gameboy emulation library

avatar-cli

Magic wrapper to run containerized CLI tools

ristretto_cli

A Java Virtual Machine (JVM) CLI

feo3boy-opcodes

Defines the opcodes for the feo3boy gameboy

bitfields

Macro for generating flexible bitfields. Useful for low-level code (embedded or emulators).

gboxide

A GameBoy Emulator written in Rust

hexxd

Standalone xxd replacement intended for Neovim users

gdbstub

GDB Remote Serial Protocol in Rust

pkmn-core-types

Basic types for Pokémon games

vax-disassembler

DEC VAX one-line disassembler

nes-ppu

A NES graphics emulator with a generic pluggable interface

zinc64-debug

Commodore 64 emulator debugger support

rustsn

This Rust-based tool generates, compiles, and tests code using LLMs, resolves dependencies, and provides explanations of existing code through embeddings

rust-gb

Compile Rust code to Nintendo GameBoy

msdos_time

Converts an MsDosDateTime (FAT time) to a Tm value

py27-marshal

port of https://github.com/python/cpython/blob/master/Python/marshal.c

gc_nes_web

WASM wrapper for my gc_nes_core crate

chip_oxide

Create chip 8 emulators for any backend!

riscy-isa

Encodes and decodes streams of RISC-V instructions

zxnumber

Converter for the floating point number format used by the Sinclair home computers ZX Spectrum and ZX-81

cvt-utils

generate CVT (Coordinated Video Timings) values

atari-env

Atari Environment for Reinforcement Learning

retroboy_common

RetroBoy common codes

msgpass

Thin wrapper to a Message Passing Interface (MPI)

kaiju-compiler-core

Compiler core module of modern assembly language toolset

yamos6502

MOS 6502 emulator

py-marshal

port of https://github.com/python/cpython/blob/master/Python/marshal.c

fsm_gen

FSM (finite state machine) DSL for code generation (c++ at the moment)

rvm

Educational Virtual Machine written in Rust

retroboy

A set of retro emulators written in Rust

rs1541

Rust bindings and helper functions for accessing Commodore disk drives

chirp

CHIP-8 Emulator

chip8

CHIP-8 emulator compatible with a no_std environment

rust-libretro-example-core

libretro example core

save_state

save state mechanism in mizu

koute/mos6502

An NES emulator written in Rust

ssbc

Interpreter written in Rust. See http://csci.viu.ca/~pwalsh/teaching/261/261/261.html

dgreid/tpm2-sys

union-fn

Proc. macro for creating efficient "inline closures".

bitmath

Tools for arbitrary-sized bitwise arithmetic

neso

An NES emulator

tgba

Game Boy Advance emulator

termal-term

Termal is a terminal emulator for x11

baryuxn

Uxn stack machine as a no_std library

super-sabicom

SNES emulator

quil-rs

Rust tooling for Quil (Quantum Instruction Language)

sega-controller

Embedded driver for reading Sega controller input

rustos

Writing an OS in Rust

pkmn-strings

String types for old Pokémon games

daml-codegen

Daml GRPC Ledger API Code Generator

tetanes-core

A NES Emulator written in Rust

lprsemu

Emulator, debugger and assembler for LPRS1 ISA & CPU

chd-capi

libchdr-compatible C API for a Rust implementation of the CHD File Format

chip8-rs

chip8 emulator

osiris-display

A display layer for an Osiris machine

qapi-qmp

QEMU Machine Protocol types

librashader-capi

RetroArch shaders for all

gameboy_opengl

Native Gameboy emulator written in Rust!

lib_stacked

Virtual Machine Byte Code For Compilers

chipo

A chip-8 emulator

zinc64-emu

Commodore 64 emulator toolkit with batteries included but swappable

libafl_bolts

Low-level bolts to create fuzzers and so much more

nes_core

A NES emulator written in Rust

dcpu16-gui

DCPU-16 emulator GUI

qemu-plugin-sys

Low level bindings to the QEMU plugin API

trapezoid-core

A PSX emulator, backed by vulkano for rendering

qemu-aarch64

QEMU binary installer for qemu-aarch64

agb_tracker_interop

interop between tracker plugins and agb itself. Designed for use with the agb library for the Game Boy Advance.

gc_nes_core

NES emulator, built on top of my emulator_6502 crate

toylang

CLI/Wrapper

libafl_qemu

QEMU user backend library for LibAFL

kaiju-compiler-cli

Compiler CLI module of modern assembly language toolset

aluasm

Alu assembler

rustzx-core

ZX Spectrum emulator core library

librashader-runtime-mtl

RetroArch shaders for all

zinc64-sdl

Commodore 64 emulator app

librashader-cache

RetroArch shaders for all

libafl_targets

Common code for target instrumentation that can be used combined with LibAFL

osiris-typed

A type context for a virtual machine

librashader-presets

RetroArch shaders for all

user-mode-riscv

RISCV CPU emulation focusing on user mode instructions only

kaiju-vm-core

Virtual machine core module of modern assembly language toolset

zinc64-loader

Commodore 64 emulator loader support

qemu-alpha

QEMU binary installer for qemu-alpha

retroboy_chip8

RetroBoy Chip-8 emulator

alure

AluVM runtime environment

rust-libretro-sys

libretro API bindings generated via bindgen

sabicom

NES emulator

mizu-core

The core library implementation of all Gameboy emulation for Mizu