How to Fix 'No Main Manifest Attribute' Error in JAR

The “no main manifest attribute” error occurs when a JAR file’s MANIFEST.MF file is missing the Main-Class attribute that tells Java which class contains the main method. For third-party applications where you can’t modify the manifest file, you can resolve this by using the -cp option to specify the main class directly, extracting and modifying the manifest, or using alternative execution methods like java -cp "app.jar" com.example.MainClass.

Contents

• Understanding the “No Main Manifest Attribute” Error
• Method 1: Using java -cp to Specify Main Class
• Method 2: Extracting and Modifying the Manifest File
• Method 3: Using the jar Command with -e Option
• Method 4: Using Build Tools for Permanent Fixes
• Method 5: Alternative Execution Approaches
• Preventing the Issue in the Future

Understanding the “No Main Manifest Attribute” Error

The “no main manifest attribute” error is a common Java runtime issue that occurs when you attempt to run a JAR file using the java -jar command. This error specifically indicates that the Java Virtual Machine (JVM) cannot find the entry point for your application because the required Main-Class attribute is missing from the JAR file’s manifest.

The MANIFEST.MF file is located in the META-INF directory within the JAR file and contains metadata about the application. The crucial line that’s usually missing is: Main-Class: com.yourpackage.YourMainClass

According to the Stack Overflow discussion, this error happens when the Main-Class entry is missing from the MANIFEST.MF file, which is essential for self-executing JAR files.

Method 1: Using java -cp to Specify Main Class

The most straightforward solution for third-party applications is to bypass the manifest entirely and specify the main class directly using the -cp (classpath) option. This method doesn’t require modifying the JAR file at all.

Step-by-Step Process:

1. First, identify the main class by examining the JAR contents or looking for clues in the documentation
2. Use the java command with -cp option instead of -jar

java -cp "app.jar" com.example.MainClass

Finding the Main Class:

If you’re unsure which class contains the main method, you can:

• Check the JAR structure: Extract the JAR and look for classes that might contain a main method
• Use jar command: jar tf app.jar | grep -i main
• Look for documentation: Check if the application comes with documentation specifying the main class

As explained in the Stack Overflow answer, when you use -cp instead of -jar, you’re telling Java exactly which class to execute, bypassing the manifest requirements.

Method 2: Extracting and Modifying the Manifest File

If you can identify the main class but need to modify the manifest, you can extract the JAR, modify the MANIFEST.MF file, and repack it.

Step-by-Step Process:

1. Extract the JAR file:

mkdir temp_jar
cd temp_jar
jar xvf ../app.jar

2. Locate and edit the MANIFEST.MF:

cd META-INF
nano MANIFEST.MF  # or use any text editor

3. Add the Main-Class attribute:

Manifest-Version: 1.0
Main-Class: com.yourpackage.MainClass

4. Repack the JAR file:

cd ..
jar cvfm app.jar META-INF/MANIFEST.MF *

5. Test the modified JAR:

java -jar app.jar

This approach is particularly useful when you have multiple JAR files or need to set other manifest attributes. As noted in the Baeldung article, the Main-Class metadata property must be properly declared in the MANIFEST.MF file located under the META-INF folder.

Method 3: Using the jar Command with -e Option

The jar command-line tool provides the -e (entrypoint) option that automatically sets the Main-Class attribute in the manifest. This is useful when you need to create a properly configured executable JAR.

Creating an Executable JAR with -e Option:

jar cfe executable.jar com.example.MainClass *.class

Or if you have an existing JAR that needs modification:

jarufe executable.jar com.example.MainClass

As explained in the Oracle documentation, the -e option “sets the class specified by the entrypoint operand to be the entry point for a standalone Java application bundled into an executable JAR file” and “creates or overrides the Main-Class attribute value in the manifest file.”

This method is particularly useful when you’re dealing with third-party applications that come as source code or class files rather than pre-packaged JARs.

Method 4: Using Build Tools for Permanent Fixes

If you’re working with Maven or Gradle projects, you can configure build plugins to ensure the manifest is properly generated with the Main-Class attribute.

Maven Solution:

Add the maven-jar-plugin to your pom.xml:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-jar-plugin</artifactId>
            <version>3.2.0</version>
            <configuration>
                <archive>
                    <manifest>
                        <addClasspath>true</addClasspath>
                        <mainClass>com.yourpackage.MainClass</mainClass>
                    </manifest>
                </archive>
            </configuration>
        </plugin>
    </plugins>
</build>

Gradle Solution:

In your build.gradle file:

jar {
    manifest {
        attributes 'Main-Class': 'com.yourpackage.MainClass'
    }
}

As mentioned in the Java2Blog article, putting the maven-jar-plugin in pom.xml is an effective way to fix the missing Main-Class attribute issue. The Java Hungry blog also demonstrates how Maven automatically adds the Main-Class property to the manifest file after updating the pom.xml.

Method 5: Alternative Execution Approaches

When dealing with third-party applications where traditional methods fail, consider these alternative approaches:

Using java -Djava.protocol.handler.pkgs

Some applications require specific classpath configurations:

java -Djava.protocol.handler.pkgs=com.example.protocols -cp "app.jar" com.example.MainClass

Using a Wrapper Script

Create a batch file (Windows) or shell script (Linux/macOS):

# run.sh (Linux/macOS)
#!/bin/bash
java -cp "app.jar:lib/*" com.example.MainClass "$@"

Using an IDE

If you have an IDE like IntelliJ IDEA or Eclipse, you can use the built-in export tools to automatically generate a JAR file with the correct manifest. Be sure to specify the main class during the export process.

Preventing the Issue in the Future

To avoid encountering the “no main manifest attribute” error in the future, follow these best practices:

When Creating JAR Files:

1. Always specify the main class when creating executable JARs
2. Use build tools like Maven or Gradle that handle manifest generation automatically
3. Test JAR files on your development system before deployment

Best Practices for JAR Creation:

# Best practice for creating executable JAR
jar cfe myapp.jar com.example.MainClass *.class

# Or using manifest file
jar cvfm myapp.jar manifest.txt *.class

For Third-Party Applications:

1. Check documentation first for proper execution instructions
2. Verify system requirements and Java version compatibility
3. Look for known issues in the application’s bug tracker or forums

As noted in the Reddit discussion, you typically need to add a Maven build plugin as a build dependency for building JAR files properly. The IOFlood article also mentions that while specifying the main class in the manifest file or using build tools are common approaches, Java provides alternative ways to define the entry point of your application.

Conclusion

The “no main manifest attribute” error is a common but solvable issue when working with JAR files. For third-party applications where you cannot modify the source code, the most practical solutions are:

1. Use java -cp to specify the main class directly, bypassing the manifest requirements
2. Extract and modify the MANIFEST.MF file to add the missing Main-Class attribute
3. Use alternative execution methods like wrapper scripts or IDE-based execution

For your specific situation where the application runs successfully on other systems but fails on yours, the issue is likely related to how the JAR was packaged or how your Java environment is configured. Try the -cp method first as it requires no modifications to the JAR file, then proceed to other methods if needed.

Remember that proper JAR file creation should always include a correctly configured manifest with the Main-Class attribute specified. When developing your own applications, use build tools like Maven or Gradle that handle manifest generation automatically, or use the jar command with the -e option to ensure your JAR files are self-executing.

Sources

1. Stack Overflow - Can’t execute jar file: “no main manifest attribute”
2. Baeldung - Fixing the No Main Manifest Attribute in Spring Boot
3. Sentry - Can’t execute JAR file: no main manifest attribute
4. LabEx - How to fix ‘no main manifest attribute’ error in Java
5. Java2Blog - [Fixed] no main manifest attribute
6. Oracle Documentation - jar command with -e option
7. Java Hungry - [Solved] No main manifest attribute, in jar Maven and SpringBoot
8. IOFlood - [SOLVED] ‘No Main Manifest Attribute’ Error in Java
9. GeeksforGeeks - How to Create an Executable JAR with Maven?
10. Reddit - r/javahelp on no main manifest attribute