Merry Virtual Machine

#c #programming #virtualmachine #merry

Overview

Merry is an attempt at reimagining computation exploration- a result of 2 years of architectural refinement. It is a powerful virtual machine designed to support multiple computation models, custom memory systems, and privilege-based control — all inside a unified, extensible architecture.

What is Merry?

Merry VM is an experimental, multi-model virtual machine — built from scratch to explore how computation can be simulated across diverse architectures.

Unlike traditional VMs that stick to one paradigm (e.g., stack-based or register-based), Merry allows multiple computation models to co-exist and collaborate within a single runtime.

Each model is represented as a virtual core (vcore), and every vcore can:

Run its own instruction set
Access its own or shared memory
Follow strict or relaxed privilege rules

Merry is not "yet another toy VM". It is an ongoing attempt to rethink what VMs can be — for learning, experimenting, and exploring systems programming in a deeply customizable way.

Core Concepts (Implemented or Planned)

Feature	Description
✅ Multi-architecture Support	Stack-based, Register-based, Hybrid — all via separate vcores
✅ Unified File Format	Modular format that adapts to new core types
⚙️ Multi-State Execution	Simulates context switching between different execution states
⚙️ MRS (Multi-RAM System)	Supports Public, Private, and Shared RAM blocks
⚙️ Privilege Model	Fine-grained access control per vcore
⚙️ Wild Request Handling	Interrupt-like system for async core signaling
🚧 Subsystems	User-defined architectures running alongside the core VM

Status

❗ This project is in early preview.

Testing is limited. Windows support is untested. No standard tooling or GUI yet.

This project at its current stage is for those interested in:

Low-level VM design
Systems simulation
Watching a weird and powerful idea evolve

Preview Build

Check out the latest preview release here.

Please take the warning seriously.

Current feature

Versatile and flexible architecture
Multi core support
64-bit GPC(General Purpose Core) support
BEB(Broadly Emitted Binary) v1.0 input file format
Switchable Multi State(SMS) implemented that mimics context switching in real life Operating systems.
Privilege system for extra protection.
Paged memory system
Separated memory for data and instructions for every core type.
Core-Graves Interface(CGI) ready for other core types.
Wild handlers and wild requests support that mimics interrupt handling in real life systems.
Core-core behavior updation via Graves requests.
Overseer of the System- Graves.
Read On Demand(ROD) for fast binary loading.
System level abstraction to hide low level complexity
Multi core type support.

Features being worked on/Features in mind

Switchable Multi RAM(SMRAM) support
Multi RAM type support
Efficient memory usage
Efficient error handling
Remember to Execute Me(REM) stack support for lazy Manager request execution.
Debugger Support.
Multiple core types to be introduced
Subsystem support
Basic system level operation support.
Multi processing support

Many more still to come.....

Discussions & Feedback

Want to ask questions or offer feedback?

Check out the GitHub Discussions page — I’d love to hear your thoughts or ideas.

Support This Project

I'm a full-time student in Nepal working on Merry alone, during nights and weekends. If you believe in the vision of accessible, open, and deep systems experimentation — your support keeps this alive.

Platform	Link
❤️ Patreon	Aryan Chauhan

Even a small tip or share means a lot. Thank you!

Give It a Star

If you found this project interesting, helpful, or just plain weird — leave a ⭐ on the repo to show support!

Top comments (5)

Nathan Tarbert • Jul 10 '25

this is extremely impressive, especially coming from a solo dev while still juggling school nights. you think more students should really try building things this ambitious or is it just a certain kind of obsession