Common JDK

A practical map of the JDK, the JRE, the JVM, tooling, APIs, diagnostics, and the historical components around them.

Back to app Open Site Map Open Compatibility

JDK includes JRE JRE includes JVM JDK adds tools + APIs + packaging + diagnostics

Think of the JDK as the complete Java builder-and-runner toolbox.

When people say “install Java,” they often really mean “install a JDK.” The JDK contains the Java language toolchain, the runtime pieces needed to execute Java code, and a wide set of developer utilities for compilation, packaging, documentation, dependency analysis, monitoring, debugging, and distribution.

One-line mental model: source code becomes bytecode via the compiler, bytecode is loaded and executed by the JVM, and the JDK is the full environment that gives you everything needed to build, inspect, run, package, and troubleshoot that journey.

Language .java source, modules, annotations, docs

Toolchain javac, jar, javadoc, jdeps, jlink

Runtime Class loading, verification, JIT, GC, native integration, monitoring

What sits inside the JDK?

Compiler, launcher, bytecode tools, module system, packaging utilities, debugging tools, profilers/recorders, standard APIs, and the runtime itself.

What changed after Java 9?

The public “standalone JRE” story changed. The platform became modular, and custom runtime images created with jlink became a first-class deployment pattern.

What is not always included forever?

Some components moved, evolved, or were removed over time—such as applets, Java Web Start, CORBA-related modules, and JavaFX from the core JDK bundle.

Conceptual map of the JDK

This visual is useful as a mental model: it shows how tooling, APIs, runtime, UI libraries, deployment technologies, and the JVM stack up inside the broader Java platform.

Conceptual diagram of the JDK, JRE, JVM, Java language, tools, APIs, deployment technologies, and supporting libraries

The exact contents vary by Java release and vendor distribution, but the layering remains valuable: the JVM powers execution, the runtime exposes core APIs, and the JDK adds the full developer experience around compilation, packaging, diagnostics, and delivery.

JDK, JRE, and JVM in plain language

JVM

The execution engine. It loads class files, verifies bytecode, links classes, manages memory, performs garbage collection, interprets or JIT-compiles hot code, and interacts with the host OS.

JRE

The runtime environment. Historically this meant the JVM plus the standard libraries and supporting runtime files needed to run Java applications. In modern Java, this idea still exists conceptually, but it is often realized through modular runtime images rather than a separate public JRE bundle.

JDK

The development kit. It includes the runtime capabilities and adds compiler, launcher, documentation tools, bytecode analyzers, packaging utilities, debuggers, monitors, module tools, and more.

How a Java program travels through the JDK

1Write source

You create .java files using language features such as classes, interfaces, records, enums, generics, annotations, lambdas, and modules.

2Compile with javac

The compiler checks syntax and types, resolves symbols, runs annotation processors when configured, and emits JVM bytecode as .class files.

3Package and analyze

You may bundle classes/resources into JARs with jar, inspect dependencies with jdeps, inspect bytecode with javap, and generate docs with javadoc.

4Run with java

The launcher boots the JVM, sets classpath/module-path rules, loads the main class or module, and hands control over to the runtime for execution.

5Observe and troubleshoot

During execution you can monitor memory, threads, GC, and CPU behavior using tools such as jcmd, jconsole, JFR, and JMC.

6Deliver to users

Modern teams may ship a JAR, WAR, container image, or a trimmed runtime image via jlink and desktop packaging via jpackage.

Major families of components inside and around the JDK

Language & compilation

The source-level part of Java that developers directly write and reason about.

javac for compilation
Annotation processing and metadata
Modules, packages, imports, access control
Class file generation with specific format versions

Execution & runtime

The machinery that turns bytecode into running application behavior.

Class loader subsystem
Bytecode verifier and linker
Interpreter + JIT compilation
Garbage collection, threads, memory areas

Standard APIs

Libraries developers rely on before adding third-party frameworks.

java.base, collections, strings, math, regex
I/O, NIO, file system, networking, HTTP client
Concurrency utilities and time APIs
Security, crypto, JDBC, XML, serialization-related APIs

Packaging & delivery

Utilities that help shape a runnable artifact for real environments.

jar for archives
jmod and the module ecosystem
jlink for custom runtime images
jpackage for native installers

Diagnostics & observability

Capabilities that help you understand running systems, not just write them.

jdb, JPDA and debugging hooks
jcmd, jstat, jstack, jmap
Java Flight Recorder (JFR)
JConsole and Java Mission Control (JMC)

Historic and adjacent technologies

Some were bundled, some moved out, and some were retired—but they shaped the platform story.

Applets and Java Plug-in
Java Web Start
AWT, Swing, Java 2D, accessibility tooling
JavaFX, CORBA/RMI-IIOP, deployment-era utilities

Interactive JDK treemap

Pick a Java/JDK release and drill into its major component families. Click a parent tile to zoom in. Click a leaf tile to inspect that component. This is a conceptual architecture treemap, so sizes represent relative emphasis rather than exact binary size.

Educational note: modern JDK distributions vary by vendor and release, and some components have been moved, deprecated, or removed over time. This treemap is designed to make the structure easier to reason about, not to claim byte-for-byte packaging equivalence across all distributions.

Aspect	JVM	JRE	JDK
Primary responsibility	Execute bytecode safely and efficiently.	Provide a runnable Java environment.	Provide a complete build, run, inspect, and package environment.
Contains	Class loading, verification, JIT, GC, memory/runtime engine.	JVM + core libraries + runtime files.	JRE/runtime capabilities + compiler + tools + docs + packaging + diagnostics.
Used by	Every running Java program.	Operators/end users running Java apps.	Developers, build systems, CI/CD pipelines, release engineering.
Key commands	java ultimately boots the JVM.	Historically runtime launchers and supporting files.	javac, jar, javadoc, jdeps, jlink, jpackage.
Modern reality	Still central and always present.	Conceptually important, often represented through modular runtimes instead of a separately marketed package.	The standard installation choice for serious Java development and most modern deployments.

How the JDK evolved over time

Java 1 through Java 8

Monolithic distributions were common. Public JRE installs, browser plug-ins, desktop UI stacks, and enterprise EAR/WAR deployments were all more visible in the mainstream story.

Java 9 modular reset

JPMS introduced strong modular structure. The platform shifted toward smaller, custom runtime images and clearer separation of what belongs in the base platform.

Modern LTS cadence

Java 11, 17, and 21 became practical anchors for enterprise teams. Tooling, container awareness, diagnostics, and cloud deployment patterns became much more central.

Current direction

The JDK increasingly emphasizes observability, productivity, smaller runtimes, strong release cadence, and features such as virtual threads, pattern matching, and safer/native interop work.

What developers usually mean by “Java install” today

Local development

Usually a full JDK from OpenJDK, Temurin, Oracle JDK, or another vendor distribution—paired with Maven or Gradle and an IDE such as IntelliJ IDEA, Eclipse, or VS Code.

CI/CD

A build agent with one or more JDKs installed, test tools, code coverage, static analysis, dependency resolution, and packaging steps that emit deployable artifacts.

Production

Often a smaller runtime footprint: a container image with a vendor JDK/JRE equivalent, or a custom runtime image produced by jlink.

Frequently confused points

Is the JDK only for compiling?

No. It includes compilation, but it also includes launchers, documentation tools, monitoring tools, module tooling, packaging tooling, and runtime capabilities.

Can you run applications with a JDK?

Yes. A JDK can run Java applications because it includes runtime capabilities; it is not “compile-only.”

Does every Java version ship exactly the same components?

No. Components have been added, modularized, deprecated, removed, or moved out over time. That is why historical diagrams are useful but should be interpreted as snapshots, not eternal truths.

Do frameworks like Spring live inside the JDK?

No. Frameworks such as Spring, Hibernate, Netty, Jakarta EE implementations, and testing libraries are ecosystem layers on top of the JDK.

Included local diagram asset: asset/CBNux.png. This page is a JavaOmnibus explainer view intended to make the JDK/JRE/JVM relationship easier to understand in one place.