All Classes and Interfaces
Class
Description
The instruction set an
ArduinoCore runs generated code on, which picks the code generator: the UNO R4's
Cortex-M4 and the UNO Q's Cortex-M33 share one Thumb-2 backend, the UNO WiFi Rev2's ATmega4809 has its own AVR one.A type token for an Arduino board
@Board can select as a compilation target.The Arduino core a
Board is built with.Selects the Arduino UNO Q as
@Board's target: Juno programs run on its STM32U585
microcontroller (Cortex-M33) under Arduino's Zephyr core.Selects the Arduino UNO R4 WiFi as
@Board's target; has the onboard 12x8 LED matrix.Selects the Arduino UNO WiFi Rev2 as
@Board's target: Juno programs run on its ATmega4809, an 8-bit
megaAVR (6 KB SRAM, 48 KB flash), under Arduino's arduino:megaavr core, with Wi-Fi through the u-blox
NINA-W102 module and the WiFiNINA library.One local array a method declares via
IrInstruction.NewArray, hoisted to the top of the function.The element type of a Juno-supported array.
The deliberately small
java.util.concurrent.atomic subset lowered by Juno: AtomicInteger,
AtomicBoolean and AtomicLong, each an arena cell the cooperative scheduler can never interrupt
halfway through an operation.Emits GNU AVR assembly (avrxmega3, the UNO WiFi Rev2's ATmega4809) straight from Juno IR — the 8-bit counterpart of
Thumb2AsmBackend, with the same storage model: every IR value and JVM local lives in a fixed stack slot
(see FrameLayout.packed(IrMethod)) and registers are only scratch within one instruction, so a method can never run
out of registers.The generated assembly, its runtime shim, and the entry point's symbol.
A maximal run of instructions with one entry point (
start) and one exit (terminator).Common baud rates exposed as named values by Juno's USB serial API.
The
java.math subset: BigInteger, BigDecimal and MathContext.Closed-world plumbing for the
java.math subset: BigInteger, BigDecimal and
MathContext are one-word handles to immutable arena blocks, and RoundingMode is its ordinal.A
static final field Juno materializes itself: a constructed value or a plain ordinal.A binary arithmetic or bitwise operation, with Java
int (32-bit two's complement) semantics.Joins a block that ends in a
Jump with its target when it is that target's only way in, so straight-line
code (an inlined body and its continuation, say) is one block with no branch between the halves.Declares which Arduino board(s) a Juno program targets, e.g.
A Juno compilation target, resolved from the entry-point class's
@Board annotation (see
io.github.jabrena.juno.annotations.Board).Which board the program was compiled for, recognized as a compiler intrinsic by Juno.
One entry in a class file's
BootstrapMethods attribute.Removes a
IrInstruction.BoundsCheck whose index is proved to lie in [0, length).Decodes the intentionally small JVM bytecode subset supported by Juno v0.1.
Lowers each reachable method's JVM bytecode into Juno IR: a non-SSA, block-structured form where every
operand-stack push/pop becomes an explicit
Value produced or consumed by an IrInstruction.An optional on-board feature a Juno program can depend on.
Loads class files from directories, individual class files, and JARs.
Monotonic clock operations recognized as compiler intrinsics by Juno.
Deterministic structural measurements of one Juno compilation.
What the compiler found while producing a
CompilationResult.What to compile: a closed-world classpath plus the entry point's fully qualified class name.
Generated Cortex-M4 assembly, its C++ runtime shim, entry symbol, and compilation report.
A user-facing error produced while linking or compiling Java bytecode.
One IR-to-IR transformation in the optimization pipeline, run between lowering and the backend.
The comparison an
IrInstruction.Compare evaluates between its two operands.Compares the
RuntimeConfig with what the program needs and suggests a better one.A change to the runtime configuration that would suit the program better.
Renders
ConfigSuggestions as human-readable lines, shared by the CLI and the Maven plugin.Folds
Binary/Unary/Compare instructions into Const when their operands are known
constants, and folds a Branch into a Jump when its condition is a known constant.Read-only lookup tables kept in flash (
.rodata) instead of the 8 KiB arena: a static final
one-dimensional primitive array whose <clinit> initializer is all compile-time constants
(static final short[] T = {1, 2, 3};) and which every reachable method only ever reads as
T[i] or T.length.A
static final constant-initialized array that has to stay in the arena, and why.One flash-resident table: element values as raw bits, sign-extended for the integer types.
The basic blocks of one method, in offset order, with branch targets resolved into block-to-block edges.
The control-flow graph of one
IrMethod, shared by the data-flow passes: every block's successors and
predecessors (by block start), a reverse postorder from the entry block, and the dominator tree.Partitions a method's decoded instructions into
BasicBlocks and resolves every branch target into
a CFG edge, replacing byte-offset jumps with an explicit block graph.Eliminates a
IrInstruction.LoadLocal when preceding stores determine the slot's value.Removes basic blocks unreachable from a method's entry block.
Removes stores to JVM/synthetic local slots that no later load can read.
Removes instructions that only compute a value nothing reads: constants, local loads, integer arithmetic other
than division and remainder (which can panic on zero), comparisons and conversions.
Timing operations recognized as compiler intrinsics by Juno.
A zero-cost GPIO handle.
One
Code attribute exception-table entry: instructions in [startPc, endPc) that throw
a catchType (or any throwable when catchType is null, as finally uses)
continue at handlerPc.Arithmetic operations with Java
float semantics.GPIO operations recognized as compiler intrinsics by Juno.
A minimal HTTP/1.1 client recognized as compiler intrinsics by Juno, backed by the Arduino
WiFiS3 library's WiFiClient.Named HTTP methods for matching against
HttpServer.method().A minimal HTTPS client recognized as compiler intrinsics by Juno, backed by Arduino's
WiFiSSLClient and its firmware CA bundle on UNO R4 WiFi, or Linux TLS through
Arduino_RouterBridge on UNO Q.A minimal, non-blocking HTTP/1.1 server recognized as compiler intrinsics by Juno, backed by
the Arduino
WiFiS3 library's WiFiServer on UNO R4 WiFi and by
BridgeTCPServer (a listener in arduino-router on Linux) on UNO Q.Named HTTP status codes for
HttpServer.respond(int, String, String)'s status parameter, which stays
a plain int — these are ordinary compile-time-constant int fields, not a new
intrinsic or type, exactly like Gpio.OUTPUT.Register access to an I2C peripheral on the board's primary I2C bus (
Wire, the SDA/SCL
pins), recognized as compiler intrinsics by Juno and backed by the core-bundled Wire
library.Serial bytes over modulated infrared light, recognized as compiler intrinsics by Juno and
bit-banged on two plain pins, with no Arduino library.
Replaces a
IrInstruction.Call to a small leaf method with the method's own blocks, so getters, setters,
constructors and small math helpers cost no call, no prologue and no argument shuffling.A bytecode
invokeinterface site, uniquely identified within its caller.Closed-world concrete targets of one reachable
invokeinterface instruction.The receiver type and either its concrete method body or its compiler-generated lambda adapter.
One object type-id branch and its concrete method in a closed-world interface dispatch.
Every hardware operation Juno understands, independent of its Java method signature or Arduino lowering.
A resolved CONSTANT_InvokeDynamic call-site name/type plus its bootstrap-table index.
A block of lowered IR instructions ending in a single
IrTerminator.One value-producing or state-mutating operation lowered from JVM bytecode.
Panics if
index is outside [0, length); emitted only when length is known.A call to a reachable user-defined static method.
The address of a read-only
static final lookup table placed in flash (see ConstantTables).JVM
dcmpl/dcmpg; nanResult is respectively -1 or 1.JVM
fcmpl/fcmpg; nanResult is respectively -1 or 1.A compiler-created immutable int/reference array, used for enum values and switch maps.
A polymorphic interface call;
arguments starts with the receiver.A call to a hardware operation;
receiver is present only for instance-style intrinsics.Invokes a resolved lambda adapter;
arguments starts with the lambda reference.Materializes a lambda function reference, allocating only when captured values need storage.
lcmp: produces a regular int in {-1, 0, 1}, which then flows through ordinary int branch opcodes.A 64-bit
long value, materialized as two 32-bit halves (targetLow/targetHigh)
since every JVM local/stack slot and every backend int32_t is 32-bit.shiftAmount is a plain (32-bit) int, per JVM lshl/lshr/lushr semantics.l2i: truncates to the low 32 bits, which is exactly valueLow by construction.Declares a fixed-size local array;
target becomes a handle to it.A fixed-size multidimensional primitive array allocated recursively from the arena.
Runtime null guard used by javac for bound method references.
Packs Juno's two stack/local halves into a native 64-bit call/field/array boundary value.
A UTF-8 string literal materialized as a null-terminated runtime string reference.
Splits a native 64-bit boundary value back into Juno's two stack/local halves.
throwableClasses lists every exception class the program allocates; a class's index is the
id stored in each of its objects' headers (see ThrowableTypes).Rebuilds IR nodes with their values, local slots and block targets mapped: every value an instruction defines or
reads goes through
values, every local slot through locals, and every jump target through
blocks.Where control flow goes after the last instruction of an
IrBasicBlock.Extracts every value referenced or produced by an IR node.
superClassName is the internal name of the direct superclass, or null only for
java/lang/Object itself (constant-pool index 0, per the class file spec).A bounded, non-allocating JSON field reader recognized as compiler intrinsics by Juno.
The scalar runtime types a Juno IR
Value can carry.Identity of one
invokedynamic lambda factory in a reachable method.Fully resolved
LambdaMetafactory.metafactory call site.Driver for the common "LCD Keypad Shield" (a 16x2 HD44780-compatible character LCD in 4-bit
mode, plus 5 buttons wired through a single resistor ladder into one analog pin), wired for its
standard pinout as used by e.g.
A pixel buffer for the board's built-in LED matrix (12x8 on the UNO R4 WiFi, 13x8 on the UNO Q), plus
the shape and text drawing operations that paint into it.
The board's built-in LED matrix operations, recognized as compiler intrinsics by Juno: 12x8 on the UNO R4
WiFi and 13x8 on the UNO Q.
A classic 5x7 dot-matrix font for digits and uppercase letters, sized to fit the UNO R4 WiFi's
12x8 LED matrix (two glyphs fit side by side: 5 + 1 gap + 5 = 11 of the 12 columns).
A 5x7 dot-matrix font covering the full printable ASCII range (32 space .. 126
~), for
printing arbitrary ASCII characters on the UNO R4 WiFi's 12x8 LED matrix one at a time (two
glyphs fit side by side: 5 + 1 gap + 5 = 11 of the 12 columns), and for the TFT shield's text.A compact 3x5 dot-matrix font for digits 0-9, offered as a smaller alternative to the 5x7
LedMatrixFont (which it does not replace).Performs closed-world reachability and resolves every static call before code generation.
The concrete, deliberately small
ReentrantLock subset lowered by Juno.Read-only introspection into Juno's arena allocator, recognized as a compiler intrinsic.
A resolved CONSTANT_MethodHandle whose target is a method or constructor.
USB HID mouse control recognized as compiler intrinsics by Juno, backed by the Arduino
Mouse library.The Bosch BNO055 orientation sensor of the Arduino 9 Axis Motion Shield, read over I2C as plain
Java on top of
I2c (so it needs no Arduino library).An 8-bit parallel output bus, as display shields wire it: eight data pins written together, latched by a write
strobe pulsed low then high.
A minimal POP3S client recognized as a compiler intrinsic by Juno, backed by the same
board-specific implicit-TLS transport as
HttpsClient.A LEGO Powered Up hub (City Hub 88009, Technic Hub 88012, BOOST Move Hub 88006, DUPLO Train
Hub, ...) controlled over Bluetooth Low Energy, recognized as compiler intrinsics by Juno and
backed by the Arduino
ArduinoBLE library (arduino-cli lib install ArduinoBLE).A LEGO Power Functions infrared remote (8885), which drives the motors, lights and servos plugged
into an IR Receiver (8884) set to one of its four channels.
classes is every class loaded from the classpath (not just reachable methods' owners) — needed so
that lowering can resolve a getstatic on an enum constant field to its ordinal, since the field's
owner class may differ from the reachable method's own owner and is otherwise never visited (its
<clinit>/<init>/values()/etc. are deliberately never added to methods).Pseudorandom-number operations backed by Arduino's random generator.
The read-only
java.io.RandomAccessFile subset, backed by the SD card's open-file table: a file opened
with mode "r" by a compile-time literal path, then seek/getFilePointer/length,
single-byte and buffer reads, skipBytes and close.Direct commands to an RCX brick that answer back, over the same infrared link as
RcxRemote (set it up with RcxRemote.begin(int, int) first, with both the IR LED and the IR
receiver module wired).The LEGO Mindstorms RCX infrared protocol, recognized as compiler intrinsics by Juno: receives
the button state of an RCX Remote Control (9709) and transmits the same remote-control and
message commands to an RCX brick.
A cheap, purely structural check (name + zero-arg descriptor against a record's component list) used by
the linker's reachability scan to avoid rejecting a record accessor call as "not a Juno intrinsic" before
it ever reaches lowering.
Severity of a runtime-risk diagnostic emitted after IR optimization.
The capacities of the generated runtime: how much RAM the arena and the task stacks take.
Runtime constants shared by analysis and the current UNO R4 backend.
One stable, machine-readable runtime-risk finding.
Conservative resource and runtime-risk analysis over the optimized closed-world IR.
Resource estimates and runtime-risk findings for one closed-world compilation.
Renders a
RuntimeRiskReport as human-readable lines, shared by the CLI and the Maven plugin.Removes an allocation whose object never escapes the method, keeping its fields in local slots instead of the
arena: no
juno_alloc, no garbage for the collector, and field accesses that copy propagation and constant
folding can see through.Closed-world plumbing for the
java.lang.ScopedValue subset (JDK 25, final API).Remote control of a LEGO Scout brick (Robotics Discovery Set) over infrared, plain Java on top of
Infrared: see there for the wiring of the IR receiver module and the IR LED.Access to an SPI SD card, backed by the Arduino
SdFat library with long-file-name support
enabled.USB serial output recognized as compiler intrinsics by Juno.
A zero-cost servo motor handle for a standard 3-wire hobby servo (signal, power, ground),
backed by the Arduino
Servo library.A minimal SMTP client recognized as a compiler intrinsic by Juno.
Authoritative target-backend stack sizing shared with static runtime-risk analysis.
Validates and decodes the bounded subset of javac's string-concatenation bootstrap protocol.
A validated
StringConcatFactory.makeConcatWithConstants call site.One literal fragment or dynamic argument in the bootstrap recipe.
Closed-world plumbing for Juno's JDK 27 preview
StructuredTaskScope subset.Small JDK bytecode idioms Juno lowers without linking their JDK implementations.
Where control flow goes after the last instruction of a
BasicBlock.A conditional branch: control goes to
trueTarget or falls through to falseTarget.Falls into the next block without an explicit branch instruction.
Unconditional
goto.A supported JVM return opcode, or the implicit return past the last instruction of a method.
athrow: control continues at one of handlers — the distinct handler offsets whose
exception-table ranges cover the throw, in matching order — or leaves the method when none catches it.Driver for the ELEGOO 2.8" TFT touch screen shield ("Pantalla Táctil TFT de 2,8 pulgadas"): a
240x320 ILI9341 display on an 8-bit parallel bus, a 4-wire resistive touch panel, and a microSD
socket, wired for the shield's standard UNO pinout as used by ELEGOO's
Elegoo_TFTLCD and
TouchScreen libraries.The closed-world plumbing behind
java.lang.Thread: a started thread runs its Runnable on a
stack of its own, entered from the runtime shim, so the linker registers one synthetic
Runnable.run() call site that resolves against every reachable Runnable (classes and lambdas)
and the lowering turns it into the generated thread entry function.The closed-world exception hierarchy: a fixed set of built-in JDK throwables (which Juno models
itself, since their class files are never on the classpath) plus any program class whose superclass
chain reaches one of them.
Emits GNU ARM Thumb-2 assembly straight from Juno IR, restricted to instructions common to the UNO R4's
Cortex-M4 and the UNO Q's Cortex-M33, so one code generator serves every board; per-core runtime
differences live in
CoreRuntime.runtimeShim is a small extern "C" C++ source that must be compiled alongside
assembly in the same sketch — see this class's doc.Allocation-free UDP transport recognized as compiler intrinsics by Juno.
A single-operand operation: arithmetic negation or a narrowing conversion.
A typed symbolic virtual register: one value, produced by exactly one
IrInstruction.Enables the RA4M1's hardware watchdog timer on
@Watchdog's entry-point class.WiFi connection control recognized as compiler intrinsics by Juno, backed by the Arduino
board networking stack (
WiFiS3 on UNO R4 WiFi, Arduino_RouterBridge on UNO Q).Wi-Fi provisioning without baking credentials into the firmware, written in plain Java on top of
Wifi and HttpServer (it adds no intrinsics, and costs nothing in a program that
does not call it).