Lib.rs

firecracker-microvm/jailer

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

agb

Game Boy Advance Development

virt

Rust bindings to the libvirt C library

tetanes

A cross-platform NES Emulator written in Rust using wgpu

librashader-cache

RetroArch shaders for all

qemu

QEMU binary installer

swf

Read and write the Adobe Flash SWF file format

trapezoid

A PSX emulator, backed by vulkano for rendering

yane

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

iz80

Z80 and 8080 emulator

gameboy

emulator written in Rust and WebAssembly

netsblox-vm

running NetsBlox code with optional native extensions

risc-y

RISC-V Emulator

enjoy

Play any game rom with associated emulator in RetroArch

libscemu

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

armv4t_emu

An emulator for the ARMv4t instruction set

kvm-ioctls

Safe wrappers over KVM ioctls

muvm

Run programs from your system in a microVM

rtlola-interpreter

An interpreter for RTLola specifications

haybale

Symbolic execution of LLVM IR, written in Rust

rust_multistackvm

Stack-based virtual machine on top of rust_multistack crate

librashader-presets

RetroArch shaders for all

binfmt-dispatcher

Smart dispatcher for binfmt_misc

vm-superio

Emulation for legacy devices

peppi

Parser for Slippi replay files

firecracker-microvm/vmm

Secure and fast microVMs for serverless computing

cargo-generate-type

Cargo subcommand to generate Rust code from and for input data

microvmi

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

teletype

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

yamos6502

MOS 6502 emulator

libslirp

High-level bindings & helper process for libslirp

chd

File Format

monistode-emulator-cli

A CLI for the Monistode emulator

resid-rs

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

z80emu

ZiLOG Z80 microprocessor emulation library

rustzx-z80

Z80 CPU emulator library

w65c816

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

jchip8-rs

emulator for the Chip8 platform

r6502

MOS 6502 emulator

xum1541

Rust driver to access Commodore disk drives using xum1541 USB device

qapi

QEMU QMP and Guest Agent API

agb-gbafix

CLI utility to convert ELF file to valid GBA ROM

hecate-vm

The main package for the hecate vm

osiris-set-std

A standard operation set

boytacean-hashing

Hashing library for Boytacen

ruboy

A gameboy emulator for desktop, based on ruboy_lib

lookbusy

You are busy

mizu

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

gabbro

A Game Boy emulator written in Rust

brainhug

brainf*ck translator

emulator_6502

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

spcfile

.spc file format reading and writing

safeboy

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

simls

cli tool that allows for managing of android emulators & iOS simulators

qook

Pure Rust unitaryfund/qrack Wrapper

scriptful

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

visa-device-handler

handle NI-VISA connections and simplify its use

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…

hecate-turtle

A turtle implementation based on hecate vm

runes

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

kaze

An HDL embedded in Rust

vines

NES emulator library

trust-80

TRS-80 Emulator

maurice

Thomson MO5 emulator

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…

plastic

A NES emulator with GUI and TUI

rvemu

RISC-V emulator core implementation

nes6502

An emulated NES version of the 6502

qip

efficient quantum computing simulations

gameboyr

A Gameboy emulator written in Rust

libafl_qemu

QEMU user backend library for LibAFL

baby-emulator

An emulation library of the Manchester SSEM 'Baby'

android-launcher

Android launcher for windows only (maybe), it launch your android without additional terminal/shell session

gpcas_forwardcom

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

libretro-proxy

Write libretro cores that act as a proxy to other cores

krata-xencall

direct interfacing to Xen privcmd for krata

sbrain

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

monistode-emulator

An emulator for the monistode set of ISA's

swamp-vm-disasm

disassembler for the opcodes in the swamp vm

bfc

An industrial-grade brainfuck compiler

rvsim

A RISC-V simulator implementing RV32G[C]

librashader-pack

RetroArch shaders for all

c8

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

z80

z80 emulator

ashpaper-plus

Rust Inpterpreter for Esopo language AshPaper conceived by William Hicks

rrs-lib

building RISC-V instruction set simulators

lwk_ledger

Liquid Wallet Kit - Interact with Ledger Hardware Wallet

libxen

Safe bindings for Xen libraries

lc3b-assembler

LC-3B assembler

chip-ahoyto

A CHIP-8 emulator in Rust

cpclib

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

spectrusty

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

pica

virtual UWB Controller implementing the FiRa UCI specification

phakebit

A 6502 CPU emulator

kvmi

Safe Rust bindings for libkvmi (v6)

virt-ic

virtual integrated circuits - an backend IC emulator

osiris-data

A data management package

libmwemu

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

rysk-core

RISCV instruction decoding and execution

zilog_z80

Zilog Z80 Emulator

gameboy_core

core library to be used for Gameboy emulation

brubeck

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

dcpu16

DCPU-16 assembler, disassembler and emulator

lemurs-8080

An emulator for the Intel 8080 microprocessor

rust-gb

Compile Rust code to Nintendo GameBoy

chip_8

CHIP-8 virtual machine / emulator

cpclib-z80emu

cpclib libraries related to snapshots

termin-8

CHIP-8 emulator that runs in your terminal

manzana-uno-emu

Apple I emulator

nescore

NES emulator

beam_bvm_interface

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

riscy-isa

Encodes and decodes streams of RISC-V instructions

modVM

A framework for easily creating modular VMs

cranefack-cli

Commandline utility for the cranefack brainfuck compiler

pir-8-emu

pir-8 ISA

kaiju-core

Core module of modern assembly language toolset

tudelft-nes-ppu

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

intel8080

Intel 8080 Emulator

runestick

Runescript, a generic stack-based virtual machine for Rust

mohanson/gameboy

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

gekkio/mooneye-gb

A Game Boy research project and emulator written in Rust

rust-libretro

libretro API abstractions

udbserver

Provide Unicorn emulator with a debug server

tinychip

CHIP-8 emulator/interpreter

gameboy-rom

Gameboy ROM parser

lr35902

Gameboy emulator written in Rust and WebAssembly

vtx

VTX sound format parsing and playback library

libafl_qemu_sys

C to Rust bindings for the LibAFL QEMU bridge

bevm

Emulator of Basic EVM for itmo students

kondrak/rust64

Commodore 64 emulator written in Rust

rrs-succinct

building RISC-V instruction set simulators

hecate-packer

The packer for the hecate vm

ch8asm

Open-source Chip-8 assembler

aluvm

Functional registry-based RISC virtual machine

simias/rustation

A PlayStation emulator

meru

Multi game console Emulator written in Rust

aphelion-util

types and traits for Aphelion instruction set architecture

psg

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

smmdb

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

rustzx-utils

Additional helpers for rustzx-core based emulators

nanowasm

A small, stand-alone WebAssembly interpreter

esrtool

Port of the PS2 Homebrew ESRtool to Rust and modern platforms

melon

creating retro computing platforms

ruboy_binutils

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

ttxcat

Show Teletext pages in the console

librashader-preprocess

RetroArch shaders for all

rgy

No-std Rust GameBoy emulator library

zinc64

Commodore 64 emulator app

emu6809

In development 6809 emulator

flips

Rust bindings to Flips, the Floating IPS patcher

zeerust

A Z80 CPU Emulator

retrom-plugin-installer

Retrom plugin that facilitates the installation of games locally

tis-100

An emulator for the TIS-100

intel-8080-emu

A small library to emulate an intel 8080

gpcas_arschitek_zero

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

rust8

A Chip-8 Emulator Library in Rust

mupen64plus

High-level Rust bindings to the Mupen64Plus Core API

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.

ruxn

Uxn stack-machine written in Rust

osiris-process

A processor implementation

rusty-boy-advance

A Gameboy Advance Emulator (WIP)

rudelctl

Commandline utility for rudelblinken

imperative-rs

Auto derivable trait to easily define instruction sets

gbr

Game Boy emulator in Rust

chip8_db

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

mem_storage

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

rusty_6502

6502 emulator

qapi-spec

QEMU QAPI common types

emu-runner

Command builder and executor for various emulators

rust-simple-stack-processor

stack processor emulator written in Rust

qemu-plugin

High level bindings to the QEMU plugin API

corewars

The classic programming battle game Core Wars

dolphin-memory

that makes reading and writing memory of the Dolphin emulator easier

toyvm

The toylang CLI/Wrapper

feo3boy

Emulator core for the gameboy

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.

femtos

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

strawberryvm

A fantasy virtual machine with limits on resources

chip8_core

A CHIP-8 emulator core library

heliometer

A basic Brainfuck interpreter

svmap

parse SVMap, used to map memory for emulators

plastic_tui

A NES emulator with terminal interface (TUI)

rustyboy

Gameboy emulator

intcodeint

An intcode interpreter for Advent of Code 2019

mindjuice

brainfuck interpreter

rs6502

A 6502 Microprocessor tool suite. Includes a Disassembler, Assembler and Emulator.

lib_stacked

Virtual Machine Byte Code For Compilers

emul8

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

yaxpeax-sm83

sm83 decoder for the yaxpeax project

falcon-mos6502

Instruction decoding for MOS 6502

automachina

Lobana Abstract Computers

schip8

Interpreter backend for Chip-8 and Super-Chip

brainpreter

easy to use brainfuck interpreter

gsm

A very simple generic stack machine crate

deca

CHIP-8 interpreter backend

retronomicon

managing the retronomicon database, including uploading and downloading artifacts

greenwasm-execution

execution section from the Webassembly spec

cpclib-asm

cpclib libraries related to z80 assembling

petscii

String library for Commodore PETSCII

ral1243

RAL 1243 is a fictional computer emulator for z80emu

gyms

Gym for Reinforcement Learning

zxbasic

Generates BASIC code for the Sinclar ZX Spectrum programmatically

cannonball

QEMU tracing framework

teletext

Interpret Teletext page content

vmtest

run your tests in virtual machines

olympia

gameboy emulator and toolkit, intended to run as a native or web assembly application targeting a cycle count accurate emulation

gbas

An assembler for Game Boy

rust-libretro-example-core

libretro example core

squid

A RISC-V emulator with AOT compilation for fuzzing

quil-py

Python bindings for quil-rs

rustration

A toy Brainfuck compiler/interpreter

dgreid/tpm2

gameboy_opengl

Native Gameboy emulator written in Rust!

cranelift-assembler-x64

A Cranelift-specific x64 assembler

retrobasic

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

angrylion-rdp-plus

Angrylion+ in a Rust form

gbsdiff

highlighting the differences in the execution of two GBS files

rgb-emu

Rust Game Boy emulator

i8080

An Intel 8080 emulator

ssemu

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

rustasm6502

A 6502 assembler in macro_rules!

dg6502

A 6502 emulator

gboxide

A GameBoy Emulator written in Rust

librashader-reflect

RetroArch shaders for all

qapi-qmp

QEMU Machine Protocol types

br4infuck

A brainfuck interpreter

daktilo-tray

brings the typewriter emulator daktilo to the tray

gpcas_simulator

A simulator of highly configurable CPU models and multiple ISAs

rusty-chip8

Chip8 emulator/interpreter

rutie

The tie between Ruby and Rust

tetanes-core

A NES Emulator written in Rust

rvm

Educational Virtual Machine written in Rust

m68000

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

tgbr

GameBoy emulator

wlvm

virtual machine with associated language written in Rust

emulot

A configuration management solution for QEMU

r8lib

CHIP-8 interpreters development

nes-ppu

A NES graphics emulator with a generic pluggable interface

ad-astra

Embeddable scripting language platform Ad Astra. Main Crate.

gdbstub

GDB Remote Serial Protocol in Rust

chipmunk-sdl2

CHIP8 Emulator built in Rust

kaiju-compiler-core

Compiler core module of modern assembly language toolset

ristretto_vm

Java Virtual Machine

ramp64-srm-convert-lib

build RetroArch Mupen64 SRM Converter

chip8_vm

Virtual machine for the CHIP-8 programming language

dgreid/tpm2-sys

pros-simulator

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

vjoy

Idiomatic and safe wrapper for vjoy-sys

opl3-rs

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

ruboy_lib

A easy-to-integrate gameboy emulation library

gc_nes_web

WASM wrapper for my gc_nes_core crate

timi

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

avatar-cli

Magic wrapper to run containerized CLI tools

fast6502

WIP Fast and accurate 6502 emulator

rust-sitter-tool

The external tool for Rust Sitter that extracts grammars from Rust definitions

boytacean

A Game Boy emulator that is written in Rust

trenchcoat

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

hecate-bf

A brainfck to hasm compiler for the hecate vm

vax-disassembler

DEC VAX one-line disassembler

py27-marshal

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

hexxd

Standalone xxd replacement intended for Neovim users

micromarshal

(De)Serialisation between Rust values and binary byte objects

libafl_sugar

Sugar builders to create common fuzzers with LibAFL

euphrates

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

bitfields

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

neso

An NES emulator

hvctrl

A hypervisor controller library

py-marshal

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

union-fn

Proc. macro for creating efficient "inline closures".

zxnumber

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

zk-aluvm

AluVM extensions for zero knowledge, STARKs and SNARKs

chip8

CHIP-8 emulator compatible with a no_std environment

lprsemu

Emulator, debugger and assembler for LPRS1 ISA & CPU

atari-env

Atari Environment for Reinforcement Learning

oi_helper

A useful tool for C++ competive programming

quil-rs

Rust tooling for Quil (Quantum Instruction Language)

fsm_gen

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

chip_8_cpu_emulator

chip 8 cpu emulator written rust

zinc64-debug

Commodore 64 emulator debugger support

ssbc

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

avr-vm

VM with JIT-compiler for ATMega32

bitmath

Tools for arbitrary-sized bitwise arithmetic

cvt-utils

generate CVT (Coordinated Video Timings) values

baryuxn

Uxn stack machine as a no_std library

sega-controller

Embedded driver for reading Sega controller input

librashader

RetroArch shaders for all

feo3boy-opcodes

Defines the opcodes for the feo3boy gameboy

termal-term

Termal is a terminal emulator for x11

daml-codegen

Daml GRPC Ledger API Code Generator

rs1541

Rust bindings and helper functions for accessing Commodore disk drives

swamp-vm-instr-build

builds opcodes for the swamp vm

waves_rs

A cross-platform, high-performance Rust implementation for various electromagnetic solvers

tgba

Game Boy Advance emulator

tudelft-nes-test

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

retroboy

A set of retro emulators written in Rust

save_state

save state mechanism in mizu

chip_oxide

Create chip 8 emulators for any backend!

rustos

Writing an OS in Rust

alure

AluVM runtime environment

chip8-rs

chip8 emulator

libafl_bolts

Low-level bolts to create fuzzers and so much more

chirp

CHIP-8 Emulator

zinc64-emu

Commodore 64 emulator toolkit with batteries included but swappable

osiris-display

A display layer for an Osiris machine

kaiju-compiler-cli

Compiler CLI module of modern assembly language toolset

qemu-plugin-sys

Low level bindings to the QEMU plugin API

nestools

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

trapezoid-core

A PSX emulator, backed by vulkano for rendering

librashader-runtime

RetroArch shaders for all

toylang

CLI/Wrapper

qemu-aarch64

QEMU binary installer for qemu-aarch64

rustzx-core

ZX Spectrum emulator core library

retroboy_chip8

RetroBoy Chip-8 emulator

rust-libretro-sys

libretro API bindings generated via bindgen

chd-capi

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

meru-interface

Core interface for MERU multi emulator

gc_nes_core

NES emulator, built on top of my emulator_6502 crate

libafl_qemu_build

Builder for LibAFL QEMU

chipo

A chip-8 emulator

user-mode-riscv

RISCV CPU emulation focusing on user mode instructions only

libafl_cc

Commodity library to wrap compilers and link LibAFL

super-sabicom

SNES emulator

osiris-typed

A type context for a virtual machine

kaiju-vm-core

Virtual machine core module of modern assembly language toolset

zinc64-loader

Commodore 64 emulator loader support

aluasm

Alu assembler

qemu-alpha

QEMU binary installer for qemu-alpha

qapi-parser

QEMU QAPI JSON specification parser

librashader-runtime-vk

RetroArch shaders for all

qemu-arm

QEMU binary installer for qemu-arm

plastic_core

An accurate NES emulator. The backend emulation for plastic and plastic-tui

mizu-core

The core library implementation of all Gameboy emulation for Mizu

libafl_frida

Frida backend library for LibAFL

sabicom

NES emulator

shiratsu-naming

Zero-copy file name parser for No-Intro, TOSEC, and GoodTools named ROM files

librashader-runtime-wgpu

RetroArch shaders for all

libafl_targets

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

qemu-system-microblazeel

QEMU binary installer for qemu-system-microblazeel

kaiju-vm-cli

Virtual machine CLI (Keijo) module of modern assembly language toolset

librashader-common

RetroArch shaders for all

qemu-system-loongarch64

QEMU binary installer for qemu-system-loongarch64

libafl

Slot your own fuzzers together and extend their features using Rust

librashader-runtime-mtl

RetroArch shaders for all

qemu-system-xtensaeb

QEMU binary installer for qemu-system-xtensaeb

qemu-system-microblaze

QEMU binary installer for qemu-system-microblaze

librashader-capi

RetroArch shaders for all

symcc_libafl

Meta package for symcc_runtime

librashader-runtime-d3d11

RetroArch shaders for all

librashader-runtime-d3d12

RetroArch shaders for all

qemu-system-mips64el

QEMU binary installer for qemu-system-mips64el