JUno: Java for Arduino

JUno /ˈxu.no/ is an ahead-of-time compiler for running a practical subset of Java on Arduino boards & M5Stack Cardputer. It keeps javac as the Java frontend, performs closed-world linking on the development machine, and emits Assembly.

Motivation

Traditionally, Java programs require a JVM to run. However, in memory-constrained environments, running Java programs inside a JVM can be difficult. Juno enables developers to create small Java programs for microcontrollers such as Arduino.

Arduino boards supported

Arduino Uno Family

Arduino Uno shields supported

Arduino Nano Family

Arduino Nano shields supported

M5Stack boards supported

Quick start

Requirements: Arduino CLI, JDK 27+, Maven 3.10+.

On macOS, install Arduino CLI with Homebrew and verify that it is on your PATH:

brew update
brew install arduino-cli
arduino-cli version

See Arduino's installation guide for direct downloads and other options.

sdk env install
./mvnw clean install

Blink

Blink runs unmodified on every supported board. Its built-in LED alternates on and off every 500 ms (one full cycle per second).

package io.github.jabrena.juno.api.hardware.gpio;

import io.github.jabrena.juno.hardware.ArduinoUno;
import io.github.jabrena.juno.hardware.gpio.DigitalOutput;
import io.github.jabrena.juno.util.Delay;

public final class Blink {

    public static void main(String[] args) {

        DigitalOutput led = DigitalOutput.of(ArduinoUno.getGpio().getBuiltinLed());

        while (true) {
            led.high();
            Delay.millis(500);

            led.low();
            Delay.millis(500);
        }
    }
}

The project provides a Maven plugin to help the user with the common operations. juno:upload generates the sketch, verifies it with arduino-cli, and flashes it in one step. Blink has no board restriction, so pick a target with -Djuno.board:

./mvnw -f juno-examples/pom.xml compile juno:upload \
  -Djuno.main=io.github.jabrena.juno.api.hardware.gpio.Blink \
  -Djuno.board=arduino-uno-q
# -Djuno.board=arduino-uno-r4-wifi
# -Djuno.board=arduino-uno-r3-wifi-rev2
# -Djuno.board=arduino-uno-r3
# -Djuno.board=arduino-nano-esp32

Select another supported board with -Djuno.board. The plugin auto-detects the port when exactly one matching board is connected; otherwise, specify it with -Djuno.port=<PORT>.

After uploading the program, you could monitor what happen in the board using the following command:

./mvnw -f juno-examples/pom.xml juno:monitor \
  -Djuno.board=arduino-uno-q

Maven plugin

The juno Maven plugin provides these goals. The commands below run them from the examples module; add -Djuno.main=<fully-qualified-class-name> and -Djuno.board=<id> when the entry point has no single-board @Board declaration.

For example, verify the Grove Temperature and Humidity Sensor Pro monitor for a UNO WiFi Rev2 without uploading it:

./mvnw -f juno-examples/pom.xml compile juno:verify \
  -Djuno.main=io.github.jabrena.juno.api.hardware.device.grove.sensors.GroveDht22Monitor \
  -Djuno.board=arduino-uno-r3-wifi-rev2

Supported Java subset

Juno is an ahead-of-time compiler, not a JVM, so it intentionally supports a focused, predictable subset of Java that can be translated into native code for resource-constrained Arduino boards. Programs are first compiled normally with javac; Juno then performs closed-world linking from main, follows every reachable method, and validates the bytecode before generating the sketch.

Valid Java is therefore not automatically valid Juno input. If reachable code needs an unsupported bytecode instruction, JDK feature, or invokedynamic bootstrap, compilation stops instead of emitting code with uncertain behavior. The diagnostic identifies the method, bytecode offset, and unsupported operation or bootstrap. The currently supported Java subset includes:

• Entrypoints and methods: static void main(String[]), the embedded-friendly static void main(), static methods with primitive arguments and results, direct closed-world calls, and removal of unreachable methods. See HelloWorld and Methods.
• Primitive types: boolean, byte, short, char, int, long, float, and double. The example prints each type's size and range using javac-folded BYTES, MIN_VALUE, and MAX_VALUE constants. See PrimitiveTypes.
• Values and control flow: constants, mutable static fields, local variables, arithmetic, bitwise and shift operations, comparisons, conditionals, switch, and loops. See Variables, Operators, and ControlFlow.
• Arrays: fixed-size primitive arrays (boolean through double, including fixed-size multidimensional arrays) allocated from the fixed 8 KiB arena, and static final read-only lookup tables with an all-constant initializer, kept in flash instead of RAM. See .

Maven modules

This is a multi-module Maven build:

• juno-api/ — the programming model: the Java-facing hardware API the compiler recognizes as intrinsics (api/) and the @Board annotations used to select a compilation target (annotations/). This is the only artifact programs compile against.
• juno-compiler/ — the compiler (classfile, bytecode, linker, backend, …), which depends on juno-api. Builds the executable juno-compiler/target/juno-compiler-<version>.jar.
• juno-maven-plugin/ — Maven goals for generating a sketch (juno:compile), compiling it with Arduino CLI (juno:verify), uploading it (juno:upload), and opening the serial monitor (juno:monitor).
• juno-examples/ — example Java programs written against juno-api, built like any other Maven module so they're checked for compile errors on every build.
• juno-site/ — the Roq/Quarkus static site generator behind the documentation site. docs/ is entirely generated from Markdown under juno-site/src/main/resources/content/ — see Documentation site below to regenerate it.
• juno-third-parties/ — integrations maintained outside the core compiler, currently including the independent H8/300 firmware generator for the LEGO RCX, its S-record, and the generated Java representation consumed by .

Architecture

Juno is an ahead-of-time compiler, not a virtual machine. An Arduino board has no JVM, so nothing is interpreted at run time: the Java program is compiled with javac as usual, and Juno then translates the resulting JVM bytecode into native ARM assembly that the Arduino toolchain builds into the sketch's firmware. The compiler is closed-world: it only sees the classes reachable from main, so it can resolve every call at build time, drop everything unused, and reject anything outside the supported subset before generating a single instruction. That is also why there is no dynamic class loading, reflection, or general heap.

From Java to a running board

 Hello.java ──javac──▶ Hello.class ──▶ Juno ──▶ Hello.S + HelloShim.cpp + HelloAsm.ino ──arduino-cli──▶ board
                                       │
                 classfile → bytecode → linker → lowering → optimize → backend

1. Write and compile Java. Programs use the Juno hardware API and optionally select a board with @Board. Maven runs javac; Juno consumes the resulting .class files.
2. Link and validate. Juno starts at main, keeps only reachable code, converts hardware calls into intrinsics, and rejects unsupported bytecode with a precise diagnostic.
3. Lower and optimize. Reachable methods become Juno IR, where compiler passes simplify the program and report risks such as excessive arena use, recursion, or unsafe array access.
4. Generate the sketch. The backend emits native assembly and a small C++ runtime shim. The Maven plugin packages them with a minimal .ino under target/juno/<Main>Asm/.
5. Build and run. Arduino CLI compiles the generated sketch for the selected board. Use juno:verify to compile it, juno:upload to flash it, and juno:monitor to read its serial output.

References

• https://dev.java/
• https://docs.oracle.com/javase/specs/jls/se25/html/index.html
• https://docs.oracle.com/en/java/javase/27/docs/api/index.html
• https://github.com/openjdk/jcstress/tree/master/jcstress-samples
• https://openjdk.org/
• https://openjdk.org/groups/conformance/JckAccess/
• https://github.com/openjdk
• https://docs.arduino.cc/hardware/uno-q/
• https://docs.arduino.cc/hardware/uno-r4-wifi/
• https://docs.arduino.cc/hardware/uno-wifi-rev2/
• https://docs.arduino.cc/hardware/uno-rev3/
• https://docs.arduino.cc/hardware/nano-esp32/
• https://lejos.sourceforge.io/
• https://lejos.sourceforge.io/ev3/docs/index.html
• https://lejos.sourceforge.io/nxt/nxj/api/index.html