This is an automated email from the ASF dual-hosted git repository.

slachiewicz pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven-compiler-plugin.git


The following commit(s) were added to refs/heads/master by this push:
     new 5885d5fc Move the Java target, toolchain and multi-release pages to 
the Maven site
5885d5fc is described below

commit 5885d5fccab998cfc6d94a85b4e841e34c173add
Author: Sylwester Lachiewicz <[email protected]>
AuthorDate: Sat Oct 31 20:00:32 2026 +0000

    Move the Java target, toolchain and multi-release pages to the Maven site
---
 .../examples/compile-using-different-jdk.md.vm     |  97 -----------
 .../markdown/examples/set-compiler-release.md.vm   | 123 --------------
 .../examples/set-compiler-source-and-target.md.vm  |  73 ---------
 src/site/markdown/index.md.vm                      |   8 +-
 src/site/markdown/multirelease.md                  | 179 ---------------------
 src/site/site.xml                                  |   9 +-
 6 files changed, 9 insertions(+), 480 deletions(-)

diff --git a/src/site/markdown/examples/compile-using-different-jdk.md.vm 
b/src/site/markdown/examples/compile-using-different-jdk.md.vm
deleted file mode 100644
index 250cab13..00000000
--- a/src/site/markdown/examples/compile-using-different-jdk.md.vm
+++ /dev/null
@@ -1,97 +0,0 @@
----
-title: Compiling Sources Using A Different JDK
-author: 
-  - Edwin Punzalan
-date: 2006-07-05
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one
-or more contributor license agreements.  See the NOTICE file
-distributed with this work for additional information
-regarding copyright ownership.  The ASF licenses this file
-to you under the Apache License, Version 2.0 (the
-"License"); you may not use this file except in compliance
-with the License.  You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
--->
-
-# Compiling Sources Using A Different JDK
-
-Using Maven Toolchains
-----------------------
-
-The preferable way to use a different JDK is to use the toolchains mechanism. 
During the build of a project, Maven, without toolchains, will use the JDK to 
perform various steps, like compiling the Java sources, generate the Javadoc, 
run unit tests or sign JARs. Each of those plugins need a tool of the JDK to 
operate: `javac`, `javadoc`, `jarsigner`, etc. A toolchain is a way to specify 
the path to the JDK to use for all of those plugins in a centralized manner, 
independent from the one  [...]
-
-To set this up, refer to the [Guide to Using 
Toolchains](/guides/mini/guide-using-toolchains.html), which makes use of the 
[Maven Toolchains Plugin](/plugins/maven-toolchains-plugin/).
-
-With the maven-toolchains-plugin you configure 1 default JDK toolchain for all 
related maven-plugins. Since maven-compiler-plugin 3.6.0 when using with Maven 
3.3.1+ it is also possible to give the plugin its own toolchain, which can be 
useful in case of different JDK calls per execution block (e.g. the test 
sources require a different compiler compared to the main sources). 
-
-Configuring the Compiler Plugin
--------------------------------
-
-Outside of a toolchain, it is still possible to tell the Compiler Plugin the 
specific JDK to use during compilation. Note that such configuration will be 
specific to this plugin, and will not affect others.
-
-The `compilerVersion` parameter can be used to specify the version of the 
compiler that the plugin will use. However, you also need to set `fork` to 
`true` for this to work. For example:
-
-```unknown
-<project>
-  [...]
-  <build>
-    [...]
-    <plugins>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-compiler-plugin</artifactId>
-        <version>${project.version}</version>
-        <configuration>
-          <verbose>true</verbose>
-          <fork>true</fork>
-          <executable><!-- path-to-javac --></executable>
-          <compilerVersion>1.3</compilerVersion>
-        </configuration>
-      </plugin>
-    </plugins>
-    [...]
-  </build>
-  [...]
-</project>
-```
-
-To avoid hard-coding a filesystem path for the executable, you can use a 
property. For example:
-
-```unknown
-          <executable>${JAVA_1_4_HOME}/bin/javac</executable>
-```
-
-Each developer then defines this property in 
[settings.xml](http://maven.apache.org/ref/current/maven-settings/settings.html),
 or sets an environment variable, so that the build remains portable.
-
-```unknown
-<settings>
-  [...]
-  <profiles>
-    [...]
-    <profile>
-      <id>compiler</id>
-        <properties>
-          <JAVA_1_4_HOME>C:\Program Files\Java\j2sdk1.4.2_09</JAVA_1_4_HOME>
-        </properties>
-    </profile>
-  </profiles>
-  [...]
-  <activeProfiles>
-    <activeProfile>compiler</activeProfile>
-  </activeProfiles>
-</settings>
-```
-
-If you build with a different JDK, you may want to [ 
customize](http://maven.apache.org/plugins/maven-jar-plugin/examples/manifest-customization.html)
 the jar file manifest.
-
diff --git a/src/site/markdown/examples/set-compiler-release.md.vm 
b/src/site/markdown/examples/set-compiler-release.md.vm
deleted file mode 100644
index aed7fc93..00000000
--- a/src/site/markdown/examples/set-compiler-release.md.vm
+++ /dev/null
@@ -1,123 +0,0 @@
----
-title: Setting the --release of the Java Compiler
-author: 
-  - Mahmoud Anouti
-date: 2019-12-20
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one
-or more contributor license agreements.  See the NOTICE file
-distributed with this work for additional information
-regarding copyright ownership.  The ASF licenses this file
-to you under the Apache License, Version 2.0 (the
-"License"); you may not use this file except in compliance
-with the License.  You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
--->
-
-# Setting the `--release` of the Java Compiler
-
-Starting with JDK 9, the `javac` executable can accept the `--release` option 
to specify against which Java SE release you want to build the project. For 
example, you have JDK 11 installed and used by Maven, but you want to build the 
project against Java 8. The `--release` option ensures that the code is 
compiled following the rules of the programming language of the specified 
release, and that generated classes target the release as well as the public 
API of that release. This means tha [...]
-
-Since version 3.6 of the Compiler Plugin, this option can be provided either 
via a property:
-
-```unknown
-<project>
-  [...]
-  <properties>
-    <maven.compiler.release>8</maven.compiler.release>
-  </properties>
-  [...]
-</project>
-```
-
-or by configuring the plugin directly:
-
-```unknown
-<project>
-  [...]
-  <build>
-    [...]
-    <plugins>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-compiler-plugin</artifactId>
-        <version>${project.version}</version>
-        <configuration>
-          <release>8</release>
-        </configuration>
-      </plugin>
-    </plugins>
-    [...]
-  </build>
-  [...]
-</project>
-```
-
-**Note:** The value in the `release` parameter follows [Java's new 
Version-String Scheme (JEP 223)](https://openjdk.org/jeps/223)} adopted since 
Java 9. As such, the release number does not start with 1.x anymore. Also note 
that the supported `release` targets include the release of the currently used 
JDK plus a limited number of previous releases.
-
-Usage on JDK 8
---------------
-
-The `--release` option is not supported using JDK 8. However, since Compiler 
plugin version `3.13.0` you can use the `release` property also on JDK 8. The 
plugin will convert it to `source` and `target` automatically.
-
-To enable a project that targets Java 8 to be built using JDK 8 and also JDK 9 
or later requires the conditional usage of the `--release` option, when using a 
plugin version below `3.13.0` or compilerId different that `javac`.
-
-This may be done through the use of a profile:
-
-```unknown
-<project>
-  [...]
-  <profiles>
-    [...]
-    <profile>
-      <id>set-compiler-release</id>
-      <activation>
-        <jdk>[9,)</jdk>
-      </activation>
-      <properties>
-        <maven.compiler.release>8</maven.compiler.release>
-      </properties>
-    </profile>
-    [...]
-  </profiles>
-  [...]
-</project>
-```
-
-Since version `3.13.0` of the Compiler Plugin together with the default 
`javac` compilerId you don't need conditional parametrisation of `release`. The 
`release` parameter will only be effective for Java 9 or above, otherwise the 
`source` and `target` will be passed to the compiler.
-
-So you can simply configure as:
-
-```unknown
-<project>
- [...]
- <build>
-   [...]
-   <plugins>
-     <plugin>
-       <groupId>org.apache.maven.plugins</groupId>
-       <artifactId>maven-compiler-plugin</artifactId>
-       <version>${project.version}</version>
-       <configuration>
-         <release>8</release>
-         <source>8</source>
-         <target>8</target>
-       </configuration>
-     </plugin>
-   </plugins>
-   [...]
- </build>
- [...]
-</project>
-```
-
diff --git a/src/site/markdown/examples/set-compiler-source-and-target.md.vm 
b/src/site/markdown/examples/set-compiler-source-and-target.md.vm
deleted file mode 100644
index cd8644a4..00000000
--- a/src/site/markdown/examples/set-compiler-source-and-target.md.vm
+++ /dev/null
@@ -1,73 +0,0 @@
----
-title: Setting the -source and -target of the Java Compiler
-author: 
-  - Edwin Punzalan
-date: 2006-07-05
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one
-or more contributor license agreements.  See the NOTICE file
-distributed with this work for additional information
-regarding copyright ownership.  The ASF licenses this file
-to you under the Apache License, Version 2.0 (the
-"License"); you may not use this file except in compliance
-with the License.  You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
--->
-
-# Setting the `-source` and `-target` of the Java Compiler
-
-(If you're are using version `3.13.0` or newer of the Compiler Plugin, use the 
recommended [`maven.compiler.release` 
property](../examples/set-compiler-release.html).)
-
-Sometimes when you may need to compile a certain project to a different 
version than what you are currently using. The `javac` can accept such command 
using `-source` and `-target`. The Compiler Plugin can also be configured to 
provide these options during compilation. You have to set the version following 
[Java's new Version-String Scheme (JEP 223)](https://openjdk.org/jeps/223)}.
-
-For example, if you want to use the Java 8 language features and also want the 
compiled classes to be compatible with JVM 8 (former 1.8) you can either add 
the two following properties, which are the default property names for the 
plugin parameters:
-
-```unknown
-<project>
-  [...]
-  <properties>
-    <maven.compiler.source>8</maven.compiler.source>
-    <maven.compiler.target>8</maven.compiler.target>
-  </properties>
-  [...]
-</project>
-```
-
-or configure the plugin directly:
-
-```unknown
-<project>
-  [...]
-  <build>
-    [...]
-    <plugins>
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-compiler-plugin</artifactId>
-        <version>${project.version}</version>
-        <configuration>
-          <source>8</source>
-          <target>8</target>
-        </configuration>
-      </plugin>
-    </plugins>
-    [...]
-  </build>
-  [...]
-</project>
-```
-
-**Note:** Merely setting the `target` option does not guarantee that your code 
actually runs on a JRE with the specified version. The pitfall is unintended 
usage of APIs that only exist in later JREs which would make your code fail at 
runtime with a linkage error. To avoid this issue, you can either configure the 
compiler's boot classpath to match the target JRE, or use the [Animal Sniffer 
Maven 
Plugin](http://www.mojohaus.org/animal-sniffer/animal-sniffer-maven-plugin/) to 
verify your c [...]
-
-In the same way, setting the `source` option does not guarantee that your code 
actually compiles on a JDK with the specified version. To compile your code 
with a specific JDK version, different than the one used to launch Maven, refer 
to the [Compile Using A Different 
JDK](../examples/compile-using-different-jdk.html) example.
-
diff --git a/src/site/markdown/index.md.vm b/src/site/markdown/index.md.vm
index a7e9ba04..74c9f4ee 100644
--- a/src/site/markdown/index.md.vm
+++ b/src/site/markdown/index.md.vm
@@ -28,7 +28,7 @@ under the License.
 
 The Compiler Plugin is used to compile the sources of your project. The 
default compiler used to compile Java sources is `javac`. If you want to use 
another compiler, refer to the [ guide: Using Non-Javac 
Compilers](./non-javac-compilers).
 
-At present the default `source` and the default `target` setting are both `8`, 
independently of the JDK you run Maven with. You are highly encouraged to 
change these defaults by setting the `release` option as described in the 
[guide: Compile Using The `--release` javac 
Option](./examples/set-compiler-release.html).
+At present the default `source` and the default `target` setting are both `8`, 
independently of the JDK you run Maven with. You are highly encouraged to 
change these defaults by setting the `release` option as described in the 
[Guide to Targeting a Java 
Version](https://maven.apache.org/guides/mini/guide-java-target.html).
 
 **NOTE:** _To know more about the JDK javac, please see: 
[https://docs.oracle.com/javase/8/docs/technotes/guides/javac/index.html](https://docs.oracle.com/javase/8/docs/technotes/guides/javac/index.html)._
 
@@ -54,8 +54,8 @@ Examples
 
 To provide you with better understanding on some usages of the Compiler 
Plugin, you can take a look into the following examples:
 
-- [Compile Using A Different JDK](./examples/compile-using-different-jdk.html)
-- [Compile Using -source and -target javac 
Options](./examples/set-compiler-source-and-target.html)
-- [Compile Using The \-\-release javac 
Option](./examples/set-compiler-release.html)
+- [Compile Using A Different 
JDK](https://maven.apache.org/guides/mini/guide-using-toolchains.html)
+- [Compile Using -source and -target javac Options or the \-\-release 
Option](https://maven.apache.org/guides/mini/guide-java-target.html)
+- [Build a Multi-Release 
JAR](https://maven.apache.org/guides/mini/guide-multi-release-jars.html)
 - [Compile Using Memory Allocation 
Enhancement](./examples/compile-with-memory-enhancements.html)
 - [Pass Compiler Arguments](./examples/pass-compiler-arguments.html)
diff --git a/src/site/markdown/multirelease.md 
b/src/site/markdown/multirelease.md
deleted file mode 100644
index 12234774..00000000
--- a/src/site/markdown/multirelease.md
+++ /dev/null
@@ -1,179 +0,0 @@
----
-title: Multi Release
-author: 
-  - Robert Scholte
-date: 2018-05-08
----
-
-<!--
-Licensed to the Apache Software Foundation (ASF) under one
-or more contributor license agreements.  See the NOTICE file
-distributed with this work for additional information
-regarding copyright ownership.  The ASF licenses this file
-to you under the Apache License, Version 2.0 (the
-"License"); you may not use this file except in compliance
-with the License.  You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing,
-software distributed under the License is distributed on an
-"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, either express or implied.  See the License for the
-specific language governing permissions and limitations
-under the License.
--->
-
-# Multi Release
-
-With [JEP-238](http://openjdk.java.net/jeps/238) the support of multirelease 
jars was introduced. This means that you can have Java version dependent 
classes inside one jar. Based on the runtime it will pick up the best matching 
version of a class.
-
-JEP-238 Introduction
---------------------
-
-### The "forward compatibility" problem
-
-The problem this JEP is trying to solve is to make it possible to use new JDK 
features even though the codebase must stay compatible with earlier versions.
-
-Let's try to make this concrete with a real world example: In Java 7 
`java.nio` was added, which was much better in File handling. In those days 
Maven still required Java 6 to run, however they wanted to make use of these 
new features when Maven was running on Java 7 or beyond.
-
-Up until Java 8 there were 2 solutions:
-
-1. Compile with the targeted JDK (i.e. Java 6) and use reflection. You can 
ensure that the code is Java 6 compatible, but the reflection-part is hard to 
verify.
-
-    ```
-      if ( isAtLeastJava7() ) {
-        Method toPathMethod = f.getClass().getMethod( "toPath" );
-        Object toPathInstance = toPathMethod.invoke( f );
-        Method isSymbolicLink = Class.forName( "java.nio.file.Files" 
).getMethod( "isSymbolicLink" );
-        ...
-      }
-      else {
-        // compare absoluteFile with canonicalFile 
-        ...
-      }
-    ```
-
-1. Compile with the required JDK (i.e. Java 7), but use source/target of the 
lowest version (i.e. 1.6). The danger here is that you cannot ensure that all 
code is Java 6 compatible. Depending on the code structure [Animal 
Sniffer](https://www.mojohaus.org/animal-sniffer/) might help.
-
-    ```
-      if ( isAtLeastJava7() ) {
-        return Files.isSymbolicLink( f.toPath() );
-      }
-      else {
-        // compare absoluteFile with canonicalFile 
-        ...
-      }
-    ```
-
-### The "forward compatibility" solution
-
-```
-A.class
-B.class
-C.class
-D.class
-META-INF/MANIFEST.MF { Multi-Release: true }
-         versions/9/A.class
-                    B.class
-                  10/A.class
-                     C.class
-                      
-```
-
-With the `Multi-Release: true` flag in the MANIFEST file, the Java runtime 
will also look inside `META-INF/versions` for version specific classes, 
otherwise only the base classes are used.
-
-Challenges
-----------
-
-The theory behind multi release jars is quite simple, but in practice it can 
become quite complex. You must ensure that all classes stay in sync; if you add 
a method to one class, don't forget to add it to the other classes as well. 
There are some options which should reduce problems at this level: Let all 
multirelease classes implement an interface and in the basecode instantiate the 
class but only call the interface methods. The best is to test the \*jar\* with 
all targeted Java versio [...]
-
-There are a couple of important facts one should know when creating Multi 
Release jars.
-
-- The Java compiler must be called for every different version. The solutions 
solve this either by having multiple Maven Projects/Modules or by adding extra 
compiler execution-blocks to the POM (like [older projects with 
module-info](./examples/module-info.html)). 
-- The `Multi-Release: true` attribute is only recognized when the classes are 
in a jar. In other words, you cannot test the classes put in 
`target/classes/META-INF/versions/${release}/`.
-- Up until the moment of writing all IDEs can only have one JDK per Maven 
Project, whereas with multi release you want to specify it per source folder.
-# Pattern 1: [Maven Multimodule](https://github.com/hboutemy/maven-jep238)
-
-This is the first pattern provided by the Maven team themselves. They had the 
following requirements:
-
-- Only one Maven call to compile, test and package the Multi Release jar
-- It must work with IDEs
-- Developers should not change their way of work / simple configuration
-
-The only solution to cover the first two bullets was to split the code into a 
Maven multimodule project. Now every Maven module is just a standard Maven 
project with close to no specific adjustments in the pom. There are several 
ways you can run this project:
-
-- Use the highest required version of the JDK to build the project. You can 
use `release` to ensure the code only uses matching code and syntax. Since the 
version-code is isolated you can run surefire with a higher Java runtime.
-- Use toolchains if you really want to compile and test with the matching Java 
version. 
-
-The downside it that a hierarchical structure is required even though the 
result is just 1 artifact.
-
-# Pattern 2: [Multi Project](http://word-bits.flurg.com/multrelease-jars/) 
-
-This solution is a response to the previous Maven multimodule setup. The 
requirements are almost the same
-
-- Do not require the project to switch to a multi-module format
-- Developers should not change their way of work / simple configuration
-
-The first requirements implies that the projects now are separate Maven 
projects. One Maven project contains the base-code and in the end this will 
also be the multirelease jar. When building such project for the first time, 
you'll need to call Maven at least 3 times: first the base needs to be 
compiled, next all version specific projects must be built and finally the main 
project needs to be built again, now including the version specific classes 
extracted from their jars. This setup is [...]
-
-# Pattern 3: Single Project
-
-By now there are 3 solutions, each inspired by their previous version.
-
-Main goal:
-
-- Do not require the project to switch to a multi-module format
-- Only one Maven call to compile and package the Multi Release jar
-
-[Single 
Project](http://in.relation.to/2017/02/13/building-multi-release-jars-with-maven/)
-------------------------------------------------------------------------------------------
-
-In this case everything stays inside one Maven project. Every specific Java 
version gets its own source folder and output folder, and just before packaging 
they are combined. What's not covered is how to test every class.
-
-[Multi-Release 
Parent](http://www.russgold.net/sw/2018/04/easier-than-it-looks/)
---------------------------------------------------------------------------------
-
-This approach replaces the maven-ant-plugin with extra exucution blocks in the 
maven-compiler-plugin. It has been setup as a parent, so other projects can use 
it. It uses toolchains to be able to build all classes with their matching Java 
version, so you always get the multi release jar. Because of the huge 
configuration and since Maven doesn't support mixins yet, it makes sense to put 
it all in a parent. However, at the same time surefire is only called once.
-
-[CI-server](https://github.com/codehaus-plexus/plexus-languages)
-----------------------------------------------------------------
-
-This approach reduces the previous solution by only specifying execution 
blocks for sources for a specific Java version. It doesn't use toolchains, but 
the JDK used to run Maven. This means that only the sources up to the specific 
Java version are compiled and tested. This solution relies heavily on a 
CI-server where every targeted Java version is available. If the CI-server 
succeeds, then all classes are tested with their matching Java version.
-
-# Pattern 4: [Maven extension + 
plugin](https://github.com/metlos/multi-release-jar-maven-plugin)
-
-This approach introduces a new packaging type and an extra plugin takes care 
of the multiple executions of the maven-compiler-plugin, but these are now 
handled by the `perReleaseConfiguration` of the 
`multi-release-jar-maven-plugin`. What's not covered is how to test every class.
-
-# Patterns Summary
-
-For every pattern there are integration tests created, based on the same set 
of sourcefiles. See 
[https://github.com/apache/maven-compiler-plugin/tree/master/src/it/multirelease-patterns](https://github.com/apache/maven-compiler-plugin/tree/master/src/it/multirelease-patterns)
-
-||Maven Multimodule|Multi Project|Single project (runtime)|Single project 
(toolchains)|Maven extension+plugin|
-|:---:|:---:|:---:|:---:|:---:|:---:|
-|\# projects|1|1 + #javaVersions|1|1|1|
-|\# builds to package|1|2 + #javaVersions|1|1|1|
-|\# builds/project to test|1|1|#javaVersions|1|N/A (a)|
-|Simple Maven Project Layout|No|Yes|Yes|Yes|Yes|
-|Additional POM adjustments(b)|1 
(c)|#javaVersions(d)|#javaVersions(e)|??(f)|#javaVersions(g)|
-|Include module descriptor|No (h)|No (h)|Yes|Yes|Yes|
-|IDE support (i)|Yes|Yes|No|No|No|
-
-(a) Project can only be executed with highest required JDK, hence you can't 
test the code for all JDKs
-
-(b) Additional POM adjustments: # of executions added to the default 
lifecycle. This reflects the complexity of the POM.
-
-(c) Maven multimodule uses maven-assembly-plugin to assemble to multirelease 
jar
-
-(d) Multi project uses the maven-dependency-plugin to unpack java specific 
dependency to its matching outputDirectory
-
-(e) There's a profile for every Java version required which contains an extra 
execution-block for that Java version.
-
-(f) 
-
-(g) Maven extension+plugin hides the multiple executions in the 
`perReleaseConfiguration` configuration
-
-(h) Requires a \-\-patch-module on a dependency 
-
-(i) IDE Support: All classes are recognized and can be tested within the IDE.
-
diff --git a/src/site/site.xml b/src/site/site.xml
index 0d6d833b..46ca9498 100644
--- a/src/site/site.xml
+++ b/src/site/site.xml
@@ -33,14 +33,15 @@ under the License.
       <item name="Download" href="download.html"/>
     </menu>
     <menu name="Examples">
-      <item name="Compile Using A Different JDK" 
href="examples/compile-using-different-jdk.html"/>
-      <item name="Compile Using -source and -target javac Options" 
href="examples/set-compiler-source-and-target.html"/>
-      <item name="Compile Using the --release javac Option" 
href="examples/set-compiler-release.html"/>
       <item name="Compile Using Memory Allocation Enhancements" 
href="examples/compile-with-memory-enhancements.html"/>
       <item name="Pass Compiler Arguments" 
href="examples/pass-compiler-arguments.html"/>
       <item name="Non-javac compilerIds" href="non-javac-compilers.html"/>
       <item name="Older projects with module-info" 
href="examples/module-info.html"/>
-      <item name="MultiRelease" href="multirelease.html"/>
+    </menu>
+    <menu name="See Also">
+      <item name="Targeting a Java Version" 
href="https://maven.apache.org/guides/mini/guide-java-target.html"/>
+      <item name="Using Toolchains" 
href="https://maven.apache.org/guides/mini/guide-using-toolchains.html"/>
+      <item name="Building Multi-Release JARs" 
href="https://maven.apache.org/guides/mini/guide-multi-release-jars.html"/>
     </menu>
   </body>
 </project>

Reply via email to