What is the difference between JVM, JRE and JDK?

Question

Accepted Answer

These three acronyms describe nested layers of the Java platform. The simplest way to remember: **JDK contains the JRE, which contains the JVM** — each adds capabilities to the one inside it.

## The nesting

```text
┌─────────────────────────── JDK (Development Kit) ───────────────────┐
│  javac (compiler), debugger, javadoc, jar, other dev tools          │
│  ┌─────────────────────── JRE (Runtime Environment) ─────────────┐  │
│  │  Java class libraries (standard API: java.util, java.io, ...)  │  │
│  │  ┌──────────────────── JVM (Virtual Machine) ───────────────┐  │  │
│  │  │  Executes bytecode, JIT compilation, garbage collection   │  │  │
│  │  └───────────────────────────────────────────────────────────┘  │  │
│  └─────────────────────────────────────────────────────────────────┘  │
└────────────────────────────────────────────────────────────────────────┘
```

## JVM — Java Virtual Machine (the runtime engine)

```text
Executes the bytecode. Responsibilities:
  ✓ Loads .class files, verifies bytecode
  ✓ Interprets / JIT-compiles bytecode to native machine code
  ✓ Manages memory & garbage collection
It's the layer that makes "write once, run anywhere" work — platform-specific
JVMs run the SAME bytecode.
```

## JRE — Java Runtime Environment (to RUN apps)

```text
JVM + the standard class libraries (the built-in API your code calls).
What you need to RUN a Java application — but NOT to compile one.
```

## JDK — Java Development Kit (to BUILD apps)

```text
JRE + development tools:
  javac   — the compiler (.java → .class bytecode)
  jdb     — debugger
  javadoc — documentation generator
  jar     — packaging tool
What a DEVELOPER needs to write, compile, and build Java programs.
```

## Which do you need?

```text
Writing/compiling Java code  → JDK (it includes everything)
Only running a Java app      → JRE was historically enough
  (modern Java often bundles the runtime; JRE is less separately distributed now)
```

## Why it matters

Understanding the JVM/JRE/JDK distinction clarifies the Java platform's architecture and answers practical questions: developers install the **JDK** (to compile and build), the **JVM** is what actually executes bytecode and enables platform independence + garbage collection, and the **JRE** historically provided just the runtime to execute apps.

This layered model explains how Java code goes from source to running program, why WORA works (the JVM layer), and what to install for a given task — foundational knowledge for setting up and reasoning about any Java environment.