explaingit

hatsugai/mc68000-x-2-virtual-memory-system

Analysis updated 2026-05-18

13Audience · researcherComplexity · 5/5Setup · hard

TLDR

A hardware project that builds a working virtual memory system from scratch using two classic MC68000 processors and discrete memory chips.

Mindmap

mindmap
  root((VirtualMemory68000))
    What it does
      Virtual memory hardware
      Two processor design
      Page fault handling
    Tech stack
      MC68000
      GAL chip
    Use cases
      Study MMU design
      Learn page swapping
      Retro hardware reference
    Audience
      Researchers
      Hardware hobbyists

Code map

Detail Auto

An interactive map of this repo's files and how they connect — its source is parsed live in your browser. Click Visualize to build it.

filefunction / class

What do people build with it?

USE CASE 1

Study how virtual memory and page swapping work at the hardware level

USE CASE 2

See a real implementation of a memory management unit built without a dedicated MMU chip

USE CASE 3

Learn how two processors can cooperate to handle page faults

USE CASE 4

Reference the design when building retro or educational computer hardware

What is it built with?

MC68000GAL 22V10

How does it compare?

hatsugai/mc68000-x-2-virtual-memory-system09catho/axon0x1-1/revival
Stars131313
LanguageJavaScriptC++
Setup difficultyhardmoderatehard
Complexity5/54/55/5
Audienceresearcherresearcherdeveloper

Figures from each repo's GitHub metadata at analysis time.

How do you get it running?

Difficulty · hard Time to first run · 1day+

Requires assembling physical hardware with two MC68000 chips and supporting logic.

In plain English

This is a hardware experiment that implements a virtual memory system, a technique that lets a computer pretend to have more memory than it physically does, using two MC68000 chips, a classic processor from the late 1970s. The project documents how the author built this from scratch as a personal exploration, and the README is written in Japanese. The two processors are called MPU[0] and MPU[1]. MPU[1] handles normal program execution, while MPU[0] acts as a dedicated helper for managing page swaps. A "page" here means a small fixed-size chunk of memory (4 kilobytes in this design). The virtual memory space covers 8 megabytes of logical address space. The memory management unit, or MMU, is constructed from two static RAM chips rather than a dedicated chip. The first, called TransRAM, translates logical page numbers (the addresses the program thinks it is using) into physical page numbers (where the data actually lives in real memory). The second, called AccessRAM, keeps track of which pages have been read from or written to, including a "dirty bit" that records whether a page has been modified. When the program tries to access a page that has not been loaded into physical memory yet, a page fault signal is generated, MPU[0] takes over the bus, performs the page swap, then hands control back to MPU[1]. A state machine implemented with a single GAL 22V10 chip manages the handoff between the two processors. The board also carries Flash memory for booting and a UART chip for serial communication.

Copy-paste prompts

Prompt 1
Explain how TransRAM and AccessRAM work together in this virtual memory design
Prompt 2
Walk me through what happens when MPU[1] triggers a page fault in this system
Prompt 3
Summarize how the GAL 22V10 state machine coordinates the two processors
Prompt 4
Help me translate this Japanese hardware README into a build guide

Frequently asked questions

What is mc68000-x-2-virtual-memory-system?

A hardware project that builds a working virtual memory system from scratch using two classic MC68000 processors and discrete memory chips.

How hard is mc68000-x-2-virtual-memory-system to set up?

Setup difficulty is rated hard, with roughly 1day+ to a first successful run.

Who is mc68000-x-2-virtual-memory-system for?

Mainly researcher.

Open on GitHub → Explain another repo

This repo across BitVibe Labs

Verify against the repo before relying on details.