+ Released on {(entry.data.pubdate ?? new Date(0)).toLocaleDateString("en", { dateStyle: "medium", timeZone: "UTC" })} + { + entry.data.link && ( + <> + - GitHub + + ) + } +
+
+ `. For example, ``.
+
+ Credit to `mbaxter`.
+
+ ```java
+ /**
+ * Creates a tag resolver capable of resolving PlaceholderAPI tags for a given player.
+ *
+ * @param player the player
+ * @return the tag resolver
+ */
+ public @NotNull TagResolver papiTag(final @NotNull Player player) {
+ return TagResolver.resolver("papi", (argumentQueue, context) -> {
+ // Get the string placeholder that they want to use.
+ final String papiPlaceholder = argumentQueue.popOr("papi tag requires an argument").value();
+
+ // Then get PAPI to parse the placeholder for the given player.
+ final String parsedPlaceholder = PlaceholderAPI.setPlaceholders(player, '%' + papiPlaceholder + '%');
+
+ // We need to turn this ugly legacy string into a nice component.
+ final Component componentPlaceholder = LegacyComponentSerializer.legacySection().deserialize(parsedPlaceholder);
+
+ // Finally, return the tag instance to insert the placeholder!
+ return Tag.selfClosingInserting(componentPlaceholder);
+ });
+ }
+ ```
+
+
+## Why am I getting a `NoSuchFieldError`, `NoSuchMethodError`, `ClassNotFoundException` or similar when updating/using `adventure-platform-*`, `adventure-text-minimessage`, `adventure-api` or other related libraries/tools?
+
+In the case of `adventure-platform-fabric`, you need to make sure you are properly `include()`-`ing` the mod. For legacy platform implementations, you need to make sure you are properly shading and relocating your specific dependencies. Specific issues may include:
+
+- Not shading the correct version of `adventure-api`. You can check your dependency tree to see what or why your build tool is not including the correct version of the API that matches the one used by the platform version you are using.
+- Not relocating your dependencies. If you are running on a platform that includes an older version of the API, or another mod/plugin is also not properly relocating their dependencies, you will use their out-of-date version of the API, causing errors.
+- Building/running against a native implementation of `adventure-api`. If you are running on a platform that includes an older version of the API, this could cause issues if the library depends on newer features that are not available in the outdated version of the API, your library will not be able to find these methods, causing errors.
+- Relocating `adventure-api` and trying to use native/library methods. If you relocate the API, you will not be able to use any methods that use the API in native implementations or libraries as method signatures will differ. Either shade and relocate this software, or do not use native methods. Alternatively, if you are shading and relocating a library but want to use the API, make sure you are only relocating the packages that you are shading.
+
+Please consult the documentation for your build tool for more information on how to shade, relocate and manage your dependencies. We do not provide one-on-one support for these sorts of issues, as there are far too many project-specific variables that make isolating issues difficult.
diff --git a/src/content/docs/adventure/getting-started.mdx b/src/content/docs/adventure/getting-started.mdx
new file mode 100644
index 000000000..cacebb0d2
--- /dev/null
+++ b/src/content/docs/adventure/getting-started.mdx
@@ -0,0 +1,60 @@
+---
+title: Getting started
+description: A guide to getting started with Adventure.
+---
+
+import { Tabs, TabItem } from "@astrojs/starlight/components";
+
+import Dependency from "/src/components/Dependency.astro";
+import { LATEST_ADVENTURE_API_RELEASE } from "/src/utils/versions";
+
+To use Adventure in your project, you will need to add the following dependency (and repository if using Gradle):
+
+Declaring the dependency:
+
+Example
+ Example method to create a MiniMessage placeholder that parses PlaceholderAPI placeholders for a player. + + The tag added is of the format `
+
+
+
+
+### Color (verbose)
+
+A more verbose way of defining colors
+
+Tag
+ * `
+
+
+
+
+### Shadow Color
+
+Color the shadow of the next parts
+
+Tag
+ * `
+ 
+ 
+ 
+
+
+### Decoration
+
+Decorate the next parts
+
+Tag
+ * `<_decorationname_[:false]>`, or `` as an alias to invert the decoration.
+
+Arguments
+ * `_decorationname_`, Any decoration supported in Minecraft:
+
+| Decoration | Aliases |
+| ----------------- | --------------- |
+| `bold` | `b` |
+| `italic` | `em` or `i` |
+| `underlined` | `u` |
+| `strikethrough` | `st` |
+| `obfuscated` | `obf` |
+
+Examples
+```mm
+
+ 
+
+
+### Reset
+
+Close all currently open tags, resetting color/decoration/etc. The reset tag cannot be closed.
+
+In strict mode, reset tags are forbidden.
+
+Tag
+ * `
+
+
+
+### Click
+
+Allows doing multiple things when clicking on the component.
+
+Tag
+ * `
+
+
+
+:::caution
+
+Since the introduction of chat signatures in 1.19.1, the client no longer executes commands that require signed arguments
+like the `/say` or `/tell` command to prevent the server from sending signed messages on the client's behalf.
+
+:::
+
+### Hover
+
+Allows doing multiple things when hovering on the component.
+
+Tag
+ * `
+
+
+
+### Keybind
+
+Allows displaying the configured key for actions
+
+Tag
+ * `
+
+
+
+### Translatable
+
+Allows displaying minecraft messages using the player locale
+
+Tag
+ * `
+
+
+
+
+### Fallback
+
+:::note
+
+The fallback option is only available since Minecraft 1.19.4.
+
+:::
+
+Allows displaying minecraft messages using the player locale, or a fallback if no text is available
+
+Tag
+ * `
+
+
+
+### Rainbow
+
+Rainbow-colored text?!
+
+Tag
+ * `
+
+
+
+### Gradient
+
+Gradient colored text
+
+Tag
+ * `
+
+
+
+
+### Transition
+
+Transitions between colors.
+Similar to a gradient, but everything is the same color and the phase chooses that color
+
+Tag
+ * `
+![The result of parsing `<transition:white:black:red:[phase]>Hello World [phase]</transition>`, shown in-game in the Minecraft client's chat window]({Transition1.src})
+
+
+
+### Font
+
+Allows to change the font of the text
+
+Tag
+ * `
+
+
+
+### Newline
+
+Insert a newline character.
+
+Tag
+ * `
+
+
+
+### Selector
+
+*(since v4.11.0)* Insert a selector component
+
+Tag
+ * `
+![The result of parsing `Hello <selector:@e[limit=5]>, I'm <selector:@s>!`, show in-game in the Minecraft client's chat window]({Selector1.src})
+
+
+### Score
+
+*(since v4.13.0)* Insert a score component.
+
+:::note
+
+The score component requires *rendering* on the server to be seen by clients. This is a platform-specific operation.
+
+:::
+
+Tag
+ * `
+
+
+:::
+
+## Basic use
+
+The easiest way to get started with this platform is to work with the Minecraft game objects that directly implement Adventure interfaces (requires Loom 0.11 or newer).
+
+This covers almost all cases where the default renderer is used.
+
+The following Adventure interfaces are directly implemented:
+
+`Audience`
+ - `net.minecraft.commands.CommandSourceStack`, `net.minecraft.server.MinecraftServer`, `net.minecraft.server.rcon.RconConsoleSource`,
+ - `net.minecraft.server.level.ServerPlayer`, `net.minecraft.client.player.LocalPlayer`
+
+`Sound.Emitter`
+ - `net.minecraft.world.entity.Entity`
+
+`Sound.Type`
+ - `net.minecraft.sounds.SoundEvent`
+
+`Identified`
+ - `net.minecraft.world.entity.player.Player`
+
+`ComponentLike`
+ - `net.minecraft.network.chat.Component`
+
+`Key`
+ - `net.minecraft.resources.ResourceLocation`
+
+`Keyed`
+ - `net.minecraft.resources.ResourceKey`
+
+`HoverEventSource`
+ - `net.minecraft.world.entity.Entity`,
+ - `net.minecraft.world.item.ItemStack`
+
+`SignedMessage`
+ - `net.minecraft.network.chat.PlayerChatMessage`
+
+`SignedMessage.Signature`
+ - `net.minecraft.network.chat.MessageSignature`
+
+Additionally, all `Key`s created will be `ResourceLocation` instances (on Loader 0.14.0+)
+
+Using these injections, getting started is as simple as:
+
+```java
+void greet(final ServerPlayer player) {
+ Component message = Component.text()
+ .content("Hello ")
+ .append(player.get(Identity.DISPLAY_NAME)
+ .get()
+ .color(NamedTextColor.RED)
+ );
+ player.sendMessage(message);
+}
+```
+
+For more complex use cases, `FabricServerAudiences` or `FabricClientAudiences` provide additional API.
+
+## Server
+
+The logical-server side of the Fabric platform can be accessed any time a server is available, through a `MinecraftServerAudiences` instance. By default, translatable components will be rendered with the global translator, but a custom renderer can be passed when initializing the platform.
+
+All `AudienceProvider` interface methods are supported, except for the `permission` method. This will become supported as soon as Fabric gets a suitable permissions API.
+
+To get started with Adventure, set up an audience provider like this:
+
+```java
+public class MyMod implements ModInitializer {
+
+ private volatile MinecraftServerAudiences adventure;
+
+ public MinecraftServerAudiences adventure() {
+ if (this.adventure == null) {
+ throw new IllegalStateException("Tried to access Adventure without a running server!");
+ }
+ return this.adventure;
+ }
+
+ @Override
+ public void onInitialize() {
+ // Register with the server lifecycle callbacks
+ // This will ensure any platform data is cleared between game instances
+ // This is important on the integrated server, where multiple server instances
+ // can exist for one mod initialization.
+ ServerLifecycleEvents.SERVER_STARTING.register(server -> this.adventure = MinecraftServerAudiences.of(server));
+ ServerLifecycleEvents.SERVER_STOPPED.register(server -> this.adventure = null);
+ }
+}
+```
+
+From here, audiences can be acquired for players and any other `CommandSource`. Specialized serializer instances are also available, to allow using
+game information in component serialization.
+
+### Localization
+
+As part of the platform's translation support, the `PlayerLocales.CHANGED_EVENT` callback will be called any time a player on the server receives an
+updated language from their client, and allows accessing the current locale for a player.
+
+### Commands
+
+The Fabric platform provides custom argument types to specify `Key` and `Component` parameters in Brigadier commands, and has helpers to easily get an
+`Audience` from a `CommandSourceStack` (yarn: `ServerCommandSource`) instance.
+
+:::caution
+
+If these custom argument types are used (pre-1.19), Vanilla clients will not be able to join unless the [Colonel](https://gitlab.com/stellardrift/colonel)
+mod is installed on the server. Like the platform, it is small and easily included in your mod jar.
+
+:::
+
+As an example, here's a simple command that will echo whatever is provided as input:
+
+```java
+// A potential method to be in the mod initializer class above
+private static final String ARG_MESSAGE = "message";
+
+void registerCommands(final CommandDispatcher dispatcher, final boolean isDedicated) {
+ dispatcher.register(literal("echo").then(argument(ARG_MESSAGE, component()).executes(ctx -> {
+ final Component message = component(ctx, ARG_MESSAGE);
+ ctx.getSource().sendMessage(Component.text("You said: ").append(message));
+ }));
+}
+```
+
+## Client
+
+Special for the Fabric platform, purely client-side operations are supported. The setup is less involved than it is for the server,
+since the client is a singleton, and there is only one subject that can be acted on: the client's player.
+
+This means that for most users the `MinecraftClientAudiences` object can be treated as a singleton. The only exception is users using a
+custom renderer. This makes using Adventure audiences fairly simple, as this code example shows:
+
+```java
+void doThing() {
+ // Get the audience
+ final Audience client = MinecraftClientAudiences.of().audience();
+
+ // Do something. This will only work when the player is in game.
+ client.sendMessage(Component.text("meow", NamedTextColor.DARK_PURPLE));
+}
+```
+
+The full functionality of the `Audience` interface is available, including localization!
+
+## Working with native types
+
+Sadly, Adventure can't provide API for every place chat components are used in the game. However, for areas not covered by the API in `Audience`,
+it's possible to convert components between native and Adventure types. See certain native types which implement
+Adventure interfaces, and the methods on `FabricAudiences` for other available conversions.
diff --git a/src/content/docs/adventure/platform/implementing.md b/src/content/docs/adventure/platform/implementing.md
new file mode 100644
index 000000000..5edd18404
--- /dev/null
+++ b/src/content/docs/adventure/platform/implementing.md
@@ -0,0 +1,63 @@
+---
+title: Implementing platforms
+description: Implementing Adventure for your own platform.
+---
+
+Most users will be here to look at information about existing platform implementations, but for those who are looking to build their own platform integrations, look no further.
+
+While at its core Adventure 'just' provides data structures and serializers, as the game evolves and more functionality is added there are more tunable options and platform hooks
+necessary to produce the correct output for the applicable game version. This has led to the introduction of a variety of services that platforms can provide implementations of using
+Java's `ServiceLoader` mechanism. Some other behaviors are expected by convention. As there are not that many platforms that integrate with Adventure, this page is an attempt to
+cover the common points. Please don't be afraid to ask us questions, and together we can work on fleshing out this page.
+
+## Services
+
+### `ComponentSerializer` services
+
+Most of the serializers (Gson, legacy, etc.) have `Provider` SPI's that allow customizing the default behaviors of serializers. These are most applicable for the Gson/other JSON
+serializers where the data structures have changed over time, but the legacy serializer's options can be worth referencing too. See the Javadoc for each serializer for more information.
+
+For any `JSONComponentSerializer` subtype, we have tried to gather relevant tunable options within a single system, keyed by the game's active
+[data version](https://minecraft.wiki/w/Data_version). To handle hover events in pre-1.16 game versions, there's the additional `LegacyHoverEventSerializer`
+interface. We offer an implementation that uses `adventure-nbt` as a separate submodule, but platforms may wish to use a native NBT library for this instead.
+Both of these options should be set on builders in the appropriate `Provider` implementation.
+
+### Data component values
+
+To handle storing platform-specific data on `show_item` hover events, we expose opaque data objects in-API. Platforms should provide logic to convert between different
+implementations by providing an implementation of `DataComponentValueConverterRegistry.Provider`. For the most part this is just converting between platform-specific types
+and the generic `TagSerializable` and `Removed` types, but platforms should make sure to include converters to `GsonDataComponentValue` (from both platform types
+*and* the generic `TagSerializable` that requires parsing SNBT for a conversion to occur).
+
+### Click callbacks
+
+As callbacks are a commonly desired feature, Adventure provides a 'virtual' click event type for callback functions. This action is not persistent between runs, and needs
+platforms to register a command to trigger callbacks to execute. This is implemented via the `ClickCallback.Provider` SPI. This command should not be sent as part of the
+command tree that clients receive to avoid spamming them.
+
+Platforms implementing the click callback provider must register a command at the appropriate time, and maintain a registry of active callbacks that is added to any time a
+callback command is requested. The platform is responsible for ensuring any execution conditions apply and implementing the effects of any `Option`s that may be set on the callback.
+
+### Component logging
+
+`ComponentLogger`, as part of the `adventure-text-logger-slf4j` module, provides a logging interface that extends SLF4J and wraps any existing SLF4J logger (compatible with
+v1 and v2). Platforms are responsible for providing the adapter that looks up the appropriate logger by name and serializes components to text.
+
+This should involve performing any translations if necessary. The default behavior of the logger is to serialize to plain text, but platforms may want to look at the
+`/serializer/ansi` serializer instead for colored output.
+
+### Boss bars
+
+Boss bars are logistically somewhat complicated. As one of the few holders of mutable state in the library, they have to re-sync any state changes to their viewers.
+In order to track viewers and link up to any internal state, the `BossBarImplementation.Provider` SPI allows platforms to provide their own implementation hooks per-bar.
+
+## Conventional behaviors
+
+Some behaviors are expected by platforms beyond what is explicitly required by implementing certain interfaces. These are:
+
+* When implementing `Audience`, any unsupported operations should fail silently.
+* When sending components to a player, they should be passed through `GlobalTranslator` before sending to perform any translations (note: `GlobalTranslator` is only for
+ custom translations, and should not contain vanilla resource pack translations - they have a different interpolation syntax than `GlobalTranslator` uses)
+* There is no specific required list of Adventure modules to distribute with your platform, but we recommend `adventure-api`, `adventure-text-minimessage`,
+ `adventure-text-logger-slf4j`, plus whatever serializers are required for the integration. We specifically do not recommend distributing the
+ `adventure-text-serializer-legacy` module unless it is necessary for backwards compatibility within your platform.
diff --git a/src/content/docs/adventure/platform/index.md b/src/content/docs/adventure/platform/index.md
new file mode 100644
index 000000000..24e084c85
--- /dev/null
+++ b/src/content/docs/adventure/platform/index.md
@@ -0,0 +1,59 @@
+---
+title: Platforms
+description: Documentation regarding various implementations of the Adventure API.
+tableOfContents: false
+sidebar:
+ label: Overview
+---
+
+Adventure integrates with many of the Minecraft platforms out there. Some platforms support
+Adventure natively, but other legacy platforms have their own types and need an adapter to handle Adventure types. To enable you to use Adventure with these platforms, Adventure provides a number of platform-specific adapters to
+allow you to obtain `Audience` instances from native user types.
+
+Contents:
+* [Native support](/adventure/platform/native)
+* [Bukkit](/adventure/platform/bukkit)
+ * [Usage](/adventure/platform/bukkit#usage)
+ * [Component serializers](/adventure/platform/bukkit#component-serializers)
+* [BungeeCord](/adventure/platform/bungeecord)
+ * [Usage](/adventure/platform/bungeecord#usage)
+ * [Component serializers](/adventure/platform/bungeecord#component-serializers)
+* [SpongeAPI](/adventure/platform/spongeapi)
+ * [Usage](/adventure/platform/spongeapi#usage)
+* [Modded (Fabric and NeoForge shared API)](/adventure/platform/modded)
+ * [Dependency](/adventure/platform/modded#dependency)
+ * [Basic use](/adventure/platform/modded#basic-use)
+ * [Working with native types](/adventure/platform/modded#working-with-native-types)
+* [Fabric](/adventure/platform/fabric)
+ * [Dependency](/adventure/platform/fabric#dependency)
+ * [Basic use](/adventure/platform/fabric#basic-use)
+ * [Server](/adventure/platform/fabric#server)
+ * [Client](/adventure/platform/fabric#dependency)
+ * [Working with native types](/adventure/platform/fabric#working-with-native-types)
+* [NeoForge](/adventure/platform/neoforge)
+ * [Dependency](/adventure/platform/neoforge#dependency)
+ * [Basic use](/adventure/platform/neoforge#basic-use)
+ * [Server](/adventure/platform/neoforge#server)
+ * [Commands](/adventure/platform/neoforge#commands)
+ * [Client](/adventure/platform/neoforge#dependency)
+* [ViaVersion](/adventure/platform/viaversion)
+* [Implementing platforms](/adventure/platform/implementing)
+ * [Services](/adventure/platform/implementing#services)
+ * [Conventional behaviors](/adventure/platform/implementing#conventional-behaviors)
+
+
+:::note
+
+**Why is adventure-platform not sending any messages or not working correctly?**
+
+Firstly, please ensure you are on the latest stable version. It can be found on [Maven Central](https://central.sonatype.com/search?q=g%3Anet.kyori+adventure-platform*).
+
+Next, make sure that the feature you are using exists on the client version that is receiving the action.
+For example, hex color codes won't work on clients older than 1.16, so hex colors will be down-sampled.
+
+If it's still not working, it is useful to enable debug mode by setting the system property `net.kyori.adventure.debug` to `true` and
+looking at the output. This will show what facets are being selected which will help point towards why it is not working for you.
+If you still cannot figure out the issue by yourself, you can always ask in the
+[`#adventure-platform-help`](https://discord.com/channels/289587909051416579/1342379165663363112) channel in the PaperMC Discord!
+
+:::
diff --git a/src/content/docs/adventure/platform/modded.mdx b/src/content/docs/adventure/platform/modded.mdx
new file mode 100644
index 000000000..4241cedca
--- /dev/null
+++ b/src/content/docs/adventure/platform/modded.mdx
@@ -0,0 +1,179 @@
+---
+title: Modded (Fabric and NeoForge shared API)
+description: Fabric and NeoForge shared Adventure implementation.
+---
+
+import { Tabs, TabItem } from "@astrojs/starlight/components";
+
+Starting with *Minecraft: Java Edition* 1.21.2, Adventure is implemented using mostly shared code between NeoForge and Fabric.
+Each major version of Minecraft will usually require a new release of the platform.
+
+The platform supports all features, including localization and custom renderers.
+
+## Dependency
+
+When building multi-loader mods, we often want to move as much code as possible into a loader-agnostic part of our projects.
+
+Adventure facilities this through the `net.kyori:adventure-platform-mod-shared` artifact.
+
+A second variant, `net.kyori:adventure-platform-mod-shared-fabric-repack`, is also published. This variant should be used
+when your common code is managed by `fabric-loom`.
+
+If you are building a Fabric-only or NeoForge-only mod, or do not care to use the platform API in shared code,
+then you don't need to use this artifact explicitly. This is because both platforms depend on it transitively.
+
+As with the rest of the Adventure projects, releases are distributed on Maven Central, and snapshots on Sonatype OSS:
+
+Historic Versions
+ | Minecraft Version | Adventure version | `adventure-platform-fabric` version | + |-------------------|-------------------|-------------------------------------| + | 1.16.2-1.16.4 | 4.9.3 | 4.0.0 | + | 1.17.x | 4.9.3 | 4.1.0 | + | 1.18, 1.18.1 | 4.10.0 | 5.1.0 | + | 1.18.2 | 4.11.0 | 5.3.1 | + | 1.19 | 4.11.0 | 5.4.0 | + | 1.19.1-1.19.2 | 4.12.0 | 5.5.2 | + | 1.19.3 | 4.13.0 | 5.7.0 | + | 1.19.4 | 4.13.0 | 5.8.0 | + | 1.20-1.20.1 | 4.14.0 | 5.9.0 | + | 1.20.2 | 4.14.0 | 5.10.1 | + | 1.20.4 | 4.16.0 | 5.12.0 | + | 1.20.5-1.20.6 | 4.17.0 | 5.13.0 | + | 1.21-1.21.1 | 4.17.0 | 5.14.1 | +
+
+
+:::
+
+## Basic use
+
+The easiest way to get started with this platform is to work with the Minecraft game objects that directly implement Adventure interfaces.
+
+This covers almost all cases where the default renderer is used.
+
+On Fabric, interface injection is used so that you can directly call interface methods on Minecraft objects (with loom 0.11+).
+
+On NeoForge, you must manually cast or use the helpers provided in `MinecraftAudiences`.
+
+The following Adventure interfaces are directly implemented:
+
+`Audience`
+ - `net.minecraft.commands.CommandSourceStack`, `net.minecraft.server.MinecraftServer`, `net.minecraft.server.rcon.RconConsoleSource`,
+ - `net.minecraft.server.level.ServerPlayer`, `net.minecraft.client.player.LocalPlayer`
+
+`AdventureCommandSourceStack`
+ - `net.minecraft.commands.CommandSourceStack`
+
+`Sound.Emitter`
+ - `net.minecraft.world.entity.Entity`
+
+`Sound.Type`
+ - `net.minecraft.sounds.SoundEvent`
+
+`Identified`
+ - `net.minecraft.world.entity.player.Player`
+
+`ComponentLike`
+ - `net.minecraft.network.chat.Component`
+
+`Key`
+ - `net.minecraft.resources.ResourceLocation`
+
+`Keyed`
+ - `net.minecraft.resources.ResourceKey`
+
+`HoverEventSource`
+ - `net.minecraft.world.entity.Entity`,
+ - `net.minecraft.world.item.ItemStack`
+
+`SignedMessage.Signature`
+ - `net.minecraft.network.chat.MessageSignature`
+
+
+Using these injections, getting started is as simple as:
+
+```java
+void greet(final ServerPlayer player) {
+ Component message = Component.text()
+ .content("Hello ")
+ .append(player.get(Identity.DISPLAY_NAME)
+ .get()
+ .color(NamedTextColor.RED)
+ );
+ player.sendMessage(message);
+}
+```
+
+For more complex use cases, `MinecraftServerAudiences` or `MinecraftClientAudiences` provide additional API.
+
+### Commands
+
+The platform provides custom argument types to specify `Key` and `Component` parameters in Brigadier commands.
+
+:::caution
+
+See the platform-specific documentation for details on registration and syncing of these argument types.
+
+:::
+
+As an example, here's a simple command that will echo whatever is provided as input:
+
+```java
+// A potential method to be in the mod initializer class above
+private static final String ARG_MESSAGE = "message";
+
+void registerCommands(final CommandDispatcher dispatcher, final boolean isDedicated) {
+ dispatcher.register(literal("echo").then(argument(ARG_MESSAGE, component()).executes(ctx -> {
+ final Component message = component(ctx, ARG_MESSAGE);
+ ((Audience) ctx.getSource()).sendMessage(Component.text("You said: ").append(message));
+ }));
+}
+```
+
+## Working with native types
+
+Sadly, Adventure can't provide API for every place chat components are used in the game. However, for areas not covered by the API in `Audience`,
+it's possible to convert components between native and Adventure types. See certain native types which implement
+Adventure interfaces, and the methods on `MinecraftAudiences` for other available conversions.
diff --git a/src/content/docs/adventure/platform/native.md b/src/content/docs/adventure/platform/native.md
new file mode 100644
index 000000000..c9a9aed48
--- /dev/null
+++ b/src/content/docs/adventure/platform/native.md
@@ -0,0 +1,18 @@
+---
+title: Native support
+description: All native supported software.
+---
+
+Native platforms integrate Adventure directly with their platform's provided API, and bundle Adventure automatically.
+This allows them to more tightly integrate Adventure with the rest of the game, and avoids users having to handle distributing
+Adventure and some platform adapter themselves.
+
+The following software provide native support for Adventure.
+
+| Platform | Minimum Version | Additional Notes |
+|-----------|--------------------------------------|------------------------------------------------------------------------------------------------------------------|
+| Sponge | Sponge 8 (1.16.5) | |
+| Velocity | 1.1.0 build 158 | For more information, see the [Velocity Docs](/velocity/dev/pitfalls#audience-operations-are-not-fully-supported) |
+| Paper | 1.16.5 build 473 | |
+| Minestom | Build 7494725 | For more information, see the [Minestom Wiki](https://minestom.net/docs/feature/adventure) |
+| Fabric | `adventure-platform-fabric` 5.3.0 | This is not strictly native, but injected interfaces provide a near-native experience |
diff --git a/src/content/docs/adventure/platform/neoforge.mdx b/src/content/docs/adventure/platform/neoforge.mdx
new file mode 100644
index 000000000..948a52d3f
--- /dev/null
+++ b/src/content/docs/adventure/platform/neoforge.mdx
@@ -0,0 +1,98 @@
+---
+title: NeoForge
+description: The NeoForge Adventure implementation.
+---
+
+import Dependency from "/src/components/Dependency.astro";
+
+Adventure supports NeoForge on *Minecraft: Java Edition* 1.21 and up, for both server-side and client-side use. Each major version of Minecraft will usually require
+a new release of the platform.
+
+The platform supports all features, including localization and custom renderers.
+
+## Dependency
+
+The NeoForge platform is packaged as a mod, designed to be included in mods via jar-in-jar packaging. As with the rest of the Adventure projects,
+releases are distributed on Maven Central, and snapshots on Sonatype OSS:
+
+