Crate libnoentiendo

source ·
Expand description

noentiendo

codecov github actions GitHub last commit demo status docs status powered by rust made with love

A modular framework for emulating retro computers.

noentiendo is a framework for retro emulation. It focuses in implementing small building blocks like the 6502, 6520, and 6560 chips, then stitches them together to emulate a variety of systems. It runs in text-mode, as a desktop GUI application, or on the web with WebAssembly.

Supported SystemsRoadmap
Commodore PETCommodore 64
Commodore VIC-20Apple IIe
Nintendo NES
Supported PlatformsRoadmap
Desktop (Linux, macOS, Windows)Android (Native)
Web (via WebAssembly)iOS (Native)
Embedded (e.g., RP2040)

Core Contributors

License

This program is free software, licensed under the AGPLv3 license. In short, this means that:

  • You may use this software for free, for personal or commercial use
  • You may make modifications to this software, but these changes must retain the AGPLv3 license
  • You may distribute this software or your modified version, but you must provide the source code to users
  • You may allow users to interact with this software over a network connection, but you must provide the source code to users

For full details, consult LICENSE.txt.

Note that some files in this repo, such as provided ROMs, are licensed under their own terms.

Modules

  • cpu
    A cpu::Cpu represents a processor and associated memory. Specific implementations include the cpu::mos6502::Mos6502, which represents the MOS 6502 or its variants (e.g. 65C02).
  • keyboard
    Various representations of keyboard scancodes are required in different parts of the codebase. Each platform typically has its own definition of a scancode (e.g. JavaScript’s event.code or Winit’s VirtualKeyCode), and each emulated system has a different set of keys (e.g. the Commodore key on the VIC-20 or the standalone " key on the PET).
  • memory
    A memory::Memory implementation can be read from and written to, but it can also be polled for interrupts. This is used for the PIA, VIA, and other chips that interface over memory but also trigger interrupts. The memory module provides implementations for various types of memory and other memory-mapped devices. Mappings are handled using memory::BranchMemory.
  • platform
    A platform::Platform consumes a system and runs it. Platforms provide access to the video output, keyboard input, system random number generator, and other details via a platform::PlatformProvider. Some platforms run synchronously (taking over the thread) while others run asynchronously with the help of an event loop (such as when compiling to WASM). Platforms are defined in the platform module. Currently, available platforms include TextPlatform for simple headless text-based operation, WinitPlatform for a graphical window on a desktop environment, and CanvasPlatform for drawing to a <canvas> element on the web. In the future, platforms for mobile apps are planned, in addition to a platform for running on a microcontroller (e.g. the RP2040).
  • roms
    ROM file loading and unloading is different on different platforms: desktop platforms typically load ROMs from a file, while WebAssembly platforms need to load ROMs from a Uint8Array. ROM file definition and loading is handled in the roms module, with specific roms::DiskLoadable and roms::JsValueLoadable traits for these two cases. Loaded ROMs are represented with a roms::RomFile object, which can be passed to memory::BlockMemory::from_file.
  • systems
    A system is created with some roms, configuration, and platform. System instantiation is handled with the systems::BuildableSystem trait, which is generic over these parameters. For instance, the build implementation on systems::pet::PetSystem takes in systems::pet::PetSystemRoms, systems::pet::PetSystemConfig, and an Arc<dyn PlatformProvider>.
  • trace
    Tools to trace the log the state of the system as it runs (e.g., to a file). This is useful for debugging.