diff --git a/docs/src/docs/asciidoc/changelog.adoc b/docs/src/docs/asciidoc/changelog.adoc
new file mode 100644
index 000000000..37f40952a
--- /dev/null
+++ b/docs/src/docs/asciidoc/changelog.adoc
@@ -0,0 +1,478 @@
+[[changelog]]
+== Changelog
+
+=== Release 0.10.3
+
+- Remove usage of macro from merger tool initialization and throw better error if executable does not exist
+- Add support for the new reachability-metadata.json config file
+- Remove custom post-processing task for filtering config files entries and use access-filter.json instead
+
+==== Gradle plugin
+
+- Add retries when downloading the metadata repository when using a URL directly
+
+==== Maven plugin
+
+- Add retries when downloading the metadata repository when using a URL directly
+
+
+=== Release 0.10.2
+
+- Fix class path directory analyzer
+- Update Reachability Metadata repository version
+
+==== Gradle plugin
+
+- Update Default Target Directory for MetadataCopy Task
+
+==== Maven plugin
+
+- Update Getting Started with Maven Plugin doc
+- Delete old stale args file
+- Add a parameter to be able to skip build native for pom type modules, leave it as false per default for backward compat
+
+=== Release 0.10.1
+
+- Mark additional JUnit 5 types for build-time initialization for compatibility with Native Image's `--strict-image-heap` option.
+
+
+=== Release 0.10.0
+
+- Update version of GraalVM dependency to 22.3.5
+
+==== Gradle plugin
+
+- Update plugin to use metadata repository by default. Metadata repository <<gradle-plugin.adoc#_configuring_the_metadata_repository,can be disabled manually.>>
+
+==== Maven plugin
+
+- Update plugin to use metadata repository by default. Metadata repository <<maven-plugin.adoc#_configuring_the_metadata_repository,can be disabled manually.>>
+
+
+=== Release 0.9.28
+
+* Fix path escaping problem for Windows users
+* Fix and improve major JDK version detection.
+
+==== Gradle plugin
+
+- Remove use of deprecated `getConvention` APIs
+
+=== Release 0.9.27
+
+* Update JUnit configuration for native testing on GraalVM for JDK 21 with `--strict-image-heap` mode.
+
+=== Release 0.9.26
+
+* Relax GraalVM version check for dev versions
+* Prepare plugins for release of _GraalVM for JDK 21_. They no longer deploy any experimental options.
+* Bump Java compliance of the plugins from Java 8+ to Java 11+.
+* Fix compatibility with Maven 3.9.
+
+==== Gradle plugin
+
+* Fix compatibility with Gradle 8.3
+
+=== Release 0.9.25
+
+* Upgrade metadata to 0.3.4
+
+=== Release 0.9.24
+
+* Upgrade metadata to 0.3.3
+
+==== Gradle plugin
+
+* Add support for PGO
+
+=== Release 0.9.23
+
+* Upgrade metadata to 0.3.2
+* Display the GraalVM logo on the generated NBT docs
+
+==== Gradle plugin
+
+- Remove use of GFileUtils
+- Fix "collect reachability metadata" with config cache
+
+=== Release 0.9.22
+
+* Upgrade metadata to 0.3.0
+* Add support for default-for attribute
+
+==== Gradle plugin
+
+- Fix lookup of metadata repository
+
+=== Release 0.9.21
+
+* Deprecate `requiredVersion` check without replacement.
+
+==== Gradle plugin
+
+- Bump minimal version of Gradle to 7.4
+- Fix compatibility with Gradle's https://docs.gradle.org/8.0.2/userguide/configuration_cache.html#header[configuration cache] (requires Gradle 7.5+)
+- Remove use of deprecated Gradle APIs
+- [Behavior change] Toolchain detection is now disabled by default
+
+==== Maven plugin
+
+- Add a new `native:write-args-file` goal that can be used to write the arguments passed to `native-image` to a file
+
+=== Release 0.9.20
+
+==== Gradle plugin
+
+- Fix `collectReachabilityMetadata` not being thread-safe
+- Add an option to configure the maximum number of images which can be built in parallel
+- Fix GraalVM version check being too strict
+
+==== Maven plugin
+
+- Add agent modes to Maven plugin
+
+=== Release 0.9.19
+
+==== Gradle plugin
+
+- Fix `nativeCompile` being out-of-date whenever native runtime arguments change
+- Fix GraalVM metadata repository not downloaded from project repositories by default
+
+==== Maven plugin
+
+=== Release 0.9.18
+
+* Trim GraalVM version to fix Windows support
+* Add tests for NativeImageUtils.escapeArg
+* Do not escape quoted regexp args when using argsfile
+* Upgrade to GraalVM metadata repository 0.2.5
+
+=== Release 0.9.17
+
+* Add a `requiredVersion` property to check the minimal GraalVM version
+* Make GraalVM installation check lazy
+
+=== Release 0.9.16
+
+* Fixed regression with a reachability-metadata repository
+
+=== Release 0.9.15
+
+* Upgrade to GraalVM metadata repository 0.2.3.
+* Ship the metadata repository as an artifact alongside the plugin
+* Add ability to collect GraalVM metadata of dependencies to a custom location
+
+==== Gradle plugin
+
+* Improved diagnostics to help users figure out what GraalVM toolchain was selected
+
+=== Release 0.9.14
+
+==== Gradle plugin
+* Add ability to set environment variables to the native image builder process
+* Argument files are now stored in the `build` directory (workaround for absolute path issue on Windows with older GraalVM versions)
+
+==== Maven plugin
+* Added `native:compile` forking goal that can be started from the command line as `mvn native:compile`.
+* Deprecated `build` goal in favour of `compile-no-fork` goal. This goal should now be used for attaching to the `package` phase in `pom.xml`. Attaching the `build` goal will (for now) produce a runtime warning.
+* Argument files are now stored in the `target` directory (workaround for absolute path issue on Windows with older GraalVM versions).
+* Default and test outputs are now much less noisy.
+* When running tests in JVM mode with the native-image-agent, GraalVM's `java` executable is now always used.
+* Maven plugin now shouldn't require that JVM running it must be GraalVM.
+
+=== Release 0.9.13
+
+==== Gradle plugin
+* Reverted a change in the `NativeImagePlugin` that removed publicly accessible constants. This should prevent breakage of external plugins.
+
+==== JUnit testing support
+* Adapted the JUnit automatic metadata registration to changes in annotation handling on newer native image versions.
+
+=== Release 0.9.12
+
+==== Gradle plugin
+* Completely reworked agent support - **BREAKING CHANGE**
+* The agent block is no longer tied to the target binary.
+* The agent can now instrument any task that extends `JavaForkOptions`.
+* Introduced the `metadataCopy` task.
+* Introduced the concept of agent modes.
+** Under the hood, the agent mode dictates what options are passed to the agent and how metadata produced by multiple runs get merged.
+* Added `excludeConfig` configuration option that allows skipping of configuration files that are present in dependencies.
+* `useArgFile` is now set to true by default only on Windows.
+* Added `quickBuild` configuration option.
+
+==== Maven plugin
+* Added support for GraalVM Reachability Metadata Repository.
+* Completely reworked Maven plugin (should fix many of previous issues and inconsistencies between main and test builds).
+* Added `classesDirectory`, `debug`, `fallback`, `verbose`, `sharedLibrary`, `configurationFileDirectories`, `excludeConfig`, `quickBuild`, and `jvmArgs` properties in order to match those present in the Gradle plugin.
++
+See <<maven-plugin.adoc#,docs>> for more information.
+* `useArgFile` is now set to true by default only on Windows.
+* Changed lookup order for `native-image` discovery -- `GRAALVM_HOME`, `JAVA_HOME`, `PATH`.
+
+=== Release 0.9.11
+
+==== Maven plugin
+
+* Fix long classpath issue under Windows when running native tests
+* Inherit environment variables and system properties from the surefire plugin configuration when executing tests
+* Fix invocation of `native-image` when classpath contains spaces
+
+==== Gradle plugin
+
+* Add support for environment variables in native test execution
+* Fix invocation of `native-image` when classpath contains spaces
+* Add experimental support for the JVM reachability metadata repository
+
+=== Release 0.9.10
+
+==== Maven plugin
+
+* Native testing support can now be explicitly disabled via `skipNativeTests`.
+   - See <<maven-plugin.adoc#testing-support-disabling, Disabling testing support>> for details.
+* Fixed race condition which prevented the agent files to be generated properly if tests were executed concurrently
+* Documented version compatibility for the JUnit Platform and Maven Surefire plugin.
+   - See <<maven-plugin.adoc#testing-support-version-compatibility, Version compatibility>> for details.
+* Add support for long classpath by using an argument file when invoking `native-image`
+
+==== Gradle plugin
+
+* Fixed `nativeRun` not working properly under Windows
+* Fixed race condition which prevented the agent files to be generated properly if tests were executed concurrently
+* Add support for long classpath by using an argument file when invoking `native-image`
+
+=== Release 0.9.9
+
+==== Gradle plugin
+
+* Fixed resource inference not working on custom binaries
+* Fixed `disableToolchainDetection` not working if a GraalVM installation isn't present. Please use `graalvmNative.toolchainDetection.set(false)` instead.
+
+=== Release 0.9.8
+
+==== Gradle plugin
+
+* [Breaking change] The `agent` option has been replaced with an `agent { ... }` configuration block which includes an `enabled` property.
+* Toolchain support can now be disabled altogether, which can be useful when using GraalVM Enterprise Edition.
+  - See <<gradle-plugin.adoc#configuration-toolchains-disabling, Disabling toolchain detection>> for details.
+* Fixed a bug when using a _fat jar_ which assumed that all entries to be repackaged were jars.
+* Agent options are now configurable.
+   - Note that the `experimental-class-loader-support` agent option is no longer added by default.
+   - See <<gradle-plugin.adoc#agent-support-configuring-options, Configuring agent options>> for details.
+* Added an option to perform resource detection in classpath entries which contain a `native-image/resource-config.json` file.
+
+==== Maven plugin
+
+* The agent can now be enabled in the POM.
+  - See <<maven-plugin.adoc#agent-support-enabling, Enabling the agent>> for details.
+* Agent options are now configurable.
+   - Note that the `experimental-class-loader-support` agent option is no longer added by default.
+   - See <<maven-plugin.adoc#agent-support-configuring-options, Configuring agent options>> for details.
+* Added an option to perform resource detection in classpath entries which contain a `native-image/resource-config.json` file.
+
+==== JUnit Platform Native
+
+* Builds now correctly fail if a container-level extension or lifecycle method fails --
+  for example, if an `@BeforeAll` method in a JUnit Jupiter test class throws an exception.
+* Builds no longer fail when tests are aborted -- for example, via a failed assumption.
+* Improved documentation for JUnit Platform and Maven Surefire support in the plugins.
+
+=== Release 0.9.7.1
+
+==== Bugfixes
+
+- Fixed https://github.com/graalvm/native-build-tools/issues/144[Maven plugin configuration not applied if declared in a parent POM].
+
+=== Release 0.9.7
+
+Release didn't include any fixes.
+
+=== Release 0.9.6
+
+==== Upgrade to JUnit 5.8
+
+The plugins now depend on JUnit 5.8 which provides an official test listener which is used by these plugins.
+As a consequence, Maven users will have to configure their builds to enable the plugin extensions:
+
+```xml
+<plugin>
+    <groupId>org.graalvm.buildtools</groupId>
+    <artifactId>native-maven-plugin</artifactId>
+    <version>${native.maven.plugin.version}</version>
+    <extensions>true</extensions>
+    ...
+</plugin>
+```
+
+The dependency on `junit-platform-native` which used to be required pre-0.9.6 can now safely be removed.
+
+For Gradle users, there's no impact on the configuration, however a good consequence is that the `junit-native-platform` dependency no longer leaks into your application's classpath.
+
+==== Agent support for Maven plugin
+
+The Maven plugin now supports the GraalVM agent to generate configuration files.
+Please refer to the <<maven-plugin.adoc#agent-support,Maven plugin documentation>> for details.
+
+==== Disabling testing support
+
+The Gradle plugin now provides an option to disable testing support.
+This can be useful if the test framework you are using doesn't work with this plugin or that you simply don't want to execute tests natively.
+
+To disable tests, use the `graalvmNative` configuration block:
+
+```kotlin
+graalvmNative {
+    testSupport.set(false)
+}
+```
+
+==== Configuring additional test images
+
+The Gradle plugin now supports building multiple test images, which can be used to execute tests natively for more kinds of tests: integration tests, functional tests, ...
+
+For more information, please refer to <<gradle-plugin.adoc#extra-test-suites,the Gradle plugin documentation>>
+
+=== Release 0.9.5
+
+This release contains, in preparation for supporting more images in the Gradle plugin:
+
+- The `nativeBuild` and `nativeTest` extensions are now deprecated. A top-level container for configuring native images has been introduced. Instead of:
+
+[source,groovy]
+----
+nativeBuild {
+   verbose = true
+}
+----
+
+you need to use:
+
+[source,groovy]
+----
+graalvmNative {
+  binaries {
+    main {
+      verbose = true
+    }
+  }
+}
+----
+
+and instead of:
+
+[source,groovy]
+----
+nativeTest {
+    buildArgs("...")
+}
+----
+
+you need to use:
+
+[source,groovy]
+----
+graalvmNative {
+  binaries {
+    test {
+      verbose = true
+    }
+  }
+}
+----
+
+- The `nativeBuild` task has been renamed to `nativeCompile`.
+- The `nativeTestBuild` task has been renamed to `nativeTestCompile`.
+
+Both `nativeBuild` and `nativeTestBuild` task invocations are still supported but deprecated and will be removed in a future release.
+
+=== Release 0.9.4
+
+This release works around a limitation for Windows users who encounter an issue with long classpath entries on CLI: the Gradle plugin will now automatically handle this problem by creating a fat jar instead of passing all entries on classpath (this behavior can be <<gradle-plugin.adoc#long_classpath_and_fat_jar_support, disabled>>) if needed).
+Maven users will have to <<maven-plugin.adoc#long_classpath_and_shading_support, configure their build differently>> to use shading.
+
+In addition to this, we're now publishing development snapshots of this plugin. For Gradle, you will need to declare this repository in your settings.gradle(.kts) file:
+
+[source,groovy]
+----
+pluginManagement {
+    plugins {
+        id 'org.graalvm.buildtools.native' version '0.9.5-SNAPSHOT'
+    }
+    repositories {
+        maven {
+            url "https://raw.githubusercontent.com/graalvm/native-build-tools/snapshots"
+        }
+        gradlePluginPortal()
+    }
+}
+----
+
+For Maven, you need to use this repository configuration:
+
+[source,xml]
+----
+<pluginRepositories>
+    <pluginRepository>
+        <id>graalvm-native-build-tools-snapshots</id>
+        <name>GraalVM native-build-tools Snapshots</name>
+        <url>https://raw.githubusercontent.com/graalvm/native-build-tools/snapshots</url>
+        <releases>
+            <enabled>false</enabled>
+        </releases>
+        <snapshots>
+            <enabled>true</enabled>
+        </snapshots>
+    </pluginRepository>
+</pluginRepositories>
+----
+
+=== Release 0.9.3
+
+This release contains:
+
+- Fix for mainClass not being optional (Gradle plugin)
+- Fix for Gradle < 7 failing to determine GraalVM toolchain
+- Gradle plugin now registers proper groups
+- Automatic native-image tool fetching via gu (Gradle plugin)
+- FIxed issue where nativeTest would fail when tests are annotated with Timeout
+- Added a sharedLibrary configuration option for Gradle plugin
+- Removed broken server configuration option from Gradle plugin
+- Added a documentation website with proper CI integration
+
+In addition to those improvements, several behind-the-scenes changes were made:
+
+- Introduced "Dockerless" Maven plugin functional testing
+- Parallelized Gradle testing in CI
+- Replaced groovy-json with jackson-databind for JSON handling
+- Fixed Github Actions syntax to enable manual workflow invoking
+
+=== Release 0.9.2
+
+This release contains:
+
+- Revamped Gradle plugin that is now a lot more idiomatic.
+- Fixes for several issues regarding JUnit testing.
+- Removal of Test Discovery mode from the Maven plugin.
+- Fix for Maven creating empty test images when no tests are present.
+- Added support for Kotlin tests in Gradle.
+
+In addition to those improvements, several behind-the-scenes changes were made in order to ensure better compatibility moving forward:
+
+- Test coverage has been greatly improved for all subprojects.
+- Build tooling for this repository has been improved significantly.
+
+Note that there has been a breaking change in the Gradle plugin - `persistConfig` configuration option was removed.
+Using said option will cause existing builds to break, so users are advised to remove it from their configuration prior to upgrading.
+System property `-DpersistConfig` will have no effect going forward.
+
+=== Release 0.9.1
+
+This release contains:
+
+- Fixes for most of the known issues regarding Gradle and Maven plugins
+- Massively improved automatic JUnit support as well as initial JUnit Vintage support
+- Improved JavaDoc and tests for the Gradle plugin
+
+=== Release 0.9.0
+
+Initial release
diff --git a/docs/src/docs/asciidoc/img/GraalVM-rgb.svg b/docs/src/docs/asciidoc/css/images/GraalVM-icon.svg
similarity index 100%
rename from docs/src/docs/asciidoc/img/GraalVM-rgb.svg
rename to docs/src/docs/asciidoc/css/images/GraalVM-icon.svg
diff --git a/docs/src/docs/asciidoc/css/images/Grabbit.svg b/docs/src/docs/asciidoc/css/images/Grabbit.svg
new file mode 100644
index 000000000..2242e9970
--- /dev/null
+++ b/docs/src/docs/asciidoc/css/images/Grabbit.svg
@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   id="svg15"
+   version="1.2"
+   viewBox="0 0 450.59 377"
+   height="377pt"
+   width="450.59pt">
+  <metadata
+     id="metadata21">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <defs
+     id="defs19" />
+  <g
+     id="surface1">
+    <path
+       id="path2"
+       d="M 129.121094 297.835938 C 129.121094 297.835938 144.878906 297.871094 144.902344 297.851562 C 157.226562 297.851562 158.605469 291.367188 163.925781 284.695312 C 169.238281 278.023438 172.046875 274.863281 175.308594 277.339844 C 186.769531 286.523438 196.308594 293.503906 204.65625 287.21875 C 219.777344 275.636719 226.453125 247.25 240.605469 230.929688 C 243.910156 226.707031 251.285156 220.441406 254.792969 216.394531 C 256.4375 214.660156 255.492188 213.015625 253.796875 214.035156 C 246.660156 218.828125 230.574219 229.3125 218.664062 251.460938 C 207.660156 271.53125 199.710938 278.382812 190.832031 273.0625 C 186.28125 270.519531 183.484375 266.859375 177.296875 262.527344 C 171.105469 258.195312 165.070312 267.078125 161.890625 270.261719 C 158.707031 273.445312 152.230469 282.667969 146.660156 283.726562 C 141.089844 284.789062 134.855469 283.199219 131.011719 290.890625 C 128.757812 295.265625 129.121094 297.835938 129.121094 297.835938 "
+       style=" stroke:none;fill-rule:nonzero;fill:rgb(17.205811%,45.355225%,57.627869%);fill-opacity:1;" />
+    <path
+       id="path4"
+       d="M 274.871094 143.382812 C 281.359375 152.117188 280.878906 159.570312 275.632812 166.640625 C 271.898438 172.289062 269.621094 177.007812 268.898438 184.65625 C 267.945312 197.285156 277.511719 208.917969 288.972656 210.0625 C 294.71875 210.300781 299.691406 208.394531 303.777344 204.355469 C 317.332031 190.953125 317.269531 158.3125 317.175781 153.386719 L 323.085938 153.3125 C 323.695312 154.878906 325.714844 159.636719 329.832031 165.734375 C 344.996094 188.1875 357.59375 193.691406 367.683594 191.648438 C 374.59375 190.066406 354.570312 175.367188 352.945312 173.804688 C 351.316406 172.238281 352.371094 170.9375 355.277344 172.574219 C 356.207031 173.097656 394.753906 193.136719 383.238281 201.558594 C 373.578125 208.148438 357.1875 206.378906 344.800781 195.828125 C 332.285156 184.796875 321.695312 163.429688 321.59375 163.214844 L 320.90625 161.824219 C 320.90625 161.824219 320.8125 161.632812 320.804688 161.84375 C 320.824219 162.550781 320.875 164.578125 320.886719 165.058594 C 321.488281 198.320312 311.027344 216.160156 291.09375 218.082031 C 275.964844 219.261719 258.527344 208.148438 256.289062 189.621094 C 253.769531 162.871094 271.230469 146.484375 274.871094 143.382812 "
+       style=" stroke:none;fill-rule:nonzero;fill:rgb(17.205811%,45.355225%,57.627869%);fill-opacity:1;" />
+    <path
+       id="path6"
+       d="M 132.457031 82.34375 C 132.457031 82.34375 134.9375 77.589844 141.382812 80.5625 C 146.453125 83.015625 156.835938 93.605469 167.875 116.101562 C 187.394531 156.71875 182.722656 136.316406 173.707031 114.960938 C 169.964844 106.09375 165.625 97.347656 160.832031 90.339844 C 155.980469 83.25 148.101562 74.710938 141.332031 70.878906 C 131.078125 65.164062 128.824219 70.761719 129.539062 76.082031 C 129.9375 79.402344 132.457031 82.34375 132.457031 82.34375 "
+       style=" stroke:none;fill-rule:nonzero;fill:rgb(17.205811%,45.355225%,57.627869%);fill-opacity:1;" />
+    <path
+       id="path8"
+       d="M 68.125 301.890625 C 71.769531 297.457031 75.09375 295.816406 83.476562 295.816406 C 91.957031 295.816406 94.695312 293.457031 101.785156 280.050781 C 109.621094 265.230469 117.128906 260.332031 123.769531 256 C 129.835938 252.597656 138.390625 248.269531 142.574219 237.964844 C 143.472656 235.980469 144.640625 232.734375 145.988281 228.976562 L 146.085938 228.707031 C 147.582031 224.535156 149.335938 219.65625 151.175781 215.242188 L 151.195312 215.332031 C 151.195312 215.332031 156.878906 200.898438 154.265625 220.445312 C 153.089844 229.242188 153.621094 234.796875 154.558594 238.289062 C 155.425781 240.695312 156.941406 243.292969 159.605469 245.558594 C 163.289062 248.695312 158.621094 247.125 152.34375 249.617188 C 150.886719 250.191406 149.421875 251.222656 147.921875 252.480469 C 144.257812 256.28125 139.507812 260.316406 133.855469 263.214844 C 119.125 270.757812 111.300781 285.664062 106.332031 292.035156 L 105.011719 293.941406 C 98.078125 303.964844 94.261719 309.480469 86.664062 309.480469 C 86.664062 309.480469 65.621094 309.5 65.605469 309.480469 C 65.652344 308.253906 65.96875 304.523438 68.125 301.890625 "
+       style=" stroke:none;fill-rule:nonzero;fill:rgb(17.205811%,45.355225%,57.627869%);fill-opacity:1;" />
+    <path
+       id="path10"
+       d="M 211.335938 138.335938 C 220.390625 123.707031 239.277344 107.480469 263.789062 107.480469 C 265.339844 107.480469 266.921875 107.546875 268.519531 107.683594 C 268.542969 107.683594 268.5625 107.691406 268.578125 107.691406 C 272.132812 102.058594 277.394531 94.703125 281.785156 92.59375 C 286.890625 90.144531 293.699219 92.070312 295.945312 99.085938 C 297.476562 103.867188 296.277344 112.890625 294.925781 111.921875 C 293.203125 110.6875 293.394531 94.8125 284.871094 100.171875 C 281.578125 102.25 279.085938 107.828125 278.28125 109.8125 C 287.378906 112.632812 294.257812 117.507812 298.808594 124.367188 C 301.726562 128.988281 306.484375 139.445312 303.355469 152.113281 C 301.972656 157.714844 301.15625 150.773438 299.652344 143.484375 C 298.253906 137.347656 296.453125 130.519531 289.355469 124.65625 C 282.257812 118.792969 271.765625 115.121094 259.332031 116.492188 C 247.289062 117.847656 236.492188 123.789062 228.507812 133.230469 C 226.53125 135.5625 221.78125 142.609375 220.894531 143.976562 C 215.578125 152.183594 212.535156 156.863281 202.039062 156.757812 C 203.714844 152.304688 206.554688 146.058594 211.335938 138.335938 "
+       style=" stroke:none;fill-rule:nonzero;fill:rgb(17.205811%,45.355225%,57.627869%);fill-opacity:1;" />
+    <path
+       id="path12"
+       d="M 113.242188 74.050781 C 118.914062 77.527344 125.882812 83.1875 133.339844 91.917969 C 141.484375 101.464844 150.808594 114.832031 161.050781 131.65625 C 167.015625 141.449219 168.75 147.128906 168.429688 147.800781 C 168.421875 147.800781 168.421875 147.800781 168.421875 147.800781 C 168.257812 147.800781 166.089844 147.523438 156.449219 134.0625 C 135.191406 103.183594 116.535156 82.734375 112.007812 85.324219 L 111.992188 85.332031 C 111.453125 85.667969 111.167969 86.363281 111.152344 87.402344 C 111.5 99.507812 137.265625 145.039062 174.089844 166.699219 C 168.710938 180.355469 170.699219 191.742188 176.917969 202.984375 C 181.179688 210.6875 196.828125 226.492188 211.28125 222.363281 C 225.738281 218.230469 221.183594 178.183594 197.414062 170.136719 C 190.617188 168.054688 186.324219 172.3125 184.804688 178.058594 C 183.367188 183.484375 184.035156 190.148438 184.496094 193.320312 C 184.664062 194.476562 184.128906 194.148438 183.816406 193.640625 C 175.144531 179.40625 181.746094 166.757812 189.84375 164.199219 C 199.296875 161.214844 212.183594 167.988281 219.972656 180.816406 C 232.496094 203.230469 226.597656 222.210938 216.566406 228.210938 C 198.546875 239.226562 169.078125 220.003906 162.910156 197.417969 C 160.597656 188.027344 162.023438 178.308594 165.507812 170.402344 C 113.253906 134.066406 101.527344 99.984375 99.207031 82.835938 C 97.949219 71.589844 105.679688 69.417969 113.242188 74.050781 "
+       style=" stroke:none;fill-rule:nonzero;fill:rgb(17.205811%,45.355225%,57.627869%);fill-opacity:1;" />
+  </g>
+</svg>
diff --git a/docs/src/docs/asciidoc/css/multi-lang-sample.css b/docs/src/docs/asciidoc/css/multi-lang-sample.css
index df018b2b1..0bdc9b565 100644
--- a/docs/src/docs/asciidoc/css/multi-lang-sample.css
+++ b/docs/src/docs/asciidoc/css/multi-lang-sample.css
@@ -52,20 +52,20 @@
 
 
 .multi-language-selector .language-option[data-lang='groovy'],
+.multi-language-selector .language-option.selected[data-lang='groovy'],
 .exampleblock[data-lang=groovy] > .content .title {
     background-image: url('data:image/svg+xml;base64,<svg
   xmlns="http://www.w3.org/2000/svg"
   width="614.06085"
   height="303.5986"
   version="1.1">
  <g
     transform="translate(-35.396599,-30.558196)">
    <path
       d="m 154.97687,332.69162 c 0,-0.80587 10.83123,-18.62172 24.0694,-39.59076 13.23819,-20.96905 22.66057,-38.62066 20.93867,-39.22577 -1.72191,-0.6051 -7.67992,0.48567 -13.24002,2.42393 -16.74524,5.83743 -20.18605,4.29016 -32.69308,-14.70155 -13.53265,-20.54906 -14.01724,-22.66983 -6.96158,-30.46624 4.60876,-5.09256 4.33159,-6.27967 -3.2319,-13.84316 -4.55009,-4.5501 -8.27289,-9.64309 -8.27289,-11.31776 0,-2.81679 -30.99145,-15.58933 -79.989496,-32.96615 -11.10966,-3.93997 -20.199375,-7.82928 -20.199375,-8.64291 0,-0.81366 23.470738,-1.00476 52.157191,-0.42469 l 52.15721,1.05466 5.09127,-8.03001 c 21.51644,-33.93592 54.00952,-64.588212 68.46705,-64.588212 3.0106,0 9.12141,2.86918 13.57953,6.375945 7.25946,5.710283 8.2565,9.248632 9.54994,33.891967 0.7943,15.13382 2.42422,28.49601 3.62198,29.69379 1.19775,1.19776 4.99769,-0.37425 8.44431,-3.49339 4.4014,-3.98323 9.03484,-5.06313 15.56761,-3.6283 6.76756,1.48641 10.6271,0.46895 14.16938,-3.73543 5.3136,-6.30666 31.90596,-48.937201 31.90596,-51.148744 0,-0.751588 5.26509,-9.757306 11.70023,-20.012703 6.43509,-10.255397 13.84664,-22.080631 16.47007,-26.278283 4.66558,-7.465201 5.3966,-6.581735 33.42692,40.398736 28.94121,48.507164 44.51767,66.406554 52.3157,60.117634 5.442,-4.38889 34.00055,-4.63794 41.98246,-0.36614 4.53665,2.42793 7.41916,2.3961 9.92484,-0.10962 5.20007,-5.20006 17.64982,-4.29437 20.90412,1.52078 2.56393,4.58146 3.21784,4.58146 7.02014,0 2.30606,-2.77867 9.13619,-5.05208 15.17803,-5.05208 8.53884,0 11.79336,1.77367 14.61403,7.96437 l 3.62881,7.96436 56.09203,-1.9858 c 30.85062,-1.09222 56.09204,-1.28688 56.09204,-0.43255 0,0.85427 -22.90608,10.07195 -50.90241,20.48371 -27.99632,10.41172 -51.367,19.24305 -51.93484,19.62512 -0.56785,0.38207 0.69847,9.49273 2.81405,20.24588 5.50457,27.97917 1.91458,46.62589 -11.92629,61.94604 -6.209,6.87263 -16.28338,14.14395 -22.38753,16.15849 -6.10415,2.01454 -11.09844,4.38614 -11.09844,5.27019 0,0.88406 6.51525,11.67893 14.47835,23.98859 7.96309,12.30969 13.2828,22.38125 11.82152,22.38125 -2.38504,0 -60.46987,-22.44238 -150.78898,-58.2607 -17.809,-7.06258 -34.02683,-12.84109 -36.03961,-12.84109 -3.75363,0 -36.1669,12.28662 -131.22423,49.74206 -55.12525,21.72103 -57.29217,22.47348 -57.29217,19.89451 z m 113.11648,-51.25265 c 29.32949,-11.39506 58.41657,-22.5308 64.63798,-24.74607 10.70068,-3.81019 14.27918,-2.85493 66.25394,17.68634 30.21825,11.94274 60.03252,23.57587 66.25392,25.85134 6.22141,2.27552 19.04317,7.22059 28.49275,10.98908 10.77503,4.29704 16.28251,5.33166 14.77108,2.77484 -16.8837,-28.56113 -17.3998,-29.03716 -29.10083,-26.84205 -14.11361,2.64772 -22.87897,-0.0685 -27.38369,-8.48554 -2.92112,-5.45816 -2.02944,-8.12759 5.25442,-15.73031 10.84887,-11.32377 9.14457,-21.74144 -4.84429,-29.61099 -5.36764,-3.01959 -12.14059,-10.48372 -15.05102,-16.58697 l -5.29169,-11.09682 -11.34551,7.69928 c -13.94458,9.46304 -30.95062,9.95063 -45.14764,1.29448 l -10.46488,-6.38065 -12.15841,8.26284 c -12.17462,8.27386 -26.19108,9.3428 -40.43752,3.08392 -3.92498,-1.72439 -5.65583,-1.05415 -5.65583,2.19008 0,2.57118 -3.70429,6.36265 -8.23181,8.42553 -13.5742,6.18479 -26.82107,4.54247 -35.80229,-4.43875 l -8.18944,-8.18944 -6.60982,8.40303 c -3.63539,4.62166 -12.04952,11.83698 -18.69805,16.03398 -8.22965,5.19518 -18.41741,17.87182 -31.9164,39.71361 -10.90549,17.64546 -19.82816,32.98042 -19.82816,34.07776 0,1.0973 8.36255,-1.52736 18.58342,-5.83259 10.22089,-4.30521 42.58028,-17.15087 71.90977,-28.54593 z m 248.76729,-12.25846 c 22.25557,-12.50833 27.41424,-35.64808 17.57685,-78.84318 -8.2214,-36.09961 -12.3255,-47.91327 -17.19494,-49.49597 -3.36902,-1.09503 -3.88674,0.10699 -1.98858,4.61635 12.31516,29.25771 12.99963,43.94662 2.24022,48.07541 -7.39151,2.83642 -15.23239,-7.79075 -21.39902,-29.00326 -4.77512,-16.42587 -9.76861,-23.82837 -13.53387,-20.06311 -0.90157,0.9016 0.67848,6.12117 3.51124,11.59913 2.83273,5.4779 6.71721,21.97455 8.63217,36.6592 1.91497,14.68462 5.61385,30.06073 8.21973,34.16912 6.77198,10.67661 17.55128,8.1036 24.52382,-5.85384 6.89373,-13.79975 7.67284,-4.60781 0.9693,11.43602 -6.96074,16.65937 -27.63442,21.65481 -51.58418,12.46442 -3.8333,-1.47096 -5.13039,0.0515 -5.13039,6.02097 0,4.39431 -2.93618,11.72245 -6.52488,16.2847 l -6.52488,8.29506 8.94881,1.51123 c 15.44945,2.60909 36.63328,-0.77642 49.2586,-7.87225 z m -320.3665,-27.53733 c 46.45965,-13.3545 54.76188,-28.93093 39.32885,-73.78782 -3.58185,-10.41079 -6.51243,-21.60971 -6.51243,-24.88654 0,-11.15712 -5.61152,-6.00161 -9.81713,9.01943 -5.56203,19.86561 -22.29115,36.75053 -36.34516,36.68364 -12.20547,-0.0582 -16.18251,-2.28008 -21.22378,-11.85768 -9.04748,-17.18882 0.81469,-43.56797 25.96954,-69.46272 18.42431,-18.966304 28.48893,-20.683965 28.48893,-4.86205 0,24.6732 -17.01134,60.9947 -25.97309,55.45604 -4.38205,-2.70826 -3.67138,-14.66752 1.41722,-23.85009 4.32735,-7.80882 3.44814,-19.70771 -1.4562,-19.70771 -5.68689,0 -16.94547,20.71196 -18.43318,33.91074 -1.31515,11.66826 -0.49286,14.50545 5.06652,17.48072 19.48244,10.4267 45.00531,-21.39545 46.29083,-57.71584 0.67504,-19.073181 -3.01676,-24.441105 -14.77906,-21.488951 -17.11879,4.296543 -63.23483,63.786641 -63.23483,81.573461 0,13.9128 6.98737,23.69728 19.28827,27.0096 20.91419,5.63162 41.13539,-4.37389 55.4633,-27.44338 l 6.02175,-9.69571 0.0132,13.17223 c 0.0162,19.0738 -12.42619,29.1274 -51.69817,41.76793 -9.77649,3.1468 -18.18332,6.05441 -18.6818,6.46137 -1.82056,1.48632 16.68739,27.47571 19.56644,27.47571 1.63262,0 11.19115,-2.36359 21.24123,-5.25238 z M 476.411,217.96301 c 4.66347,-5.1531 5.48551,-10.75103 4.48579,-30.54823 -1.08739,-21.53331 -2.27746,-25.33851 -10.66143,-34.08949 -15.14882,-15.81194 -33.86123,-11.77828 -22.90819,4.93814 5.82256,8.88637 12.9254,7.36864 10.41641,-2.22581 -1.99864,-7.64276 1.72998,-7.84358 8.22839,-0.44322 12.19301,13.88537 9.11534,33.12698 -5.2986,33.12698 -9.86716,0 -12.94195,-4.23176 -19.37353,-26.66318 -2.93059,-10.22087 -6.49964,-18.58343 -7.93127,-18.58343 -4.76899,0 -6.89287,4.20878 -3.92721,7.7824 1.61088,1.9411 6.07218,15.89127 9.91404,31.00041 9.66903,38.02596 23.17666,51.04145 37.0556,35.70543 z m -183.77125,0.60395 c 1.98978,-1.335 2.89975,-7.64893 2.07865,-14.423 -1.32449,-10.92702 -2.06662,-11.7241 -7.9727,-8.56327 -8.48733,4.54227 -17.60839,-4.06351 -20.70222,-19.5326 -2.34707,-11.73538 -3.06526,-11.50489 14.02576,-4.50149 2.14288,0.87808 7.59671,-2.10402 12.11963,-6.62694 8.27408,-8.27408 10.99802,-18.21299 4.99156,-18.21299 -1.77754,0 -3.2319,1.45436 -3.2319,3.2319 0,4.64923 -8.84231,3.98982 -10.83465,-0.80797 -1.16224,-2.79879 -3.63807,-1.80591 -8.05915,3.2319 -3.50985,3.99948 -7.79673,7.27178 -9.52641,7.27178 -1.72969,0 -4.0656,-3.2723 -5.19088,-7.27178 -1.97195,-7.00856 -2.21366,-7.05277 -6.67737,-1.22169 -3.9106,5.10854 -3.94557,6.73583 -0.22461,10.45661 3.94062,3.94064 11.42615,30.87102 11.42615,41.10744 0,12.72867 17.52933,22.73832 27.7783,15.8621 z m 58.94309,-16.87531 c 12.14567,-12.14567 15.74452,-30.35143 9.12943,-46.18357 -5.17016,-12.37397 -14.14466,-17.00516 -26.79878,-13.82918 -9.40263,2.35991 -23.72311,29.77659 -23.77387,45.51536 -0.0792,24.52902 23.25053,32.69005 41.44322,14.49739 z m -22.08341,-19.43407 c -3.5551,-3.5551 -6.41755,-10.46328 -6.36102,-15.35153 0.0934,-8.07965 0.49315,-8.3735 4.39619,-3.2319 4.82464,6.35569 13.39797,7.45666 16.68241,2.14232 1.19432,-1.93241 0.55295,-5.13202 -1.4252,-7.11017 -5.08132,-5.08132 -4.46561,-11.99963 1.06792,-11.99963 6.15137,0 14.72679,12.51477 14.72679,21.49191 0,6.60674 -13.4444,20.5228 -19.82724,20.5228 -1.53785,0 -5.70476,-2.90872 -9.25985,-6.4638 z m 86.34897,18.58341 c 13.41074,-14.60263 12.10376,-37.098 -3.09825,-53.32634 -7.85057,-8.3806 -25.29298,-9.82552 -32.43185,-2.68664 -6.58761,6.58761 -13.16465,32.49303 -10.72122,42.22841 5.21122,20.76318 32.40041,28.86652 46.25132,13.78457 z m -27.45565,-23.61452 c -5.30623,-3.71664 -7.12941,-8.14974 -6.97806,-16.96747 0.16935,-9.86033 0.6843,-10.74981 2.96145,-5.11415 3.34573,8.28032 10.36292,11.40734 16.51814,7.3609 3.81753,-2.50963 3.63929,-3.69597 -1.10104,-7.32907 -6.32189,-4.84523 -7.55508,-11.70191 -2.10465,-11.70191 4.87364,0 22.30402,19.06666 22.30402,24.39778 0,5.20316 -12.37739,14.38503 -19.39139,14.38503 -2.76405,0 -8.2579,-2.26402 -12.20847,-5.03111 z m 189.96292,-14.28887 33.93495,-12.73682 -36.35888,-0.13125 c -32.5392,-0.11736 -36.35424,0.46307 -36.31475,5.52475 0.0401,5.12757 3.33073,20.28395 4.3727,20.13967 0.23722,-0.0329 15.70177,-5.79124 34.36598,-12.79648 z m -443.49343,-2.2793 3.46825,-10.28761 -30.46686,-1.02404 c -16.756744,-0.56322 -30.463584,-0.13213 -30.45958,0.95804 0.0058,1.59513 52.50657,22.10707 53.66174,20.96552 0.18035,-0.1784 1.88892,-4.95372 3.79645,-10.61191 z m 208.9092,-31.88695 c 7.16667,1.146 15.24981,4.07924 17.96256,6.51835 4.21279,3.78783 6.04528,3.52966 12.56207,-1.76985 4.19643,-3.4125 9.65026,-6.20457 12.11963,-6.20457 2.46939,0 4.48982,-0.71308 4.48982,-1.58467 0,-3.00918 -46.53954,-79.21252 -48.31447,-79.10961 -2.085,0.120872 -49.78603,80.08798 -51.25464,85.92437 -0.61634,2.44952 1.31804,3.35371 5.07364,2.3716 3.33836,-0.873 7.95416,0.68326 10.25727,3.45836 3.7354,4.50087 5.26108,4.14229 14.13068,-3.32097 8.42647,-7.09041 11.9308,-8.0488 22.97344,-6.28301 z"
       style="fill:#333333;fill-opacity:1" />
    <path
       style="fill:#6398aa;fill-opacity:1;stroke:none"
       d="m 309.54579,140.87922 c -0.50075,-0.23311 -1.11804,-0.76799 -2.5278,-2.19035 -1.91188,-1.92897 -2.67188,-2.49013 -4.26108,-3.14628 -2.08791,-0.86204 -4.3549,-1.09423 -6.48231,-0.66391 -1.89808,0.38393 -2.42435,0.42527 -3.28242,0.2578 -1.43224,-0.27953 -1.94157,-1.14929 -1.53583,-2.62272 0.50573,-1.83657 4.33693,-8.94255 12.00899,-22.27387 15.5837,-27.078988 36.53624,-61.220968 38.85056,-63.306662 0.25631,-0.230994 0.265,-0.230994 0.52248,0 1.37768,1.235976 9.4762,13.725889 20.54036,31.678298 14.96696,24.285004 27.41102,45.643714 27.41102,47.047704 0,0.85729 -1.31608,1.37215 -4.08591,1.59845 -3.44226,0.28124 -7.42478,2.30188 -12.86887,6.52936 -2.58712,2.00898 -3.69126,2.75933 -4.95062,3.36438 -1.04928,0.50411 -1.13692,0.52437 -2.26854,0.52437 -1.11368,0 -1.22661,-0.0249 -2.09623,-0.46128 -0.51213,-0.25702 -1.50469,-0.9493 -2.24155,-1.56342 -2.17848,-1.81561 -4.79918,-3.13614 -9.07197,-4.57124 -5.42997,-1.82376 -11.24454,-2.9184 -16.19551,-3.04896 -3.90934,-0.10308 -5.71201,0.24798 -8.67602,1.68963 -2.41988,1.17698 -3.58621,2.01311 -9.12475,6.54145 -5.63376,4.60617 -7.63442,5.56205 -9.664,4.61725 z" />
    <path
       style="fill:#6398aa;fill-opacity:1;stroke:none"
       d="m 128.63786,170.739 c -10.159,-2.9607 -45.503171,-16.91962 -50.450924,-19.92523 -0.682916,-0.41484 -0.738098,-0.47787 -0.543207,-0.62038 1.131563,-0.82741 12.337983,-1.23901 25.004031,-0.91836 5.05131,0.12788 35.50132,1.13323 35.5509,1.17377 0.0997,0.0815 -6.52164,19.2888 -7.03051,20.39433 -0.21251,0.4617 -0.65063,0.44367 -2.53029,-0.10413 z" />
    <path
       style="fill:#6398aa;fill-opacity:1;stroke:none"
       d="m 543.69413,175.31055 c -1.3862,-2.71287 -3.88769,-14.97067 -3.96078,-19.40858 -0.0284,-1.72424 0.18667,-2.42741 0.9606,-3.1408 1.77378,-1.63501 5.37938,-2.2232 15.29017,-2.49434 5.00347,-0.13689 28.1019,-0.15796 44.41127,-0.0405 l 11.42859,0.0823 -27.5177,10.31427 c -25.09292,9.4054 -39.68473,14.84126 -40.22491,14.9849 -0.13517,0.036 -0.26981,-0.0674 -0.38724,-0.29723 l 0,0 z" />
    <path
       style="fill:#6398aa;fill-opacity:1;stroke:none"
       d="m 178.08835,315.51433 c 0,-0.77078 3.2689,-6.5331 11.55395,-20.36698 19.85118,-33.14631 28.92715,-45.16012 40.07292,-53.04429 9.97127,-7.05337 15.30279,-11.9294 21.24539,-19.43033 l 3.66409,-4.62492 4.9399,4.85652 c 8.64784,8.50189 13.8613,10.96668 23.29717,11.01432 11.54058,0.0583 24.17849,-6.3881 24.17849,-12.33299 0,-1.3398 0.95404,-2.72236 1.87857,-2.72236 0.39132,0 2.61686,0.68365 4.94565,1.51923 6.06992,2.1779 9.63028,2.96548 14.60912,3.23165 4.93998,0.26409 8.54848,-0.1704 13.35817,-1.60841 4.72561,-1.41288 7.44709,-2.85905 15.59833,-8.28882 4.1076,-2.73618 7.59954,-4.97487 7.75988,-4.97487 0.16033,0 3.12534,1.71896 6.5889,3.81991 3.46356,2.10095 7.62542,4.38133 9.24859,5.06751 11.06862,4.67918 23.02445,4.3739 33.97126,-0.86741 1.95795,-0.93747 6.56793,-3.73074 10.2444,-6.20727 3.67648,-2.47653 6.73613,-4.44576 6.79923,-4.37606 0.0631,0.0697 1.45605,2.9208 3.09544,6.33578 1.6394,3.41498 3.69895,7.2667 4.57679,8.55937 3.80001,5.59578 8.17588,9.75141 14.08343,13.37464 6.08122,3.72975 9.83206,8.6868 10.21882,13.50507 0.38367,4.77968 -1.70329,9.01939 -7.72189,15.68721 -4.69747,5.20419 -5.8733,7.2354 -5.86113,10.12491 0.0122,2.89262 1.70103,6.22854 4.66964,9.22379 4.80533,4.84844 12.34605,6.28777 23.43534,4.47319 2.47408,-0.40484 5.59479,-0.73757 6.93491,-0.73938 4.28551,-0.006 6.90319,2.09595 11.89251,9.54859 3.44351,5.14365 10.97396,17.75508 10.97396,18.37836 0,0.32407 -0.35145,0.55208 -0.85097,0.55208 -1.05109,0 -5.62314,-1.2438 -8.93214,-2.42994 -4.3485,-1.55875 -57.27238,-22.00526 -74.74786,-28.87795 -46.6635,-18.35162 -62.02805,-24.21246 -69.53657,-26.52489 -8.11417,-2.49895 -13.64029,-3.08522 -18.12661,-1.92306 -5.57996,1.44546 -81.72067,30.86888 -126.13245,48.74195 -21.93119,8.826 -24.67749,9.87577 -28.78116,11.00159 -3.26303,0.89521 -3.14407,0.88294 -3.14407,0.32426 z" />
  </g>
</svg>');
-    background-position: 16px 80%;
     background-repeat: no-repeat;
-    background-size: 20px 12px;
+    background-size: 25px 14px;
     padding-left: 2.5em;
 }
 
 .multi-language-selector .language-option[data-lang='kotlin'],
+.multi-language-selector .language-option.selected[data-lang='kotlin'],
 .exampleblock[data-lang=kotlin] > .content .title {
     background-image: url('data:image/svg+xml;base64,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');
-    background-position: 17px 80%;
     background-repeat: no-repeat;
-    background-size: 11px 11px;
+    background-size: 12px 12px;
     padding-left: 2.3em;
 }
 
@@ -108,8 +108,9 @@
 }
 
 .multi-language-selector .language-option {
-    background-color: white;
-    border: 1px solid #f7f7f8;
+    color: #ffc107;
+    border: 1px solid gray;
+    background: none;
     border-radius: 4px 4px 0 0;
     cursor: pointer;
     display: inline-block;
@@ -122,16 +123,14 @@
     text-align: center;
     filter: grayscale(1);
     -webkit-filter: grayscale(1);
-    opacity: 0.7;
 }
 
 .multi-language-selector .language-option.selected {
-    background-color: #f7f7f8;
-    color: #000000;
+    color: #ffc107;
+    border: 1px solid #ffc107;
     font-weight: bold;
     filter: none;
     -webkit-filter: none;
-    opacity: 1;
 }
 
 .multi-language-text.hidden,
@@ -149,8 +148,8 @@
 .copytoclipboard {
     font-family: "Open Sans";
     cursor: pointer;
-    background-color: lightgray;
-    color: #000000;
+    border: 1px solid #ffc107;
+    border-top: none;
     float: right;
     padding: 10px 15px;
     font-size: 10px;
@@ -159,3 +158,9 @@
     border-bottom-left-radius: 5px;
     border-bottom-right-radius: 5px;
 }
+
+.copytoclipboard:hover {
+    background: #ffc107;
+    color: #00758F;
+    font-weight: 600;
+}
diff --git a/docs/src/docs/asciidoc/css/page.css b/docs/src/docs/asciidoc/css/page.css
new file mode 100644
index 000000000..62ef99e25
--- /dev/null
+++ b/docs/src/docs/asciidoc/css/page.css
@@ -0,0 +1,74 @@
+body {
+    background: linear-gradient(rgba(0, 0, 0, 0.8), rgba(0, 0, 0, 0.85));
+    color: white;
+}
+
+#grabbit-logo {
+    position: absolute;
+    right: 0;
+    top: 0;
+    width: 150px;
+}
+
+#toc {
+    background: none !important;
+}
+
+#toc > #toctitle {
+    color: #ffc107;
+}
+
+#header > h1:first-child {
+    color: white;
+    font-weight: 600;
+}
+
+#header>.details {
+    color: white;
+}
+
+#preamble>.sectionbody>[class="paragraph"]:first-of-type p {
+    color: white;
+}
+
+h2, h3, h4, .title {
+    color: #ffc107 !important;
+}
+
+p {
+    color: white;
+}
+
+a {
+    color: #00a8cd;
+}
+
+a:hover {
+    color: #ffc107;
+}
+
+.listingblock >.content>pre:not(.highlight) {
+    color: white;
+    background: none;
+    border: 1px solid #ffc107;
+    border-radius: 4px;
+}
+
+:not(pre):not([class^=L])>code {
+    background: #00758F;
+    color: white;
+}
+
+.admonitionblock td.icon .icon-tip::before,
+.admonitionblock td.icon .icon-note::before,
+.admonitionblock td.icon .icon-warning::before {
+    color: white;
+}
+
+.admonitionblock>table td.content {
+    color: white;
+}
+
+#footer {
+    background: rgba(0, 0, 0, 0.2);
+}
diff --git a/docs/src/docs/asciidoc/docinfo-footer.html b/docs/src/docs/asciidoc/docinfo-footer.html
index 0ec25b33b..bde51b7e7 100644
--- a/docs/src/docs/asciidoc/docinfo-footer.html
+++ b/docs/src/docs/asciidoc/docinfo-footer.html
@@ -1,7 +1,8 @@
 <link rel="stylesheet" href="css/multi-lang-sample.css">
+<link rel="stylesheet" href="css/page.css">
 <script src="js/multi-lang-sample.js"></script>
 <div id="footer">
     <div id="footer-text">
-        <img src="img/GraalVM-rgb.svg" alt="GraalVM"> (c) {docyear}. Licensed under the Universal Permissive License (UPL), Version 1.0
+        <img src="css/images/GraalVM-rgb.svg" alt="GraalVM"> (c) {docyear}. Licensed under the Universal Permissive License (UPL), Version 1.0
     </div>
 </div>
diff --git a/docs/src/docs/asciidoc/docinfo-header.html b/docs/src/docs/asciidoc/docinfo-header.html
new file mode 100644
index 000000000..917e239f9
--- /dev/null
+++ b/docs/src/docs/asciidoc/docinfo-header.html
@@ -0,0 +1,3 @@
+<div id="grabbit-logo">
+    <img src="css/images/Grabbit.svg" alt="">
+</div>
diff --git a/docs/src/docs/asciidoc/end-to-end-gradle-guide.adoc b/docs/src/docs/asciidoc/end-to-end-gradle-guide.adoc
new file mode 100644
index 000000000..6d1900935
--- /dev/null
+++ b/docs/src/docs/asciidoc/end-to-end-gradle-guide.adoc
@@ -0,0 +1,447 @@
+= Building Native Images with Gradle: An End-to-End Guide
+The GraalVM team
+:highlighjsdir: {gradle-relative-srcdir}/highlight
+
+This guide walks you through integrating the Gradle plugin for Native Image into your project.
+It starts from enabling the plugin, building the first native image, and running it.
+
+Then it takes you to more advanced use-cases such as plugin's configuration, applying optimizations, running native tests, and troubleshooting.
+If you are an advanced user, you can skip the getting started part and go directly to the advanced section.
+
+[[getting-started]]
+== Getting Started
+To compile your application ahead of time with https://www.graalvm.org/latest/reference-manual/native-image/[GraalVM Native Image] and Gradle, enable the Gradle plugin for Native Image building.
+The plugin requires that you https://www.graalvm.org/downloads/[install GraalVM].
+
+[NOTE]
+====
+A JDK version between 17 and 21 is required to execute Gradle (see the https://docs.gradle.org/current/userguide/compatibility.html[Gradle Compatibility Matrix]).
+====
+
+[[add-plugin]]
+=== Add the Plugin
+
+- Add the plugin declaration to your _build.gradle_ / _build.gradle.kts_ file inside the `plugins` block:
+
+[source,groovy,subs="verbatim,attributes", role="multi-language-sample"]
+----
+  id 'org.graalvm.buildtools.native' version '{gradle-plugin-version}'
+----
+
+[source,kotlin,subs="verbatim,attributes",role="multi-language-sample"]
+----
+  id("org.graalvm.buildtools.native") version "{gradle-plugin-version}"
+----
+
+All plugin versions are listed https://github.com/graalvm/native-build-tools/releases[here]
+
+[[run-your-project]]
+=== Build and Run Your Application
+
+This plugin works with the `application` plugin and registers a number of tasks and extensions for you to configure.
+
+- Build a native executable of your application.
+This command will compile your application and create a native executable in the _build/native/nativeCompile/_ directory:
+
+[source,bash,role="multi-language-sample"]
+----
+./gradlew nativeCompile
+----
+
+- Run the application from the native executable:
+
+[source,bash,role="multi-language-sample"]
+----
+./gradlew nativeRun
+----
+
+Continue reading below to learn more about the plugin.
+
+[[advanced-use-cases]]
+== Advanced Use Cases: How to
+
+For advanced use cases, this guide provides instructions for configuring the build process, running tests on native code, gathering execution profiles, troubleshooting missing configuration, and enabling diagnostic tools to analyze native images.
+
+[[configure-image-build]]
+=== Configure Native Image Build
+
+The plugin supports passing options directly to Native Image inside the `graalvmNative` block in the _build.gradle_ / _build.gradle.kts_ file.
+Using `buildArgs.add("<option>")`, you can pass any Native Image build option listed on https://www.graalvm.org/reference-manual/native-image/overview/Options/[this page].
+You can pass options to <<gradle-plugin.adoc#configure-native-image,configure the `main` or the `test` native binary>>, or both at the same time.
+
+The plugin also provides special properties to configure the build:
+
+- `mainClass` - Provides the main class to use, defaults to the `application.mainClass`
+- `imageName` - Specifies the name for the native executable file. If a custom name is not supplied, the artifact ID of the project will be used by default (defaults to the project name).
+- `jvmArgs` - Passes the given argument directly to the JVM running the `native-image` tool
+- `quickBuild` - Enables quick build mode
+- `verbose` - Enables the verbose output
+- and many more <<gradle-plugin.adoc#native-image-options,listed here>>.
+
+Here is an example of additional options usage:
+
+[source,groovy,subs="verbatim,attributes", role="multi-language-sample"]
+----
+graalvmNative {
+    binaries.all {
+        // common options
+        verbose = true
+    }
+
+    binaries.main {
+        // options to configure the main binary
+        imageName = 'myApp'
+        mainClass = 'org.example.Main'
+        buildArgs.add('-O3') // enables additional compiler optimizations
+    }
+
+    binaries.test {
+        // options to configure the test binary
+        quickBuild = true
+        debug = true
+    }
+}
+----
+
+[source,kotlin,subs="verbatim,attributes", role="multi-language-sample"]
+----
+graalvmNative {
+    binaries.all {
+        // common options
+        verbose.set(true)
+    }
+
+    binaries.main {
+        // options to configure the main binary
+        imageName.set('application')
+        mainClass.set('org.example.Main')
+        buildArgs.add('-O3')  // enables additional compiler optimizations
+    }
+
+    binaries.test {
+        // options to configure the test binary
+        quickBuild.set(true)
+        debug.set(true)
+    }
+}
+----
+
+[TIP]
+====
+As an alternative, you can pass additional build options via the `NATIVE_IMAGE_OPTIONS` environment variable, on the command line.
+This works similarly to `JAVA_TOOL_OPTIONS`, where the value of the environment variable is prefixed to the options supplied to `native-image`.
+====
+
+Learn more about Native Image build configuration https://www.graalvm.org/reference-manual/native-image/overview/BuildConfiguration/[on the website].
+
+[[run-junit-tests]]
+=== Run Junit Tests
+
+This plugin supports running tests on the JUnit Platform.
+The tests are compiled ahead of time and executed as native code.
+
+- Add the JUnit 5 dependency to _build.gradle_ / _build.gradle.kts_ to include the testing framework:
+
+[source,groovy,role="multi-language-sample"]
+----
+testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
+testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
+testImplementation 'junit:junit:4.13.2'
+----
+
+[source,kotlin,role="multi-language-sample"]
+----
+testImplementation('org.junit.jupiter:junit-jupiter-api:5.8.1')
+testRuntimeOnly('org.junit.jupiter:junit-jupiter-engine:5.8.1')
+testImplementation('junit:junit:4.13.2')
+----
+
+- Run the tests:
+
+[source,bash,role="multi-language-sample"]
+----
+./gradlew nativeTest
+----
+
+The tests are compiled ahead of time and executed as native code.
+
+[[gather-execution-profiles]]
+=== Gather Execution Profiles and Build Optimized Images
+
+You may want to gather profiling information from your application's execution to pinpoint areas of inefficiency.
+With this profiling data, you can also build an optimized native image.
+
+The technique for building native images optimized on profiles is called https://www.graalvm.org/latest/reference-manual/native-image/optimizations-and-performance/PGO/[Profile-Guided Optimization (PGO)].
+With PGO you can “train” your native application for specific workloads to improve performance and throughput.
+The PGO workflow includes three steps.
+
+[NOTE]
+====
+PGO is available in Oracle GraalVM.
+====
+
+Step 1: **Build an instrumented native image** by passing the `--pgo-instrument` option directly to the compile command:
+
+[source,bash, role="multi-language-sample"]
+----
+./gradlew nativeCompile --pgo-instrument
+----
+
+This generates a native executable under _build/native/nativeCompile_ with the _-instrumented_ suffix.
+
+Step 2: **Gather profiles** by running the instrumented executable.
+By default, the _default.iprof_ file, if not specified otherwise, is generated alongside the native executable.
+
+[source,bash, role="multi-language-sample"]
+----
+./build/native/nativeCompile/application-instrumented
+----
+
+Step 3. **Build an optimized native image with profiles**.
+This step involves copying the generated profile to the conventional directory, ensuring it is automatically used during the build process.
+Place the _default.iprof_ file in the _src/pgo-profiles/main_ directory, and then run:
+
+[source,bash, role="multi-language-sample"]
+----
+./gradlew nativeCompile
+----
+
+If everything was done properly, you will see _"PGO: user-provided"_ in the native image build output.
+Once the optimized image is built, run it:
+
+[source,bash, role="multi-language-sample"]
+----
+./gradlew nativeRun
+----
+
+The application's performance when running from this native executable should be comparable to, or even faster than, running on the JVM.
+Learn more about PGO https://www.graalvm.org/reference-manual/native-image/optimizations-and-performance/PGO/basic-usage[on the website].
+
+[[troubleshoot-missing-configuration]]
+=== Troubleshoot Missing Configuration
+
+[[detect-missing-metadata]]
+==== Detect Missing Metadata
+
+Quite possibly, your application relies on external libraries.
+If your application uses a well-supported framework such as Spring or Micronaut, its dependencies should be compatible with Native Image.
+Frameworks and libraries that support Native Image by default provide configurations in the https://github.com/oracle/graalvm-reachability-metadata[GraalVM Reachability Metadata Repository].
+When you build a native image, Native Build Tools reference this repository to apply the required configuration automatically.
+
+[TIP]
+====
+You can find an extensive list of libraries and frameworks from the Java ecosystem tested with Native Image on https://www.graalvm.org/native-image/libraries-and-frameworks/[this page].
+====
+
+However, it may happen, that your native image crashes at run time with a missing class or resource.
+To address this, start by checking if any required configuration is missing.
+
+The best way to detect missing metadata is by running your native tests.
+Alternatively, you can **identify missing configuration manually** using the following method.
+
+- Pass the `--exact-reachability-metadata` option to the `native-image` tool inside `graalvmNative` block of your _build.gradle_, as shown below:
+
+[source,groovy,subs="verbatim,attributes", role="multi-language-sample"]
+----
+graalvmNative {
+    binaries.all {
+        buildArgs.add('--exact-reachability-metadata')
+        runtimeArgs.add('-XX:MissingRegistrationReportingMode=Warn')
+    }
+}
+----
+
+[source,kotlin,subs="verbatim,attributes", role="multi-language-sample"]
+----
+graalvmNative {
+    binaries.all {
+        buildArgs.add('--exact-reachability-metadata')
+        runtimeArgs.add('-XX:MissingRegistrationReportingMode=Warn')
+    }
+}
+----
+
+[NOTE]
+====
+The `--exact-reachability-metadata` option was introduced in GraalVM for JDK 23. With older versions, use `-H:ThrowMissingRegistrationErrors=` instead.
+====
+
+- Rebuild and re-run the application:
+
+[source,bash, role="multi-language-sample"]
+----
+./gradlew nativeRun
+----
+
+- If there is any missing metadata printed to the console, **add it to the configuration file manually**, as described https://www.graalvm.org/reference-manual/native-image/metadata/#specifying-metadata-with-json[here], or **collect it automatically using the Tracing agent**.
+(See next.)
+
+- Rebuild your native image and test again.
+
+[[collect-metadata]]
+==== Collect Metadata Automatically with Tracing Agent
+
+Your application may use dynamic Java features such as reflection, serialization, or resource loading.
+It is also possible that a framework your application relies on uses a library dependency incompatible with Native Image.
+In such cases, additional metadata is required.
+
+The easiest way to collect this metadata is by using the https://www.graalvm.org/reference-manual/native-image/metadata/AutomaticMetadataCollection/[Tracing Agent].
+This agent tracks all usages of dynamic features during application execution on the JVM and generates the necessary configuration.
+
+The agent is disabled by default.
+You can enable it on the command line or inside the `graalvmNative` block in _build.gradle_ / _build.gradle.kts_.
+
+To enable the agent via the command line, pass the `-Pagent` option when running Gradle:
+
+[source,bash, role="multi-language-sample"]
+----
+./gradlew -Pagent run
+----
+
+[NOTE]
+====
+Enabling the agent via the command line only attaches it for a specific run; it does not automatically run every time you build the application.
+====
+
+To enable the agent inside the build configuration and collect missing metadata, do the following.
+
+Step 1: **Enable the agent** by setting `agent` to `true` in the `graalvmNative` block:
+
+[source,groovy,subs="verbatim,attributes", role="multi-language-sample"]
+----
+graalvmNative {
+    agent {
+        enabled = true
+    }
+}
+----
+
+[source,kotlin,subs="verbatim,attributes", role="multi-language-sample"]
+----
+graalvmNative {
+    agent {
+        enabled.set(true)
+    }
+}
+----
+
+From that point on, commands such as `run` or `test` will execute with the agent attached.
+For example you can execute the following command and the agent will be attached automatically:
+
+[source,bash, role="multi-language-sample"]
+----
+./gradlew run
+----
+
+By default, the agent creates the metadata in the _build/native/agent-output_ directory.
+
+Step 2: **Copy the generated metadata** from the default location, _build/native/agent-output_, to the resources directory, for example, _resources/META-INF/native-image_.
+Native Image automatically uses the metadata from this location.
+
+To do that with Gradle, configure and run the `metadataCopy` task.
+
+Add a new task named `metadataCopy` inside the `graalvmNative` block.
+Your `agent` configuration should look like this:
+
+[source,groovy,subs="verbatim,attributes", role="multi-language-sample"]
+----
+agent {
+    enabled = true
+    metadataCopy {
+        inputTaskNames.add("run")
+        outputDirectories.add("src/main/resources/META-INF/native-image/org.example")
+        mergeWithExisting = true
+    }
+}
+----
+
+[source,kotlin,subs="verbatim,attributes", role="multi-language-sample"]
+----
+agent {
+    enabled.set(true)
+    metadataCopy {
+        inputTaskNames.add("run")
+        outputDirectories.add("src/main/resources/META-INF/native-image/org.example")
+        mergeWithExisting.set(true)
+    }
+}
+----
+
+In this block:
+
+- `inputTaskNames` - specifies tasks previously executed with the agent attached (tasks that generated metadata in the last step)
+- `outputDirectories` - specifies the location where you want to copy the generated metadata
+- `mergeWithExisting` - specifies whether the metadata you want to copy should be merged with the metadata that already exists on the give location, or not. This only makes sense when there is already some existing metadata, created before.
+
+Step 3: Now that the `metadataCopy` task is configured, **run the metadataCopy task**:
+
+[source,bash,subs="verbatim,attributes", role="multi-language-sample"]
+----
+./gradlew metadataCopy
+----
+
+Step 4: Finally, **build the native image with the metadata**:
+
+[source,bash, role="multi-language-sample"]
+----
+./gradlew nativeCompile
+----
+
+Run it:
+
+[source,bash, role="multi-language-sample"]
+----
+./gradlew nativeRun
+----
+
+If your native image is successfully build, but still fails at run time, check the troubleshooting guide https://www.graalvm.org/reference-manual/native-image/guides/troubleshoot-run-time-errors/[Troubleshoot Native Image Run-Time Errors].
+
+Learn more about how to fine-tune the agent further <<gradle-plugin.adoc#native-image-tracing-agent,here>>.
+
+[[use-diagnostics-tools]]
+=== Use Diagnostics Tools
+
+If you need to diagnose the native applications you build, or monitor your Java application when launched from a native executable, Native Image offers tools for debugging and analyzing the produced binary.
+For example:
+
+[source,groovy, role="multi-language-sample"]
+----
+graalvmNative {
+    binaries.all {
+        buildArgs.add('--emit build-report')
+        buildArgs.add('--enable-monitoring=jfr')
+        debug = true
+    }
+}
+----
+
+[source,kotlin, role="multi-language-sample"]
+----
+graalvmNative {
+    binaries.all {
+        buildArgs.add('--emit build-report')
+        buildArgs.add('--enable-monitoring=jfr')
+        debug.set(true)
+    }
+}
+----
+
+- The `--emit build-report` option generates an HTML page report alongside the native executable that you can open in a browser.
+It provides broad information about each build stage as well as the generated binary’s contents.
+You can read more about Build Report features https://www.graalvm.org/latest/reference-manual/native-image/overview/build-report/[here].
+
+[NOTE]
+====
+Build Report is available in Oracle GraalVM.
+When running on GraalVM for JDK 21, pass the `-H:+BuildReport` option instead to generate a build report.
+====
+
+- The `--enable-monitoring=jfr` instructs the plugin to https://www.graalvm.org/reference-manual/native-image/guides/build-and-run-native-executable-with-jfr/[build a native executable with the JDK Flight Recorder (JFR) support].
+
+- The `<debug>` option generates a native executable with debug information for https://www.graalvm.org/reference-manual/native-image/guides/debug-native-image-process/[source-level debugging with the GNU Debugger (GDB)].
+
+All the monitoring and debugging tools https://www.graalvm.org/reference-manual/native-image/debugging-and-diagnostics/[listed on the website], can be enabled in the plugin configuration using `buildArgs`.
+
+=== Learn more
+
+To continue learning, refer to the <<changelog.adoc#,extensive reference documentation for the GraalVM Native Image Gradle plugin>>.
diff --git a/docs/src/docs/asciidoc/end-to-end-maven-guide.adoc b/docs/src/docs/asciidoc/end-to-end-maven-guide.adoc
new file mode 100644
index 000000000..0ebb621fb
--- /dev/null
+++ b/docs/src/docs/asciidoc/end-to-end-maven-guide.adoc
@@ -0,0 +1,503 @@
+= Building Native Images with Maven: An End-to-End Guide
+The GraalVM team
+:highlighjsdir: {maven-relative-srcdir}/highlight
+
+This guide walks you through integrating the Maven plugin for Native Image into your project.
+It starts from enabling the plugin, building the first native image, and running it.
+
+Then it takes you to more advanced use-cases such as plugin's configuration, applying optimizations, running native tests, and troubleshooting.
+If you are an advanced user, you can skip the getting started part and go directly to the advanced section.
+
+[[getting-started]]
+== Getting Started
+To compile your application ahead of time with https://www.graalvm.org/reference-manual/native-image/[GraalVM Native Image] and Maven, enable the Maven plugin for Native Image building. 
+The plugin requires that you https://www.graalvm.org/downloads/[install GraalVM].
+
+[[add-plugin]]
+=== Add the Plugin
+
+Add the plugin declaration to your _pom.xml_:
+
+[source,xml, role="multi-language-sample"]
+----
+<plugin>
+  <groupId>org.graalvm.buildtools</groupId>
+  <artifactId>native-maven-plugin</artifactId>
+  <version>${native.maven.plugin.version}</version>
+  <extensions>true</extensions>
+  <executions>
+    <execution>
+      <id>build-native</id>
+      <goals>
+        <goal>compile-no-fork</goal>
+      </goals>
+      <phase>package</phase>
+    </execution>
+  </executions>
+  <configuration>
+      <mainClass>org.example.Main</mainClass>
+  </configuration>
+</plugin>
+----
+
+For convenience, you can create a Maven profile and add the plugin into it:
+
+[source,xml, role="multi-language-sample"]
+----
+<profiles>
+  <profile>
+    <id>native</id>
+    <build>
+      <plugins>
+        <plugin>
+          <groupId>org.graalvm.buildtools</groupId>
+          <artifactId>native-maven-plugin</artifactId>
+          <version>${native.maven.plugin.version}</version>
+          <extensions>true</extensions>
+          <executions>
+            <execution>
+              <id>build-native</id>
+              <goals>
+                <goal>compile-no-fork</goal>
+              </goals>
+              <phase>package</phase>
+            </execution>
+          </executions>
+          <configuration>
+            <mainClass>org.example.Main</mainClass>
+          </configuration>
+        </plugin>
+      </plugins>
+    </build>
+  </profile>
+</profiles>
+----
+
+Replace `maven-plugin-version` with the latest released version.
+All plugin versions are listed https://github.com/graalvm/native-build-tools/releases[here].
+
+The `<mainClass>` tag provides the path to the application main class (the main entry point).
+Adjust the path according to your application sources.
+
+[[run-your-project]]
+=== Build and Run Your Application
+
+Once you registered the plugin, you can use the standard https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html[Maven phases].
+If you added the plugin inside the `native` profile, run your commands with the `-Pnative` option.
+
+- Build a native executable of your application.
+This command will compile your application and create a native executable in the _target/_ directory:
+
+[source,bash, role="multi-language-sample"]
+----
+./mvnw -Pnative package
+----
+
+- Run the application from the native executable:
+
+[source,bash, role="multi-language-sample"]
+----
+./target/myApp
+----
+
+You can have multiple profiles, which is very convenient if you want to produce different versions of your native images for your application (optimized, static, and others).
+Continue to advanced use cases to learn more.
+
+[[advanced-use-cases]]
+== Advanced Use Cases: How to
+
+For advanced use cases, this guide provides instructions for configuring the build process, running tests on native code, gathering execution profiles, troubleshooting missing configuration, and enabling diagnostic tools to analyze native images.
+
+[[configure-image-build]]
+=== Configure Native Image Build
+
+The plugin supports passing options directly to Native Image inside the `<configuration>` block.
+Using `<buildArg>`, you can pass any Native Image build option listed on https://www.graalvm.org/reference-manual/native-image/overview/Options/[this page].
+
+The plugin also provides special properties to configure the build:
+
+- `<environment>` - Sets the environment options
+- `<imageName>` - Specifies of the name for the native executable file. If a custom name is not supplied, the artifact ID of the project will be used by default (defaults to the project name).
+- `<jvmArgs>` - Passes the given argument directly to the JVM running the `native-image` tool
+- `<quickBuild>` - Enables quick build mode
+- `<verbose>` - Enables the verbose output
+- and many more https://graalvm.github.io/native-build-tools/latest/maven-plugin.html#configuration-options[listed here].
+
+Here is an example of additional options usage:
+[source,xml, role="multi-language-sample"]
+----
+<configuration>
+  <mainClass>org.example.Main</mainClass>
+  <imageName>myApp</imageName>
+  <verbose>true</verbose>
+  <buildArgs>
+    <buildArg>-O3</buildArg> <!-- enables additional compiler optimizations -->
+  </buildArgs>
+  <environment>
+    <variable1>value1</variable1>
+    <variable2>value2</variable2>
+  </environment>
+  <jvmArgs>
+    <arg>your-argument</arg>
+  </jvmArgs>
+</configuration>
+----
+
+[TIP]
+====
+As an alternative, you can pass additional build options via the `NATIVE_IMAGE_OPTIONS` environment variable, on the command line.
+This works similarly to `JAVA_TOOL_OPTIONS`, where the value of the environment variable is prefixed to the options supplied to `native-image`.
+====
+
+Learn more about Native Image build configuration https://www.graalvm.org/reference-manual/native-image/overview/BuildConfiguration/[on the website].
+
+[[run-junit-tests]]
+=== Run Junit Tests
+
+This plugin supports running tests on the JUnit Platform.
+The tests are compiled ahead of time and executed as native code.
+
+- To execute tests, add one more `<execution>` to the plugin declaration:
+
+[source,xml, role="multi-language-sample"]
+----
+<execution>
+  <id>test-native</id>
+  <goals>
+    <goal>test</goal>
+  </goals>
+  <phase>test</phase>
+</execution>
+----
+
+- Add the JUnit 5 dependency to _pom.xml_ to include the testing framework. It will only be used during the `test` phase and not included in the final build artifact:
+
+[source,xml, role="multi-language-sample"]
+----
+<dependency>
+  <groupId>org.junit.jupiter</groupId>
+  <artifactId>junit-jupiter</artifactId>
+  <version>5.10.0</version>
+  <scope>test</scope>
+</dependency>
+----
+
+- Add the Maven Surefire Plugin into the `plugins` section of the `native` profile:
+
+[source,xml, role="multi-language-sample"]
+----
+<plugin>
+  <groupId>org.apache.maven.plugins</groupId>
+  <artifactId>maven-surefire-plugin</artifactId>
+  <version>3.0.0</version>
+</plugin>
+----
+
+- Run the tests:
+
+[source,bash, role="multi-language-sample"]
+----
+./mvnw -Pnative test
+----
+
+The new execution you have just added, `test-native`, integrates with the Maven `test` phase.
+First, Maven runs the tests on the JVM, then compiles them ahead of time and executes them as native code.
+
+==== Disable tests
+
+If you wish to disable tests on the JVM as well as running native code tests, invoke Maven with the `-DskipTests` flag. 
+This flag is supported by the Maven Surefire plugin and Native Build Tools. 
+
+[source,bash, role="multi-language-sample"]
+----
+./mvnw -Pnative -DskipTests package
+----
+
+If you wish to run tests on the JVM with the Maven Surefire plugin, but skip running tests as native code, invoke Maven with the `-DskipNativeTests` flag.
+This flag is specific to Native Build Tools.
+
+[source,bash, role="multi-language-sample"]
+----
+./mvnw -Pnative -DskipNativeTests package
+----
+
+Alternatively, set `<skipNativeTests>` to `true` in the plugin configuration: 
+
+[source,xml, role="multi-language-sample"]
+----
+<configuration>
+  <skipNativeTests>true</skipNativeTests>
+</configuration>
+----
+
+This way you configure your Maven profile to skip generation and execution of tests as native code.
+
+[[gather-execution-profiles]]
+=== Gather Execution Profiles and Build Optimized Images
+
+You may want to gather profiling information from your application's execution to pinpoint areas of inefficiency.
+With this profiling data, you can also build an optimized native image.
+
+The technique for building native images optimized on profiles is called https://www.graalvm.org/latest/reference-manual/native-image/optimizations-and-performance/PGO/[Profile-Guided Optimization (PGO)].
+With PGO you can “train” your native application for specific workloads to improve performance and throughput.
+The PGO workflow includes three steps.
+
+[NOTE]
+====
+PGO is available in Oracle GraalVM.
+====
+
+Step 1: **Build an instrumented native image** by passing the `--pgo-instrument` option to `native-image` using `<buildArg>`.
+To prevent overwriting a previously built native executable, we recommend either creating a separate Maven profile for each build or specifying a unique file name using the `<imageName>` tag.
+For example:
+
+[source,xml, role="multi-language-sample"]
+----
+<configuration>
+  <imageName>instrumentedApp</imageName>
+  <buildArgs>
+      <buildArg>--pgo-instrument</buildArg>
+  </buildArgs>
+</configuration>
+----
+
+Run the build command:
+
+[source,bash, role="multi-language-sample"]
+----
+./mvnw -Pnative package
+----
+
+Step 2: **Gather profiles** by running the instrumented executable.
+By default, the _default.iprof_ file, if not specified otherwise, is generated alongside the native executable.
+
+[source,bash, role="multi-language-sample"]
+----
+./target/instrumentedApp
+----
+
+Step 3. **Build an optimized native image with profiles** by passing the `--pgo` option.
+You may want to provide a different name for the native image or create another Maven profile to handle this configuration:
+
+[source,xml, role="multi-language-sample"]
+----
+<configuration>
+  <imageName>optimizedApp</imageName>
+  <buildArgs>
+      <buildArg>--pgo</buildArg>
+  </buildArgs>
+</configuration>
+----
+
+Run the build command:
+ 
+[source,bash, role="multi-language-sample"]
+----
+./mvnw -Pnative package
+----
+
+If the profile file has the default name and location, it will be automatically picked up.
+Alternatively, you can specify the file path as following: `--pgo=myprofile.iprof`.
+
+If everything was done properly, you will see _"PGO: user-provided"_ in the native image build output.
+Once the optimized image is built, run it: `./target/optimizedApp`.
+The application's performance when running from this native executable should be comparable to, or even faster than, running on the JVM.
+Learn more about PGO https://www.graalvm.org/reference-manual/native-image/optimizations-and-performance/PGO/basic-usage[on the website].
+
+[[troubleshoot-missing-configuration]]
+=== Troubleshoot Missing Configuration
+ 
+[[detect-missing-metadata]]
+==== Detect Missing Metadata
+
+Quite possibly, your application relies on external libraries.
+If your application uses a well-supported framework such as Spring or Micronaut, its dependencies should be compatible with Native Image.
+Frameworks and libraries that support Native Image by default provide configurations in the https://github.com/oracle/graalvm-reachability-metadata[GraalVM Reachability Metadata Repository]. 
+When you build a native image, Native Build Tools reference this repository to apply the required configuration automatically.
+
+[TIP]
+====
+You can find an extensive list of libraries and frameworks from the Java ecosystem tested with Native Image on https://www.graalvm.org/native-image/libraries-and-frameworks/[this page].
+====
+
+However, it may happen, that your native image crashes at run time with a missing class or resource.
+To address this, start by checking if any required configuration is missing.
+
+The best way to detect missing metadata is by running your native tests.
+Alternatively, you can **identify missing configuration manually** using the following method.
+
+- Pass the `--exact-reachability-metadata` option to the `native-image` tool in _pom.xml_, as shown below:
+
+[source,xml, role="multi-language-sample"]
+----
+<configuration>
+  <buildArgs>
+    <buildArg>--exact-reachability-metadata</buildArg>
+  </buildArgs>
+</configuration>
+----
+
+[NOTE]
+====
+The `--exact-reachability-metadata` option was introduced in GraalVM for JDK 23. With older versions, use `-H:ThrowMissingRegistrationErrors=` instead. 
+====
+
+- Rebuild the application:
+
+[source,bash, role="multi-language-sample"]
+----
+./mvnw -Pnative package
+----
+
+- Run the application from the native executable with the `-XX:MissingRegistrationReportingMode=Warn` option: 
+
+[source,bash, role="multi-language-sample"]
+----
+./target/myApp -XX:MissingRegistrationReportingMode=Warn
+----
+
+[NOTE]
+====
+With GraalVM versions older than JDK 23, pass `-H:MissingRegistrationReportingMode=Warn` at build time instead.
+====
+
+- If there is any missing metadata printed to the console, **add it to the configuration file manually**, as described https://www.graalvm.org/latest/reference-manual/native-image/metadata/#specifying-metadata-with-json[here], or **collect it automatically using the Tracing agent**.
+(See next.) 
+
+- Rebuild your native image and test again.
+
+[[collect-metadata]]
+==== Collect Metadata Automatically with Tracing Agent
+
+Your application may use dynamic Java features such as reflection, serialization, or resource loading.
+It is also possible that a framework your application relies on uses a library dependency incompatible with Native Image.
+In such cases, additional metadata is required.
+
+The easiest way to collect the missing metadata is by using the https://www.graalvm.org/reference-manual/native-image/metadata/AutomaticMetadataCollection/[Tracing Agent].
+This agent tracks all usages of dynamic features during application execution on the JVM and generates the necessary configuration.
+
+[NOTE]
+====
+This guide demonstrates how to generate metadata from your tests.
+Generating metadata from your main application requires <<maven-plugin.adoc#agent-support-running-application,more configuration>>. The process is otherwise identical, except that you use the `package` phase instead of the `test` phase.
+====
+
+The agent is disabled by default.
+You can enable it on the command line or in _pom.xml_.
+
+To enable the agent via the command line, pass the `-Dagent=true` option when running Maven:
+
+[source,bash, role="multi-language-sample"]
+----
+./mvnw -Pnative -Dagent=true test
+----
+
+[NOTE]
+====
+Enabling the agent via the command line only attaches it for a specific run; it does not automatically run every time you build the application.
+====
+
+To enable the agent in _pom.xml_ and collect missing metadata, do the following.
+
+Step 1: **Enable the agent** by setting `<agent>` to `true` in the `native` profile:
+
+[source,xml, role="multi-language-sample"]
+----
+<configuration>
+  <agent>
+    <enabled>true</enabled>
+  </agent>
+</configuration>
+----
+From that point on, commands you execute will run with the agent attached.
+
+Step 2: **Copy the generated metadata** from the default location, _target/native/agent-output_, to the resources directory, for example, _resources/META-INF/native-image_.
+Native Image automatically uses the metadata from this location.
+
+To do that with Maven, configure and run the `metadataCopy` task.
+
+Add a new task named `metadataCopy` inside the `agent` block that you added in step 1. 
+Your `agent` configuration should look like this:
+
+[source,xml, role="multi-language-sample"]
+----
+<agent>
+  <enabled>true</enabled>
+  <metadataCopy>
+    <disabledStages>
+      <stage>main</stage>
+    </disabledStages>
+    <merge>true</merge>
+    <outputDirectory>src/test/resources/META-INF/native-image</outputDirectory>
+  </metadataCopy>
+</agent>
+----
+
+In this block:
+ 
+- `<outputDirectory>` specifies location where you want to copy the generated metadata.
+- `<disableStages>` - you can disable metadata copy for a concrete Maven phase. In this you do not want the agent output from the `main` phase.
+- `<merge>` - specifies whether the metadata you want to copy, should be merged with the metadata that already exists in the given location, or not. This only makes sense when there is already some existing metadata, created before.
+
+Step 3: Now that the `metadataCopy` task is configured, **run the agent to collect the metadata and copy it to the other location**:
+
+[source,bash,subs="verbatim,attributes", role="multi-language-sample"]
+----
+./mvnw -Pnative test native:metadata-copy
+----
+
+Step 4: Finally, proceed without the agent and **build the native image with the metadata**.
+From that point on, you can run your tests with:
+
+[source,bash, role="multi-language-sample"]
+----
+./mvnw -Pnative test
+----
+
+If your native image is successfully build, but still fails at run time, check the troubleshooting guide https://www.graalvm.org/reference-manual/native-image/guides/troubleshoot-run-time-errors/[Troubleshoot Native Image Run-Time Errors].
+
+Learn more about how to fine-tune the agent further <<maven-plugin.adoc#agent-support-configuring-options,here>>.
+
+[[use-diagnostics-tools]]
+=== Use Diagnostics Tools
+
+If you need to diagnose the native applications you build, or monitor your Java application when launched from a native executable, Native Image offers tools for debugging and analyzing the produced binary.
+For example:
+
+[source,xml, role="multi-language-sample"]
+----
+<configuration>
+  <debug>true</debug>
+  <buildArgs>
+    <buildArg>--emit build-report</buildArg>
+    <buildArg>--enable-monitoring=jfr</buildArg>
+  </buildArgs>
+</configuration>
+----
+
+- The `--emit build-report` option generates an HTML page report alongside the native executable that you can open in a browser.
+It provides broad information about each build stage as well as the generated binary’s contents.
+You can read more about Build Report features https://www.graalvm.org/latest/reference-manual/native-image/overview/build-report/[here].
+
+[NOTE]
+====
+Build Report is available in Oracle GraalVM.
+When running on GraalVM for JDK 21, pass the `-H:+BuildReport` option instead to generate a build report.
+====
+
+- The `--enable-monitoring=jfr` instructs the plugin to https://www.graalvm.org/reference-manual/native-image/guides/build-and-run-native-executable-with-jfr/[build a native executable with the JDK Flight Recorder (JFR) support]. 
+
+- The `<debug>` option generates a native executable with debug information for https://www.graalvm.org/reference-manual/native-image/guides/debug-native-image-process/[source-level debugging with the GNU Debugger (GDB)].
+
+All the monitoring and debugging tools https://www.graalvm.org/reference-manual/native-image/debugging-and-diagnostics/[listed on the website], can be enabled in the plugin configuration using `<buildArgs>`.
+
+You will find the output of these tools among the generated artifacts after running:
+
+[source,bash, role="multi-language-sample"]
+----
+./mvnw -Pnative package
+----
+
+=== Learn more
+
+To continue learning, refer to the <<changelog.adoc#,extensive reference documentation for the GraalVM Native Image Maven plugin>>.
\ No newline at end of file
diff --git a/docs/src/docs/asciidoc/gradle-plugin-quickstart.adoc b/docs/src/docs/asciidoc/gradle-plugin-quickstart.adoc
deleted file mode 100644
index 01e03e20e..000000000
--- a/docs/src/docs/asciidoc/gradle-plugin-quickstart.adoc
+++ /dev/null
@@ -1,341 +0,0 @@
-= Getting Started with Gradle Plugin for GraalVM Native Image
-The GraalVM team
-:highlighjsdir: {gradle-relative-srcdir}/highlight
-
-This guide shows how to get started with the <<gradle-plugin.adoc#,Gradle plugin for GraalVM Native Image>> and build a native executable for a Java application.
-
-You will create a sample application, enable the plugin, add support for dynamic features, build a native executable, and run JUnit tests.
-
-Two ways of building a native executable using the plugin will be demonstrated:
-
-- <<#build-a-native-executable-with-resources-autodetection,Build a Native Executable with Resources Autodetection>>
-- <<#build-a-native-executable-detecting-resources-with-the-agent,Build a Native Executable Detecting Resources with the Agent>>
-
-====
-The plugin requires that you https://www.graalvm.org/latest/docs/getting-started/[setup GraalVM].
-
-The easiest way to install GraalVM is to use https://sdkman.io/jdks[SDKMAN!].
-
-For other installation options, go to https://www.graalvm.org/downloads/[GraalVM Downloads].
-====
-
-== Prepare a Demo Application
-
-====
-You start by creating a **Fortune Teller** sample application that simulates the traditional
-https://en.wikipedia.org/wiki/Fortune_(Unix)[fortune Unix program].
-The data for the fortune phrases is provided by https://github.com/your-fortune[YourFortune].
-====
-
-. Create a new Java project with *Gradle* using the following command (alternatively, you can use your IDE to generate a project):
-+
-[source,shell]
-----
-gradle init --project-name fortune-parent --type java-application --package demo --test-framework junit-jupiter --dsl groovy
-----
-. Rename the default _app_ directory to _fortune_, edit the _settings.gradle_ file to replace `app` with `fortune`, then rename the default filename _App.java_ to _Fortune.java_, and replace its contents with the following:
-+
-[source,java]
-----
-package demo;
-
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.Random;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-public class Fortune {
-
-    private static final Random RANDOM = new Random();
-    private final ArrayList<String> fortunes = new ArrayList<>();
-
-    public Fortune() throws JsonProcessingException {
-        // Scan the file into the array of fortunes
-        String json = readInputStream(ClassLoader.getSystemResourceAsStream("fortunes.json"));
-        ObjectMapper omap = new ObjectMapper();
-        JsonNode root = omap.readTree(json);
-        JsonNode data = root.get("data");
-        Iterator<JsonNode> elements = data.elements();
-        while (elements.hasNext()) {
-            JsonNode quote = elements.next().get("quote");
-            fortunes.add(quote.asText());
-        }
-    }
-
-    private String readInputStream(InputStream is) {
-        StringBuilder out = new StringBuilder();
-        try (InputStreamReader streamReader = new InputStreamReader(is, StandardCharsets.UTF_8);
-             BufferedReader reader = new BufferedReader(streamReader)) {
-            String line;
-            while ((line = reader.readLine()) != null) {
-                out.append(line);
-            }
-
-        } catch (IOException e) {
-            Logger.getLogger(Fortune.class.getName()).log(Level.SEVERE, null, e);
-        }
-        return out.toString();
-    }
-
-    public String randomFortune() {
-        // Pick a random number
-        int r = RANDOM.nextInt(fortunes.size());
-        // Use the random number to pick a random fortune
-        return fortunes.get(r);
-    }
-
-    private void printRandomFortune() throws InterruptedException {
-        String f = randomFortune();
-        // Print out the fortune s.l.o.w.l.y
-        for (char c : f.toCharArray()) {
-            System.out.print(c);
-            Thread.sleep(100);
-        }
-        System.out.println();
-    }
-
-    /**
-     * @param args the command line arguments
-     */
-    public static void main(String[] args) throws InterruptedException, JsonProcessingException {
-        Fortune fortune = new Fortune();
-        fortune.printRandomFortune();
-    }
-}
-----
-. Delete the _fortune/src/test/java_ directory (you will add tests in a later stage).
-. Copy and paste the following file,
-https://raw.githubusercontent.com/graalvm/graalvm-demos/refs/heads/master/fortune-demo/fortune-gradle/fortune/src/main/resources/fortunes.u8[fortunes.json] under _fortune/src/main/resources/_.
-Your project tree should be:
-+
-[source,shell]
-----
-.
-├── fortune
-│   ├── build.gradle
-│   └── src
-│       ├── main
-│       │   ├── java
-│       │   │   └── demo
-│       │   │       └── Fortune.java
-│       │   └── resources
-│       │       └── fortunes.json
-│       └── test
-│           └── resources
-├── gradle
-│   └── wrapper
-│       ├── gradle-wrapper.jar
-│       └── gradle-wrapper.properties
-├── gradlew
-├── gradlew.bat
-└── settings.gradle
-----
-. Open the Gradle configuration file _build.gradle_, and update the main class in the `application` section:
-+
-[source,xml]
-----
-application {
-    mainClass = 'demo.Fortune'
-}
-----
-. Add explicit FasterXML Jackson dependencies that provide functionality to read and write JSON, data bindings (used in the demo application). 
-Insert the following three lines in the `dependencies` section of _build.gradle_:
-+
-[source,xml]
-----
-implementation 'com.fasterxml.jackson.core:jackson-core:2.13.2'
-implementation 'com.fasterxml.jackson.core:jackson-databind:2.13.2.2'
-implementation 'com.fasterxml.jackson.core:jackson-annotations:2.13.2'
-----
-+
-Also, remove the dependency on `guava` that will not be used.
-+
-The next steps demonstrate what you should do to enable the
-https://graalvm.github.io/native-build-tools/latest/gradle-plugin.html[Gradle Plugin for GraalVM Native Image].
-. Register the plugin. Add the following to `plugins` section of your project’s _build.gradle_ file:
-+
-[source,groovy,subs="verbatim,attributes", role="multi-language-sample"]
-----
-plugins {
-  id 'org.graalvm.buildtools.native' version '{gradle-plugin-version}'
-}
-----
-+
-[source,kotlin,subs="verbatim,attributes",role="multi-language-sample"]
-----
-plugins {
-  id("org.graalvm.buildtools.native") version "{gradle-plugin-version}"
-}
-----
-+
-The `{gradle-plugin-version}` block pulls the latest plugin version.
-Replace it with a specific version if you prefer.
-The plugin discovers which JAR files it needs to pass to the `native-image` builder and what the executable main class should be.
-
-[[build-a-native-executable-with-resources-autodetection]]
-== Build a Native Executable with Resources Autodetection
-
-You can already build a native executable by running `./gradlew nativeCompile` or run it directly by invoking `./gradlew nativeRun`.
-However, at this stage, running the native executable will fail because this application requires additional metadata: you need to provide it with a list of resources to load.
-
-. Instruct the plugin to automatically detect resources to be included in the native executable.
-Add this to your _build.gradle_ file:
-+
-[source,groovy,subs="verbatim,attributes", role="multi-language-sample"]
-----
-graalvmNative {
-    binaries.all {
-        resources.autodetect()
-    }
-}
-----
-+
-[source,kotlin,subs="verbatim,attributes", role="multi-language-sample"]
-----
-graalvmNative {
-    binaries.all {
-        resources.autodetect()
-    }
-}
-----
-[start=2]
-. Compile the project and build a native executable at one step:
-+
-[source,shell]
-----
-./gradlew nativeRun
-----
-+
-The native executable, named _fortune_, is created in the _/fortune/build/native/nativeCompile_ directory.
-[start=3]
-. Run the native executable:
-+
-[source,shell]
-----
-./fortune/build/native/nativeCompile/fortune
-----
-+
-The application starts and prints a random quote.
-
-Configuring the `graalvmNative` plugin to automatically detect resources (`resources.autodetect()`) to be included in a binary is one way to make this example work.
-Using `resources.autodetect()` works because the application uses resources (_fortunes.json_) which are directly available in the `src/main/resources` location.
-
-In the next section, the guide shows that you can use the tracing agent to do the same.
-
-[[build-a-native-executable-detecting-resources-with-the-agent]]
-== Build a Native Executable by Detecting Resources with the Agent
-
-The Native Image Gradle plugin simplifies generation of the required metadata by injecting the
-https://graalvm.github.io/native-build-tools/latest/gradle-plugin.html#agent-support[
-tracing agent] automatically for you at compile time.
-To enable the agent, just pass the `-Pagent` option to any Gradle tasks that extends `JavaForkOptions` (for example, `test` or `run`).
-
-The following steps illustrate how to collect metadata using the agent, and then build a native executable using that metadata.
-
-. To demonstrate this approach, remove the `resources.autodetect()` block from your _build.gradle_ file:
-+
-[source,shell]
-----
-binaries.all {
-    resources.autodetect()
-}
-----
-. Run your application with the agent enabled:
-+
-[source,shell]
-----
-./gradlew -Pagent run
-----
-It runs your application on the JVM with the agent, collects the metadata, and generates configuration files in the _$\{buildDir}/native/agent-output/$\{taskName}_ directory.
-. Copy the configuration files into the project's _/META-INF/native-image_ directory using the `metadataCopy` task:
-+
-[source,shell]
-----
-./gradlew metadataCopy --task run --dir src/main/resources/META-INF/native-image
-----
-. Build a native executable using metadata acquired by the agent:
-+
-[source,shell]
-----
-./gradlew nativeCompile
-----
-+
-The native executable, named _fortune_, is created in the _build/native/nativeCompile_ directory.
-. Run the native executable:
-+
-[source,shell]
-----
-./fortune/build/native/nativeCompile/fortune
-----
-+
-The application starts and prints a random quote.
-
-== Add JUnit Testing
-
-The Gradle plugin for GraalVM Native Image can run
-https://junit.org/junit5/docs/current/user-guide/[JUnit Platform] tests on your native executable.
-This means that the tests will be compiled and run as native code.
-
-. Create the following test in the
-_fortune/src/test/java/demo/FortuneTest.java_ file:
-+
-.fortune/src/test/java/demo/FortuneTest.java
-[source,java]
-----
-package demo;
-
-import com.fasterxml.jackson.core.JsonProcessingException;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
-class FortuneTest {
-    @Test
-    @DisplayName("Returns a fortune")
-    void testItWorks() throws JsonProcessingException {
-        Fortune fortune = new Fortune();
-        assertTrue(fortune.randomFortune().length()>0);
-    }
-}
-----
-
-. Run JUnit tests:
-[source,shell]
-----
-./gradlew nativeTest
-----
-
-The plugin runs tests on the JVM prior to running tests from the native executable.
-To disable testing support (which comes by default), add the following configuration to the _build.gradle_ file:
-
-[source,groovy,subs="verbatim,attributes", role="multi-language-sample"]
-----
-graalvmNative {
-    testSupport = false
-}
-----
-
-[source,kotlin,subs="verbatim,attributes", role="multi-language-sample"]
-----
-graalvmNative {
-    testSupport.set(false)
-}
-----
-
-=== Summary
-
-The Gradle plugin for GraalVM Native Image adds support for building and testing native executables using the https://gradle.org[Gradle].
-The plugin has many features, described in the 
-https://graalvm.github.io/native-build-tools/latest/gradle-plugin.html[plugin
-reference documentation].
\ No newline at end of file
diff --git a/docs/src/docs/asciidoc/gradle-plugin.adoc b/docs/src/docs/asciidoc/gradle-plugin.adoc
index f962e9d41..de3c0093e 100644
--- a/docs/src/docs/asciidoc/gradle-plugin.adoc
+++ b/docs/src/docs/asciidoc/gradle-plugin.adoc
@@ -1,41 +1,23 @@
-= Gradle plugin for GraalVM Native Image building
+= Gradle plugin for GraalVM Native Image
 The GraalVM team
 :highlighjsdir: {gradle-relative-srcdir}/highlight
 
 image:https://github.com/graalvm/native-build-tools/actions/workflows/test-native-gradle-plugin.yml/badge.svg[]
 
+[[introduction]]
 == Introduction
 
 The {doctitle} adds support for building and testing native images using the https://gradle.org[Gradle build tool].
 
-For upgrading please take a look at the <<index.adoc#changelog,Changelog>>.
+Find the differences between the versions in the <<changelog.adoc#,project changelog>>.
 
-[[quickstart]]
-== Quickstart
+You can find sample applications in the https://github.com/graalvm/native-build-tools/tree/master/samples[source repository].
 
-====
-<<gradle-plugin-quickstart.adoc#,Getting Started with Gradle Plugin for GraalVM Native Image>>
-====
-
-====
-You can find full samples in https://github.com/graalvm/native-build-tools/tree/master/samples[the source repository].
-====
-
-====
-The plugin requires that you https://www.graalvm.org/latest/docs/getting-started/[setup GraalVM].
-
-The easiest way to install GraalVM is to use the https://sdkman.io/jdks[SDKMAN!].
-
-For other installation options, go to https://www.graalvm.org/downloads/[GraalVM Downloads].
-====
-
-== Reference documentation
+[[adding-the-plugin]]
+== Adding the plugin
 
-=== Adding the plugin
+Add following to `plugins` section of the project's _build.gradle_ / _build.gradle.kts_ file:
 
-Add following to `plugins` section of your project's `build.gradle` / `build.gradle.kts`:
-
-.Applying the plugin
 [source,groovy,subs="verbatim,attributes", role="multi-language-sample"]
 ----
 plugins {
@@ -56,12 +38,14 @@ plugins {
 }
 ----
 
-NOTE: This plugin supplements and heavily relies on regular Java plugins (e.g. `application`, `java-library`, `java` etc). Not having them included in your project will most probably cause errors.
+[NOTE]
+====
+This plugin supplements and heavily relies on regular Java plugins such as `application`, `java-library`, `java`, and others. Not having them included in your project will most probably cause errors.
+====
 
 [TIP]
-.Testing pre-releases
 ====
-You can use development versions of the plugin by adding our snapshot repository instead. Pre-releases are provided for convenience, without any guarantee.
+You can use development versions of the plugin by adding the snapshot repository instead. Pre-releases are provided for convenience, without any guarantee.
 [source, groovy, role="multi-language-sample"]
 ----
 include::../snippets/gradle/groovy/settings.gradle[tags=pre-release, indent=0]
@@ -73,48 +57,27 @@ include::../snippets/gradle/kotlin/settings.gradle.kts[tags=pre-release, indent=
 ----
 ====
 
-=== Installing GraalVM Native Image tool
-
-By default, the plugin will try to use the `native-image` tool that is bundled with the JDK that is used to run Gradle.
-This means you must make sure that you run Gradle with a GraalVM JDK.
-
-Alternatively, you may choose to:
-
-1. Set up a `GRAALVM_HOME` environment variable pointing to your GraalVM installation, in which case the JDK pointed at this location will be used for Native Image builds instead
-2. <<configuration-toolchains-enabling, Enable toolchain support>>
-
-[[configuration]]
-== Configuration
-
-This plugin works with the `application` plugin and will register a number of tasks and extensions for you to configure.
-
-=== Available tasks
-
-The main tasks that you will want to execute are:
+[[installing-graalvm]]
+== Installing GraalVM
 
-- `nativeCompile`, which will trigger the generation of a native executable of your application
-- `nativeRun`, which executes the generated native executable
-- `nativeTestCompile`, which will build a native image with tests found in the `test` source set
-- `nativeTest`, which will <<testing-support,execute tests>> found in the `test` source set in native mode
-
-Those tasks are configured with reasonable defaults using the `graalvmNative` extension `binaries` container of type link:javadocs/native-gradle-plugin/org/graalvm/buildtools/gradle/dsl/NativeImageOptions.html[NativeImageOptions].
-
-The main executable is configured by the image named `main`, while the test executable is configured via the image named `test`.
+The plugin requires that you https://www.graalvm.org/latest/docs/getting-started/[install GraalVM].
+The easiest way to install GraalVM is to use the https://sdkman.io/jdks[SDKMAN!].
+For other installation options, go to https://www.graalvm.org/downloads/[GraalVM Downloads].
 
-=== Native image options
+By default, the plugin attempts to use the `native-image` tool bundled with the JDK running Gradle. 
+Therefore, you must ensure that Gradle runs on a GraalVM JDK.
 
-The link:javadocs/native-gradle-plugin/org/graalvm/buildtools/gradle/dsl/NativeImageOptions.html[NativeImageOptions] allows you to tweak how the native image is going to be built.
-The plugin allows configuring the final binary, the <<test-binary-config,tests>> one, as well as apply options to both.
+You may choose to:
 
-[source,groovy,role="multi-language-sample"]
-----
-include::../snippets/gradle/groovy/build.gradle[tags=configure-binaries]
-----
+1. Set the `GRAALVM_HOME` environment variable to point to your GraalVM installation. When this variable is configured, the JDK specified at this location will be used for Native Image builds.
+2. <<configuration-toolchains-enabling, Enable toolchain support>>.
 
-[source,kotlin,role="multi-language-sample"]
-----
-include::../snippets/gradle/kotlin/build.gradle.kts[tags=configure-binaries]
-----
+[TIP]
+====
+Check out https://docs.gradle.org/current/userguide/compatibility.html[which Java versions are compatible with the Gradle version] you are using.
+In case the Gradle version you are using is not compatible with the GraalVM version,
+you can set up the `GRAALVM_HOME` environment variable pointing to your GraalVM installation, and the `JAVA_HOME` environment variable pointing to some JDK that is compatible with the Gradle on your system.
+====
 
 [[configuration-toolchains]]
 === Using Gradle toolchains
@@ -125,11 +88,11 @@ include::../snippets/gradle/kotlin/build.gradle.kts[tags=configure-binaries]
 Instead of relying on the JDK which is used to run Gradle, you can use the https://docs.gradle.org/current/userguide/toolchains.html[Gradle toolchain support] to select a specific GraalVM installation.
 
 However, because of limitations in Gradle, the plugin may not be able to properly detect the toolchain.
-In particular, this will only work properly if you _only_ have GraalVM JDKs installed on the machine: **Otherwise, Gradle will not be able to reliably detect GraalVM JDKs**, nor detect GraalVM distributions from different vendors.
+In particular, this will only work properly if you _only_ have GraalVM JDKs installed on the machine.
+**Otherwise, Gradle will not be able to reliably detect GraalVM JDKs**, nor detect GraalVM distributions from different vendors.
 
 Should you still want to enable toolchain support, you do it via the `graalvmNative` extension:
 
-.Enabling toolchain detection
 [source,groovy,role="multi-language-sample"]
 ----
 include::../snippets/gradle/groovy/build.gradle[tags=enabling-toolchain, indent=0]
@@ -142,13 +105,11 @@ include::../snippets/gradle/kotlin/build.gradle.kts[tags=enabling-toolchain, ind
 
 ==== Selecting the GraalVM toolchain
 
-By default, the plugin will select a Java 11 GraalVM toolchain using the vendor string `GraalVM`,
-which works properly for GraalVM up to version 22.3 included.
+By default, the plugin will select a Java 11 GraalVM toolchain using the vendor string `GraalVM`, which works properly for GraalVM up to version 22.3 included.
 More recent versions of GraalVM do not have a specific version and are aligned with the language version they support.
 
-If you want to use a different toolchain, for example a distribution compatible with Java 20 from Oracle, you can configure the toolchain like this:
+If you want to use a different toolchain, for example, a distribution compatible with Java 20 from Oracle, you can configure the toolchain like this:
 
-.Selecting the GraalVM toolchain
 [source, groovy, role="multi-language-sample"]
 ----
 include::../snippets/gradle/groovy/build.gradle[tags=select-toolchain]
@@ -159,14 +120,51 @@ include::../snippets/gradle/groovy/build.gradle[tags=select-toolchain]
 include::../snippets/gradle/kotlin/build.gradle.kts[tags=select-toolchain]
 ----
 
-Again, be aware that the toolchain detection _cannot_ distinguish between GraalVM JDKs and standard JDKs without Native Image support: if you have both installed on the machine, Gradle may randomly pick one or the other.
+Again, be aware that the toolchain detection _cannot_ distinguish between GraalVM JDKs and standard JDKs without Native Image support.
+If you have both installed on the machine, Gradle may randomly pick one or the other.
+
+[[configuration]]
+== Plugin configuration
+
+The plugin works with the `application` plugin and registers a number of tasks and extensions for you to configure.
+
+[[available-tasks]]
+=== Available tasks
+
+The main tasks that you may want to execute are:
+
+- `nativeCompile` triggers the generation of a native executable of your application
+- `nativeRun` executes the generated native executable
+- `nativeTestCompile` builds a native image with tests found in the `test` source set
+- `nativeTest` <<testing-support,executes tests>> found in the `test` source set in native mode
 
-[[configuration-options]]
-==== Configuration options
+Those tasks are configured with reasonable defaults using the `graalvmNative` extension `binaries` container of type link:javadocs/native-gradle-plugin/org/graalvm/buildtools/gradle/dsl/NativeImageOptions.html[NativeImageOptions].
+
+The main executable is configured by the image named `main`, while the test executable is configured via the image named `test`.
 
-The following configuration options are available for building images:
+[[configure-native-image]]
+=== Native Image configuration
+
+The link:javadocs/native-gradle-plugin/org/graalvm/buildtools/gradle/dsl/NativeImageOptions.html[NativeImageOptions] allows you to tweak how the native image is going to be built.
+The plugin allows configuring the final binary, the <<test-binary-config,tests>> one, as well as apply options to both.
+
+[source,groovy,subs="verbatim,attributes", role="multi-language-sample"]
+----
+graalvmNative {
+    binaries.main {
+        // options for the main binary
+    }
+    binaries.test {
+        // options for the test binary
+    }
+    binaries.all {
+        // common options for both main and test binaries
+    }
+}
+----
+
+The following configuration options are available for building native images:
 
-.NativeImageOption configuration
 [source, groovy, role="multi-language-sample"]
 ----
 include::../snippets/gradle/groovy/build.gradle[tags=all-config-options]
@@ -177,23 +175,452 @@ include::../snippets/gradle/groovy/build.gradle[tags=all-config-options]
 include::../snippets/gradle/kotlin/build.gradle.kts[tags=all-config-options]
 ----
 
-NOTE: For options that can be set using command-line, if both DSL and command-line options are present, command-line options take precedence.
+[[native-image-options]]
+==== Native Image options
+
+- `imageName` - The name of the native executable, defaults to the project name
+- `mainClass` - The main class to use, defaults to the _application.mainClass_
+- `debug` - Determines if debug info should be generated; defaults to `false` (alternatively, add `--debug-native` to the CLI)
+- `verbose` - Adds verbose output (`false` by default)
+- `fallback` - Sets the fallback mode of `native-image` (`false` by default)
+- `sharedLibrary` - Determines if the image is a shared library
+- `quickBuild` - Determines if the image is being built in quick build mode
+- `richOutput` - Determines whether `native-image` building should produce a rich output
+- `systemProperties`: Defines the system properties to use for the `native-image` tool
+- `configurationFileDirectories`: Adds a directory containing configuration files for `native-image`, such as reflection configuration
+ -`excludeConfig`: Excludes configuration that matches any of the specified regex patterns from the JAR of a dependency with the given coordinates
+- `jvmArgs`: Passes the specified arguments directly to the JVM running the `native-image` builder
+- `useFatJar`: Builds a fat JAR instead of passing each JAR individually
+
+You can also pass **build-time** and **run-time** arguments:
+
+- `buildArgs.add('<buildArg>')`: Configures the build by passing options directly to `native-image`. You can pass any Native Image build option listed https://www.graalvm.org/reference-manual/native-image/overview/Options/[here].
+- `runtimeArgs.add('<runtimeArg>')`: Specifies runtime arguments consumed by your application.
+
+[NOTE]
+====
+For options that can be set using the command line, if both DSL and command-line options are present, command-line options take precedence.
+====
+
+[[native-image-tracing-agent]]
+==== Native Image Tracing Agent
+
+If your project requires reflection, classpath resources, dynamic proxies, or other features that need explicit configuration, it may be helpful to first run your application or tests using the https://www.graalvm.org/reference-manual/native-image/metadata/AutomaticMetadataCollection/[Native Image Tracing Agent].
+
+The Native Image Gradle plugin simplifies generation of the required metadata files by injecting the agent automatically for you (this includes, but is not limited to the reflection file).
+
+Any task that extends `JavaForkOptions` (such as `test`, `run`, and so on) can be instrumented by passing `-Pagent` to Gradle when running those tasks.
+
+Enable the agent by adding the following block inside `graalvmNative`:
+
+[source,groovy,subs="verbatim,attributes", role="multi-language-sample"]
+----
+agent {
+    enabled = true
+}
+----
+
+[source,kotlin,subs="verbatim,attributes", role="multi-language-sample"]
+----
+agent {
+    enabled.set(true)
+}
+----
+
+You can then run it:
+
+[source,bash, role="multi-language-sample"]
+----
+./gradlew -Pagent run # Runs on HotSpot with the agent
+----
+
+The generated configuration files can be found in the `${buildDir}/native/agent-output/${taskName}` directory, for example, _build/native/agent-output/run_.
+The plugin also substitutes `{output_dir}` in the agent options to point to this directory during the agent run.
+
+The agent can run in multiple modes that dictate how the metadata is collected and merged.
+
+* `defaultMode` - Specifies the default agent mode if one isn't specified using `-Pagent=mode_name`
+* `enabled` - Enables the agent
+* `modes`- Configures the following agent modes:
+    ** `standard` - Generates metadata without conditions
+    ** `conditional` - Generates metadata with conditions
+        *** `userCodeFilterPath` - Path to a filter file that specifies which classes to include in metadata conditions
+        *** `extraFilterPath` - (Optional) An additional filter file to further refine the collected metadata
+    ** `direct` - Allows users to directly pass options to the agent
+        *** `{output_dir}` -  The output directory to store agent files
+* `tasksToInstrumentPredicate` - By default, when `-Pagent` is specified, all tasks extending `JavaForkOptions` are instrumented.
+This can be limited to only specific tasks that match this predicate.
+
+[source,groovy,subs="verbatim,attributes", role="multi-language-sample"]
+----
+agent {
+    enabled = true
+    defaultMode = "conditional"
+    modes {
+        conditional {
+            userCodeFilterPath = "src/test/native-image/filters/user-code-filter.json"
+        }
+        direct {
+            options.add("config-output-dir=src/test/resources/direct-mode-metadata")
+            options.add("experimental-configuration-with-origins")
+        }
+    }
+}
+----
+
+[source,kotlin,subs="verbatim,attributes", role="multi-language-sample"]
+----
+agent {
+    enabled.set(true)
+    defaultMode.set("conditional")
+    modes {
+        conditional {
+            userCodeFilterPath.set("src/test/native-image/filters/user-code-filter.json")
+        }
+        direct {
+            options.add("config-output-dir=src/test/resources/direct-mode-metadata")
+            options.add("experimental-configuration-with-origins")
+        }
+    }
+}
+----
+
+If you want to **enable the agent on the command line**, you can specify in which mode you want to run it. For example:
+
+[source,bash,subs="verbatim,attributes", role="multi-language-sample"]
+----
+./gradlew -Pagent=standard nativeTest
+./gradlew -Pagent=conditional nativeTest
+./gradlew -Pagent=direct nativeTest
+----
+
+==== MetadataCopy task
+
+Once the metadata is collected, it can be copied into the project using the `metadataCopy` task.
+To do so, add the following block inside your `agent` block:
+
+[source,groovy,subs="verbatim,attributes", role="multi-language-sample"]
+----
+agent {
+    enabled = true
+    metadataCopy {
+        inputTaskNames.add("test")
+        outputDirectories.add("src/test/resources/META-INF/native-image/org.example")
+        mergeWithExisting = false
+    }
+}
+----
+
+[source,kotlin,subs="verbatim,attributes", role="multi-language-sample"]
+----
+agent {
+    enabled.set(true)
+    metadataCopy {
+        inputTaskNames.add("test")
+        outputDirectories.add("resources/META-INF/native-image/org.example")
+        mergeWithExisting.set(false)
+    }
+}
+----
+
+Inside this block, you configure:
+
+- `inputTaskNames` - specifies tasks previously executed with the agent attached (tasks that generated metadata in the last step).
+- `outputDirectories` -  specifies the location where you want to copy the generated metadata
+- `mergeWithExisting` - specifies whether the metadata you want to copy, should be merged with the metadata that already exists on the give location, or not. This only makes sense when there is already some existing metadata, created before.
+
+Then you can copy metadata to the location you specified with:
+
+
+
+[TIP]
+====
+You can configure the `metadataCopy` task on the command line as well:
+
+[source,bash,subs="verbatim,attributes"]
+----
+./gradlew metadataCopy --task run  # if you used nativeRun (or just run) to collect metadata
+./gradlew metadataCopy --task test  # if you used nativeTest (or just test) to collect metadata
+./gradlew metadataCopy --dir <pathToSomeDirectory> # to specify the output directory
+----
+====
+
+[[common-agent-options]]
+==== Common agent options
+
+All the mentioned modes share certain common configuration options like:
+
+- `callerFilterFiles`
+- `accessFilterFiles`
+- `builtinCallerFilter`
+- `builtinHeuristicFilter`
+- `enableExperimentalPredefinedClasses`
+- `enableExperimentalUnsafeAllocationTracing`
+- `trackReflectionMetadata`
+
+[WARNING]
+====
+These options are for advanced usages. You can read more about them https://www.graalvm.org/latest/reference-manual/native-image/metadata/AutomaticMetadataCollection/#agent-advanced-usage[here].
+====
+
+A complete example of the agent block should look like this:
+
+[source,groovy,subs="verbatim,attributes", role="multi-language-sample"]
+----
+agent {
+    defaultMode = "standard"
+    enabled = true
+
+    modes {
+        conditional {
+            userCodeFilterPath = "path-to-filter.json"
+            extraFilterPath = "path-to-another-filter.json"
+        }
+        direct {
+            options.add("config-output-dir={output_dir}")
+            options.add("experimental-configuration-with-origins")
+        }
+    }
+
+    callerFilterFiles.from("filter.json")
+    accessFilterFiles.from("filter.json")
+    builtinCallerFilter = true
+    builtinHeuristicFilter = true
+    enableExperimentalPredefinedClasses = false
+    enableExperimentalUnsafeAllocationTracing = false
+    trackReflectionMetadata = true
+
+    metadataCopy {
+        inputTaskNames.add("test")
+        outputDirectories.add("src/main/resources/META-INF/native-image/<groupId>/<artifactId>/")
+        mergeWithExisting = true
+    }
+}
+----
+
+[source,kotlin,subs="verbatim,attributes", role="multi-language-sample"]
+----
+agent {
+    defaultMode.set("standard")
+    enabled.set(true)
+
+    modes {
+        conditional {
+            userCodeFilterPath.set("path-to-filter.json")
+            extraFilterPath.set("path-to-another-filter.json")
+        }
+        direct {
+            options.add("config-output-dir={output_dir}")
+            options.add("experimental-configuration-with-origins")
+        }
+    }
+
+    callerFilterFiles.from("filter.json")
+    accessFilterFiles.from("filter.json")
+    builtinCallerFilter.set(true)
+    builtinHeuristicFilter.set(true)
+    enableExperimentalPredefinedClasses.set(false)
+    enableExperimentalUnsafeAllocationTracing.set(false)
+    trackReflectionMetadata.set(true)
+
+    metadataCopy {
+        inputTaskNames.add("test")
+        outputDirectories.add("src/main/resources/META-INF/native-image/<groupId>/<artifactId>/")
+        mergeWithExisting.set(true)
+    }
+}
+----
+
+[[agent-filter-file]]
+==== Reduce the amount of generated metadata
+
+In some cases the agent may include more metadata than it is actually needed.
+You can filter metadata using the agent filter files.
+These filter files that agent consumes have the following structure:
+
+[source,json,subs="verbatim,attributes", role="multi-language-sample"]
+----
+{
+ "rules": [
+    {"includeClasses": "some.class.to.include.**"},
+    {"excludeClasses": "some.class.to.exclude.**"},
+  ],
+  "regexRules": [
+    {"includeClasses": "regex\.example\.class.*"},
+    {"excludeClasses": "regex\.example\.exclude[0-9]+"},
+  ]
+}
+----
+
+The process how you can pass the config files to the agent is described in the <<additional-agent-options,previous section>>.
+
+You can see on some simple Java application how different filter files affect generated metadata.
+
+Let's start with this filter:
+
+[source,json,subs="verbatim,attributes", role="multi-language-sample"]
+----
+{
+  "rules": [
+    {"includeClasses": "**"}
+  ]
+}
+----
+
+This filter instructs the agent to include everything, which will result in a massive configuration file.
+For example, this is how _reachability-metadata.json_ looks like:
+
+[source,json,subs="verbatim,attributes", role="multi-language-sample"]
+----
+{
+  {
+    "reflection": [
+      {
+        "condition": {
+          "typeReached": "java.io.ObjectInputStream"
+        },
+        "type": "[Ljava.lang.Object;"
+      },
+      {
+        "condition": {
+          "typeReached": "java.io.ObjectInputStream"
+        },
+        "type": "java.util.LinkedHashSet"
+      },
+      {
+        "condition": {
+          "typeReached": "org.gradle.api.internal.tasks.testing.junitplatform.JUnitPlatformTestClassProcessor"
+        },
+        "type": "org.example.NativeTests"
+      },
+      {
+        "condition": {
+          "typeReached": "org.junit.jupiter.engine.descriptor.ClassBasedTestDescriptor"
+        },
+        "type": "org.example.NativeTests",
+        "allDeclaredFields": true
+      },
+      {
+        "condition": {
+          "typeReached": "org.junit.jupiter.engine.descriptor.ExtensionUtils"
+        },
+        "type": "org.example.NativeTests"
+      },
+      ...
+    ],
+    "resources": [
+      {
+        "condition": {
+          "typeReached": "org.junit.platform.launcher.core.LauncherFactory"
+        },
+        "glob": "META-INF/services/org.junit.platform.engine.TestEngine"
+      },
+      {
+        "condition": {
+          "typeReached": "java.lang.ClassLoader"
+        },
+        "glob": "TestResource.txt"
+      },
+      ...
+    ],
+    "bundles": [],
+    "jni": [
+      {
+        "condition": {
+          "typeReached": "java.net.InetAddress"
+        },
+        "type": "java.lang.Boolean",
+        "methods": [
+          {
+            "name": "getBoolean",
+            "parameterTypes": [
+              "java.lang.String"
+            ]
+          }
+        ]
+      }
+    ]
+  }
+----
+
+As you can see, there are lots of entries that you likely do not want.
+They are present because the metadata was generated using tests, and that the testing library was present at run time during the agent execution pass, but in practice, your application will not use the testing library in production.
+To reduce the amount of generated metadata, use the following _user-code-filter.json_:
+
+[source,json,subs="verbatim,attributes", role="multi-language-sample"]
+----
+{
+  "rules": [
+    {"includeClasses": "**"},
+    {"excludeClasses": "org.junit.**"},
+    {"excludeClasses": "org.gradle.**"},
+    {"excludeClasses": "worker.org.gradle.**"},
+    {"excludeClasses": "org.slf4j.**"},
+    {"excludeClasses": "java.**"}
+  ]
+}
+----
+
+[WARNING]
+====
+Always be careful when removing entries in metadata, as this may result in a broken native image.
+====
+
+After updating the filter, you can regenerate the metadata, which will result in the following _reachability-metadata.json_ file:
+
+[source,json,subs="verbatim,attributes", role="multi-language-sample"]
+----
+{
+  "reflection": [
+    {
+      "condition": {
+        "typeReached": "org.example.NativeTests"
+      },
+      "type": "org.example.NativeTests$Person",
+      "allDeclaredFields": true
+    },
+    {
+      "condition": {
+        "typeReached": "sun.security.jca.GetInstance"
+      },
+      "type": "sun.security.provider.SHA",
+      "methods": [
+        {
+          "name": "<init>",
+          "parameterTypes": []
+        }
+      ]
+    }
+  ],
+  "resources": [
+    {
+      "condition": {
+        "typeReached": "org.example.NativeTests"
+      },
+      "glob": "TestResource.txt"
+    }
+  ],
+  "bundles": []
+}
+----
+
+As you can see there are no more entries that contain classes from `org.junit` (as their condition).
 
 [[max_parallel_builds]]
 ==== Max parallel builds
 
-When using Gradle parallel builds, the plugin will automatically limit the number of native images which can be built concurrently, in order to limit CPU and memory usage.
-By default, it's limited to the number of CPU cores / 16, but you can change this limit either by setting the `org.graalvm.buildtools.max.parallel.builds` gradle property (e.g in your `gradle.properties` file) or by setting the `GRAALVM_BUILDTOOLS_MAX_PARALLEL_BUILDS` environment variable.
+When using Gradle parallel builds, the plugin automatically limits the number of native images which can be built concurrently, in order to limit CPU and memory usage.
+By default, it is limited to the number of CPU cores / 16, but you can change this limit either by setting the `org.graalvm.buildtools.max.parallel.builds` gradle property (in your _gradle.properties_ file), or by setting the `GRAALVM_BUILDTOOLS_MAX_PARALLEL_BUILDS` environment variable.
 
 [[configuration-advanced]]
 
 [[long_classpath_and_fat_jar_support]]
-==== Long classpath, @argument file and fat jar support
+==== Long classpath, @argument file, and fat JAR support
 
-Since release 0.9.10, the plugin will automatically pass arguments to the `native-image` tool using an argument file, which should prevent all https://github.com/graalvm/native-build-tools/issues/85[long classpath issues] under Windows.
-However, if you are using an older GraalVM release (older than 21.3) which doesn't support argument files, you will need to rely on creating a "fat jar", which includes all entries from the classpath automatically, to workaround the problem:
+The plugin automatically passes arguments to the `native-image` tool from the argument file, which should prevent all https://github.com/graalvm/native-build-tools/issues/85[long classpath issues] under Windows.
+However, if you are using an older GraalVM release (older than 21.3) which doesn't support argument files, you will need to rely on creating a "fat JAR", which includes all entries from the classpath automatically, to workaround the problem:
 
-.Enabling the fat jar creation
+.Enabling the fat JAR creation
 [source, groovy, role="multi-language-sample"]
 ----
 include::../snippets/gradle/groovy/build.gradle[tags=enable-fatjar]
@@ -204,9 +631,8 @@ include::../snippets/gradle/groovy/build.gradle[tags=enable-fatjar]
 include::../snippets/gradle/kotlin/build.gradle.kts[tags=enable-fatjar]
 ----
 
-Alternatively, it is possible to use your own fat jar (for example created using the https://imperceptiblethoughts.com/shadow/[Shadow plugin]) by setting the `classpathJar` property directly on the _task_:
+Alternatively, it is possible to use your own JAR file (for example, created using the https://imperceptiblethoughts.com/shadow/[Shadow plugin]) by setting the `classpathJar` property directly on the _task_:
 
-.Enabling a custom fat jar creation
 [source, groovy, role="multi-language-sample"]
 ----
 include::../snippets/gradle/groovy/build.gradle[tags=custom-fatjar]
@@ -222,21 +648,22 @@ When the `classpathJar` property is set, the `classpath` property is _ignored_.
 [[testing-support]]
 == Testing support
 
-This plugin supports running tests on the
-https://junit.org/junit5/docs/current/user-guide/[JUnit Platform] as native images. This
-means that tests will be compiled and executed as native code.
+The plugin supports running tests on the
+https://junit.org/junit5/docs/current/user-guide/[JUnit Platform] as native images.
+This means that tests are compiled and executed as native code.
 
-NOTE: The minimum supported version is JUnit 5.8.1 (JUnit Platform 1.8.1, JUnit Jupiter 5.8.1, JUnit Vintage 5.8.1)
+[NOTE]
+====
+The minimum supported version is JUnit 5.8.1 (JUnit Platform 1.8.1, JUnit Jupiter 5.8.1, JUnit Vintage 5.8.1).
+====
 
-In theory, any `TestEngine` supported on the JUnit Platform should be supported by this
-plugin as long as the programming language used by the `TestEngine` and the programming
-language used to write the tests is supported in a GraalVM native image. This plugin
-provides explicit support for the JUnit Jupiter and JUnit Vintage test engines, and
-support for additional test engines should be possible with custom native configuration.
+In theory, any `TestEngine` supported on the JUnit Platform should be supported by the plugin as long as the programming language used by the `TestEngine` and the programming language used to write the tests is supported by GraalVM Native Image.
+The plugin provides explicit support for the JUnit Jupiter and JUnit Vintage test engines, and support for additional test engines should be possible with custom native configuration.
 
-Currently, this feature requires the execution of the tests in the classic "JVM" mode _prior to_ the execution of tests in native mode. To execute the tests, execute:
+Currently, this feature requires the execution of the tests on the JVM _prior to_ the execution of tests as native code.
+To execute the tests, run:
 
-[source,bash]
+[source,bash, role="multi-language-sample"]
 ----
 ./gradlew nativeTest
 ----
@@ -260,16 +687,13 @@ include::../snippets/gradle/kotlin/build.gradle.kts[tags=configure-test-binary]
 [[testing-support-disabling]]
 === Disabling testing support
 
-There are cases where you might want to disable native testing support:
+There are cases where you might want to disable running native tests:
 
-- You don't actually want to run your tests in native mode.
-- Your library or application uses a testing framework that is not supported on the JUnit
-  Platform.
-- You need to use the <<agent-support, agent>> when running tests on the JVM but do not
-  wish to run those same tests in native mode.
+- You don't actually want to run your tests as native code.
+- Your library or application uses a testing framework that is not supported on the JUnit Platform.
+- You need to use the <<native-image-tracing-agent, agent>> when running tests on the JVM, but do not wish to run the same tests as native code.
 
-In this case, you can disable native testing support by configuring the `graalvmNative`
-extension as follows:
+In this case, you can disable native testing support by configuring the `graalvmNative` option as follows:
 
 .Disabling testing support
 [source,groovy,role="multi-language-sample"]
@@ -285,14 +709,13 @@ include::../snippets/gradle/kotlin/build.gradle.kts[tags=disable-test-support]
 [[extra-test-suites]]
 === Configuring additional test suites
 
-It's common to have multiple test source sets in a Gradle build.
+It is common to have multiple test source sets in a Gradle build.
 Typically, you may have an integration test suite, or a functional test suite, in addition to the unit test suite.
 The plugin supports running those tests as native binaries too.
 
 For example, imagine that you have a source set named `integTest` and that its corresponding test task is named `integTest`.
-In this case you can register a new native test binary via the `graalvmNative` extension:
+In this case you can register a new native test binary with `graalvmNative`:
 
-.Registering a new test suite
 [source, groovy, role="multi-language-sample"]
 ----
 include::../../../../samples/java-application-with-custom-tests/build.gradle[tag=register-native-test]
@@ -303,69 +726,30 @@ include::../../../../samples/java-application-with-custom-tests/build.gradle[tag
 include::../snippets/gradle/kotlin/build.gradle.kts[tags=custom-binary]
 ----
 
-The plugin will then automatically create the following tasks:
+The plugin then automatically creates the following tasks:
 
-- `nativeIntegTestCompile`, to compile a native image using the `integTest` source set
-- `nativeIntegTest`, to execute the tests in native mode
+- `nativeIntegTestCompile` to compile a native image using the `integTest` source set
+- `nativeIntegTest` to execute the tests as native code
 
 The same mechanism can be used if you have multiple test tasks for a single test source set, which is often the case with manual test sharding.
 
-[[agent-support]]
-== Reflection support and running with the native agent
-
-If your project requires reflection, classpath resources, dynamic proxies or other features requiring explicit native configuration, it may prove helpful to first run your application or tests using the https://www.graalvm.org/reference-manual/native-image/metadata/AutomaticMetadataCollection/[`native-image-agent`].
-
-The Native Image Gradle plugin simplifies generation of the required metadata files by injecting the agent automatically for you (this includes, but is not limited to the reflection file).
-
-Any task that extends `JavaForkOptions` (like `test`, `run` etc) can be instrumented by passing `-Pagent` to gradle when running said tasks.
-
-The agent can run in multiple modes that dictate how the metadata is collected and merged.
-
-Once the metadata is collected, it can be copied into the project using the `metadataCopy` task.
-
-[source,bash]
-----
-./gradlew -Pagent run # Runs on JVM with native-image-agent.
-./gradlew metadataCopy --task run --dir src/main/resources/META-INF/native-image # Copies the metadata collected by the agent into the project sources
-./gradlew nativeCompile # Builds image using metadata acquired by the agent.
-
-# For testing
-./gradlew -Pagent nativeTest # Runs on JVM with the native-image agent, collects the metadata and uses it for testing on native-image.
-----
-
-The agent can run in multiple modes:
-
-* Standard - Collects metadata without conditions. This is recommended if you are building an executable.
-* Conditional - Collects metadata with conditions. This is recommended if you are creating conditional metadata for a library intended for further use.
-* Direct - For advanced users only. This mode allows directly controlling the command line passed to the agent.
-
-The default mode is specified in the DSL but can be changed by passing the mode name to Gradle when using the agent: `-Pagent=conditional`
-
-The generated configuration files will be found in the `${buildDir}/native/agent-output/${taskName}` directory, for example, `build/native/agent-output/run`.
-The plugin will also substitute `{output_dir}` in the agent options to point to this directory during the agent run.
-
-[[agent-support-configuring-options]]
-=== Configuring agent options
-
-The native agent can be configured https://www.graalvm.org/reference-manual/native-image/Agent/[with additional options].
-This can be done using the `agent` configuration block.
-Each agent option has a corresponding field in the DSL.
-See <<configuration-options>> for the full list of available options.
-
-
 [[metadata-support]]
-== GraalVM Reachability Metadata Support
+== GraalVM Reachability Metadata support
 
-The plugin adds support for the https://github.com/oracle/graalvm-reachability-metadata/[GraalVM reachability metadata repository].
-This repository provides https://www.graalvm.org/latest/reference-manual/native-image/metadata/[reachability metadata] for libraries that do not support GraalVM Native Image.
+The plugin adds support for the https://github.com/oracle/graalvm-reachability-metadata/[GraalVM Reachability Metadata Repository].
+This repository provides the https://www.graalvm.org/latest/reference-manual/native-image/metadata/[configuration] for libraries that do not support GraalVM Native Image.
 
-NOTE: This version of the plugin defaults to the using the metadata repository in version {metadata-repository-version}. There is nothing for you to configure if you are fine with this version. The repository is also published on Maven Central at the following coordinates: `org.graalvm.buildtools:graalvm-reachability-metadata:graalvm-reachability-metadata` with the `repository` classifier and `zip` extension, e.g. `graalvm-reachability-metadata-{gradle-plugin-version}-repository.zip`.
+[NOTE]
+====
+The GraalVM Reachability Metadata Repository is also published on Maven Central at the following coordinates: `org.graalvm.buildtools:graalvm-reachability-metadata:graalvm-reachability-metadata` with the `repository` classifier and `zip` extension, for example, `graalvm-reachability-metadata-{gradle-plugin-version}-repository.zip`.
+====
 
 === Configuring the metadata repository
 
-Metadata repository support is enabled by default. Support can be disabled explicitly:
+The plugin automatically downloads the configuration metadata from the official repository if you supply the version of the repository you want to use.
+
+The support is enabled by default, but can be disabled explicitly:
 
-.Disabling the metadata repository
 [source, groovy, role="multi-language-sample"]
 ----
 include::../snippets/gradle/groovy/build.gradle[tags=disable-metadata-repository]
@@ -376,10 +760,8 @@ include::../snippets/gradle/groovy/build.gradle[tags=disable-metadata-repository
 include::../snippets/gradle/kotlin/build.gradle.kts[tags=disable-metadata-repository]
 ----
 
-A metadata repository consists of configuration files for GraalVM.
-The plugin will automatically download the configuration metadata from the official repository if you supply the version of the repository you want to use:
+To override the repository version, use:
 
-.Overriding the repository version
 [source, groovy, role="multi-language-sample"]
 ----
 include::../snippets/gradle/groovy/build.gradle[tags=specify-metadata-repository-version]
@@ -392,7 +774,6 @@ include::../snippets/gradle/kotlin/build.gradle.kts[tags=specify-metadata-reposi
 
 Alternatively, it is possible to use a _local repository_, in which case you can specify the path to the repository:
 
-.Using a local repository
 [source, groovy, role="multi-language-sample"]
 ----
 include::../snippets/gradle/groovy/build.gradle[tags=specify-metadata-repository-file]
@@ -403,11 +784,10 @@ include::../snippets/gradle/groovy/build.gradle[tags=specify-metadata-repository
 include::../snippets/gradle/kotlin/build.gradle.kts[tags=specify-metadata-repository-file]
 ----
 
-For each library included in the native image, the plugin will automatically search for GraalVM image build configuration metadata in the repository.
+For each library dependency, the plugin automatically searches for the configuration metadata in the repository.
 In some cases, you may need to exclude a particular module from the search.
 This can be done by adding it to the exclude list:
 
-.Excluding a module from search
 [source, groovy, role="multi-language-sample"]
 ----
 include::../snippets/gradle/groovy/build.gradle[tags=exclude-module-from-metadata-repo]
@@ -418,10 +798,9 @@ include::../snippets/gradle/groovy/build.gradle[tags=exclude-module-from-metadat
 include::../snippets/gradle/kotlin/build.gradle.kts[tags=exclude-module-from-metadata-repo]
 ----
 
-Last, it is possible for you to override the _metadata version_ of a particular module.
-This may be interesting if there's no specific metadata available for the particular version of the library that you use, but that you know that a version works:
+Lastly, it is possible for you to override the _metadata version_ of a particular module.
+This may be interesting if there is no specific metadata available for the particular version of the library that you use, but that you know that a version works:
 
-.Specifying the metadata version to use for a particular library
 [source, groovy, role="multi-language-sample"]
 ----
 include::../snippets/gradle/groovy/build.gradle[tags=specify-metadata-version-for-library]
@@ -434,18 +813,17 @@ include::../snippets/gradle/kotlin/build.gradle.kts[tags=specify-metadata-versio
 
 === Including metadata repository files
 
-By default, reachability metadata will be used only when your native image is generated.
-In some situations, you may want a copy of the reachability metadata to use directly.
+By default, reachability metadata is used only when your native image is being generated.
+In some situations, you may want a copy of the reachability metadata to use it directly.
 
-For example, copying the reachability metadata into your jar can be useful when some other process is responsible for converting your jar into a native image.
-You might be generating a shaded jar and using a https://paketo.io/[Paketo buildpack] to convert it to a native image.
+Copying the reachability metadata into the application JAR can be useful when some other process is responsible for converting your JAR into a native image.
+For example, you might be generating a shaded JAR file and using a https://paketo.io/[Paketo buildpack] to convert it to a native image.
 
-To download a copy of the metadata into the `build/native-reachability-metadata` directory you can the `collectReachabilityMetadata` task.
+To download a copy of the metadata into the _build/native-reachability-metadata_ directory, you can the `collectReachabilityMetadata` task.
 Files will be downloaded into `META-INF/native-image/<groupId>/<versionId>` subdirectories.
 
-To include metadata repository inside your jar you can link to the task using the `jar` DSL `from` directive:
+To include metadata repository inside the JAR file, you can link to the task using the `jar` DSL `from` directive:
 
-.Including metadata repository files
 [source, groovy, role="multi-language-sample"]
 ----
 include::../snippets/gradle/groovy/build.gradle[tags=include-metadata]
@@ -456,63 +834,70 @@ include::../snippets/gradle/groovy/build.gradle[tags=include-metadata]
 include::../snippets/gradle/kotlin/build.gradle.kts[tags=include-metadata]
 ----
 
-For more advanced configurations you can declare a `org.graalvm.buildtools.gradle.tasks.CollectReachabilityMetadata` task and set the appropriate properties.
+For more advanced configurations you can declare the `org.graalvm.buildtools.gradle.tasks.CollectReachabilityMetadata` task and set the appropriate properties.
 
 [[pgo-support]]
-== Profile-guided optimizations
+== Profile-Guided Optimization
 
-The plugin supports building images with https://www.graalvm.org/latest/reference-manual/native-image/guides/optimize-native-executable-with-pgo/[Profile-Guided Optimizations].
+The plugin supports building images with https://www.graalvm.org/latest/reference-manual/native-image/guides/optimize-native-executable-with-pgo/[Profile-Guided Optimization (PGO)].
 
 It works in 3 phases:
 
-- the first one consists in generating a binary with instrumentation enabled
-- the second phase consists in running the binary in order to gather profiling information
-- the third phase consists in compiling the binary with the generated profile
+- the first one consists in generating a native image with instrumentation enabled
+- the second phase consists in running the image in order to gather profiling information
+- the third phase consists in creating an optimized native image based on the profiles
 
-In order to generate a binary with instrumentation enabled, you should run the `nativeCompile` command with the `--pgo-instrument` command line option:
+To generate a binary with instrumentation enabled, you should run the `nativeCompile` command with the `--pgo-instrument` command line option:
 
-`./gradlew nativeCompile --pgo-instrument`
+[source,bash, role="multi-language-sample"]
+----
+./gradlew nativeCompile --pgo-instrument
+----
 
-This will generate a binary under `build/native/nativeCompile` with the `-instrumented` suffix.
-You can run the binary to gather profiling data:
+This generates a native image under _build/native/nativeCompile_ with the `-instrumented` suffix.
+You can run this image to gather profiling data:
 
-[source,bash]
+[source,bash, role="multi-language-sample"]
 ----
-$ cd build/native/nativeCompile/
-$ ./my-application-instrumented`
+./my-app-instrumented
 ----
 
-A `default.iprof` file will be generated once the application is stopped.
+A _default.iprof_ file will be generated once the application is stopped.
 Alternatively, you can have Gradle both generate and run the instrumented binary in a single command by running:
 
-`./gradlew nativeCompile --pgo-instrument nativeRun`
+[source,bash, role="multi-language-sample"]
+----
+./gradlew nativeCompile --pgo-instrument nativeRun
+----
 
-In which case the profile will automatically be stored into `build/native/nativeCompile`.
+In this case, the profile will automatically be stored under _build/native/nativeCompile_.
 
-The last phase consists in copying the generated profile, so that it's automatically used when building the native binary.
-The conventional location for profiles is `src/pgo-profiles/<name of the binary>`.
-By default, we're using the `main` binary so the location will be `src/pgo-profiles/main`.
-Copy the `default.iprof` file into that directory, then run:
+The last phase consists in copying the generated profile, so that it is automatically used when building an optimized native image.
+The conventional location for profiles is _src/pgo-profiles/<name of the binary>_.
+By default, the location will be _src/pgo-profiles/main_.
+Copy _default.iprof_ into that directory, and then run:
 
-`./gradlew nativeCompile`
+[source,bash, role="multi-language-sample"]
+----
+./gradlew nativeCompile
+----
 
-The profile will automatically be used and the binary compiled with PGO.
-It is possible to include more than one profile, in which case you should rename the `.iprof` files in the `src/pgo-profiles/main` directory.
+The profile will automatically be used.
+It is possible to include more than one profile, in which case you should rename the _.iprof_ files in the _src/pgo-profiles/main_ directory.
 
 [[plugin-configurations]]
 == Configurations defined by the plugin
 
 For each binary (`main` and `test`), the plugin declares 2 configurations that users or plugin authors can use to tweak the native image compilation classpath:
 
-- `nativeImageCompileOnly` (for the `main` binary) and `nativeImageTestCompileOnly` (for the `test` binary) can be used to declare dependencies which are only needed at image compilation.
-- `nativeImageClasspath` (for the `main` binary) and `nativeImageTestClasspath` (for the `test` binary) are the configurations which are resolved to determine the image classpaths.
+- `nativeImageCompileOnly` (for the `main` binary) and `nativeImageTestCompileOnly` (for the `test` binary) can be used to declare dependencies which are only needed during the ahead-of-time compilation.
+- `nativeImageClasspath` (for the `main` binary) and `nativeImageTestClasspath` (for the `test` binary) are the configurations which are resolved to determine the image classpath.
 
-The native image "compile only" configurations can typically be used to declare dependencies which are only required when building a native binary, and therefore shouldn't leak to the classic "JVM" runtime.
+The native image "compile only" configurations can typically be used to declare dependencies which are only required when building a native binary, and therefore should not leak when running on the JVM.
 
-For example, you could declare a source set which uses the GraalVM SDK to implement native features.
+For example, you can declare a source set which uses the GraalVM SDK to implement native features.
 This source set would contain code which is only relevant to native images building:
 
-.Declaring a custom source set
 [source, groovy, role="multi-language-sample"]
 ----
 include::../../../../samples/java-application-with-extra-sourceset/build.gradle[tag=extra-sourceset]
@@ -525,4 +910,4 @@ include::../../../../samples/java-application-with-extra-sourceset/build.gradle.
 
 == Javadocs
 
-In addition, you can consult the link:javadocs/native-gradle-plugin/index.html[Javadocs of the plugin].
+For further reference, you can review the link:javadocs/native-gradle-plugin/index.html[Javadocs of the plugin].
\ No newline at end of file
diff --git a/docs/src/docs/asciidoc/highlight/styles/equilibrium-light.min.css b/docs/src/docs/asciidoc/highlight/styles/equilibrium-light.min.css
index 8d7561df7..80fcf8a4e 100644
--- a/docs/src/docs/asciidoc/highlight/styles/equilibrium-light.min.css
+++ b/docs/src/docs/asciidoc/highlight/styles/equilibrium-light.min.css
@@ -4,4 +4,98 @@
   License: ~ MIT (or more permissive) [via base16-schemes-source]
   Maintainer: @highlightjs/core-team
   Version: 2021.05.0
-*/pre code.hljs{display:block;overflow-x:auto;padding:1em}code.hljs{padding:3px 5px}.hljs{color:#43474e;background:#f5f0e7}.hljs ::selection{color:#d8d4cb}.hljs-comment{color:#73777f}.hljs-tag{color:#5a5f66}.hljs-operator,.hljs-punctuation,.hljs-subst{color:#43474e}.hljs-operator{opacity:.7}.hljs-bullet,.hljs-deletion,.hljs-name,.hljs-selector-tag,.hljs-template-variable,.hljs-variable{color:#d02023}.hljs-attr,.hljs-link,.hljs-literal,.hljs-number,.hljs-symbol,.hljs-variable.constant_{color:#bf3e05}.hljs-class .hljs-title,.hljs-title,.hljs-title.class_{color:#9d6f00}.hljs-strong{font-weight:700;color:#9d6f00}.hljs-addition,.hljs-code,.hljs-string,.hljs-title.class_.inherited__{color:#637200}.hljs-built_in,.hljs-doctag,.hljs-keyword.hljs-atrule,.hljs-quote,.hljs-regexp{color:#007a72}.hljs-attribute,.hljs-function .hljs-title,.hljs-section,.hljs-title.function_,.ruby .hljs-property{color:#0073b5}.diff .hljs-meta,.hljs-keyword,.hljs-template-tag,.hljs-type{color:#4e66b6}.hljs-emphasis{color:#4e66b6;font-style:italic}.hljs-meta,.hljs-meta .hljs-keyword,.hljs-meta .hljs-string{color:#c42775}.hljs-meta .hljs-keyword,.hljs-meta-keyword{font-weight:700}
\ No newline at end of file
+*/
+pre code.hljs {
+    display: block;
+    overflow-x: auto;
+    padding: 1em;
+    color: white;
+}
+
+code.hljs {
+    padding: 3px 5px
+}
+
+.hljs {
+    color: white;
+    background: none;
+    border: 1px solid #ffc107;
+    border-radius: 4px;
+}
+
+::selection {
+    background: gray;
+    color: inherited;
+}
+
+.hljs-comment {
+    color: white;
+    font-style: italic;
+}
+
+
+.hljs-operator,.hljs-punctuation,.hljs-subst {
+    color: white;
+}
+
+.hljs-operator {
+    opacity: 0.8
+}
+
+
+.hljs-tag {
+    color: #00758F;
+    font-weight: 600;
+}
+
+.hljs-name {
+    color: #ffc107;
+    font-weight: 600;
+}
+
+.hljs-attr {
+    color: #ff0091;
+    font-weight: 400;
+}
+
+.hljs-bullet,.hljs-deletion,.hljs-selector-tag,.hljs-template-variable,.hljs-variable {
+    color: #ff00b4;
+    font-weight: 600;
+}
+
+.hljs-link,.hljs-literal,.hljs-number,.hljs-symbol,.hljs-variable.constant_ {
+    color: #05a4bf;
+}
+
+.hljs-class .hljs-title,.hljs-title,.hljs-title.class_ {
+    color: #00ff68;
+}
+
+.hljs-addition,.hljs-code,.hljs-string,.hljs-title.class_.inherited__ {
+    color: #00ff68;
+}
+
+.hljs-built_in,.hljs-doctag,.hljs-keyword.hljs-atrule,.hljs-quote,.hljs-regexp {
+    color: #05a4bf;
+}
+
+.hljs-attribute,.hljs-function .hljs-title,.hljs-section,.hljs-title.function_,.ruby .hljs-property {
+    color: #ffc107;
+}
+
+.diff .hljs-meta,.hljs-keyword,.hljs-template-tag,.hljs-type {
+    color: #ffc107;
+}
+
+.hljs-emphasis {
+    color: #4e66b6;
+    font-style: italic;
+}
+
+.hljs-meta,.hljs-meta .hljs-keyword,.hljs-meta .hljs-string {
+    color: #05a4bf;
+}
+
+.hljs-meta .hljs-keyword,.hljs-meta-keyword {
+    font-weight: 700;
+}
diff --git a/docs/src/docs/asciidoc/index.adoc b/docs/src/docs/asciidoc/index.adoc
index 703456ede..ceb4e6b36 100644
--- a/docs/src/docs/asciidoc/index.adoc
+++ b/docs/src/docs/asciidoc/index.adoc
@@ -1,496 +1,36 @@
 = Native Build Tools
 The GraalVM team
 
-The {doctitle} project provides plugins for different build tools to add support for building and testing native applications written in Java (or any other language compiled to JVM bytecode).
+The {doctitle} project provides plugins for various build tools, enabling support for building and testing native applications written in Java (or any other language compiled to JVM bytecode) using https://www.graalvm.org/reference-manual/native-image/[GraalVM  Native Image].
+Currently, you can build your native applications using our Gradle or Maven plugins.
 
-Most notably, this is the official source for integrating with the https://www.graalvm.org/reference-manual/native-image/[GraalVM  Native Image].
-
-Please refer to the following pages for build tool specific documentation:
-
-- The <<gradle-plugin.adoc#,Gradle plugin documentation>>
-- The <<maven-plugin.adoc#,Maven plugin documentation>>
-
-This release of Native Build Tools ships with the GraalVM reachability metadata repository release {metadata-repository-version}.
-
-If you are interested in contributing, please refer to the https://github.com/graalvm/native-build-tools[Git repository].
+Each plugin takes metadata for available libraries from the https://github.com/oracle/graalvm-reachability-metadata[GraalVM reachability metadata repository]
+to provide better experience during the development of your native project.
 
 If you are using alternative build systems, see <<alternative-build-systems.adoc#,Useful Hints for Alternative Build Systems>>.
 
-[[changelog]]
-== Changelog
-
-=== Release 0.10.3
-
-- Remove usage of macro from merger tool initialization and throw better error if executable does not exist
-- Add support for the new reachability-metadata.json config file
-- Remove custom post-processing task for filtering config files entries and use access-filter.json instead
-
-==== Gradle plugin
-
-- Add retries when downloading the metadata repository when using a URL directly
-
-==== Maven plugin
-
-- Add retries when downloading the metadata repository when using a URL directly
-
-
-=== Release 0.10.2
-
-- Fix class path directory analyzer
-- Update Reachability Metadata repository version
-
-==== Gradle plugin
-
-- Update Default Target Directory for MetadataCopy Task
-
-==== Maven plugin
-
-- Update Getting Started with Maven Plugin doc
-- Delete old stale args file
-- Add a parameter to be able to skip build native for pom type modules, leave it as false per default for backward compat
-
-=== Release 0.10.1
-
-- Mark additional JUnit 5 types for build-time initialization for compatibility with Native Image's `--strict-image-heap` option.
-
-
-=== Release 0.10.0
-
-- Update version of GraalVM dependency to 22.3.5
-
-==== Gradle plugin
-
-- Update plugin to use metadata repository by default. Metadata repository <<gradle-plugin.adoc#_configuring_the_metadata_repository,can be disabled manually.>>
-
-==== Maven plugin
-
-- Update plugin to use metadata repository by default. Metadata repository <<maven-plugin.adoc#_configuring_the_metadata_repository,can be disabled manually.>>
-
-
-=== Release 0.9.28
-
-* Fix path escaping problem for Windows users
-* Fix and improve major JDK version detection.
-
-==== Gradle plugin
-
-- Remove use of deprecated `getConvention` APIs
-
-=== Release 0.9.27
-
-* Update JUnit configuration for native testing on GraalVM for JDK 21 with `--strict-image-heap` mode.
-
-=== Release 0.9.26
-
-* Relax GraalVM version check for dev versions
-* Prepare plugins for release of _GraalVM for JDK 21_. They no longer deploy any experimental options.
-* Bump Java compliance of the plugins from Java 8+ to Java 11+.
-* Fix compatibility with Maven 3.9.
-
-==== Gradle plugin
-
-* Fix compatibility with Gradle 8.3
-
-=== Release 0.9.25
-
-* Upgrade metadata to 0.3.4
-
-=== Release 0.9.24
-
-* Upgrade metadata to 0.3.3
-
-==== Gradle plugin
-
-* Add support for PGO
-
-=== Release 0.9.23
-
-* Upgrade metadata to 0.3.2
-* Display the GraalVM logo on the generated NBT docs
-
-==== Gradle plugin
-
-- Remove use of GFileUtils
-- Fix "collect reachability metadata" with config cache
-
-=== Release 0.9.22
-
-* Upgrade metadata to 0.3.0
-* Add support for default-for attribute
-
-==== Gradle plugin
-
-- Fix lookup of metadata repository
-
-=== Release 0.9.21
-
-* Deprecate `requiredVersion` check without replacement.
-
-==== Gradle plugin
-
-- Bump minimal version of Gradle to 7.4
-- Fix compatibility with Gradle's https://docs.gradle.org/8.0.2/userguide/configuration_cache.html#header[configuration cache] (requires Gradle 7.5+)
-- Remove use of deprecated Gradle APIs
-- [Behavior change] Toolchain detection is now disabled by default
-
-==== Maven plugin
-
-- Add a new `native:write-args-file` goal that can be used to write the arguments passed to `native-image` to a file
-
-=== Release 0.9.20
-
-==== Gradle plugin
-
-- Fix `collectReachabilityMetadata` not being thread-safe
-- Add an option to configure the maximum number of images which can be built in parallel
-- Fix GraalVM version check being too strict
-
-==== Maven plugin
-
-- Add agent modes to Maven plugin
-
-=== Release 0.9.19
-
-==== Gradle plugin
-
-- Fix `nativeCompile` being out-of-date whenever native runtime arguments change
-- Fix GraalVM metadata repository not downloaded from project repositories by default
-
-==== Maven plugin
-
-=== Release 0.9.18
-
-* Trim GraalVM version to fix Windows support
-* Add tests for NativeImageUtils.escapeArg
-* Do not escape quoted regexp args when using argsfile
-* Upgrade to GraalVM metadata repository 0.2.5
-
-=== Release 0.9.17
-
-* Add a `requiredVersion` property to check the minimal GraalVM version
-* Make GraalVM installation check lazy
-
-=== Release 0.9.16
-
-* Fixed regression with a reachability-metadata repository
-
-=== Release 0.9.15
-
-* Upgrade to GraalVM metadata repository 0.2.3.
-* Ship the metadata repository as an artifact alongside the plugin
-* Add ability to collect GraalVM metadata of dependencies to a custom location
-
-==== Gradle plugin
-
-* Improved diagnostics to help users figure out what GraalVM toolchain was selected
-
-=== Release 0.9.14
-
-==== Gradle plugin
-* Add ability to set environment variables to the native image builder process
-* Argument files are now stored in the `build` directory (workaround for absolute path issue on Windows with older GraalVM versions)
-
-==== Maven plugin
-* Added `native:compile` forking goal that can be started from the command line as `mvn native:compile`.
-* Deprecated `build` goal in favour of `compile-no-fork` goal. This goal should now be used for attaching to the `package` phase in `pom.xml`. Attaching the `build` goal will (for now) produce a runtime warning.
-* Argument files are now stored in the `target` directory (workaround for absolute path issue on Windows with older GraalVM versions).
-* Default and test outputs are now much less noisy.
-* When running tests in JVM mode with the native-image-agent, GraalVM's `java` executable is now always used.
-* Maven plugin now shouldn't require that JVM running it must be GraalVM.
-
-=== Release 0.9.13
-
-==== Gradle plugin
-* Reverted a change in the `NativeImagePlugin` that removed publicly accessible constants. This should prevent breakage of external plugins.
-
-==== JUnit testing support
-* Adapted the JUnit automatic metadata registration to changes in annotation handling on newer native image versions.
-
-=== Release 0.9.12
-
-==== Gradle plugin
-* Completely reworked agent support - **BREAKING CHANGE**
-* The agent block is no longer tied to the target binary.
-* The agent can now instrument any task that extends `JavaForkOptions`.
-* Introduced the `metadataCopy` task.
-* Introduced the concept of agent modes.
-** Under the hood, the agent mode dictates what options are passed to the agent and how metadata produced by multiple runs get merged.
-* Added `excludeConfig` configuration option that allows skipping of configuration files that are present in dependencies.
-* `useArgFile` is now set to true by default only on Windows.
-* Added `quickBuild` configuration option.
-
-==== Maven plugin
-* Added support for GraalVM Reachability Metadata Repository.
-* Completely reworked Maven plugin (should fix many of previous issues and inconsistencies between main and test builds).
-* Added `classesDirectory`, `debug`, `fallback`, `verbose`, `sharedLibrary`, `configurationFileDirectories`, `excludeConfig`, `quickBuild`, and `jvmArgs` properties in order to match those present in the Gradle plugin.
-+
-See <<maven-plugin.adoc#,docs>> for more information.
-* `useArgFile` is now set to true by default only on Windows.
-* Changed lookup order for `native-image` discovery -- `GRAALVM_HOME`, `JAVA_HOME`, `PATH`.
-
-=== Release 0.9.11
-
-==== Maven plugin
-
-* Fix long classpath issue under Windows when running native tests
-* Inherit environment variables and system properties from the surefire plugin configuration when executing tests
-* Fix invocation of `native-image` when classpath contains spaces
-
-==== Gradle plugin
-
-* Add support for environment variables in native test execution
-* Fix invocation of `native-image` when classpath contains spaces
-* Add experimental support for the JVM reachability metadata repository
-
-=== Release 0.9.10
-
-==== Maven plugin
-
-* Native testing support can now be explicitly disabled via `skipNativeTests`.
-   - See <<maven-plugin.adoc#testing-support-disabling, Disabling testing support>> for details.
-* Fixed race condition which prevented the agent files to be generated properly if tests were executed concurrently
-* Documented version compatibility for the JUnit Platform and Maven Surefire plugin.
-   - See <<maven-plugin.adoc#testing-support-version-compatibility, Version compatibility>> for details.
-* Add support for long classpath by using an argument file when invoking `native-image`
-
-==== Gradle plugin
-
-* Fixed `nativeRun` not working properly under Windows
-* Fixed race condition which prevented the agent files to be generated properly if tests were executed concurrently
-* Add support for long classpath by using an argument file when invoking `native-image`
-
-=== Release 0.9.9
-
-==== Gradle plugin
-
-* Fixed resource inference not working on custom binaries
-* Fixed `disableToolchainDetection` not working if a GraalVM installation isn't present. Please use `graalvmNative.toolchainDetection.set(false)` instead.
-
-=== Release 0.9.8
-
-==== Gradle plugin
-
-* [Breaking change] The `agent` option has been replaced with an `agent { ... }` configuration block which includes an `enabled` property.
-* Toolchain support can now be disabled altogether, which can be useful when using GraalVM Enterprise Edition.
-  - See <<gradle-plugin.adoc#configuration-toolchains-disabling, Disabling toolchain detection>> for details.
-* Fixed a bug when using a _fat jar_ which assumed that all entries to be repackaged were jars.
-* Agent options are now configurable.
-   - Note that the `experimental-class-loader-support` agent option is no longer added by default.
-   - See <<gradle-plugin.adoc#agent-support-configuring-options, Configuring agent options>> for details.
-* Added an option to perform resource detection in classpath entries which contain a `native-image/resource-config.json` file.
-
-==== Maven plugin
-
-* The agent can now be enabled in the POM.
-  - See <<maven-plugin.adoc#agent-support-enabling, Enabling the agent>> for details.
-* Agent options are now configurable.
-   - Note that the `experimental-class-loader-support` agent option is no longer added by default.
-   - See <<maven-plugin.adoc#agent-support-configuring-options, Configuring agent options>> for details.
-* Added an option to perform resource detection in classpath entries which contain a `native-image/resource-config.json` file.
-
-==== JUnit Platform Native
-
-* Builds now correctly fail if a container-level extension or lifecycle method fails --
-  for example, if an `@BeforeAll` method in a JUnit Jupiter test class throws an exception.
-* Builds no longer fail when tests are aborted -- for example, via a failed assumption.
-* Improved documentation for JUnit Platform and Maven Surefire support in the plugins.
-
-=== Release 0.9.7.1
-
-==== Bugfixes
-
-- Fixed https://github.com/graalvm/native-build-tools/issues/144[Maven plugin configuration not applied if declared in a parent POM].
-
-=== Release 0.9.7
-
-Release didn't include any fixes.
-
-=== Release 0.9.6
-
-==== Upgrade to JUnit 5.8
-
-The plugins now depend on JUnit 5.8 which provides an official test listener which is used by these plugins.
-As a consequence, Maven users will have to configure their builds to enable the plugin extensions:
-
-```xml
-<plugin>
-    <groupId>org.graalvm.buildtools</groupId>
-    <artifactId>native-maven-plugin</artifactId>
-    <version>${native.maven.plugin.version}</version>
-    <extensions>true</extensions>
-    ...
-</plugin>
-```
-
-The dependency on `junit-platform-native` which used to be required pre-0.9.6 can now safely be removed.
-
-For Gradle users, there's no impact on the configuration, however a good consequence is that the `junit-native-platform` dependency no longer leaks into your application's classpath.
-
-==== Agent support for Maven plugin
-
-The Maven plugin now supports the GraalVM agent to generate configuration files.
-Please refer to the <<maven-plugin.adoc#agent-support,Maven plugin documentation>> for details.
-
-==== Disabling testing support
-
-The Gradle plugin now provides an option to disable testing support.
-This can be useful if the test framework you are using doesn't work with this plugin or that you simply don't want to execute tests natively.
-
-To disable tests, use the `graalvmNative` configuration block:
-
-```kotlin
-graalvmNative {
-    testSupport.set(false)
-}
-```
-
-==== Configuring additional test images
-
-The Gradle plugin now supports building multiple test images, which can be used to execute tests natively for more kinds of tests: integration tests, functional tests, ...
-
-For more information, please refer to <<gradle-plugin.adoc#extra-test-suites,the Gradle plugin documentation>>
-
-=== Release 0.9.5
-
-This release contains, in preparation for supporting more images in the Gradle plugin:
-
-- The `nativeBuild` and `nativeTest` extensions are now deprecated. A top-level container for configuring native images has been introduced. Instead of:
-
-[source,groovy]
-----
-nativeBuild {
-   verbose = true
-}
-----
-
-you need to use:
-
-[source,groovy]
-----
-graalvmNative {
-  binaries {
-    main {
-      verbose = true
-    }
-  }
-}
-----
-
-and instead of:
-
-[source,groovy]
-----
-nativeTest {
-    buildArgs("...")
-}
-----
-
-you need to use:
-
-[source,groovy]
-----
-graalvmNative {
-  binaries {
-    test {
-      verbose = true
-    }
-  }
-}
-----
-
-- The `nativeBuild` task has been renamed to `nativeCompile`.
-- The `nativeTestBuild` task has been renamed to `nativeTestCompile`.
-
-Both `nativeBuild` and `nativeTestBuild` task invocations are still supported but deprecated and will be removed in a future release.
-
-=== Release 0.9.4
-
-This release works around a limitation for Windows users who encounter an issue with long classpath entries on CLI: the Gradle plugin will now automatically handle this problem by creating a fat jar instead of passing all entries on classpath (this behavior can be <<gradle-plugin.adoc#long_classpath_and_fat_jar_support, disabled>>) if needed).
-Maven users will have to <<maven-plugin.adoc#long_classpath_and_shading_support, configure their build differently>> to use shading.
-
-In addition to this, we're now publishing development snapshots of this plugin. For Gradle, you will need to declare this repository in your settings.gradle(.kts) file:
-
-[source,groovy]
-----
-pluginManagement {
-    plugins {
-        id 'org.graalvm.buildtools.native' version '0.9.5-SNAPSHOT'
-    }
-    repositories {
-        maven {
-            url "https://raw.githubusercontent.com/graalvm/native-build-tools/snapshots"
-        }
-        gradlePluginPortal()
-    }
-}
-----
-
-For Maven, you need to use this repository configuration:
-
-[source,xml]
-----
-<pluginRepositories>
-    <pluginRepository>
-        <id>graalvm-native-build-tools-snapshots</id>
-        <name>GraalVM native-build-tools Snapshots</name>
-        <url>https://raw.githubusercontent.com/graalvm/native-build-tools/snapshots</url>
-        <releases>
-            <enabled>false</enabled>
-        </releases>
-        <snapshots>
-            <enabled>true</enabled>
-        </snapshots>
-    </pluginRepository>
-</pluginRepositories>
-----
-
-=== Release 0.9.3
-
-This release contains:
-
-- Fix for mainClass not being optional (Gradle plugin)
-- Fix for Gradle < 7 failing to determine GraalVM toolchain
-- Gradle plugin now registers proper groups
-- Automatic native-image tool fetching via gu (Gradle plugin)
-- FIxed issue where nativeTest would fail when tests are annotated with Timeout
-- Added a sharedLibrary configuration option for Gradle plugin
-- Removed broken server configuration option from Gradle plugin
-- Added a documentation website with proper CI integration
-
-In addition to those improvements, several behind-the-scenes changes were made:
-
-- Introduced "Dockerless" Maven plugin functional testing
-- Parallelized Gradle testing in CI
-- Replaced groovy-json with jackson-databind for JSON handling
-- Fixed Github Actions syntax to enable manual workflow invoking
-
-=== Release 0.9.2
-
-This release contains:
-
-- Revamped Gradle plugin that is now a lot more idiomatic.
-- Fixes for several issues regarding JUnit testing.
-- Removal of Test Discovery mode from the Maven plugin.
-- Fix for Maven creating empty test images when no tests are present.
-- Added support for Kotlin tests in Gradle.
+[discrete]
+=== Documentation
 
-In addition to those improvements, several behind-the-scenes changes were made in order to ensure better compatibility moving forward:
+If you're new to the Native Build Tools, whether as an end user or a library author, check out our:
 
-- Test coverage has been greatly improved for all subprojects.
-- Build tooling for this repository has been improved significantly.
+- <<end-to-end-gradle-guide.adoc#,Building Native Images with Gradle: An End-to-End Guide>>
+- <<end-to-end-maven-guide.adoc#,Building Native Images with Maven: An End-to-End Guide>>
 
-Note that there has been a breaking change in the Gradle plugin - `persistConfig` configuration option was removed.
-Using said option will cause existing builds to break, so users are advised to remove it from their configuration prior to upgrading.
-System property `-DpersistConfig` will have no effect going forward.
+For detailed documentation, see the corresponding page for each build tool:
 
-=== Release 0.9.1
+- <<gradle-plugin.adoc#,Gradle plugin documentation>>
+- <<maven-plugin.adoc#,Maven plugin documentation>>
 
-This release contains:
+For updates to the Native Build Tools between releases, see the full changelog <<changelog.adoc#,here>>.
 
-- Fixes for most of the known issues regarding Gradle and Maven plugins
-- Massively improved automatic JUnit support as well as initial JUnit Vintage support
-- Improved JavaDoc and tests for the Gradle plugin
+[discrete]
+=== Contributing
 
-=== Release 0.9.0
+If you are interested in contributing or reporting an issue related to the plugins, please refer to the https://github.com/graalvm/native-build-tools[Native Build Tools repository].
+Please note that all contributors must sign the https://oca.opensource.oracle.com/[Oracle Contributor Agreement] (OCA).
 
-Initial release
+[TIP]
+--
+This repository should be used for reporting issues related specifically to the Maven or Gradle plugins for GraalVM Native Image.
+For issues related to frameworks such as https://spring.io/[Spring Framework] or https://micronaut.io/[Micronaut framework], please report them to their respective repositories.
diff --git a/docs/src/docs/asciidoc/maven-plugin-quickstart.adoc b/docs/src/docs/asciidoc/maven-plugin-quickstart.adoc
deleted file mode 100644
index 82e7dec6a..000000000
--- a/docs/src/docs/asciidoc/maven-plugin-quickstart.adoc
+++ /dev/null
@@ -1,494 +0,0 @@
-= Getting Started with Maven Plugin for GraalVM Native Image
-The GraalVM team
-:highlighjsdir: {gradle-relative-srcdir}/highlight
-
-This guide shows how to get started with the <<maven-plugin.adoc#,Maven plugin for GraalVM Native Image>> and build a native executable for a Java application.
-
-You will create a sample application, enable the plugin, add support for dynamic features, build a native executable, and run JUnit tests.
-
-====
-The plugin requires that you https://www.graalvm.org/latest/docs/getting-started/[setup GraalVM].
-
-The easiest way to install GraalVM is to use https://sdkman.io/jdks[SDKMAN!].
-
-For other installation options, go to https://www.graalvm.org/downloads/[GraalVM Downloads].
-====
-
-== Prepare a Demo Application
-
-====
-You start by creating a **Fortune Teller** sample application that simulates the traditional
-https://en.wikipedia.org/wiki/Fortune_(Unix)[fortune Unix program].
-The data for the fortune phrases is provided by https://github.com/your-fortune[YourFortune].
-====
-
-. Create a new Java project with *Maven* in your favorite IDE, called _Fortune_, in the package named _demo_. Make sure to choose
-https://mvnrepository.com/artifact/org.junit.jupiter/junit-jupiter[JUnit Jupiter] as the test engine. The _pom.xml_ file
-should look similar to the following.
-+
-[source,xml]
-----
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <groupId>demo</groupId>
-    <artifactId>fortune</artifactId>
-    <version>1.0.0</version>
-    <name>Fortune Teller GraalVM Demo</name>
-
-    <dependencies>
-        <dependency>
-            <groupId>org.junit.jupiter</groupId>
-            <artifactId>junit-jupiter</artifactId>
-            <version>5.10.1</version>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
-</project>
-----
-
-. Create the _Fortune.java_ (_src/main/java/demo/Fortune.java_) class.
-+
-[source,java]
-----
-package demo;
-
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.databind.JsonNode;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.Random;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-public class Fortune {
-
-    private static final Random RANDOM = new Random();
-    private final ArrayList<String> fortunes = new ArrayList<>();
-
-    public Fortune() throws JsonProcessingException {
-        // Scan the file into the array of fortunes
-        String json = readInputStream(ClassLoader.getSystemResourceAsStream("fortunes.json"));
-        ObjectMapper omap = new ObjectMapper();
-        JsonNode root = omap.readTree(json);
-        JsonNode data = root.get("data");
-        Iterator<JsonNode> elements = data.elements();
-        while (elements.hasNext()) {
-            JsonNode quote = elements.next().get("quote");
-            fortunes.add(quote.asText());
-        }
-    }
-
-    private String readInputStream(InputStream is) {
-        StringBuilder out = new StringBuilder();
-        try (InputStreamReader streamReader = new InputStreamReader(is, StandardCharsets.UTF_8);
-            BufferedReader reader = new BufferedReader(streamReader)) {
-            String line;
-            while ((line = reader.readLine()) != null) {
-                out.append(line);
-            }
-
-        } catch (IOException e) {
-            Logger.getLogger(Fortune.class.getName()).log(Level.SEVERE, null, e);
-        }
-        return out.toString();
-    }
-
-    private void printRandomFortune() throws InterruptedException {
-        //Pick a random fortune
-        String f = randomFortune();
-        // Print out the fortune s.l.o.w.l.y
-        for (char c : f.toCharArray()) {
-            System.out.print(c);
-            Thread.sleep(100);
-        }
-        System.out.println();
-    }
-
-    public String randomFortune() {
-        //Pick a random number
-        int r = RANDOM.nextInt(fortunes.size());
-        //Use the random number to pick a random fortune
-        return fortunes.get(r);
-    }
-
-    /**
-    * @param args the command line arguments
-    * @throws java.lang.InterruptedException
-    * @throws com.fasterxml.jackson.core.JsonProcessingException
-    */
-    public static void main(String[] args) throws InterruptedException, JsonProcessingException {
-        Fortune fortune = new Fortune();
-        fortune.printRandomFortune();
-    }
-}
-----
-. Copy and paste the following file,
-https://raw.githubusercontent.com/graalvm/graalvm-demos/refs/heads/master/fortune-demo/fortune-maven/src/main/resources/fortunes.u8[fortunes.json]
-under the _resources_ directory (_src/main/resources/fortunes.json_). Your project tree should be:
-+
-[source,shell]
-----
-.
-├── pom.xml
-└── src
-    └── main
-        ├── java
-        │   └── demo
-        │       └── Fortune.java
-        └── resources
-            └── fortunes.json
-----
-. Add the https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind[FasterXML Jackson]
-dependency that provide functionality to read and write JSON, data bindings (used in the demo application). Open the
-_pom.xml_ file (a Maven configuration file), and insert the following in the `<dependencies>` section:
-+
-[source,xml]
-----
-<dependency>
-    <groupId>com.fasterxml.jackson.core</groupId>
-    <artifactId>jackson-databind</artifactId>
-    <version>2.16.0</version>
-</dependency>
-----
-There should be two dependencies, the FasterXML Jackson dependency and the JUnit 5 dependency as shown below.
-+
-[source,xml]
-----
-<dependencies>
-    <dependency>
-        <groupId>com.fasterxml.jackson.core</groupId>
-        <artifactId>jackson-databind</artifactId>
-        <version>2.16.0</version>
-    </dependency>
-    <dependency>
-        <groupId>org.junit.jupiter</groupId>
-        <artifactId>junit-jupiter</artifactId>
-        <version>5.10.1</version>
-        <scope>test</scope>
-    </dependency>
-</dependencies>
-----
-. Add regular Maven plugins for building and assembling a Maven project into an executable JAR.
-Insert the following into the `build` section in the _pom.xml_ file:
-+
-[source,xml]
-----
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.codehaus.mojo</groupId>
-                <artifactId>exec-maven-plugin</artifactId>
-                <version>3.1.1</version>
-                <executions>
-                    <execution>
-                        <id>java</id>
-                        <goals>
-                            <goal>java</goal>
-                        </goals>
-                        <configuration>
-                            <mainClass>${mainClass}</mainClass>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.11.0</version>
-                <configuration>
-                    <source>${maven.compiler.source}</source>
-                    <target>${maven.compiler.source}</target>
-                </configuration>
-            </plugin>
-
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-jar-plugin</artifactId>
-                <version>3.3.0</version>
-                <configuration>
-                    <archive>
-                        <manifest>
-                            <addClasspath>true</addClasspath>
-                            <mainClass>${mainClass}</mainClass>
-                        </manifest>
-                    </archive>
-                </configuration>
-            </plugin>
-
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-assembly-plugin</artifactId>
-                <version>3.6.0</version>
-                <executions>
-                    <execution>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>single</goal>
-                        </goals>
-                    </execution>
-                </executions>
-                <configuration>
-                    <archive>
-                        <manifest>
-                            <addClasspath>true</addClasspath>
-                            <mainClass>${mainClass}</mainClass>
-                        </manifest>
-                    </archive>
-                    <descriptorRefs>
-                        <descriptorRef>jar-with-dependencies</descriptorRef>
-                    </descriptorRefs>
-                </configuration>
-            </plugin>
-        </plugins>
-    </build>
-----
-. Replace the default `<properties>` section in the _pom.xml_ file with this content:
-+
-[source,xml,subs="verbatim,attributes"]
-----
-    <properties>
-        <native.maven.plugin.version>{maven-plugin-version}</native.maven.plugin.version>
-        <maven.compiler.source>${java.specification.version}</maven.compiler.source>
-        <maven.compiler.target>${java.specification.version}</maven.compiler.target>
-        <imageName>fortune</imageName>
-        <mainClass>demo.Fortune</mainClass>
-    </properties>
-----
-+
-The statements "hardcoded" plugin versions and the entry point class to your application.
-The next steps demonstrate what you should do to enable the
-https://graalvm.github.io/native-build-tools/latest/maven-plugin.html[Maven plugin for GraalVM Native Image].
-. Register the Maven plugin for GraalVM Native Image, `native-maven-plugin`, within a Maven profile, `native`, by adding the following to the _pom.xml_ file:
-+
-[source,xml]
-----
-    <profiles>
-        <profile>
-            <id>native</id>
-            <build>
-                <plugins>
-                    <plugin>
-                        <groupId>org.graalvm.buildtools</groupId>
-                        <artifactId>native-maven-plugin</artifactId>
-                        <version>${native.maven.plugin.version}</version>
-                        <executions>
-                            <execution>
-                                <id>build-native</id>
-                                <goals>
-                                    <goal>compile-no-fork</goal>
-                                </goals>
-                                <phase>package</phase>
-                            </execution>
-                            <execution>
-                                <id>test-native</id>
-                                <goals>
-                                    <goal>test</goal>
-                                </goals>
-                                <phase>test</phase>
-                            </execution>
-                        </executions>
-                        <configuration>
-                            <fallback>false</fallback>
-                        </configuration>
-                    </plugin>
-                </plugins>
-            </build>
-        </profile>
-    </profiles>
-----
-+
-It pulls the latest plugin version. 
-Replace `${native.maven.plugin.version}` with a specific version if you prefer.
-The plugin discovers which JAR files it needs to pass to the `native-image` builder and what the executable main class should be.
-With this plugin you can already build a native executable directly with Maven by running `mvn -Pnative package` (if your application does not call any methods reflectively at run time).
-
-== Build a Native Executable by Detecting Resources with the Agent
-
-This demo application and requires metadata before building a native executable. 
-You do not have to configure anything manually: the plugin can generate the required configuration for you by injecting the https://graalvm.github.io/native-build-tools/latest/maven-plugin.html#agent-support[tracing agent] at package time.
-The agent is disabled by default, and can be enabled in project's _pom.xml_ file or via the command line.
-
-. To enable the agent via the _pom.xml_ file, specify `<enabled>true</enabled>` in the `native-maven-plugin` plugin configuration:
-+
-[source,xml]
-----
-<configuration>
-    <fallback>false</fallback>
-    <agent>
-        <enabled>true</enabled>
-    </agent>
-</configuration>
-----
-To enable the agent via the command line, pass the `-Dagent=true` option when running Maven. 
-
-. Before running with the agent, register a separate Mojo execution in the `native` profile which allows forking the Java process.
-It is required to run your application with the agent.
-+
-[source,xml]
-----
-<plugin>
-    <groupId>org.codehaus.mojo</groupId>
-    <artifactId>exec-maven-plugin</artifactId>
-    <version>3.1.1</version>
-    <executions>
-        <execution>
-            <id>java-agent</id>
-            <goals>
-                <goal>exec</goal>
-            </goals>
-            <configuration>
-                <executable>java</executable>
-                <workingDirectory>${project.build.directory}</workingDirectory>
-                <arguments>
-                    <argument>-classpath</argument>
-                    <classpath/>
-                    <argument>${mainClass}</argument>
-                </arguments>
-            </configuration>
-        </execution>
-        <execution>
-            <id>native</id>
-            <goals>
-                <goal>exec</goal>
-            </goals>
-            <configuration>
-                <executable>${project.build.directory}/${imageName}</executable>
-                <workingDirectory>${project.build.directory}</workingDirectory>
-            </configuration>
-        </execution>
-    </executions>
-</plugin>
-----
-+
-Now you are all set to to build a native executable. 
-
-. Compile the project on the JVM to create a runnable JAR with all dependencies.
-Open a terminal window and, from the root application directory, run:
-+
-[source,shell]
-----
-mvn clean package
-----
-. Run your application with the agent enabled:
-+
-[source,shell]
-----
-mvn -Pnative -Dagent exec:exec@java-agent
-----
-+
-The agent collects the metadata and generates the configuration files in a subdirectory of _target/native/agent-output_.
-Those files will be automatically used by the `native-image` tool if you pass the appropriate options.
-. Now build a native executable with the Maven profile:
-+
-[source,shell]
-----
-mvn -DskipTests=true -Pnative -Dagent package
-----
-+
-When the command completes, a native executable, _fortune_, is created in the _target_ directory of the project and ready for use.
-+
-The executable's name is derived from the artifact ID, but you can specify any custom name in `native-maven-plugin`
-by providing the `<imageName>fortuneteller</imageName>` within a `<configuration>` node:
-+
-[source,xml]
-----
-<configuration>
-    <imageName>fortuneteller</imageName>
-    <fallback>false</fallback>
-    <agent>
-        <enabled>true</enabled>
-    </agent>
-</configuration>
-----
-. Run the demo directly or with the Maven profile:
-+
-[source,shell]
-----
-./target/fortune
-----
-+
-The application starts and prints a random quote.
-
-== Add JUnit Testing
-
-The Maven plugin for GraalVM Native Image can run
-https://junit.org/junit5/docs/current/user-guide/[JUnit Platform] tests on a native executable.
-This means that tests will be compiled and executed as native code.
-
-This plugin requires JUnit Platform 1.10 or higher and Maven Surefire 2.22.0 or higher to run tests on a native
-executable.
-
-. Enable extensions in the plugin's configuration, `<extensions>true</extensions>`:
-+
-[source,xml]
-----
-<plugin>
-    <groupId>org.graalvm.buildtools</groupId>
-    <artifactId>native-maven-plugin</artifactId>
-    <version>${native.maven.plugin.version}</version>
-    <extensions>true</extensions>
-    ...
-</plugin>
-----
-. Add an explicit dependency on the `junit-platform-launcher` artifact in the dependencies section of your native profile configuration as in the following example:
-+
-[source,xml]
-----
-<profile>
-    <id>native</id>
-    <dependencies>
-        <dependency>
-            <groupId>org.junit.platform</groupId>
-            <artifactId>junit-platform-launcher</artifactId>
-            <version>1.10.0</version>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
-    ...
-</profile>
-----
-. Create the following test in the _src/test/java/demo/FortuneTest.java_ file:
-+
-[source,java]
-----
-package demo;
-
-import com.fasterxml.jackson.core.JsonProcessingException;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.assertFalse;
-
-class FortuneTest {
-    @Test
-    @DisplayName("Returns a fortune")
-    void testItWorks() throws JsonProcessingException {
-        Fortune fortune = new Fortune();
-        assertFalse(fortune.randomFortune().isEmpty());
-    }
-}
-----
-+
-. Run JUnit tests:
-+
-[source,shell]
-----
-mvn -Pnative -Dagent test
-----
-+
-The `-Pnative` profile will then build and run JUnit tests.
-
-=== Summary
-
-The Maven plugin for GraalVM Native Image adds support for building and testing native executables using https://maven.apache.org/[Apache Maven™].
-The plugin has many features, described in the <<maven-plugin.adoc#,plugin reference documentation>>.
\ No newline at end of file
diff --git a/docs/src/docs/asciidoc/maven-plugin.adoc b/docs/src/docs/asciidoc/maven-plugin.adoc
index c00ac9df5..1cad90db0 100644
--- a/docs/src/docs/asciidoc/maven-plugin.adoc
+++ b/docs/src/docs/asciidoc/maven-plugin.adoc
@@ -1,4 +1,4 @@
-= Maven plugin for GraalVM Native Image building
+= Maven plugin for GraalVM Native Image
 The GraalVM team
 :highlighjsdir: {gradle-relative-srcdir}/highlight
 
@@ -9,35 +9,16 @@ image:https://github.com/graalvm/native-build-tools/actions/workflows/test-nativ
 
 The {doctitle} adds support for building and testing native images using https://maven.apache.org[Apache Maven]™.
 
-For upgrading please take a look at the <<index.adoc#changelog,Changelog>>.
+Find the differences between the versions in the <<changelog.adoc#,project changelog>>.
 
-[[quickstart]]
-== Quickstart
+You can find sample applications in the https://github.com/graalvm/native-build-tools/tree/master/samples[source repository].
 
-====
-<<maven-plugin-quickstart.adoc#,Getting Started with Maven Plugin for GraalVM Native Image>>
-====
-
-====
-You can find full samples in https://github.com/graalvm/native-build-tools/tree/master/samples[the source repository].
-====
-
-====
-The plugin requires that you https://www.graalvm.org/latest/docs/getting-started/[setup GraalVM].
+[[adding-the-plugin]]
+== Adding the plugin
 
-The easiest way to install GraalVM is to use the https://sdkman.io/jdks[SDKMAN!].
-
-For other installation options, go to https://www.graalvm.org/downloads/[GraalVM Downloads].
-====
-
-[[configuration]]
-== Reference documentation
-
-[[configuration-registering-plugin]]
-=== Registering the plugin
-
-Add the following profile to your `pom.xml` file to register the `native-maven-plugin`.
+Add the following profile to the project's _pom.xml_ file to register the plugin:
 
+[source,xml, role="multi-language-sample"]
 ```xml
   <profiles>
     <profile>
@@ -75,21 +56,27 @@ Add the following profile to your `pom.xml` file to register the `native-maven-p
   </profiles>
 ```
 
-You can then build a native executable directly with Maven using the `mvn -Pnative -DskipTests package` command without running the `native-image` command as a separate step.
+You can then build a native image directly with Maven:
 
-The plugin figures out which JAR files it needs to pass to the native image and
-what the executable main class should be.
+[source,bash,subs="verbatim,attributes"]
+----
+./mvnw -Pnative package
+----
+
+The `native-maven-plugin` plugin figures out which JAR file it needs to pass to `native-image`, and what the executable main class should be.
 If the heuristics fail with the `no main manifest attribute, in target/<name>.jar` error, the main class should be
-specified in the `<configuration>` node of the plugin.
-When `mvn -Pnative package` completes, an executable is ready for use, generated in the `target` directory of the project.
+specified in the `<configuration>` block of the plugin.
+A native image is generated in the _target_ directory of the project.
 
-NOTE: Building native image without attaching to the `package` phase can be done by invoking the forking `compile` goal directly, e.g. `mvn native:compile`
+[NOTE]
+====
+Building a native executable without attaching to the `package` phase can be done by invoking the `compile` goal directly. For example: `./mvnw native:compile`.
+====
 
 [TIP]
-.Testing pre-releases
 ====
-You can use development versions of the plugin by adding our snapshot repository. Pre-releases are provided for convenience, without any guarantee.
-[source,xml]
+You can use development versions of the plugin by adding the snapshot repository. Pre-releases are provided for convenience, without any guarantee.
+[source,xml, role="multi-language-sample"]
 ----
 <pluginRepositories>
     <pluginRepository>
@@ -108,80 +95,80 @@ You can use development versions of the plugin by adding our snapshot repository
 ====
 
 [[configuration-options]]
-=== Configuration options
+== Plugin configuration
+
+[[native-image-options]]
+=== Native Image options
 
-If you use Native Image Maven plugin, it will pick up all the configuration for your
-application stored below the `META-INF/native-image/` resource location, as described in
-https://www.graalvm.org/reference-manual/native-image/BuildConfiguration/[Native Image
-Build Configuration]. It is also possible to customize the plugin within a
-`<configuration>` node. The following configuration options are available.
+The plugin picks up all the configuration for your application stored below the _META-INF/native-image/_ resource location, as described in
+https://www.graalvm.org/reference-manual/native-image/BuildConfiguration/[Native Image Build Configuration].
+It is also possible to customize the plugin within the `<configuration>` block.
+The following configuration options are available:
 
 `<mainClass>`::
    If the execution fails with the `no main manifest attribute, in target/<name>.jar`
    error, the main class should be specified. By default the plugin consults several
-   locations in the `pom.xml` file in the following order to determine what the main class
-   of the image should be.
+   locations in _pom.xml_ in the following order to determine what the main class should be:
       * `<maven-shade-plugin> <transformers> <transformer> <mainClass>`
       * `<maven-assembly-plugin> <archive> <manifest> <mainClass>`
       * `<maven-jar-plugin> <archive> <manifest> <mainClass>`
 `<imageName>`::
-   Use `<imageName>` to set a custom filename for the generated native image. If a custom
+   Use `<imageName>` to set a custom filename for the native image. If a custom
    image name is not supplied, the artifact ID of the project will be used by default.
 `<buildArgs>`::
-   If you want to pass additional arguments to the native image builder, use `<buildArgs>`
-   in the configuration of the plugin:
-[source,xml]
+   If you want to pass additional build options to `native-image`, use the `<buildArgs>` tag. You can pass any Native Image build option listed https://www.graalvm.org/reference-manual/native-image/overview/Options/[here].
+[source,xml, role="multi-language-sample"]
 ----
 <buildArgs>
     <buildArg>--argument</buildArg>
 </buildArgs>
 ----
 `<skipNativeBuild>`::
-   To skip generation of the native image, supply the following in the configuration of the plugin:
-[source,xml]
+   To skip generation of the native image, add:
+[source,xml, role="multi-language-sample"]
 ----
 <skipNativeBuild>true</skipNativeBuild>
 ----
 `<skipNativeTests>`::
-   To skip generation and execution of the native image compiled tests, supply the following in the configuration of the plugin:
-[source,xml]
+   To skip generation and execution of the native image compiled tests, add:
+[source,xml, role="multi-language-sample"]
 ----
 <skipNativeTests>true</skipNativeTests>
 ----
 `<debug>`::
-   If you want to enable generation of debugging information supply the following in the configuration of the plugin:
-[source,xml]
+   If you want to enable generation of debugging information, add:
+[source,xml, role="multi-language-sample"]
 ----
 <debug>true</debug>
 ----
 `<verbose>`::
-   If you want to enable verbose output during native-image building supply the following in the configuration of the plugin:
-[source,xml]
+   If you want to enable verbose output during the native image build, add:
+[source,xml, role="multi-language-sample"]
 ----
 <verbose>true</verbose>
 ----
 `<sharedLibrary>`::
-   If you want to build image as a shared library supply the following in the configuration of the plugin:
-[source,xml]
+   If you want to build image as a shared library, add:
+[source,xml, role="multi-language-sample"]
 ----
 <sharedLibrary>true</sharedLibrary>
 ----
 `<useArgFile>`::
-   If you want to use argument file for native-image building supply the following in the configuration of the plugin:
-[source,xml]
+   If you want to use the argument file for a native image building, add:
+[source,xml, role="multi-language-sample"]
 ----
 <useArgFile>true</useArgFile>
 ----
 `<quickBuild>`::
-   If you want to build the image using https://www.graalvm.org/latest/reference-manual/native-image/overview/BuildOutput/#qbm-use-quick-build-mode-for-faster-builds[quick build mode], supply the following in the configuration of the plugin (alternatively set the `GRAALVM_QUICK_BUILD` environment variable to `true`):
-[source,xml]
+   If you want to build a native image using https://www.graalvm.org/latest/reference-manual/native-image/overview/BuildOutput/#qbm-use-quick-build-mode-for-faster-builds[quick build mode], add (alternatively, set the `GRAALVM_QUICK_BUILD` environment variable to `true`):
+[source,xml, role="multi-language-sample"]
 ----
 <quickBuild>true</quickBuild>
 ----
 
 `<excludeConfig>`::
-   In order to exclude configuration from present jar files, specify:
-[source,xml]
+   To exclude configuration from present JAR files, specify:
+[source,xml, role="multi-language-sample"]
 ----
 <excludeConfig>
     <entry>
@@ -191,41 +178,33 @@ Build Configuration]. It is also possible to customize the plugin within a
 </excludeConfig>
 ----
 `<environment>`::
-   To set environment options for native-image building supply the following in the configuration of the plugin:
-[source,xml]
+   To set environment options for a native image build, use:
+[source,xml, role="multi-language-sample"]
 ----
 <environment>
     <variable>value</variable>
 </environment>
 ----
 `<systemPropertyVariables>`::
-   To specify system properties used for native-image building supply the following in the configuration of the plugin:
-[source,xml]
+   To specify system properties used for a native image build, use:
+[source,xml, role="multi-language-sample"]
 ----
 <systemPropertyVariables>
     <propertyName>value</propertyName>
 </systemPropertyVariables>
 ----
 `<jvmArgs>`::
-   To specify JVM arguments used for native-image building supply the following in the configuration of the plugin:
-[source,xml]
+   To specify JVM arguments used for a native image build, use:
+[source,xml, role="multi-language-sample"]
 ----
 <jvmArgs>
     <arg>argument1</arg>
     <arg>argument2</arg>
 </jvmArgs>
 ----
-`<configurationFileDirectories>`::
-   If you want to specify custom directories where configuration files should be looked up, supply the following in the configuration of the plugin:
-[source,xml]
-----
-<configurationFileDirectories>
-    <dir>path/to/dir</dir>
-</configurationFileDirectories>
-----
 `<classpath>`::
-   Sets a custom classpath instead of plugin generated one. Usage:
-[source,xml]
+   Sets a custom classpath instead of the plugin generated one, use:
+[source,xml, role="multi-language-sample"]
 ----
 <classpath>
     <param>path/to/file.jar</param>
@@ -233,10 +212,10 @@ Build Configuration]. It is also possible to customize the plugin within a
 </classpath>
 ----
 `<classesDirectory>`::
-   If you want to specify custom path to packed JAR, or a custom directory that contains
-only application classes, but want the plugin to still automatically add classpath entries for
-dependencies, simply add:
-[source,xml]
+   If you want to specify custom path to the JAR, or a custom directory that contains
+only application classes, but you want the plugin to still automatically add classpath entries for
+dependencies, add:
+[source,xml, role="multi-language-sample"]
 ----
 <classesDirectory>
     path/to/dir
@@ -246,29 +225,412 @@ dependencies, simply add:
    Configuration of the <<agent-support, native agent>>. See <<agent-support-enabling>>
    and <<agent-support-configuring-options>> for details.
 
-For example, to build a native image named `executable-name` that uses
-`org.example.ClassName` as its main class with assertions enabled, add the following
-`<configuration>` block for the `native-maven-plugin`.
+For example, to build a native image named `myapp` that uses `org.example.ClassName` as its main class with assertions enabled, the `<configuration>` should look like this:
 
-[source,xml]
+[source,xml, role="multi-language-sample"]
 ----
 <configuration>
-  <imageName>executable-name</imageName>
+  <imageName>myapp</imageName>
   <mainClass>org.example.ClassName</mainClass>
   <fallback>false</fallback>
   <verbose>true</verbose>
 </configuration>
 ----
 
-NOTE: Most of the aforementioned properties can also be set from command line as a part of Maven invocation -- for example if you want to temporarily enable verbose mode you can append `-Dverbose` to your Maven invocation.
+[NOTE]
+====
+Most of the aforementioned properties can also be set on the command line as a part of Maven invocation. For example, if you want to temporarily enable verbose mode, you can append `-Dverbose` to your Maven command.
+====
+
+[[native-image-tracing-agent]]
+=== Native Image Tracing Agent
 
-NOTE: If you use GraalVM Enterprise as the `JAVA_HOME` environment, the plugin builds a native image with enterprise features enabled -- for example, an executable will automatically be built with https://medium.com/graalvm/isolates-and-compressed-references-more-flexible-and-efficient-memory-management-for-graalvm-a044cc50b67e[compressed references] and other optimizations enabled.
+If your project requires reflection, classpath resources, dynamic proxies or other
+features requiring explicit native configuration, it may prove helpful to first run your
+application or tests using the
+https://www.graalvm.org/reference-manual/native-image/metadata/AutomaticMetadataCollection/[Native Image Tracing Agent].
+
+The Native Image Maven plugin simplifies generation of the required configuration files by injecting the agent automatically for you (this includes, but is not limited to the reflection configuration).
+
+The agent generates the configuration file(s) under _target/native/agent-output_.
+Although those files will be automatically used by `native-image`, you should consider reviewing the generated files and adding them to your sources instead.
+
+[[agent-support-enabling]]
+==== Enabling the agent
+
+The agent is disabled by default, but it can be enabled in the _pom.xml_ file or on the command line.
+
+To enable the agent by default, specify `<enabled>true</enabled>` as follows in the configuration of `native-maven-plugin`:
+
+[source,xml, role="multi-language-sample"]
+```xml
+<configuration>
+  <agent>
+    <enabled>true</enabled>
+  </agent>
+</configuration>
+```
+
+To enable the agent on the command line, pass the `-Dagent=true` option when running Maven.
+The examples in the following sections demonstrate how to do this for your application and for tests.
+
+[TIP]
+====
+If you have enabled the agent in _pom.xml_, you can still disable it on the command line by passing `-Dagent=false`.
+====
+
+[[agent-support-configuring-options]]
+==== Configuring agent options
+
+If you would like to configure the options for the agent -- for example, to configure agent mode or advanced features such as
+https://www.graalvm.org/latest/reference-manual/native-image/metadata/AutomaticMetadataCollection/#caller-based-filters[Caller-based Filters]
+and https://www.graalvm.org/latest/reference-manual/native-image/metadata/AutomaticMetadataCollection/#access-filters[Access Filters]
+- you can specify them in _pom.xml_ as described bellow.
+
+[source,xml, indent=0, role="multi-language-sample"]
+include::../snippets/maven/pom.xml[tag=native-plugin-agent-configuration]
+
+This example shows all possibilities you can use for the agent configuration. 
+If you do not need some of the options, just remove them.
+
+Agent can be run in one of the following modes:
+
+* `standard` - in this mode you run agent only with options provided in the `options` section.
+* `direct` - in this mode you can provide command line options for the agent. In this
+     mode, a user is fully responsible for agent configuration, and the rest of the agent configuration, provided in _pom.xml_ file, will be ignored.
+* `conditional` - in this mode you can provide additional files that can be used as a filter for the agent output. Read more about conditional mode https://www.graalvm.org/latest/reference-manual/native-image/metadata/ExperimentalAgentOptions/[here].
+
+Here is an explanation for each option you can specify in the agent block:
+
+* `enabled` - Specifies whether the agent is enabled or not. Can be set to `true` or `false`.
+* `defaultMode` - Agent mode switcher. Can be set to: `standard`, `direct`, or `conditional`.
+* `modes` - A list of additional mode options, specific for certain mode type. Inside this tag, you can specify options for
+ direct or conditional modes. Standard mode does not have any specific options.
+  ** in case of `direct` mode, you can specify `<direct>` tag, with the agent command line as its value
+  ** in case of `conditional` mode, you can specify `<conditional>` tag, and set additional https://github.com/oracle/graalvm-reachability-metadata/blob/master/docs/CollectingMetadata.md[filter files] inside `<userCodeFilterPath>` and `<extraCodeFilterPath>`. Also, you can set value for `<parallel>` tag. If the value is `true`, the agent will create the _partial-config_ file, and merge it with conditional merge. Otherwise the agent will generate the same kind of output as other modes.
+* `options` - A list of options that can be specified independently from the agent mode. Learn more about these options https://www.graalvm.org/latest/reference-manual/native-image/metadata/AutomaticMetadataCollection/[here].
+
+[[agent-support-running-tests]]
+==== Running tests with the agent
+
+The simplest way to use the agent is to do it via execution of your tests.
+
+Run your test suite with:
+
+[source,bash, role="multi-language-sample"]
+----
+./mvnw -Pnative -Dagent=true test
+----
+
+When the `agent` system property is set to `true` (or when the agent is <<agent-support-enabling, enabled in the POM>>), the agent will be automatically attached to your Maven Surefire test execution, and the generated files will be stored in the _target/native/agent-output/test_ directory.
+
+[TIP]
+====
+If you want to run the _metadataCopy_ task as well, first define its configuration as described <<metadata-copy, above>>, and add `native:metadata-copy`
+at the end of the agent invocation command. For example:
+
+[source,bash, role="multi-language-sample"]
+----
+./mvnw -Pnative -Dagent=true test native:metadata-copy
+----
+====
+
+[[agent-support-running-application]]
+==== Running your application with the agent
+
+Executing your application with the agent is more involved and requires you to configure a separate Mojo execution which allows forking the Java process.
+
+In your `native` profile section, add the following:
+
+[source,xml, indent=0, role="multi-language-sample"]
+include::../../../../samples/java-application-with-reflection/pom.xml[tag=java-agent-exec]
+
+Then you can execute your application with the agent by running:
+
+[source,bash, role="multi-language-sample"]
+----
+./mvnw -Pnative -Dagent=true -DskipTests -DskipNativeBuild=true package exec:exec@java-agent
+----
+
+Both of the above commands generate configuration files in the _target/native/agent-output/main_ directory.
+If you want to run your native application with those configuration files, you then need to execute the following command:
+
+[source,bash, role="multi-language-sample"]
+----
+./mvnw -Pnative -Dagent=true -DskipTests package exec:exec@native
+----
+
+[[agent-filter-file]]
+==== Reduce the amount of generated metadata
+
+In some cases the agent may include more metadata than it is actually needed.
+You can filter metadata using the agent filter file(s).
+These filter files that agent consumes have the following structure:
+
+[source,json,subs="verbatim,attributes", role="multi-language-sample"]
+----
+{
+ "rules": [
+    {"includeClasses": "some.class.to.include.**"},
+    {"excludeClasses": "some.class.to.exclude.**"},
+  ],
+  "regexRules": [
+    {"includeClasses": "regex\.example\.class.*"},
+    {"excludeClasses": "regex\.example\.exclude[0-9]+"},
+  ]
+}
+----
+
+The process how you can pass the configuration files to the agent is described in the <<agent-support-configuring-options,previous section>>.
+
+You can see on some simple Java application how different filter files affect generated metadata.
+
+Let's start with this filter:
+
+[source,json,subs="verbatim,attributes", role="multi-language-sample"]
+----
+{
+  "rules": [
+    {"includeClasses": "**"}
+  ]
+}
+----
+
+This filter instructs the agent to include everything, which will result in a massive configuration file.
+For example, this is how _reachability-metadata.json_ looks like:
+
+[source,json,subs="verbatim,attributes", role="multi-language-sample"]
+----
+{
+  "reflection": [
+    {
+      "condition": {
+        "typeReached": "java.util.concurrent.atomic.AtomicBoolean"
+      },
+      "type": "java.util.concurrent.atomic.AtomicBoolean",
+      "fields": [
+        {
+          "name": "value"
+        }
+      ]
+    },
+    {
+      "condition": {
+        "typeReached": "org.apache.maven.surefire.booter.ForkedBooter"
+      },
+      "type": "org.apache.maven.surefire.booter.spi.LegacyMasterProcessChannelProcessorFactory"
+    },
+    {
+      "condition": {
+        "typeReached": "org.apache.maven.surefire.booter.ForkedBooter"
+      },
+      "type": "org.apache.maven.surefire.booter.spi.SurefireMasterProcessChannelProcessorFactory"
+    },
+    {
+      "condition": {
+        "typeReached": "org.junit.platform.launcher.core.DefaultLauncher"
+      },
+      "type": "org.apiguardian.api.API"
+    },
+    {
+      "condition": {
+        "typeReached": "java.lang.Class"
+      },
+      "type": "org.example.NativeTests"
+    },
+    {
+      "condition": {
+        "typeReached": "java.util.Collections$2"
+      },
+      "type": "org.example.NativeTests"
+    },
+    {
+      "condition": {
+        "typeReached": "org.apache.maven.surefire.api.util.DefaultScanResult"
+      },
+      "type": "org.example.NativeTests"
+    },
+    {
+      "condition": {
+        "typeReached": "org.junit.jupiter.engine.JupiterTestEngine"
+      },
+      "type": "org.example.NativeTests"
+    },
+    {
+      "condition": {
+        "typeReached": "org.junit.jupiter.engine.discovery.ClassSelectorResolver$$Lambda/0x00007a5c0f03fbb8"
+      },
+      "type": "org.example.NativeTests"
+    },
+    {
+      "condition": {
+        "typeReached": "java.security.Provider$Service"
+      },
+      "type": "sun.security.provider.SHA",
+      "methods": [
+        {
+          "name": "<init>",
+          "parameterTypes": []
+        }
+      ]
+    }
+    ...
+  ],
+  "resources": [
+    {
+      "condition": {
+        "typeReached": "jdk.internal.logger.BootstrapLogger$DetectBackend$1"
+      },
+      "glob": "META-INF/services/java.lang.System$LoggerFinder"
+    },
+    {
+      "condition": {
+        "typeReached": "jdk.internal.logger.LoggerFinderLoader"
+      },
+      "glob": "META-INF/services/java.lang.System$LoggerFinder"
+    },
+    {
+      "condition": {
+        "typeReached": "org.apache.maven.surefire.booter.ForkedBooter"
+      },
+      "glob": "META-INF/services/org.apache.maven.surefire.spi.MasterProcessChannelProcessorFactory"
+    },
+    {
+      "condition": {
+        "typeReached": "java.lang.ClassLoader"
+      },
+      "glob": "TestResource.txt"
+    },
+    ...
+  ],
+  "bundles": [],
+  "jni": [
+    {
+      "condition": {
+        "typeReached": "sun.nio.ch.IOUtil"
+      },
+      "type": "java.lang.Boolean",
+      "methods": [
+        {
+          "name": "getBoolean",
+          "parameterTypes": [
+            "java.lang.String"
+          ]
+        }
+      ]
+    },
+    {
+      "condition": {
+        "typeReached": "sun.management.VMManagementImpl"
+      },
+      "type": "sun.management.VMManagementImpl",
+      "fields": [
+        {
+          "name": "compTimeMonitoringSupport"
+        },
+        {
+          "name": "currentThreadCpuTimeSupport"
+        },
+        {
+          "name": "objectMonitorUsageSupport"
+        },
+        {
+          "name": "otherThreadCpuTimeSupport"
+        },
+        {
+          "name": "remoteDiagnosticCommandsSupport"
+        },
+        {
+          "name": "synchronizerUsageSupport"
+        },
+        {
+          "name": "threadAllocatedMemorySupport"
+        },
+        {
+          "name": "threadContentionMonitoringSupport"
+        }
+      ]
+    }
+  ]
+}
+----
+
+As you can see, there are lots of entries that you likely do not want.
+They are present because the metadata was generated using tests, and that the testing library was present at run time during the agent execution pass, but in practice, your application will not use the testing library in production.
+To reduce the amount of generated metadata, use the following _user-code-filter.json_:
+
+
+[source,json,subs="verbatim,attributes", role="multi-language-sample"]
+----
+{
+  "rules": [
+    {"includeClasses": "**"},
+    {"excludeClasses": "org.apache.maven.**"},
+    {"excludeClasses": "org.junit.**"},
+    {"excludeClasses": "java.**"},
+    {"excludeClasses": "jdk.internal.**"},
+    {"excludeClasses": "sun.**"},
+    {"excludeClasses": "com.sun.**"}
+  ]
+}
+----
+
+[WARNING]
+====
+Always be careful when removing entries in metadata, as this may result in a broken native image.
+====
+
+After updating the filter, you can regenerate the metadata, which will result in the following _reachability-metadata.json_ file:
+
+[source,json,subs="verbatim,attributes", role="multi-language-sample"]
+----
+{
+  "reflection": [
+    {
+      "condition": {
+        "typeReached": "org.example.NativeTests"
+      },
+      "type": "org.example.NativeTests$Person",
+      "allDeclaredFields": true
+    }
+  ],
+  "resources": [
+    {
+      "condition": {
+        "typeReached": "org.example.NativeTests"
+      },
+      "glob": "TestResource.txt"
+    }
+  ],
+  "bundles": []
+}
+----
+
+As you can see, there are no more entries that contain classes from `org.apache.maven` (as their condition).
+
+[[metadata-copy]]
+==== Metadata copy
+
+The `metadataCopy` task provides additional options for manipulating the agent output after it finishes its job.
+
+[source,xml, indent=0, role="multi-language-sample"]
+include::../snippets/maven/metadataCopy.xml[tag=native-plugin-agent-metadata-copy]
+
+You can set values for the following tags:
+
+* `<outputDirectory>` - where you want to copy agent output.
+* `<merge>` - in case you already have some other configuration files inside output directory, you can choose whether you want to override those files or
+    merge new files with the existing once (set `merge` to `true`).
+* `<disabledStages>` - in case you do not want to copy output of the certain stage (main or test), you can disable them, and `metadataCopy` will not look at
+    the agent output for that stage. For example, if you want to copy only configuration files generated in tests, you can disable main stage. Also, if you want to copy only files generated in the main phase, you can disable the test stage. Therefore, if you skip both stages, `metadataCopy` will not be executed.
 
 [[configuration-reusing-config-from-parent]]
-==== Reusing configuration from a parent POM
+== Reusing configuration from a parent POM
 
-The `<buildArgs>` element can be combined between parent and children POMs. Suppose you have the following parent POM definition:
+The `<buildArgs>` element can be combined between parent and children POMs.
+Suppose you have the following parent POM definition:
 
+[source,xml, role="multi-language-sample"]
 ```xml
 <plugin>
   <groupId>org.graalvm.buildtools</groupId>
@@ -286,6 +648,7 @@ The `<buildArgs>` element can be combined between parent and children POMs. Supp
 
 Children projects have the ability to append `<buildArg>` arguments in the following way:
 
+[source,xml, role="multi-language-sample"]
 ```xml
 <plugin>
   <groupId>org.graalvm.buildtools</groupId>
@@ -298,51 +661,46 @@ Children projects have the ability to append `<buildArg>` arguments in the follo
 </plugin>
 ```
 
-In this case, the arguments that will be passed to the `native-image` executable will be:
-```shell
+In this case, the arguments that are passed to the `native-image` executable will be:
+
+[source,shell, role="multi-language-sample"]
+----
 --no-fallback --verbose
-```
+----
 
 [[testing-support]]
 == Testing support
 
-This plugin supports running tests on the
-https://junit.org/junit5/docs/current/user-guide/[JUnit Platform] as native images. This
-means that tests will be compiled and executed as native code.
+This plugin supports running tests on the https://junit.org/junit5/docs/current/user-guide/[JUnit Platform] as native images.
+This means that tests will be compiled and executed as native code.
 
-NOTE: The minimum supported version is JUnit 5.8.1 (JUnit Platform 1.8.1, JUnit Jupiter 5.8.1, JUnit Vintage 5.8.1)
+[NOTE]
+====
+The minimum supported version is JUnit 5.8.1 (JUnit Platform 1.8.1, JUnit Jupiter 5.8.1, JUnit Vintage 5.8.1).
+====
 
-In theory, any `TestEngine` supported on the JUnit Platform should be supported by this
-plugin as long as the programming language used by the `TestEngine` and the programming
-language used to write the tests is supported in a GraalVM native image. This plugin
-provides explicit support for the JUnit Jupiter and JUnit Vintage test engines, and
-support for additional test engines should be possible with custom native configuration.
+In theory, any `TestEngine` supported on the JUnit Platform should be supported by the plugin as long as the programming language used by the `TestEngine` and the programming language used to write the tests is supported by GraalVM Native Image.
+The plugin provides explicit support for the JUnit Jupiter and JUnit Vintage test engines, and support for additional test engines should be possible with custom native configuration.
 
-In order to use the recommended JUnit Platform test listener mode, you need to enable
-extensions for the `native-maven-plugin` by adding `<extensions>true</extensions>` as follows.
+To use the recommended JUnit Platform test listener mode, you need to enable extensions for `native-maven-plugin` by adding `<extensions>true</extensions>` as follows.
 
-[source,xml,indent=0]
+[source,xml, indent=0, role="multi-language-sample"]
 include::../../../../samples/java-application-with-tests/pom.xml[tag=native-plugin-extensions]
 
-Running `mvn -Pnative test` will then build and run native tests.
+Running the `./mvnw -Pnative test` will then build and run tests as native code.
 
 [[testing-support-version-compatibility]]
 === Version compatibility
 
-This plugin requires Maven Surefire 2.22.0 or higher to run tests within a native image.
+This plugin requires the Maven Surefire plugin 3.0.0 or higher to run tests as native code.
 
-Each version of the Maven Surefire plugin has a dependency on a particular version of the
-JUnit Platform. You therefore need to ensure that Maven Surefire is using at least version
-1.8 of the JUnit Platform. Beginning with version 3.0 M4, Maven Surefire will
-automatically align the JUnit Platform version used by Surefire with the version needed by
-the user's configured version of JUnit Jupiter or JUnit Vintage. Since the examples in
-this document use Maven Surefire 3.0 M5, their maven POMs do not require any special
-configuration regarding the JUnit Platform version. However, if you are using a version of
-Maven Surefire prior to 3.0 M4 you will need to add an explicit dependency on the
-`junit-platform-launcher` artifact to the `dependencies` section of your `native` profile
-configuration as in the following example.
+Each version of the Maven Surefire plugin has a dependency on a particular version of the JUnit Platform.
+You therefore need to ensure that Maven Surefire is using at least version 1.8 of the JUnit Platform.
+Beginning with version 3.0 M4, Maven Surefire automatically aligns the JUnit Platform version used by Surefire with the version needed by the user's configured version of JUnit Jupiter or JUnit Vintage.
+Since the examples here use Maven Surefire 3.0 M5, their maven POMs do not require any special configuration regarding the JUnit Platform version.
+However, if you are using a version of Maven Surefire prior to 3.0 M4, you will need to add an explicit dependency on the `junit-platform-launcher` artifact to the `dependencies` section of your `native` profile configuration. For example:
 
-[source,xml]
+[source,xml, role="multi-language-sample"]
 ----
 <dependencies>
 	<dependency>
@@ -354,12 +712,14 @@ configuration as in the following example.
 </dependencies>
 ----
 
-TIP: If you have imported the `junit` BOM or are using a plugin that manages JUnit
+[TIP]
+====
+If you import the `junit` BOM or are using a plugin that manages JUnit
 versions for you -- for example, Spring Boot -- you may want to omit the `<version>`
 configuration in the above example.
+==== 
 
-If Maven Surefire is using an older version of the JUnit Platform, the build will fail
-with an error similar to the following when attempting to run tests in a native image.
+If Maven Surefire is using an older version of the JUnit Platform, the build will fail with an error similar to the following when attempting to run tests in a native image:
 
 ----
 [ERROR] Test configuration file wasn't found. Make sure that test execution wasn't skipped.
@@ -368,55 +728,50 @@ with an error similar to the following when attempting to run tests in a native
 [[testing-support-disabling]]
 === Disabling testing support
 
-If you wish to disable tests on the JVM as well as tests within a native image, you can
-invoke Maven with the `-DskipTests` flag. This flag is supported by Maven Surefire and
-Native Build Tools. Several examples in <<agent-support-running-application>> demonstrate
-the use of this flag.
+If you wish to disable running tests on the JVM as well as tests as native code, you can invoke Maven with the `-DskipTests` flag.
+This flag is supported by Maven Surefire and Native Build Tools. 
+Several examples in <<agent-support-running-application>> demonstrate the use of this flag.
 
-If you wish to run tests on the JVM with Maven Surefire but skip testing within a native
-image, you can invoke Maven with the `-DskipNativeTests` flag. This flag is specific to
-Native Build Tools. For example, you might wish to disable only native testing support for
-use cases such as the following:
+If you wish to run tests on the JVM with Maven Surefire but skip running tests as native code, you can invoke Maven with the `-DskipNativeTests` flag.
+This flag is specific to Native Build Tools.
+For example, you might wish to disable only native testing support for use cases such as the following:
 
-- You don't actually want to run your tests in native mode.
-- Your library or application uses a testing framework that is not supported on the JUnit
-  Platform.
-- You need to use the <<agent-support, agent>> when running tests on the JVM but do not
-  wish to run those same tests in native mode.
+- You do not actually want to run your tests as native code.
+- Your library or application uses a testing framework that is not supported on the JUnit Platform.
+- You need to use the <<agent-support, agent>> when running tests on the JVM but do not wish to run those same tests as native code.
 
 [[long_classpath_and_shading_support]]
 == Long classpath, @argument file and shading support
 
 Under Windows, https://github.com/graalvm/native-build-tools/issues/85[it is possible that the length of the classpath exceeds what the operating system supports] when invoking the CLI to build a native image.
 
-To avoid this, since release 0.9.10, the plugin will use an argument file to pass the arguments to the `native-image` tool, instead of passing them directly.
+The plugin automatically passes arguments to the `native-image` tool from the argument file, instead of passing them directly.
 
-There is also a `native:write-args-file` goal that can be used to generate this argument file. This can be useful in situations where the Native Build Tools plugin is not available, for example, when running native-image in a Docker container. The path to the args file is stored in the project properties
-under the key `graalvm.native-image.args-file`, so that other Maven plugins further in the lifecycle can use it.
+There is also the `native:write-args-file` goal that can be used to generate this argument file.
+This can be useful in situations where `native-maven-plugin` is not available, for example, when running `native-image` in a Docker container.
+The path to the arguments file is stored in the project properties under the key `graalvm.native-image.args-file`, so that other Maven plugins further in the lifecycle can use it.
 
 In case you are using a GraalVM version older than 21.3, you will however have to use a workaround, since the argument file wasn't supported.
 
-One option is to use a https://maven.apache.org/plugins/maven-shade-plugin[shaded jar] and use it instead of individual jars on classpath.
-
-First, you'll need to setup the https://maven.apache.org/plugins/maven-shade-plugin[Maven Shade plugin]:
+One option is to use a https://maven.apache.org/plugins/maven-shade-plugin[shaded JAR] and use it instead of individual JAR files on classpath.
+For that, you need to setup the https://maven.apache.org/plugins/maven-shade-plugin[Maven Shade plugin]:
 
-[source,xml,indent=0]
+[source,xml, indent=0, role="multi-language-sample"]
 include::../../../../samples/java-application/pom.xml[tag=shade-plugin]
 
-If you need testing support, add the JUnit Platform Native dependency explicitly:
+If you need the testing support, add the JUnit Platform dependency explicitly:
 
-[source,xml,indent=0]
+[source,xml, indent=0, role="multi-language-sample"]
 include::../../../../samples/java-application-with-tests/pom.xml[tag=junit-platform-native-dependency]
 
-Then the native plugin needs to be configured to use this jar instead of the full classpath:
+Then `native-maven-plugin` needs to be configured to use this JAR instead of the full classpath:
 
-[source,xml,indent=0]
+[source,xml, indent=0, role="multi-language-sample"]
 include::../../../../samples/java-application/pom.xml[tag=native-plugin]
 
-
 Depending on the other plugins your build uses (typically the Spring Boot plugin), you might have to configure, in addition, the main class:
 
-[source,xml]
+[source,xml, role="multi-language-sample"]
 ----
 <plugin>
     <groupId>org.graalvm.buildtools</groupId>
@@ -436,189 +791,43 @@ Depending on the other plugins your build uses (typically the Spring Boot plugin
 ...
 ----
 
-To be able to <<testing-support,execute tests in native mode>>, you will need more setup:
+To be able to <<testing-support,execute tests as native code>>, you also need:
 
-- Create a `src/assembly/test-jar-with-dependencies.xml` file with the following contents:
+- Create a _src/assembly/test-jar-with-dependencies.xml_ file with the following contents:
 
-[source,xml,indent=0]
+[source,xml, indent=0, role="multi-language-sample"]
 include::../../../../samples/java-application-with-tests/src/assembly/test-jar-with-dependencies.xml[tag=assembly]
 
-- Add the assembly plugin to your `native` profile:
+- Add the Maven Assembly plugin to your `native` profile:
 
-[source,xml,indent=0]
+[source,xml, indent=0, role="multi-language-sample"]
 include::../../../../samples/java-application-with-tests/pom.xml[tag=assembly-plugin]
 
-- Due to a limitation in Maven, you will need to move the tests execution to the "integration-test" phase:
+- Due to a limitation in Maven, you need to move the tests execution to the `integration-test` phase:
 
-[source,xml,indent=0]
+[source,xml, indent=0, role="multi-language-sample"]
 include::../../../../samples/java-application-with-tests/pom.xml[tag=native-plugin]
 
-Finally, you will need to execute tests using the `integration-test` phase instead of `test`:
-
-```bash
-./mvn -Pnative integration-test
-```
-
-Please refer to the https://maven.apache.org/plugins/maven-shade-plugin[Maven Shade plugin documentation] for more details on how to configure shading and the https://maven.apache.org/plugins/maven-assembly-plugin[Maven Assembly plugin documentation] to tweak what to include in tests.
-
-[[agent-support]]
-== Reflection support and running with the native agent
-
-If your project requires reflection, classpath resources, dynamic proxies or other
-features requiring explicit native configuration, it may prove helpful to first run your
-application or tests using the
-https://www.graalvm.org/reference-manual/native-image/metadata/AutomaticMetadataCollection/[`native-image-agent`].
-
-The Native Image Maven plugin simplifies generation of the required configuration files by
-injecting the agent automatically for you (this includes, but is not limited to the
-reflection file).
-
-The agent generates the native configuration files in subdirectories of
-`target/native/agent-output`. Although those files will be automatically used if you run
-your build with the agent enabled, you should consider reviewing the generated files and
-adding them to your sources instead.
-
-[[agent-support-enabling]]
-=== Enabling the agent
-
-The agent is disabled by default, but it can be enabled within your `pom.xml` file or via
-the command line.
-
-To enable the agent by default, specify `<enabled>true</enabled>` as follows in the
-configuration of the `native-maven-plugin` in your POM.
-
-```xml
-<configuration>
-  <agent>
-    <enabled>true</enabled>
-  </agent>
-</configuration>
-```
-
-To enable the agent via the command line, supply the `-Dagent=true` flag when running
-Maven. The examples in the following sections demonstrate how to do this for your
-application and for tests.
-
-[TIP]
-====
-If you have enabled the agent within your POM, you can still disable it via the command
-line by supplying the `-Dagent=false` flag.
-====
-
-[[agent-support-configuring-options]]
-=== Configuring agent options
-
-If you would like to configure the options for the agent -- for example, to configure
-agent mode or advanced features
-such as
-https://www.graalvm.org/latest/reference-manual/native-image/metadata/AutomaticMetadataCollection/#caller-based-filters[Caller-based Filters]
-and https://www.graalvm.org/latest/reference-manual/native-image/metadata/AutomaticMetadataCollection/#access-filters[Access Filters]
-- you can specify them in your POM as described bellow.
-
-[source,xml,indent=0]
-include::../snippets/maven/pom.xml[tag=native-plugin-agent-configuration]
-
-This example shows all possibilities you can use for native agent configuration. If you don't need some of the options,
-just remove them.
-
-Agent can be run in one of the following modes:
-
-* `standard` - in this mode you run agent only with options provided in `options` section.
-* `direct` - in this mode you can provide command line that you want to be executed as an agent configuration. In this
-     mode, user is fully responsible for agent configuration, and the rest of the agent configuration, provided in pom.xml file, will be ignored.
-* `conditional` - in this mode you can provide additional files that can be used as a filter for the agent output. You
-can read more about conditional mode https://www.graalvm.org/latest/reference-manual/native-image/metadata/ExperimentalAgentOptions/[here].
-
-Each option and how you should use it is described bellow:
-
-* `enabled` - a simple flag that specifies whether the agent is enabled or not. Can be set to true or false.
-* `defaultMode` - agent mode switcher. Can be set to: standard, direct or conditional.
-* `modes` - list of additional mode options, specific for certain mode type. Inside this tag, you can specify options for
- direct or conditional modes. Standard mode doesn't have any specific options.
-  ** in case of `direct` mode you can specify `<direct>` tag, with the agent command line as its value
-  ** in case of `conditional` mode you can specify `<conditional>` tag, and set additional https://github.com/oracle/graalvm-reachability-metadata/blob/master/docs/CollectingMetadata.md[filter files]
-   inside `<userCodeFilterPath>` and `<extraCodeFilterPath>`. Also, you can set value for `<parallel>` tag. If the value is true, agent will create
-   partial-config file, and merge it with conditional merge, otherwise agent will generate same kind of output as other modes.
-* `options` - list of options that can be specify independent from agent mode. More about common options can be found
-https://www.graalvm.org/latest/reference-manual/native-image/metadata/AutomaticMetadataCollection/[here].
-
-
-[[metadata-copy]]
-==== Metadata copy
-`metadataCopy` provides additional options for manipulating the agent output after agent finishes its job.
-
-[source,xml,indent=0]
-include::../snippets/maven/metadataCopy.xml[tag=native-plugin-agent-metadata-copy]
-
-You can set values for the following tags:
-
-* `<outputDirectory>` - where you want to copy agent output.
-* `<merge>` - in case you already have some other config files inside `output directory`, you can choose whether you want to override those files or
-    merge new files with the existing once (set merge value to true).
-* `<disabledStages>` - in case you don't want to copy output of the certain stage (main or test) you can disable them and metadataCopy will not look at
-    the agent output for that stage. For example, if you want to copy only config files generated in tests, you can disable main stage. Also, if you want
-    to copy only files generated in main phase, you can disable test stage. Therefore, if you skip both stages, metadataCopy will not be executed.
-
-
-[[agent-support-running-tests]]
-=== Running tests with the agent
-
-The simplest way to use the agent is to do it via execution of your tests.
-
-Run your test suite with:
-
-```bash
-mvn -Pnative -Dagent=true test
-```
-
-When the `agent` system property is set to `true` (or when the agent is
-<<agent-support-enabling, enabled in the POM>>), the agent will be automatically attached
-to your Maven Surefire test execution, and the generated files can be found in the
-`target/native/agent-output/test` directory.
-
-[TIP]
-====
-If you want to run metadataCopy as well, first define its configuration as described <<metadata-copy, above>> and add `native:metadata-copy`
-at the end of the agent invocation command. Example:
-```bash
-mvn -Pnative -Dagent=true test native:metadata-copy
-```
-====
-
-[[agent-support-running-application]]
-=== Running your application with the agent
-
-Executing your application with the agent is more involved and requires you to configure a
-separate mojo execution which allows forking the Java process.
-
-In your `native` Maven profile section, add the following:
-
-[source,xml,indent=0]
-include::../../../../samples/java-application-with-reflection/pom.xml[tag=java-agent-exec]
-
-Then you can execute your application with the agent by running:
+Finally, you need to execute tests using the `integration-test` phase instead of `test`:
 
+[source,bash, role="multi-language-sample"]
 ```bash
-mvn -Pnative -Dagent=true -DskipTests -DskipNativeBuild=true package exec:exec@java-agent
+./mvnw -Pnative integration-test
 ```
 
-Both of the above commands will generate configuration files in the
-`target/native/agent-output/main` directory. If you want to run your native application
-with those configuration files, you then need to execute the following command:
-
-```bash
-mvn -Pnative -Dagent=true -DskipTests package exec:exec@native
-```
+Refer to the https://maven.apache.org/plugins/maven-shade-plugin[Maven Shade plugin documentation] for more details on how to configure shading, and the https://maven.apache.org/plugins/maven-assembly-plugin[Maven Assembly plugin documentation] to tweak what to include in tests.
 
 [[metadata-support]]
-== GraalVM Reachability Metadata Support
+== GraalVM Reachability Metadata support
 
-The plugin adds support for the https://github.com/oracle/graalvm-reachability-metadata/[GraalVM reachability metadata repository].
-This repository provides https://www.graalvm.org/latest/reference-manual/native-image/metadata/[reachability metadata] for libraries that do not support GraalVM Native Image.
+The plugin adds support for the https://github.com/oracle/graalvm-reachability-metadata/[GraalVM Reachability Metadata Repository].
+This repository provides the https://www.graalvm.org/latest/reference-manual/native-image/metadata/[configuration] for libraries that do not support GraalVM Native Image.
 
 [NOTE]
 ====
-This version of the plugin defaults to the using the metadata repository in version {metadata-repository-version}. There is nothing for you to configure if you are fine with this version. The repository is also published on Maven Central at the following coordinates:
+The repository is also published on Maven Central at the following coordinates:
+
+[source,xml, role="multi-language-sample"]
 ```xml
 <dependency>
    <groupId>org.graalvm.buildtools</groupId>
@@ -628,77 +837,72 @@ This version of the plugin defaults to the using the metadata repository in vers
     <type>zip</type>
 </dependency>
 ```
-e.g. `graalvm-reachability-metadata-{maven-plugin-version}-repository.zip`.
+For example: `graalvm-reachability-metadata-{maven-plugin-version}-repository.zip`.
 ====
 
 === Configuring the metadata repository
 
-Metadata repository is enabled by default. Support can be disabled by including the following into the `<configuration>` element:
+The plugin automatically downloads the configuration metadata from the official repository if you supply the version of the repository you want to use.
 
-.Disabling the metadata repository
-[source,xml,indent=0]
+The support is enabled by default, but can be disabled explicitly:
+
+[source,xml, indent=0, role="multi-language-sample"]
 ----
 include::../../../../samples/metadata-repo-integration/pom.xml[tag=metadata-disable]
 ----
 
 Alternatively, you can use a _remote repository_, in which case you can specify the URL of the ZIP file:
 
-.Enabling a remote repository
-[source,xml,indent=0]
+[source,xml, indent=0, role="multi-language-sample"]
 ----
 include::../../../../samples/native-config-integration/pom.xml[tag=metadata-url]
 ----
 
 For debugging purposes you can use a local repository:
 
-.Enabling a local repository
-[source,xml,indent=0]
+[source,xml, indent=0, role="multi-language-sample"]
 ----
 include::../../../../samples/native-config-integration/pom.xml[tag=metadata-local]
 ----
-<1> The local path can point to an _exploded_ directory, or to a compressed ZIP file.
 
 For each library included in the native image, the plugin will automatically search for GraalVM image build configuration metadata in the repository that was released together with the plugin.
-In case you want to use another version of the metadata use:
 
-.Choosing a version for the metadata repository
-[source,xml,indent=0]
+For each library dependency, the plugin automatically searches for the configuration metadata in the repository.
+In some cases, you may want to override the repository version:
+
+[source,xml, indent=0, role="multi-language-sample"]
 ----
 include::../../../../samples/metadata-repo-integration/pom.xml[tag=metadata-versioned]
 ----
 
-
-In some cases, you may need to exclude a particular module from the search.
+You may want to exclude a particular module from the search.
 This can be done by configuring that particular dependency:
 
-.Excluding a module from search
-[source,xml,indent=0]
+[source,xml, indent=0, role="multi-language-sample"]
 ----
 include::../../../../samples/native-config-integration/pom.xml[tag=metadata-exclude]
 ----
 
-Last, it is possible for you to override the _metadata version_ of a particular module.
-This may be interesting if there's no specific metadata available for the particular version of the library that you use, but that you know that a version works:
+Lastly, it is possible for you to override the _metadata version_ of a particular module.
+This may be interesting if there is no specific metadata available for the particular version of the library that you use, but that you know that a version works:
 
-.Specifying the metadata version to use for a particular library
-[source,xml,indent=0]
+[source,xml, indent=0, role="multi-language-sample"]
 ----
 include::../../../../samples/native-config-integration/pom.xml[tag=metadata-force-version]
 ----
 
 === Adding metadata repository files
 
-By default, repository metadata will be used only when your native image is generated.
-In some situations, you may want to include the metadata directly inside your jar.
+By default, reachability metadata is used only when your native image is being generated.
+In some situations, you may want to include the metadata directly inside your JAR file.
 
-Adding metadata to your jar can be useful when some other process is responsible for converting your jar into a native image.
-For example, you might be generating a shaded jar and using a https://paketo.io/[Paketo buildpack] to convert it to a native image.
+Copying the reachability metadata into the application JAR can be useful when some other process is responsible for converting your JAR into a native image.
+For example, you might be generating a shaded JAR file and using a https://paketo.io/[Paketo buildpack] to convert it to a native image.
 
-To include metadata repository inside your jar you can use the `add-reachability-metadata` goal.
-Typically the goal will be included in an execution step where by default it will be bound to the `generate-resources` phase:
+To include metadata repository inside the JAR file, you can use the `add-reachability-metadata` goal.
+Typically, the goal will be included in an execution step where, by default, it will be bound to the `generate-resources` phase:
 
-.Configuring the `add-reachability-metadata` goal to execute with the `generate-resources` phase
-[source,xml,indent=0]
+[source,xml, indent=0, role="multi-language-sample"]
 ----
 include::../../../../samples/native-config-integration/pom.xml[tag=add-reachability-metadata-execution]
 ----
@@ -706,4 +910,4 @@ include::../../../../samples/native-config-integration/pom.xml[tag=add-reachabil
 [[javadocs]]
 == Javadocs
 
-In addition, you can consult the link:javadocs/native-maven-plugin/index.html[Javadocs of the plugin].
+For further reference, you can review the link:javadocs/native-maven-plugin/index.html[Javadocs of the plugin].
\ No newline at end of file
diff --git a/docs/src/docs/snippets/gradle/groovy/build.gradle b/docs/src/docs/snippets/gradle/groovy/build.gradle
index 71da0fd42..5b0ce5b44 100644
--- a/docs/src/docs/snippets/gradle/groovy/build.gradle
+++ b/docs/src/docs/snippets/gradle/groovy/build.gradle
@@ -67,22 +67,45 @@ if (providers.environmentVariable("ENABLE_TOOLCHAIN").isPresent()) {
 
 // tag::all-config-options[]
 graalvmNative {
+    binaries {
+        main {
+            imageName = 'application'
+            mainClass = 'org.test.Main'
+            debug = true
+            verbose = true
+            fallback = true
+            sharedLibrary = false
+            quickBuild = false
+            richOutput = false
+
+            systemProperties = [name1: 'value1', name2: 'value2']
+            configurationFileDirectories.from(file('src/my-config'))
+            excludeConfig.put("org.example.test:artifact:version", ["^/META-INF/native-image/.*", "^/config/.*"])
+            excludeConfig.put(file("path/to/artifact.jar"), listOf("^/META-INF/native-image/.*", "^/config/.*"))
+
+            // Advanced options
+            buildArgs.add('--link-at-build-time')
+            jvmArgs.add('flag')
+
+            // Runtime options
+            runtimeArgs.add('--help')
+
+            useFatJar = true
+        }
+    }
+
     agent {
-        defaultMode = "standard" // Default agent mode if one isn't specified using `-Pagent=mode_name`
-        enabled = true // Enables the agent
+        defaultMode = "standard"
+        enabled = true
 
         modes {
-            // The standard agent mode generates metadata without conditions.
             standard {
             }
-            // The conditional agent mode generates metadata with conditions.
             conditional {
-                userCodeFilterPath = "path-to-filter.json" // Path to a filter file that determines classes which will be used in the metadata conditions.
-                extraFilterPath = "path-to-another-filter.json" // Optional, extra filter used to further filter the collected metadata.
+                userCodeFilterPath = "path-to-filter.json"
+                extraFilterPath = "path-to-another-filter.json" // Optional
             }
-            // The direct agent mode allows users to directly pass options to the agent.
             direct {
-                // {output_dir} is a special string expanded by the plugin to where the agent files would usually be output.
                 options.add("config-output-dir={output_dir}")
                 options.add("experimental-configuration-with-origins")
             }
@@ -96,48 +119,14 @@ graalvmNative {
         enableExperimentalUnsafeAllocationTracing = false
         trackReflectionMetadata = true
 
-        // Copies metadata collected from tasks into the specified directories.
         metadataCopy {
-            inputTaskNames.add("test") // Tasks previously executed with the agent attached.
-            outputDirectories.add("src/main/resources/META-INF/native-image/<groupId>/<artifactId>/") // Replace <groupId> and <artifactId> with GAV coordinates of your project
-            mergeWithExisting = true // Instead of copying, merge with existing metadata in the output directories.
+            inputTaskNames.add("test")
+            outputDirectories.add("META-INF/native-image/<groupId>/<artifactId>/")
+            mergeWithExisting = true
         }
 
-        /*
-        By default, if `-Pagent` is specified, all tasks that extend JavaForkOptions are instrumented.
-        This can be limited to only specific tasks that match this predicate.
-         */
         tasksToInstrumentPredicate = t -> true
     }
-
-    binaries {
-        main {
-            // Main options
-            imageName = 'application' // The name of the native image, defaults to the project name
-            mainClass = 'org.test.Main' // The main class to use, defaults to the application.mainClass
-            debug = true // Determines if debug info should be generated, defaults to false (alternatively add --debug-native to the CLI)
-            verbose = true // Add verbose output, defaults to false
-            fallback = true // Sets the fallback mode of native-image, defaults to false
-            sharedLibrary = false // Determines if image is a shared library, defaults to false if `java-library` plugin isn't included
-            quickBuild = false // Determines if image is being built in quick build mode (alternatively use GRAALVM_QUICK_BUILD environment variable, or add --native-quick-build to the CLI)
-            richOutput = false // Determines if native-image building should be done with rich output
-            requiredVersion = '22.3' // The minimal GraalVM version, can be `MAJOR`, `MAJOR.MINOR` or `MAJOR.MINOR.PATCH`
-
-            systemProperties = [name1: 'value1', name2: 'value2'] // Sets the system properties to use for the native image builder
-            configurationFileDirectories.from(file('src/my-config')) // Adds a native image configuration file directory, containing files like reflection configuration
-            excludeConfig.put("org.example.test:artifact:version", ["^/META-INF/native-image/.*", "^/config/.*"]) // Excludes configuration that matches one of given regexes from JAR of dependency with said coordinates.
-            excludeConfig.put(file("path/to/artifact.jar"), listOf("^/META-INF/native-image/.*", "^/config/.*"))
-
-            // Advanced options
-            buildArgs.add('--link-at-build-time') // Passes '--link-at-build-time' to the native image builder options. This can be used to pass parameters which are not directly supported by this extension
-            jvmArgs.add('flag') // Passes 'flag' directly to the JVM running the native image builder
-
-            // Runtime options
-            runtimeArgs.add('--help') // Passes '--help' to built image, during "nativeRun" task
-
-            useFatJar = true // Instead of passing each jar individually, builds a fat jar
-        }
-    }
 }
 // end::all-config-options[]
 
diff --git a/docs/src/docs/snippets/gradle/kotlin/build.gradle.kts b/docs/src/docs/snippets/gradle/kotlin/build.gradle.kts
index 50a9dfbd4..ce7ac7ff0 100644
--- a/docs/src/docs/snippets/gradle/kotlin/build.gradle.kts
+++ b/docs/src/docs/snippets/gradle/kotlin/build.gradle.kts
@@ -68,22 +68,45 @@ if (providers.environmentVariable("ENABLE_TOOLCHAIN").isPresent()) {
 
 // tag::all-config-options[]
 graalvmNative {
+    binaries {
+        named("main") {
+            imageName.set("application")
+            mainClass.set("org.test.Main")
+            debug.set(true)
+            verbose.set(true)
+            fallback.set(true)
+            sharedLibrary.set(false)
+            richOutput.set(false)
+            quickBuild.set(false)
+
+            systemProperties.putAll(mapOf("name1" to "value1", "name2" to "value2"))
+            configurationFileDirectories.from(file("src/my-config"))
+            excludeConfig.put("org.example.test:artifact:version", listOf("^/META-INF/native-image/.*", "^/config/.*"))
+            excludeConfig.put(file("path/to/artifact.jar"), listOf("^/META-INF/native-image/.*", "^/config/.*"))
+
+            // Advanced options
+            buildArgs.add("--link-at-build-time")
+            jvmArgs.add("flag")
+
+            // Runtime options
+            runtimeArgs.add("--help")
+
+            useFatJar.set(true)
+        }
+    }
+
     agent {
-        defaultMode.set("standard") // Default agent mode if one isn't specified using `-Pagent=mode_name`
-        enabled.set(true) // Enables the agent
+        defaultMode.set("standard")
+        enabled.set(true)
 
         modes {
-            // The standard agent mode generates metadata without conditions.
             standard {
             }
-            // The conditional agent mode generates metadata with conditions.
             conditional {
-                userCodeFilterPath.set("path-to-filter.json") // Path to a filter file that determines classes which will be used in the metadata conditions.
-                extraFilterPath.set("path-to-another-filter.json") // Optional, extra filter used to further filter the collected metadata.
+                userCodeFilterPath.set("path-to-filter.json")
+                extraFilterPath.set("path-to-another-filter.json") // Optional
             }
-            // The direct agent mode allows users to directly pass options to the agent.
             direct {
-                // {output_dir} is a special string expanded by the plugin to where the agent files would usually be output.
                 options.add("config-output-dir={output_dir}")
                 options.add("experimental-configuration-with-origins")
             }
@@ -97,48 +120,14 @@ graalvmNative {
         enableExperimentalUnsafeAllocationTracing.set(false)
         trackReflectionMetadata.set(true)
 
-        // Copies metadata collected from tasks into the specified directories.
         metadataCopy {
-            inputTaskNames.add("test") // Tasks previously executed with the agent attached.
-            outputDirectories.add("src/main/resources/META-INF/native-image/<groupId>/<artifactId>/") // Replace <groupId> and <artifactId> with GAV coordinates of your project
-            mergeWithExisting.set(true) // Instead of copying, merge with existing metadata in the output directories.
+            inputTaskNames.add("test")
+            outputDirectories.add("/META-INF/native-image/<groupId>/<artifactId>/")
+            mergeWithExisting.set(true)
         }
 
-        /*
-        By default, if `-Pagent` is specified, all tasks that extend JavaForkOptions are instrumented.
-        This can be limited to only specific tasks that match this predicate.
-         */
         tasksToInstrumentPredicate.set(t -> true)
     }
-
-    binaries {
-        named("main") {
-            // Main options
-            imageName.set("application") // The name of the native image, defaults to the project name
-            mainClass.set("org.test.Main") // The main class to use, defaults to the application.mainClass
-            debug.set(true) // Determines if debug info should be generated, defaults to false (alternatively add --debug-native to the CLI)
-            verbose.set(true) // Add verbose output, defaults to false
-            fallback.set(true) // Sets the fallback mode of native-image, defaults to false
-            sharedLibrary.set(false) // Determines if image is a shared library, defaults to false if `java-library` plugin isn't included
-            quickBuild.set(false) // Determines if image is being built in quick build mode (alternatively use GRAALVM_QUICK_BUILD environment variable, or add --native-quick-build to the CLI)
-            richOutput.set(false) // Determines if native-image building should be done with rich output
-            requiredVersion.set('22.3') // The minimal GraalVM version, can be `MAJOR`, `MAJOR.MINOR` or `MAJOR.MINOR.PATCH`
-
-            systemProperties.putAll(mapOf("name1" to "value1", "name2" to "value2")) // Sets the system properties to use for the native image builder
-            configurationFileDirectories.from(file("src/my-config")) // Adds a native image configuration file directory, containing files like reflection configuration
-            excludeConfig.put("org.example.test:artifact:version", listOf("^/META-INF/native-image/.*", "^/config/.*")) // Excludes configuration that matches one of given regexes from JAR of dependency with said coordinates.
-            excludeConfig.put(file("path/to/artifact.jar"), listOf("^/META-INF/native-image/.*", "^/config/.*"))
-
-            // Advanced options
-            buildArgs.add("--link-at-build-time") // Passes '--link-at-build-time' to the native image builder options. This can be used to pass parameters which are not directly supported by this extension
-            jvmArgs.add("flag") // Passes 'flag' directly to the JVM running the native image builder
-
-            // Runtime options
-            runtimeArgs.add("--help") // Passes '--help' to built image, during "nativeRun" task
-
-            useFatJar.set(true) // Instead of passing each jar individually, builds a fat jar
-        }
-    }
 }
 // end::all-config-options[]