Basically, Java source code is compiled by the Java compiler  into the binary format specified in the JVM specification .
This binary code is linked by a tool named SOAR before execution:
.class files and some other application-related files (see Classpath chapter) are linked to produce the final binary file that the Core Engine will execute.
|||The JDT compiler from the Eclipse IDE.|
|||Tim Lindholm & Frank Yellin, The Java™ Virtual Machine Specification, Second Edition, 1999|
This section describes the core libraries which make up the runtime. Theses Foundation Libraries are tightly coupled with the Core Engine.
Embedded Device Configuration (EDC)¶
The Embedded Device Configuration specification defines the minimal standard runtime environment for embedded devices. It defines all default API packages:
Beyond Profile (BON)¶
This profile defines a suitable and flexible way to fully control both memory usage and start-up sequences on devices with limited memory resources. It does so within the boundaries of Java semantics. More precisely, it allows:
- Controlling the initialization sequence in a deterministic way.
- Defining persistent, immutable, read-only objects (that may be placed into non-volatile memory areas), and which do not require copies to be made in RAM to be manipulated.
- Defining immortal, read-write objects that are always alive.
- Defining and accessing compile-time constants.
Simple Native Interface (SNI)¶
SNI provides a simple mechanism for implementing native Java methods in the C language.
SNI allows you to:
- Call a C function from a Java method.
- Access an Immortal array in a C function (see the Beyond Profile (BON) to learn about immortal objects).
SNI does not allow you to:
- Access or create a Java object in a C function (except byte arrays).
- Access Java static variables in a C function.
- Call Java methods from a C function.
SNI also provides some Java APIs to manipulate some data arrays between Java and the native (C) world.
Please refer to Simple Native Interface (SNI) section for more details.
The Core Engine features a Green Threads model. The semantic is as follows:
- preemptive for different priorities,
- round-robin for same priorities,
- “priority inheritance protocol” when priority inversion occurs. 
Threads stacks automatically adapt their sizes according to the thread requirements: once a thread terminates, its associated stack is reclaimed, freeing the corresponding RAM memory.
|||This protocol raises the priority of a thread that is holding a monitor needed by a higher-priority thread, to the priority of that higher-priority thread (until exiting the monitor).|
The Core Engine includes a state-of-the-art memory management system, the Garbage Collector (GC). It manages a bounded piece of RAM memory, devoted to the Java world. The GC automatically frees dead Java objects, and defragments the memory in order to optimize RAM usage. This is done transparently while the Application keep running.