JDK vs JRE vs JVM: What Each One Does

The JVM (Java Virtual Machine) runs compiled Java code, called bytecode; the JRE (Java Runtime Environment) is the JVM plus Java's standard class library, which is everything you need to run a program; and the JDK (Java Development Kit) is a runtime plus the tools for building programs, such as the compiler javac. Each one contains the one before it. This page follows one small program through all three, shows what bytecode looks like, explains where the JRE went after Java 11, and tells you which one to install.

From Hello.java to a running program#

Here is a complete Java program. Press Run and it prints one line.

There is no JVM in this page. The Run button uses an interpreter written for this site, which follows Java's rules and runs in your browser, so you can try code before installing anything. On your own computer the same program takes two commands, one for the JDK's compiler and one that starts the JVM:

1. 1javac Hello.java runs the compiler, a JDK tool. It checks the code and writes Hello.class, a file of bytecode: instructions for the JVM rather than for your processor.
2. 2java Hello starts a JVM, which loads Hello.class and the library classes it uses, such as System, and runs the bytecode. The command takes the class name, with no .class on the end.

Since Java 11 (JEP 330), the java command also accepts the source file itself. It compiles the code in memory, runs it, and leaves no .class file behind:

Key idea

The JDK's compiler turns your source code into bytecode once. A JVM, which every Java runtime contains, runs that bytecode each time the program starts.

What bytecode looks like#

A .class file is binary, but the JDK's javap tool prints its bytecode as text. Take a class with one small method:

That is the output of javap; the spacing differs slightly between JDK versions. Read the add method from the top. The JVM works with a stack of values: iload_0 pushes the first argument, a, onto it, iload_1 pushes b, iadd takes both off and pushes their sum, and ireturn hands the sum back. The block above it is the constructor Add(), which javac writes for any class that does not declare one. Nothing in the listing mentions an operating system or a processor.

Why the same .class file runs on Windows, macOS and Linux#

Bytecode is written for the JVM, which the Java Virtual Machine Specification defines as an abstract computing machine: a computer described by rules. Each real JVM is a program built for one operating system and processor, so a JDK for Windows on an Intel chip contains a different JVM from a JDK for a Mac with Apple silicon. All of them run the same bytecode. You compile Hello.java once, and Hello.classruns on any computer with a recent enough Java runtime. Java's old slogan for this is “write once, run anywhere”.

The specification also says that the JVM knows nothing of the Java language, only of the class file format. That is why Kotlin, Scala and Groovy, which compile to class files too, run on the same JVMs.

What is inside the JVM#

A JVM has three main parts, which is what people mean by JVM architecture:

• The class loader finds the .class files a program needs, loads them into memory and checks that the bytecode is valid before any of it runs.
• The runtime data areas are the memory a running program uses: the heap, where objects live; one stack per thread, with a frame for each method call that holds its local variables; and the method area, which holds the code of each class.
• The execution engine runs the bytecode. Its interpreter carries out one instruction at a time, and its garbage collector frees the memory of objects the program no longer uses.

The execution engine also has a JIT compiler(JIT stands for just in time). A JVM starts by interpreting bytecode, and while the program runs it finds the methods that run most often and compiles them into your processor's machine code, so the busiest parts of a program stop being interpreted over and over.

Is the JRE part of the JDK?#

Yes: a JDK contains everything a JRE has, the same JVM and the same standard library, with the development tools added. Up to Java 8 you could see this on disk, because the JDK kept a complete JRE in a folder named jre. Java 9 changed the layout (JEP 220): a JDK is now one runtime with extra tools in its bin folder, and it has no jre folder. That bin folder holds about 30 tools; the ones you meet first are java, javac, jshell, jar and javadoc.

The same nesting answers “does the JRE have a JVM?”. Yes: every Java runtime contains a JVM, because the JVM is the part that runs the program. The library on its own cannot run anything.

Key idea

A JDK is a Java runtime plus tools, and every runtime has a JVM inside. Install a JDK and you have all three.

What happened to the JRE?#

Until Java 11, Oracle offered a JRE download for people who only ran Java programs, next to the JDK for developers. For Java 11 and every version since, Oracle offers only the JDK, and its notes for that release point to jlink instead: a JDK tool, added in Java 9 (JEP 282), that builds a runtime holding only the modules a program needs. This one is made for the Hello program:

java.base is the module with Java's core classes, which is all Hello uses. The result has a JVM, that one module and the java command (keytool, a tool for security certificates, belongs to the same module), but no javac: a JRE in all but name, cut to fit one program. A program can ship with a runtime like this, so the people using it never install Java at all. Packaging and shipping a Java app builds one for a real program and turns it into an installer with jpackage.

Some vendors still publish a ready-made JRE for each version. Eclipse Temurin, for one, offers JRE downloads of Java 25 next to its JDK downloads.

Which one do you need?#

• To learn Java or write programs, install a JDK, because only a JDK has javac. Any build of Java 25 is fine, and your first Java program walks through installing one.
• To run a program someone gives you, use whatever runtime it comes with. If it is a plain .jar file, you need a Java runtime of the version it was built for or later. A JRE is enough, and a JDK works just as well.
• To play Minecraft: Java Edition, you need neither. The game includes its own Java: the notes for version 26.1 say it requires Java 25 and ships the Microsoft Build of OpenJDK 25.
• To host a Minecraft server, you install Java yourself, because the server is a .jar file you start with the javacommand. Minecraft's server page asks for a compatible JRE, and a JDK of the same version works too.

How to check whether you have a JDK#

Run two commands in a terminal. java -version answers when any Java runtime is installed, and javac -versionanswers only when you have a JDK. With Eclipse Temurin's first Java 25 release they print:

The three lines from java -version name the layers: the version, the runtime environment, and the JVM itself, here the 64-Bit Server VM.

OpenJDK, Oracle JDK and other builds#

OpenJDK is the open-source project where Java itself is written, led by Oracle together with other companies and volunteers. A JDK you download is a build of its code:

• Oracle JDK, Oracle's own build under Oracle's license. Oracle also publishes plain OpenJDK builds under the GPL at jdk.java.net.
• Eclipse Temurin, from the Adoptium project, free, with JDK and JRE downloads.
• Amazon Corretto, Amazon's free build.
• The Microsoft Build of OpenJDK, the one Minecraft ships.

All of them start from the same OpenJDK source code, so they run your programs the same way. They differ in who builds them, how long each version gets updates, and the license terms. For learning, any of them at version 25 does the job.