# Where Are Maven Core Implementations Located? A Deep Dive into apache/maven

> Discover where Maven core implementations reside within the apache/maven repository's impl/maven-core module. Explore the Java source code for build, dependency, and plugin execution.

- Repository: [The Apache Software Foundation/maven](https://github.com/apache/maven)
- Tags: deep-dive
- Published: 2026-07-07

---

**The Maven core implementations are located in the `impl/maven-core` module of the Apache Maven repository, specifically under `impl/maven-core/src/main/java/org/apache/maven/`, containing concrete classes that handle project building, dependency resolution, and plugin execution.**

 Apache Maven is a software project management and comprehension tool that relies on a central core to execute build lifecycles. The **Maven core implementations** provide the concrete logic behind the public APIs, driving everything from POM parsing to artifact resolution. This module serves as the engine that the Maven CLI and embedder invoke to perform actual build work.

## Location of Maven Core Implementations

 The heart of Apache Maven resides in the **`impl/maven-core`** module. This directory contains the concrete implementations of the `org.apache.maven.*` packages that drive the build lifecycle, project model handling, and settings processing.

 All core classes live under:

 ```

 impl/maven-core/src/main/java/org/apache/maven/
 ```

 The module's [`pom.xml`](https://github.com/apache/maven/blob/main/pom.xml) at [`impl/maven-core/pom.xml`](https://github.com/apache/maven/blob/main/impl/maven-core/pom.xml) defines dependencies on Aether (for artifact resolution) and Plexus (for dependency injection), assembling the final JAR used by the Maven CLI.

## Key Components Inside impl/maven-core

### Project Building and Model Handling

 The **project building** subsystem parses [`pom.xml`](https://github.com/apache/maven/blob/main/pom.xml) files and constructs the in-memory project representation.

- **`DefaultProjectBuilder`**: Located at [`impl/maven-core/src/main/java/org/apache/maven/project/DefaultProjectBuilder.java`](https://github.com/apache/maven/blob/main/impl/maven-core/src/main/java/org/apache/maven/project/DefaultProjectBuilder.java), this class parses POMs, resolves parent/child relationships, and validates the model.
- **`MavenProject`**: Found at [`impl/maven-core/src/main/java/org/apache/maven/project/MavenProject.java`](https://github.com/apache/maven/blob/main/impl/maven-core/src/main/java/org/apache/maven/project/MavenProject.java), this is the in-memory representation containing coordinates, build information, dependencies, and plugins.
- **`ProjectBuilder`**: The public facade at [`impl/maven-core/src/main/java/org/apache/maven/project/ProjectBuilder.java`](https://github.com/apache/maven/blob/main/impl/maven-core/src/main/java/org/apache/maven/project/ProjectBuilder.java) used by the embedder and CLI to construct projects from requests.

### Dependency Resolution

 The **dependency resolution** engine handles transitive dependencies and builds the artifact graph.

- **`DefaultProjectDependenciesResolver`**: Located at [`impl/maven-core/src/main/java/org/apache/maven/project/DefaultProjectDependenciesResolver.java`](https://github.com/apache/maven/blob/main/impl/maven-core/src/main/java/org/apache/maven/project/DefaultProjectDependenciesResolver.java), this class resolves direct and transitive dependencies, builds the dependency graph, and records resolution results using the Aether repository system.

### Plugin Management

 Plugin discovery and validation occur through specialized resolvers and validators.

- **`DefaultPluginPrefixResolver`**: At [`impl/maven-core/src/main/java/org/apache/maven/plugin/prefix/internal/DefaultPluginPrefixResolver.java`](https://github.com/apache/maven/blob/main/impl/maven-core/src/main/java/org/apache/maven/plugin/prefix/internal/DefaultPluginPrefixResolver.java), this maps plugin prefixes (e.g., `compiler`) to full artifact coordinates (e.g., `maven-compiler-plugin`).
- **`DefaultMavenPluginValidator`**: Found at [`impl/maven-core/src/main/java/org/apache/maven/plugin/internal/DefaultMavenPluginValidator.java`](https://github.com/apache/maven/blob/main/impl/maven-core/src/main/java/org/apache/maven/plugin/internal/DefaultMavenPluginValidator.java), this checks that plugin goals, parameters, and prerequisites are compatible with the current Maven version.

### Configuration and Runtime Support

 Supporting infrastructure includes settings processing and repository integration.

- **`SettingsUtils`**: Located at [`impl/maven-core/src/main/java/org/apache/maven/settings/SettingsUtils.java`](https://github.com/apache/maven/blob/main/impl/maven-core/src/main/java/org/apache/maven/settings/SettingsUtils.java), this reads and validates global and user [`settings.xml`](https://github.com/apache/maven/blob/main/settings.xml) files.
- **`RepositorySystemSessionFactory`**: At [`impl/maven-core/src/main/java/org/apache/maven/resolver/RepositorySystemSessionFactory.java`](https://github.com/apache/maven/blob/main/impl/maven-core/src/main/java/org/apache/maven/resolver/RepositorySystemSessionFactory.java), this creates Aether sessions wired with Maven-specific policies for mirrors, proxies, and authentication.
- **`DefaultRuntimeInformation`**: Found at [`impl/maven-core/src/main/java/org/apache/maven/rtinfo/internal/DefaultRuntimeInformation.java`](https://github.com/apache/maven/blob/main/impl/maven-core/src/main/java/org/apache/maven/rtinfo/internal/DefaultRuntimeInformation.java), this provides Maven version, Java version, and OS details to plugins.
- **`SessionScope`**: At [`impl/maven-core/src/main/java/org/apache/maven/session/scope/internal/SessionScope.java`](https://github.com/apache/maven/blob/main/impl/maven-core/src/main/java/org/apache/maven/session/scope/internal/SessionScope.java), this manages the per-execution Plexus DI container for plugin and extension lookup.

## Architecture Flow: How the Core Fits Together

 The Maven core implementations operate in a specific sequence during build execution:

1. **CLI to Core**: The command-line interface in `maven-embedder` creates a `MavenExecutionRequest` and delegates to the core implementation.
2. **Project Building**: The `ProjectBuilder` constructs a full `MavenProject` model by parsing the POM and resolving inheritance.
3. **Dependency Resolution**: The `DefaultProjectDependenciesResolver` uses the `RepositorySystem` (Aether) to download and resolve the project dependency graph.
4. **Plugin Resolution**: The `DefaultPluginPrefixResolver` maps plugin prefixes to artifacts, while `DefaultMavenPluginValidator` ensures compatibility.
5. **Lifecycle Execution**: The core drives lifecycle phases (`validate`, `compile`, `test`, etc.) via the `MavenLifecycleExecutor` (located in `impl/maven-impl` but reliant on core services).

## Working with Maven Core Classes

 While typical usage goes through higher-level APIs like `Maven` or `MavenCli`, you can interact with core classes directly for embedded scenarios.

### Building a Project Programmatically

 ```java
 import org.apache.maven.project.DefaultProjectBuilder;
 import org.apache.maven.project.ProjectBuilder;
 import org.apache.maven.project.ProjectBuildingRequest;
 import org.apache.maven.project.ProjectBuildingResult;
 import org.apache.maven.project.MavenProject;
 import java.io.File;

 MavenExecutionRequest request = new DefaultMavenExecutionRequest()
     .setBaseDirectory(new File("my-project"))
     .setUserSettingsFile(new File(System.getProperty("user.home"), ".m2/settings.xml"));

 ProjectBuilder builder = new DefaultProjectBuilder();
 ProjectBuildingRequest pbr = new DefaultProjectBuildingRequest()
     .setProcessPlugins(true)
     .setRepositorySession(RepositorySystemSessionFactory.newSession());

 ProjectBuildingResult result = builder.build(new File("my-project/pom.xml"), pbr);
 MavenProject project = result.getProject();
 System.out.println("Project: " + project.getId());
 ```

*Source: `DefaultProjectBuilder` implementation in `impl/maven-core`.*

### Resolving a Plugin Prefix

 ```java
 import org.apache.maven.plugin.prefix.internal.DefaultPluginPrefixResolver;
 import org.apache.maven.plugin.prefix.PluginPrefixRequest;
 import org.apache.maven.plugin.prefix.PluginPrefixResult;

 PluginPrefixRequest prefixReq = new PluginPrefixRequest()
     .setPrefix("compiler")
     .setPom(project.getFile())
     .setRepositorySession(session);

 PluginPrefixResult prefixRes = new DefaultPluginPrefixResolver()
     .resolve(prefixReq);
 System.out.println("Plugin artifact: " + prefixRes.getPluginArtifact());
 ```

*Source: `DefaultPluginPrefixResolver` in `impl/maven-core`.*

### Validating a Plugin Before Execution

 ```java
 import org.apache.maven.plugin.internal.DefaultMavenPluginValidator;
 import org.apache.maven.plugin.MavenPluginValidator;

 MavenPluginValidator validator = new DefaultMavenPluginValidator();
 MavenPluginValidationResult vRes = validator.validate(plugin, project, session);
 if (!vRes.isValid()) {
     throw new MavenExecutionException("Invalid plugin configuration");
 }
 ```

*Source: `DefaultMavenPluginValidator` in `impl/maven-core`.*

## Summary

- The **Maven core implementations** reside in the **`impl/maven-core`** module, specifically under `impl/maven-core/src/main/java/org/apache/maven/`.
- **`DefaultProjectBuilder`** and **`MavenProject`** handle POM parsing and in-memory model representation.
- **`DefaultProjectDependenciesResolver`** manages transitive dependency resolution using Aether.
- **`DefaultPluginPrefixResolver`** and **`DefaultMavenPluginValidator`** handle plugin discovery and compatibility checking.
- The core classes are used by the Maven CLI and embedder to execute the full build lifecycle from project initialization through plugin execution.

## Frequently Asked Questions

### What is the difference between maven-core and maven-impl?

 The `impl/maven-core` module contains the concrete implementations of project building, dependency resolution, and plugin management classes. The `impl/maven-impl` module contains higher-level orchestration components like `Maven` and `MavenLifecycleExecutor` that coordinate these core services during build execution.

### How does Maven resolve dependencies programmatically?

 Maven uses the **`DefaultProjectDependenciesResolver`** class located in `impl/maven-core/src/main/java/org/apache/maven/project/`. This class constructs a dependency graph, resolves conflicts, and downloads artifacts using the Eclipse Aether repository system through the `RepositorySystemSession` created by `RepositorySystemSessionFactory`.

### Where is the POM parsing logic located in Maven?

 The primary POM parsing logic resides in **[`DefaultProjectBuilder.java`](https://github.com/apache/maven/blob/main/DefaultProjectBuilder.java)** at [`impl/maven-core/src/main/java/org/apache/maven/project/DefaultProjectBuilder.java`](https://github.com/apache/maven/blob/main/impl/maven-core/src/main/java/org/apache/maven/project/DefaultProjectBuilder.java). This class reads the [`pom.xml`](https://github.com/apache/maven/blob/main/pom.xml), resolves parent POMs, validates the model, and produces a `MavenProject` instance representing the build configuration.

### Can I use Maven core classes in my own application?

 Yes, you can embed Maven by depending on the `maven-core` artifact and using classes like `ProjectBuilder` and `DefaultProjectDependenciesResolver`. However, you must configure a `RepositorySystemSession` and Plexus container (CDI) properly, as these core implementations rely on dependency injection and the Aether repository system to function.