Seeing an error like java.lang.UnsupportedClassVersionError: Unsupported major.minor version 51.0 or class file version 65.0 after running your program can be confusing. This message means the Java Virtual Machine (JVM) cannot run a class because it was compiled for a newer version of Java than your runtime supports. The problem often surfaces when mixing different JDK and JRE versions or misconfiguring environment variables. In this guide, you’ll learn what the error means, why it occurs, and how to resolve it.

Quick Answer

The UnsupportedClassVersionError is thrown when you try to run a class compiled with a newer JDK on an older JVM. For example, a class compiled with Java 8 (major version 52) will not run on a Java 7 runtime (which only understands class file versions up to 51). To fix it, install a runtime that matches the version used to compile the program, adjust your PATH so the correct Java tools are used, or compile your code for an older target version using javac -target or --release.

Understanding the Error

How Class File Versions Work

Every compiled .class file contains a major version number that indicates the Java platform version it was compiled for. If the JVM encounters a class file whose major version is higher than it supports, it throws UnsupportedClassVersionError. Here’s a mapping of some major versions to Java releases:

Why It Happens

The error typically occurs in these scenarios:

1. Newer compiler, older runtime: You compiled your code with a newer JDK and then ran it using an older JRE. The blog Java Revisited notes that an “Unsupported major.minor version 52.0” appears when running a class compiled with Java 8 on JRE 7 or 6.
2. Incorrect PATH order: If you have multiple Java versions installed, an older JRE may be listed first in your PATH environment variable. Running java from the command line will use the first match, so you may inadvertently execute an older runtime.
3. Using JRE instead of JDK: The Java Runtime Environment (JRE) contains only the java command for running applications. The Java Development Kit (JDK) includes both java and javac for compiling. Mixing JRE and JDK in different versions can lead to mismatches.
4. IDE or build tools: Tools like Eclipse or Maven can compile your classes for a target version that differs from the JRE you run them with.

Fixing Unsupported Class Version Errors

1. Install Matching JDK/JRE Versions

The simplest fix is to install a JDK or JRE that matches the version used to compile your program. If the class was compiled with Java 8, use a Java 8 runtime. According to Java Revisited, upgrading to the latest Java release is the easiest way to resolve the error.

2. Adjust the PATH Environment Variable

If you have multiple versions of Java installed, ensure the latest version comes first in your PATH so the correct java and javac commands are used. The Java Revisited article explains that if a lower version of Java appears before the higher version in PATH, you’ll encounter this error. To fix it:

1. Set JAVA_HOME to the directory of your desired JDK.
2. Update PATH to reference $JAVA_HOME/bin before any other Java paths.

3. Use the JDK’s Cross‑Compilation Options

When compiling, you can target an older Java version so your classes run on that version’s runtime. Use javac with the -target option (and optionally -source or --release) to generate compatible class files. For example, to compile for Java 6:

javac -source 1.6 -target 1.6 HelloWorld.java

The Java Revisited article notes that you can even generate JDK 1.4‑compatible classes using javac -target 1.4. Starting with Java 9, use --release 8 instead of separate -source and -target options.

4. Ensure Your IDE Builds for the Correct Version

Integrated Development Environments (IDEs) may compile using a default compiler level that doesn’t match your runtime. For instance, Eclipse compiles based on the JRE version defined for the project. Change the compiler compliance level or Java version in your IDE’s project settings to match your deployment environment.

5. Understand PATH vs CLASSPATH

Many new developers confuse the purpose of PATH and CLASSPATH. The PATH variable is used by the operating system to locate executables like java, javac and other utility tools. The best practice is to set JAVA_HOME and then include the JDK’s bin directory in your PATH so you can run Java tools from any folder. The CLASSPATH variable tells the JVM where to find .class files and libraries, and is used by the class loader to load application classes. In modern builds, you usually configure classpaths via your IDE or build tool rather than relying on a global environment variable.

6. Use a Consistent Java Installation for Compilation and Runtime

When working across development and production environments, ensure that the same major version of Java is used everywhere. If you must target an older runtime, compile using the corresponding JDK version or cross‑compile as described above.

Summary Table of Solutions

Conclusion

The java.lang.UnsupportedClassVersionError signals a mismatch between the version of Java used to compile a class and the version used to run it. By aligning your JDK and JRE versions, adjusting your PATH to use the correct installation, using the javac -target or --release options to compile for an older platform, and understanding the roles of PATH and CLASSPATH, you can eliminate this error and ensure your Java applications run smoothly.