Jace is a mature cycle-accurate emulation of an Apple //e computer. The full library of software for that series is 100% compatible with this emulator, as well as many popular hardware add-ons such as:

Joysticks (emulated by mouse or using real gamepads)
Mouse
Extended 80 Column card or Ramworks (Apple memory expansion compatible)
Ramfactor
Floppy drives (up to 14 supported)
Hard drives (up to 12 supported) and 800kb disk images
Mockingboard/Applied engineering Phasor (up to 6 supported)
Passport MIDI Interface
Super Serial Card (over TCP/IP emulation)
Transwarp / Zip Chip
Thunderclock / NoSlot Clock
Apple RGB graphics modes

Other features of Jace include:

Small IDE for programming Applesoft basic and Assembly (via built-in ACME cross assembler)
Built-in terminal with fully integrated monitor and debugger (Apple II-like syntax)
Cheat features for some popular games like Prince of Persia, Montezuma's Revenge, Wolfenstein and more
Metacheat feature allows searching memory for discovering new game cheats/mods

Download:

See releases page for most recent

To Run:

The easiest way to run Jace is by downloading a native build from gitub (see releases link above)

Running the standard java version of Jace requires you have installed Java 17 or later.

If you are building from source you can use any of the following:
- mvn javafx:run
- mvn gluonfx:run (Note: gluonfx plugin currently only supports up to Maven 3.8.8)

To Build natively:

In order to build Jace as a native application you need to install the following:

Gluon's fork of GraalVM: https://github.com/gluonhq/graal/releases
Compiler (XCode for Mac, GCC for Linux, Visual Studio for Windows)
Maven 3.8.8 (not a newer version, unfortunately)

The Gluon instructions have more details about where to find and download these components. Once you have them installed you can test the Java version via mvn gluonfx:run and if that is working correctly, then you can use mvn gluonfx:build to create a native binary in the target/gluonfx folder for your local platform. Gluon is only able to build for the OS you are running it on, so building for multiple platforms requires separate windows, mac and linux machines.

The Gluon documentation provides a compatibility matrix for each OS platform and the prerequisites needed to create native applications on each. See here for more details: https://docs.gluonhq.com/#_platforms

All other native dependencies are automatically downloaded as needed by Maven for the various LWJGL libraries.

First time build note:

Because Jace provides an annotation processor for compilation, there is a chicken-and-egg problem when building the first time. Currently, this means the first time you compile, run mvn install twice. You don't have to do this step again as long as Maven is able to find a previously build version of Jace to provide this annotation processor. I tried to set up the profiles in the pom.xml so that it disables the annotation processor the first time you compile to avoid any issues. If running in a CICD environment, keep in mind you will likely always need to run the "mvn install" step twice, but only if your goal is to build the entire application including the annotations (should not be needed for just running unit tests.)

Development

Running Tests

Jace uses JUnit for testing. You can run tests using Maven:

# Run all tests
mvn test

# Run a specific test class
mvn test -Dtest=ClassName

# Run a specific test method
mvn test -Dtest=ClassName#methodName

Test Logging

The test output is configured to be concise by default, showing only essential information. Two system properties can be used to control verbosity:

jace.test.debug - Enables debug output for terminal-related tests

mvn test -Dtest=jace.terminal.MainModeTest -Djace.test.debug=true

jace.test.verbose - Enables verbose output for CPU and video initialization
```
mvn test -Djace.test.verbose=true
```

These properties allow you to see detailed information about the test environment setup, mock initialization, and test execution when needed, while keeping the default output clean.

Code Coverage

JaCoCo is used for code coverage analysis. You can generate coverage reports with:

mvn jacoco:report

The coverage reports will be available in target/site/jacoco/index.html after running the above command.

Support JACE:

JACE will always be free, and remain Apache-licensed, but it does take considerable time to refine and add new features. If you would like to show your support and encourage the author to keep maintaining this emulator, why not throw him some change to buy him a drink? (The emulator was named for the Jack and Cokes consumed during its inception.) Also, should you want to use Jace under the terms of the Apache-license for commercial works, you are under no obligation to contribute any source code modifications or royalties to me, but I would appreciate you credit and mention my project and let me know about it.

Donate here to support Jace developement:

More information here: https://sites.google.com/site/brendanrobert/projects/java-apple-computer-emulator