Home / Java / How to Fix Java JAR File Not Executable Error

Java

How to Fix Java JAR File Not Executable Error

Resolve JAR file not executable errors with proper MANIFEST.MF configuration and build tool setup.

Published: Nov 23, 20258 min readBy FixWikiHub Editorial Team

Abstract illustration for Java troubleshooting guides.

# How to Fix Java JAR File Not Executable Error

You created a JAR file, but when you try to run it, you get one of these errors:

bash

no main manifest attribute, in myapp.jar

Or:

bash

Error: Could not find or load main class com.myapp.Main

Or:

bash

Exception in thread "main" java.lang.NoClassDefFoundError: com/myapp/dependency/Logger
    at com.myapp.Main.main(Main.java:10)
Caused by: java.lang.ClassNotFoundException: com.myapp.dependency.Logger

These errors occur when the JAR lacks proper manifest configuration or is missing dependencies.

Introduction

This article covers troubleshooting steps and solutions for How to Fix Java JAR File Not Executable Error. The error typically occurs in production environments and can cause service disruptions if not addressed promptly.

Symptoms

Common error messages include:

bash

no main manifest attribute, in myapp.jar

bash

Error: Could not find or load main class com.myapp.Main

bash

Exception in thread "main" java.lang.NoClassDefFoundError: com/myapp/dependency/Logger
    at com.myapp.Main.main(Main.java:10)
Caused by: java.lang.ClassNotFoundException: com.myapp.dependency.Logger

Common Causes

Configuration misconfiguration
Missing or incorrect credentials
Network connectivity issues
Version compatibility problems
Resource exhaustion or limits
Permission or access denied

Understanding JAR Execution

1.For a JAR to be executable with java -jar myapp.jar, it needs:
2.A MANIFEST.MF file in META-INF/
3.A Main-Class attribute pointing to your main class
4.All dependencies either bundled or on the classpath

Step-by-Step Fix

Step 1: Check for Main-Class Attribute

```bash # Extract and view manifest jar tf myapp.jar | grep MANIFEST # Output: META-INF/MANIFEST.MF

# View manifest contents unzip -p myapp.jar META-INF/MANIFEST.MF

# Or extract and view jar xf myapp.jar META-INF/MANIFEST.MF cat META-INF/MANIFEST.MF ```

A valid manifest for executable JAR should look like:

bash

Manifest-Version: 1.0
Main-Class: com.myapp.Main

Step 2: Verify Main Class Exists in JAR

```bash # List all classes in JAR jar tf myapp.jar | grep Main

# Check if class file exists jar tf myapp.jar | grep "com/myapp/Main.class" ```

Step 3: Check for Dependencies

```bash # See if JAR contains dependencies jar tf myapp.jar | head -50

# If you see only your classes, dependencies are missing # If you see other package structures, dependencies may be bundled ```

Step 4: Test Class Execution

```bash # Try running main class directly (not as JAR) java -cp myapp.jar:dependency1.jar:dependency2.jar com.myapp.Main

# If this works, your manifest or dependencies are the issue ```

Step-by-Step Fix

Solution 1: Create Manifest Manually

Create a manifest file:

```bash # Create manifest file cat > MANIFEST.MF << 'EOF' Manifest-Version: 1.0 Main-Class: com.myapp.Main

EOF # Note: manifest must end with a blank line ```

Create JAR with manifest:

```bash # Compile your code javac -d out src/com/myapp/Main.java

# Create JAR with manifest jar cfm myapp.jar MANIFEST.MF -C out . ```

Solution 2: Create Executable JAR with jar Command

```bash # Compile with output directory javac -d build/classes src/com/myapp/*.java

# Create JAR with Main-Class jar cfe myapp.jar com.myapp.Main -C build/classes .

# Run java -jar myapp.jar ```

The -e flag specifies the Main-Class directly.

Solution 3: Configure Maven for Executable JAR

Using maven-jar-plugin:

xml

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>3.3.0</version>
            <configuration>
                <archive>
                    <manifest>
                        <mainClass>com.myapp.Main</mainClass>
                        <addClasspath>true</addClasspath>
                        <classpathPrefix>lib/</classpathPrefix>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-dependency-plugin</artifactId>
            <version>3.6.1</version>
            <executions>
                <execution>
                    <id>copy-dependencies</id>
                    <phase>package</phase>
                    <goals>
                        <goal>copy-dependencies</goal>
                    </goals>
                    <configuration>
                        <outputDirectory>${project.build.directory}/lib</outputDirectory>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

This creates a JAR with manifest pointing to a lib/ folder of dependencies.

Using maven-shade-plugin (Fat JAR):

xml

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-shade-plugin</artifactId>
            <version>3.5.1</version>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>shade</goal>
                    </goals>
                    <configuration>
                        <transformers>
                            <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                <mainClass>com.myapp.Main</mainClass>
                            </transformer>
                        </transformers>
                        <filters>
                            <filter>
                                <artifact>*:*</artifact>
                                <excludes>
                                    <exclude>META-INF/*.SF</exclude>
                                    <exclude>META-INF/*.DSA</exclude>
                                    <exclude>META-INF/*.RSA</exclude>
                                </excludes>
                            </filter>
                        </filters>
                    </configuration>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Build and run:

bash

mvn clean package
java -jar target/myapp-1.0.0.jar

Using maven-assembly-plugin:

xml

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-assembly-plugin</artifactId>
            <version>3.6.0</version>
            <configuration>
                <archive>
                    <manifest>
                        <mainClass>com.myapp.Main</mainClass>
                    </manifest>
                </archive>
                <descriptorRefs>
                    <descriptorRef>jar-with-dependencies</descriptorRef>
                </descriptorRefs>
            </configuration>
            <executions>
                <execution>
                    <phase>package</phase>
                    <goals>
                        <goal>single</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Solution 4: Configure Gradle for Executable JAR

Using application plugin:

```groovy plugins { id 'application' }

application { mainClass = 'com.myapp.Main' }

// Run with: ./gradlew run // Create distribution: ./gradlew installDist ```

Using shadow plugin (Fat JAR):

```groovy plugins { id 'java' id 'com.github.johnrengelman.shadow' version '8.1.1' }

group = 'com.myapp' version = '1.0.0'

repositories { mavenCentral() }

dependencies { implementation 'org.slf4j:slf4j-api:2.0.9' implementation 'ch.qos.logback:logback-classic:1.4.11' }

jar { manifest { attributes( 'Main-Class': 'com.myapp.Main' ) } }

shadowJar { archiveBaseName.set('myapp') archiveClassifier.set('') archiveVersion.set('') } ```

Build and run:

bash

./gradlew shadowJar
java -jar build/libs/myapp.jar

Solution 5: Fix Missing Dependencies

If you have a "thin" JAR without dependencies:

```bash # Option 1: Run with classpath java -cp "myapp.jar:lib/*" com.myapp.Main

# Option 2: Use manifest-only JAR with Class-Path cat > MANIFEST.MF << 'EOF' Manifest-Version: 1.0 Main-Class: com.myapp.Main Class-Path: lib/dependency1.jar lib/dependency2.jar

EOF

jar cfm myapp.jar MANIFEST.MF -C out . ```

Solution 6: Fix Main-Class Not Found

If the class exists but isn't found:

```java // Ensure main method signature is correct package com.myapp;

public class Main { public static void main(String[] args) { System.out.println("Hello, World!"); } } ```

Check the compiled class:

```bash # Verify class has main method javap -public build/classes/com/myapp/Main.class

# Should show: # public static void main(java.lang.String[]); ```

Solution 7: Create Modular JAR (Java 9+)

For modular applications:

java

// module-info.java
module com.myapp {
    exports com.myapp;
    requires org.slf4j;
}

```bash # Compile module javac -d out --module-source-path src $(find src -name "*.java")

# Create modular JAR jar --create --file myapp.jar --main-class com.myapp.Main -C out .

# Run java -jar myapp.jar # Or with module path java -p myapp.jar -m com.myapp/com.myapp.Main ```

Verification

After building, verify the JAR:

```bash # Check manifest unzip -p myapp.jar META-INF/MANIFEST.MF

# Verify Main-Class grep "Main-Class" META-INF/MANIFEST.MF

# Test run java -jar myapp.jar

# If fails, check classpath java -verbose:class -jar myapp.jar 2>&1 | head -20 ```

Create a test script:

```bash #!/bin/bash # test-jar.sh

JAR_FILE=$1

echo "=== Checking JAR: $JAR_FILE ==="

# Check if file exists if [ ! -f "$JAR_FILE" ]; then echo "ERROR: JAR file not found" exit 1 fi

# Check manifest echo -e "\n=== Manifest ===" unzip -p "$JAR_FILE" META-INF/MANIFEST.MF

# Check main class echo -e "\n=== Main Class ===" MAIN_CLASS=$(unzip -p "$JAR_FILE" META-INF/MANIFEST.MF | grep "Main-Class:" | cut -d: -f2 | tr -d ' ') if [ -n "$MAIN_CLASS" ]; then echo "Main-Class: $MAIN_CLASS" CLASS_FILE=$(echo "$MAIN_CLASS" | tr '.' '/').class if unzip -l "$JAR_FILE" | grep -q "$CLASS_FILE"; then echo "✓ Main class found in JAR" else echo "✗ Main class NOT found in JAR" fi else echo "✗ No Main-Class attribute in manifest" fi

# Try running echo -e "\n=== Running JAR ===" java -jar "$JAR_FILE" ```

Verification

Error	Cause	Solution
no main manifest attribute	No Main-Class in MANIFEST.MF	Add Main-Class to manifest
Could not find main class	Wrong class name or missing class	Check class name and file existence
NoClassDefFoundError	Dependencies not in JAR	Use shade/assembly plugin or specify classpath
ClassNotFoundException	Class missing from JAR	Rebuild and verify compilation
Invalid or corrupt jarfile	Malformed JAR	Rebuild JAR

The simplest path to an executable JAR: use Maven shade plugin or Gradle shadow plugin to create a "fat JAR" with all dependencies bundled.

[Technical troubleshooting: Fix Beanvalidation Constraintviolationexception En](beanvalidation-constraintviolationexception-entity-persist)
[Technical troubleshooting: Fix Classnotfoundexception Maven Shade Plugin Relo](classnotfoundexception-maven-shade-plugin-relocation)
[Technical troubleshooting: Fix Concurrentmodificationexception Arraylist Iter](concurrentmodificationexception-arraylist-iteration)
[Fix Ehcache Cache Eviction Memory Overflow Fix Issue in Java](ehcache-cache-eviction-memory-overflow-fix)
[Fix Java Ehcache Eviction Memory Threshold Fix Issue in Java](java-ehcache-eviction-memory-threshold-fix)

Was this guide helpful?

Related search paths

People also search for

If the symptom is close but not identical, these search paths usually surface the right neighboring fixes faster than scrolling the full archive.

Java JAR File Not Executable Error Java JAR File Not Executable Error Java Java JAR File Not Executable Error troubleshooting Java JAR File Not Executable Error fix Resolve JAR file not executable errors with proper MANIFEST Java Resolve JAR file not executable errors with proper MANIFEST

Explore Related Topics

Browse Guides from Other Categories

Discover troubleshooting guides from related categories to expand your knowledge.

FAQ

Java Troubleshooting FAQs

Common questions about troubleshooting and preventing similar issues

How do I know if this java-errors troubleshooting guide applies to my situation?

This guide is designed for java-errors issues. If you're experiencing similar symptoms described in the article, follow the step-by-step instructions. Start with the most common causes and work through the diagnostic process.

Is it safe to follow these java-errors troubleshooting steps?

Yes, all steps are designed to be safe and non-destructive. We recommend creating backups before making significant changes and testing each step before proceeding to the next.

How long does it typically take to resolve this type of java-errors issue?

Most java-errors issues can be resolved within 30 minutes to 2 hours, depending on the complexity and root cause. Follow the troubleshooting flow to identify and fix the problem efficiently.

How can I prevent this java-errors issue from happening again?

Regular maintenance, monitoring, and following best practices for java-errors configuration can help prevent recurrence. Consider implementing automated checks and alerts for early detection.

Written by

FixWikiHub Editorial Team

Our editorial team consists of experienced DevOps engineers, systems administrators, and cloud architects with hands-on experience in production environments across AWS, Azure, GCP, and on-premises infrastructure.

Every guide undergoes technical review for accuracy and is updated when software versions, commands, or best practices change.

Last updated: Nov 23, 2025

About our team

Important Notice

Disclaimer & Safety Guidelines

The troubleshooting steps in this guide are provided for educational and informational purposes. Before applying any changes to production systems:

Test in a staging environment first — Always verify commands and configurations in a non-production environment before deploying to live systems.
Create backups — Ensure you have current backups of databases, configurations, and critical files before making changes.
Understand the impact — Review how each step may affect your specific environment, dependencies, and users.
Consult official documentation — This guide supplements, but does not replace, official vendor documentation and best practices.

FixWikiHub is not responsible for any damages arising from the use of this content. See our Terms of Use for more information.

Resources

Official Documentation & Further Reading

For authoritative information, consult the official documentation for the technologies discussed in this guide. Our troubleshooting content supplements, but does not replace, vendor documentation.

AWS Documentation — Official Amazon Web Services guides and API references
Kubernetes Documentation — Official Kubernetes documentation
Nginx Documentation — Official Nginx web server documentation
Apache Documentation — Official Apache HTTP Server documentation
Docker Documentation — Official Docker container documentation

How to Fix Java JAR File Not Executable Error

Introduction

Symptoms

Common Causes

Understanding JAR Execution

Step-by-Step Fix

Step 1: Check for Main-Class Attribute

Step 2: Verify Main Class Exists in JAR

Step 3: Check for Dependencies

Step 4: Test Class Execution

Step-by-Step Fix

Solution 1: Create Manifest Manually

Solution 2: Create Executable JAR with jar Command

Solution 3: Configure Maven for Executable JAR

Solution 4: Configure Gradle for Executable JAR

Solution 5: Fix Missing Dependencies

Solution 6: Fix Main-Class Not Found

Solution 7: Create Modular JAR (Java 9+)

Verification

Verification

People also search for

Browse Guides from Other Categories

WordPress

SSL

DNS

Java Troubleshooting FAQs

FixWikiHub Editorial Team

Disclaimer & Safety Guidelines

Official Documentation & Further Reading

How to Fix Java JAR File Not Executable Error

Introduction

Symptoms

Common Causes

Understanding JAR Execution

Step-by-Step Fix

Step 1: Check for Main-Class Attribute

Step 2: Verify Main Class Exists in JAR

Step 3: Check for Dependencies

Step 4: Test Class Execution

Step-by-Step Fix

Solution 1: Create Manifest Manually

Solution 2: Create Executable JAR with jar Command

Solution 3: Configure Maven for Executable JAR

Solution 4: Configure Gradle for Executable JAR

Solution 5: Fix Missing Dependencies

Solution 6: Fix Main-Class Not Found

Solution 7: Create Modular JAR (Java 9+)

Verification

Verification

Related Articles

People also search for

Share this guide

More Java Troubleshooting Guides

Browse Guides from Other Categories

Java Troubleshooting FAQs

FixWikiHub Editorial Team

Disclaimer & Safety Guidelines

Official Documentation & Further Reading