JVic: A Web-Based Commodore VIC 20 Emulator Built with libGDX

The Commodore VIC 20, released in 1980, was the first computer to sell one million units. Its 5KB of RAM and distinctive color palette made it a defining machine of the early home computer era. Now, a project called JVic brings this hardware to the browser, not through traditional JavaScript emulation, but via libGDX—a Java-based game development framework that typically powers desktop and mobile games.

JVic represents an interesting intersection of retro computing preservation and modern web technology. Instead of writing a VIC 20 emulator in JavaScript, the developer ported libGDX to the browser using Google's WebAssembly (WASM) toolchain. This approach allows the emulator to run in any modern browser while maintaining the performance characteristics of a native application.

The Technology Stack

libGDX is a cross-platform game development framework that abstracts away platform-specific details. It provides a unified API for rendering, input, and audio across desktop, Android, iOS, and web platforms. The framework's architecture makes it particularly suitable for emulator development because it handles low-level graphics and input operations efficiently.

The VIC 20's hardware specifications present unique challenges for emulation:

• 6502 CPU: Running at 1.02 MHz
• 5KB RAM (expandable to 32KB)
• 2KB ROM containing the BASIC interpreter
• Color palette: 16 colors with specific limitations
• Sound: 3-voice sound chip (SID variant)
• Display: 22x23 character grid with custom character sets

JVic emulates these components at the cycle level, ensuring accurate timing for games and demos that rely on precise hardware behavior. The emulator includes a complete 6502 processor emulation, VIC-I chip emulation for graphics, and a simplified SID chip for audio.

WebAssembly Performance

The decision to use libGDX with WebAssembly rather than JavaScript is significant. JavaScript emulation of 8-bit systems has matured significantly, with projects like JSMESS and Emularity providing comprehensive solutions. However, these JavaScript-based emulators often struggle with performance on complex systems or when running multiple emulators simultaneously.

WebAssembly offers near-native performance by compiling C/C++ or Rust code to a binary format that runs in the browser. libGDX's WASM backend allows Java code to be compiled to this format, giving JVic performance advantages over pure JavaScript implementations. The emulator can maintain consistent frame rates even when running demanding VIC 20 games or demos that push the hardware's limits.

Implementation Details

JVic's architecture follows a modular design:

1. CPU Core: A cycle-accurate 6502 implementation that handles all undocumented opcodes and illegal instructions commonly used in VIC 20 software.

2. VIC-I Chip: Emulates the VIC Interface chip responsible for graphics. The VIC 20's graphics are character-based with limited color options per character cell. JVic correctly implements the chip's memory mapping and color limitations.

3. Memory Management: The VIC 20's memory map is complex, with ROM, RAM, and I/O regions overlapping in specific ways. JVic implements the complete memory map, including the 1KB color RAM that exists separately from main memory.

4. Input Handling: Keyboard input is mapped to the VIC 20's matrix keyboard system. The emulator supports both physical keyboard mapping and virtual on-screen keyboards for touch devices.

5. Audio: A simplified SID chip implementation provides basic sound capabilities. While not cycle-accurate like some desktop emulators, it captures the essence of VIC 20 audio for most software.

Practical Applications

JVic serves several purposes beyond nostalgia:

Educational Tool: Students learning about computer architecture can interact with a real 8-bit system without installing software. The browser-based nature makes it accessible in classroom settings.

Software Preservation: Many VIC 20 games and demos exist only on physical media. JVic provides a platform for running this software in its original environment.

Development Platform: The emulator includes a BASIC interpreter, allowing users to write and test VIC 20 programs directly in the browser.

Limitations and Trade-offs

The WebAssembly approach has trade-offs:

Startup Time: WASM modules can be larger than equivalent JavaScript, leading to longer initial load times.

Memory Usage: The emulator maintains a complete state of the VIC 20's memory and hardware components, which can consume significant browser memory when running multiple instances.

Browser Compatibility: While WebAssembly is widely supported, older browsers or restricted environments may not run JVic.

Accuracy vs. Performance: JVic prioritizes playability over absolute cycle accuracy. Some timing-sensitive demos or copy-protected software may not run correctly.

Broader Context

JVic joins a growing ecosystem of web-based emulators. Projects like PCE.js (PC Engine) and MESS.js demonstrate that browser emulation is viable for complex systems. However, JVic's use of libGDX represents a different architectural approach that may influence future emulator development.

The project also highlights how game development frameworks can serve purposes beyond their original design. libGDX's abstraction layers and cross-platform capabilities make it surprisingly well-suited for emulation tasks that require consistent behavior across different execution environments.

Getting Started

JVic is available as an open-source project on GitHub. To run it locally:

1. Clone the repository: git clone https://github.com/retro-projects/jvic
2. Build the project using Gradle: ./gradlew html:dist
3. Serve the generated html/build/dist directory with any web server

The project includes several sample VIC 20 programs and a BASIC interpreter for creating new software.

Future Development

Potential areas for improvement include:

• Enhanced SID chip emulation for more accurate audio
• Support for VIC 20 cartridges and disk images
• Save state functionality
• Network multiplayer for games that support it
• Integration with online software archives

JVic demonstrates that modern web technology can effectively preserve and present computing history. By leveraging libGDX's cross-platform capabilities and WebAssembly's performance, it offers a compelling alternative to traditional desktop emulators while maintaining the authentic VIC 20 experience.