Skip to content

Wiki en pt

Jump to bottom
pjscruggs edited this page Nov 11, 2026 · 2 revisions

Raknetify2 · Pirate Speak (The Seven Seas)

Lingo

Play with yer mates

RakNet links yer Minecraft ships with their islands.

Build ship · GitHub

Minecraft Raknetify2 Yer ship / Island
Fabric mods/raknetify2-fabric-*.jar Yer ship / Island
Forge mods/raknetify2-forge-*.jar Yer ship / Island
NeoForge mods/raknetify2-neoforge-*.jar Yer ship / Island
Spigot / Paper plugins/raknetify2-spigot-*.jar Island
Velocity plugins/raknetify2-velocity-*.jar Velocity
BungeeCord plugins/raknetify2-bungee-*.jar BungeeCord

Meet a crew

  1. Play with yer mates

  2. Meet a crew

  3. Coordinates

    Coordinates
    RakNet · UDP raknet;play.example.com:25565
    TCP play.example.com:25565

  4. Plundered

  5. Join this crew

F3 · Raknetify2

F3
RakNet · UDP Under way · MTU 1400
TCP Becalmed

Velocity / BungeeCord

  1. Yer ship · Raknetify2 → UDP → Velocity / BungeeCord · Raknetify2
  2. Velocity / BungeeCord → TCP → Island
Port numb'r · UDP Java
Fabric / Forge / NeoForge 1–65534 -Draknetify.fabric.portOverride=25570
Spigot / Paper ≥ 0.1.0-beta.1.431 1–65535 -Draknetify.spigot.portOverride=25570
Velocity 1–65534 -Draknetify.velocity.portOverride=25570
BungeeCord 1–65534 -Draknetify.bungee.portOverride=25570

Time to be hirin' a new navigator

Coordinates UDP
raknet;play.example.com:25580 play.example.com:25580 → NAT → 192.0.2.10:25570
Island · 192.0.2.10 25570/udp

config/raknetify2-compatibility.json

Island / Velocity / BungeeCord

JSON
① ② ③ {"mode":"ordered"}
① ∥ ② ∥ ③ {"mode":"multichannel"}

Simple Voice Chat

Island Raknetify2 · UDP 25565 Simple Voice Chat
Fabric / Forge / NeoForge config/raknetify2-voicechat.json · {"enabled":true} config/voicechat/voicechat-server.properties · port=-1
Spigot / Paper config/raknetify2-voicechat.json · {"enabled":true} plugins/voicechat/voicechat-server.properties · port=-1

Simple Voice Chat · Velocity / BungeeCord

PROXY protocol v2 · UDP

Coordinates trustedProxies RakNet
192.0.2.10 · PROXY v2 / UDP ["192.0.2.10"] ✓
192.0.2.11 · PROXY v2 / UDP ["192.0.2.10"] ✗
Yer ship → RakNet / UDP ["192.0.2.10"] ✗

config/raknetify2-proxy-protocol.json

{"trustedProxies":["192.0.2.10"]}

Minecraft ≥ 1.20.5 · /transfer

  1. Island A · Fabric / Forge / NeoForge · config/raknetify2-transfers.json

    {"destinations":[{"host":"play.example.com","tcpPort":25565,"udpPort":25570}]}

  2. Island B · play.example.com · server.properties → accepts-transfers=true

  3. Island A · /transfer play.example.com 25565 Alex → Yer ship (Alex) → RakNet · play.example.com:25570

PacketOrdering

Minecraft
ui Scribble
entity Bag o' bones
world_interaction Loot bag
effects Bits an' pieces
chunk Blocks

PacketOrdering.java

Ye can't hop on board wit' this version!

Report foul seas

Home port

Raknetify2

When ye play Minecraft with yer mates, Raknetify2 sends the cargo by RakNet over UDP. It uses several channels. If a packet goes overboard on one, the others can still carry their cargo. Ye can often keep playin’ whilst the lost packet is fetched or the next chunks come aboard.

ishland first launched Raknetify. Raknetify2 is a fork with its own crew. The crew keeps it shipshape for newer Minecraft versions and looks after the transport, the platform integrations and the compatibility trials.

Set sail

  1. Check Minecraft an’ mod compatibility.
  2. Pick a haul down an’ install it.
  3. Connect with an address such as raknet;play.example.com.

Charts for captains

Mod authors can use the packet ordering interface to declare dependencies between custom payloads an’ Minecraft traffic.

Charts an’ papers

Raknetify2 uses the MIT license an’ retains the original copyright notices. Its networking implementation builds on Raknetify an’ netty-raknet.

Fitting out

Haul down a release from GitHub Releases. Check the Minecraft version an’ loader requirements for that release afore installing.

Where ye are installing File Folder
Fabric client or server raknetify2-fabric-*.jar mods
Forge client or server raknetify2-forge-*.jar mods
NeoForge client or server raknetify2-neoforge-*.jar mods
Spigot or Paper server raknetify2-spigot-*.jar plugins
Velocity proxy raknetify2-velocity-*.jar plugins
BungeeCord proxy raknetify2-bungee-*.jar plugins

Close the client or stop the server afore replacing its JAR. Take out the original Raknetify JAR an’ any older Raknetify2 JAR from the same Fitting out afore adding the new file.

Client folders belong to the Minecraft instance or modpack ye launch. Server an’ proxy folders belong to that server or proxy Fitting out. Create the appropriate folder if yer loader has not created it yet.

Direct server connections

  1. Install the client mod for yer loader.
  2. Install the matching server mod, or the Spigot/Paper plugin on a compatible server.
  3. Follow Firewall an’ router configuration to allow UDP connections to the server.
  4. Start up again the client an’ server.
  5. Add a server address such as raknet;play.example.com or raknet;play.example.com:25565.

Addresses without the raknet; prefix use TCP.

Installing the client mod alone doesn’t add RakNet support to a remote server. The captain of the server must provide a RakNet endpoint. Crewmates coming aboard another captain's server usually need no inbound router forwarding rules.

Velocity an’ BungeeCord

Install the matching proxy plugin an’ the client mod. Follow Velocity an’ BungeeCord for listener settings, backend forwarding, access restrictions, an’ the address crewmates should use.

A separate UDP listener port

For a direct Minecraft server, set the appropriate Java argument below. Proxy operators should use the Velocity an’ BungeeCord listener settings.

Platform Java argument Accepted ports
Fabric, Forge, or NeoForge server -Draknetify.fabric.portOverride=25570 1 through 65534
Spigot or Paper server -Draknetify.spigot.portOverride=25570 1 through 65535

Forge an’ NeoForge use the shared listener code, so their property name also contains fabric. Replace 25570 with the desired UDP port.

Spigot / Paper ≥ 0.1.0-beta.1.431

Add the argument afore -jar in the Java command, or in yer host's JVM arguments field. Start up again the server an’ allow UDP on the chosen listener port. If the public port is also 25570, connect with raknet;play.example.com:25570. If a router translates the port, use its public port in the client address. The TCP port stays at its existing value.

On Spigot/Paper, the UDP listener keeps the Minecraft TCP listener's local bind address. An invalid override or occupied UDP port prevents RakNet from starting. Check the startup log for the bound UDP address an’ port. Take out the argument an’ start up again to sail back to the TCP listener's port number.

A router or UDP proxy can also expose a different public UDP port an’ forward it to the existing listener without changing the server's Java arguments.

Development builds

Open a successful main run in GitHub Actions an’ haul down its Artifacts archive. GitHub requires an account to haul down workflow artifacts. Use the Fitting out table above to pick a JAR from the archive.

Velocity an’ BungeeCord

Velocity an’ BungeeCord sit between crewmates an’ backend Minecraft servers. Install Raknetify2 on the proxy an’ on each client that will connect over RakNet.

Raknetify2 client --UDP--> Velocity or BungeeCord --TCP--> backend server

The backend servers don’t need Raknetify2 for this connection path. They still need the mods, plugins, an’ forwarding support required by yer network. Raknetify2 doesn’t translate Minecraft versions or change the proxy's account authentication.

Install the proxy plugin

  1. Make sure that ordinary TCP connections through yer proxy work, including authentication an’ switching between backend servers.
  2. Stop the proxy an’ haul down the matching plugin from GitHub Releases.
  3. Put raknetify2-velocity-*-all.jar or raknetify2-bungee-*-all.jar in the proxy's plugins folder. Take out any older Raknetify or Raknetify2 plugin from that folder.
  4. Install the appropriate Raknetify2 client mod using the Fitting out chart.
  5. Check the listener settings below, start up again the proxy, an’ look over its log for RakNet listener errors.
  6. Allow public UDP traffic to the proxy an’ restrict backend gameplay ports as described in Firewall an’ router configuration.

Use compatible Raknetify2 releases on the client an’ proxy. Check Compatibility afore mixing releases.

Velocity

The bind setting in velocity.toml selects Velocity's Minecraft listening address an’ TCP port. Raknetify2 as a rule uses the same port number for UDP. The [servers] entries identify the backend servers. Keep those entries pointed at the backend TCP addresses. See Velocity's configuration reference.

To use a separate UDP port, add this JVM argument afore -jar in Velocity's startup command:

-Draknetify.velocity.portOverride=25570

Replace 25570 with yer chosen port. This changes the RakNet UDP port whilst retaining Velocity's TCP port an’ backend addresses. Start up again Velocity after changing the argument.

Configure crewmate forwarding on both Velocity an’ its backends. Use modern forwarding when the backend software supports it, an’ keep its forwarding secret private. Follow the backend-specific directions in Velocity's crewmate information forwarding chart. Keep the backend firewall restrictions in place alongside forwarding.

BungeeCord

In BungeeCord's config.yml, the host value under each listeners entry identifies a Minecraft listening address an’ TCP port. Raknetify2 as a rule adds UDP on that port number. The servers entries hold backend TCP addresses. These settings are described in the BungeeCord configuration chart.

For a separate UDP port, add this JVM argument afore -jar in BungeeCord's startup command:

-Draknetify.bungee.portOverride=25570

The override belongs to the whole proxy process. For a configuration with multiple Minecraft listeners, check the actual RakNet endpoints in the startup log afore adding firewall rules. Start up again BungeeCord after changing the argument.

Preserve account authentication at the proxy. For Spigot backends, BungeeCord's IP forwarding chart pairs ip_forward: true on the proxy with settings.bungeecord: true on the backend. Forwarding alone doesn’t prevent someone from connecting directly to a backend. Restrict backend access using the firewall directions.

Pick the address crewmates use

Both proxy overrides accept ports from 1 through 65534. Invalid values are ignored, so make sure of the bound UDP port in the startup log. Take out the argument an’ start up again to sail back to the Minecraft listener's port number.

Crewmates connect to the proxy's public hostname an’ UDP port, for example raknet;play.example.com:25570. When a router translates ports, use its public UDP port in the client address. Addresses without the raknet; prefix continue to use the proxy's TCP listener.

Leave Query, Geyser, an’ other UDP services on separate UDP ports. A different TCP port doesn’t resolve a UDP socket conflict.

Voice Chat an’ additional UDP forwarding

Simple Voice Chat uses its own proxy plugin an’ UDP port on Velocity an’ BungeeCord. Follow the Voice Chat proxy guidance for that setup.

If a separate UDP relay sits in front o’ yer Minecraft proxy an’ sends PROXY protocol v2 headers, configure Raknetify2 using UDP forwarding an’ PROXY protocol. Installing Velocity or BungeeCord by itself doesn’t require that configuration.

Try the crossing

Test from outside yer local network with a Raknetify2 client. Come aboard through the proxy, switch between the backend servers ye use, an’ make sure that crewmate identity an’ permissions remain correct.

  • If TCP through the proxy works but RakNet times out, check the proxy's UDP listener, public port, IPv4 an’ IPv6 routes, an’ firewall rules.
  • If both transports fail when the proxy connects to a backend, check that backend's TCP address, access rules, an’ crewmate forwarding configuration.
  • If the proxy reports an occupied UDP port, check for Query, Geyser, a voice proxy, or another process bound to it.

For reports, include both proxy an’ backend logs from the same connection attempt. See When ye run aground for the version information to include.

Firewall an’ router configuration

This chart is for captains who run servers. Raknetify2 needs a working UDP route to the server or proxy accepting RakNet connections. The default setup uses the same port number as Minecraft's TCP listener.

For crewmates on the same local network, use the server's local address an’ allow UDP through its host firewall. Router port forwarding is needed when internet traffic must cross yer router's IPv4 NAT.

Pick the port of call an’ port

Direct server

Send public UDP traffic to the machine running the Minecraft server with Raknetify2. The port of call port is that server's RakNet UDP listener. Allow that port in the server machine's host firewall. Keep its existing TCP route for ordinary Minecraft connections.

For example, if Raknetify2 listens on UDP 25570, forward the public UDP port to the server's local address on port 25570. The server's TCP port can stay at 25565. See direct-server listener settings to pick a different UDP port.

Velocity or BungeeCord

Send public UDP traffic to the machine running Velocity or BungeeCord with the Raknetify2 proxy plugin. Use the proxy's RakNet UDP listener as the forwarding port of call. Keep the proxy's existing public TCP route for ordinary Minecraft connections.

The proxy connects to backend Minecraft servers over TCP. Adding Raknetify2 to the proxy doesn’t require opening backend gameplay UDP ports to crewmates.

Connection Access to allow
Crewmates to the proxy Public UDP to the RakNet listener, plus the existing public TCP listener
Proxy to backend servers Backend Minecraft TCP ports, reachable only from the intended proxy hosts
Crewmates directly to backend gameplay ports Keep blocked, including through IPv6

When the proxy an’ backends run directly on a dedicated machine ye control, backend listeners can use loopback addresses with the proxy configured to reach them there. Across machines, restrict backend TCP access to the proxy hosts using a firewall or an isolated private network. Containers an’ managed hosts need equivalent restrictions for their network layout. See Velocity's backend security chart an’ BungeeCord's firewall chart.

Crewmate forwarding an’ firewall restrictions work together. Direct backend access can bypass the proxy's login checks. For plugin Fitting out, forwarding settings, an’ UDP port overrides, follow Velocity an’ BungeeCord.

Public an’ local port numbers

The public port an’ the listener's port can differ when a router translates between them:

Setting Port to use
Client server address Public UDP port
Router forwarding rule's external port Public UDP port
Router forwarding rule's internal port RakNet listener's UDP port
Host firewall's local port RakNet listener's UDP port

IPv4 port forwarding

For hosting behind an IPv4 router:

  1. Find the local IPv4 address o’ the machine accepting RakNet connections. Use a DHCP reservation or a suitable static address so the forwarding rule continues to target that machine.
  2. Add a UDP forwarding rule for the public port crewmates will use.
  3. Set the rule's port of call to that machine's local address an’ the RakNet listener's UDP port.
  4. Allow inbound UDP on the listener's port in the host firewall.

For example, a server listening on UDP port 25565 can use a rule with public port 25565, port of call address 192.168.1.100, an’ port of call port 25565. Replace the example address with yer server's actual local address.

Keep the existing TCP rule for ordinary Minecraft connections. A TCP forwarding rule alone doesn’t carry UDP.

When forwarding still fails

Check whether another router or yer ISP performs NAT afore traffic reaches yer router. With two routers ye control, forwarding must cover both. If yer ISP uses carrier-grade NAT, ask whether it can provide a public IPv4 address or use a hosting service or tunnel that supports inbound UDP. Yer router's forwarding rule can’t configure the ISP's NAT. See TP-Link's port forwarding guidance for the public WAN address requirement.

IPv6 firewall rules

Allow the selected UDP port through both the router's IPv6 firewall an’ the host firewall. Target the IPv6 address o’ the machine accepting RakNet connections.

Check that the hostname's IPv6 address points to that machine. If its IPv6 address changes, update the DNS write down an’ any address-specific firewall rules.

A hostname that publishes both IPv4 an’ IPv6 addresses needs a working route for each advertised address. Check both sets o’ rules when one crewmate can connect an’ another can’t.

If IPv4 forwarding changes the port number, make sure the port crewmates enter also reaches the IPv6 listener. An IPv4 port translation doesn’t configure the IPv6 route.

Hosting providers an’ tunnels

The provider or tunnel must support UDP on the public endpoint ye give crewmates. Check its port allocations an’ network firewall rules as well as the server's own firewall.

If an additional UDP proxy forwards client addresses using PROXY protocol v2, follow UDP forwarding an’ PROXY protocol an’ restrict access to the receiving UDP listener to the trusted proxy.

Try the crossing

Connect from outside the server's local network with an updated Raknetify2 client, using an address such as raknet;play.example.com:25565. Use the public UDP port in this address.

Use a real RakNet connection to make sure of the route. A UDP scan that receives no response can report an inconclusive result because a working service may discard an unfamiliar probe. Nmap's UDP scan documentation explains this behavior.

A successful TCP connection confirms only the TCP route. If RakNet times out, check the listener, forwarding port of call, UDP port, an’ firewall rules using the When ye run aground chart.

Compatibility

Check compatibility for the particular release ye haul down. The development branch can contain support that has not appeared in a release yet.

Minecraft an’ Java versions

Minecraft an’ Java versions

The Java requirement declared by Raknetify2 is its minimum. Minecraft or the loader may require a newer runtime. Pick a Java version that satisfies all three.

Client an’ server versions

Stick to the same Raknetify2 release on the client an’ the server or proxy accepting its connection when possible. Check the release notes afore mixing releases. Encrypted RakNet connections require support for the authenticated encryption protocol at both ends. Original Raknetify an’ Raknetify2 builds from afore that protocol was introduced can’t make these encrypted connections to updated peers.

Raknetify2 carries Minecraft's existing game protocol. Connecting different Minecraft versions requires a compatible protocol translation setup.

Other mods

Tested mods and plugins

For a failure in a larger modpack, follow the When ye run aground chart. Include the complete mod versions in yer report.

Ordered mode

Ordered mode

As a rule, Raknetify2 lets independent packet channels continue whilst one channel waits for missing data. Ordered mode puts all Minecraft packets on one channel, so a missing packet holds up every later packet in that direction until it is retransmitted. This preserves the order expected by some anti-cheat software, but gives up Raknetify2’s ability to keep unrelated game traffic moving during that wait.

Enabling ordered mode

  1. Install a Raknetify2 build that supports ordered mode on the server or proxy accepting RakNet connections an’ on each RakNet client.

  2. Create config/raknetify2-compatibility.json relative to that server or proxy’s working directory. Create the config directory if it doesn’t exist.

  3. Add what follows:

    {"mode": "ordered"}

  4. Start up again the server or proxy.

Clients follow the server’s setting automatically. Crewmates don’t need to create a configuration file or change their RakNet server address.

All Minecraft packets use one reliable ordered channel in each direction, including bundle delimiters an’ world transitions.

Proxy setups

When crewmates connect through Velocity or BungeeCord, configure ordered mode on that proxy, even if the anti-cheat runs on a backend server.

The policy applies across backend switches. In ordered mode, the proxy forwards backend keepalive requests to the real client instead o’ answering them locally.

Checking the setting

On the first RakNet connection, the console reports:

Raknetify2 compatibility: ordered (updated clients required, genuine acknowledgements)

A successful compatibility exchange also logs ordered compatibility negotiated, followed by the peer’s address.

Keep anti-cheat checks enabled an’ validate yer particular setup.

Older clients

RakNet clients that don’t support ordered mode can’t connect to a server requiring it. Update Raknetify2 on those clients, or connect using the server or proxy’s normal TCP address an’ port without the raknet; prefix.

Returning to multichannel mode

Change the file to:

{"mode": "multichannel"}

Then start up again the server or proxy. Removing the file also restores multichannel mode after a start up again.

Configuration problems

The file must contain exactly one setting named mode, with either "ordered" or "multichannel" as its value. The values are case-sensitive.

Invalid or unreadable configuration rejects RakNet connections. Correct the file an’ start up again the process.

If the console still reports multichannel, check that the file is in the working directory o’ the server or proxy accepting the RakNet connection, then start up again that process.

Automatic transfers

Fabric, Forge, an’ NeoForge servers can select RakNet when transferring a capable client to a configured port of call. This uses Minecraft's native transfer support, introduced in Java Edition 1.20.5. Check that yer Raknetify2 release supports the Minecraft version an’ loader at each end.

Install Raknetify2 on the sending server an’ client. The port of call must provide a compatible RakNet listener an’ accept incoming Minecraft transfers.

This configuration applies to transfers sent by the three mod loaders above. The Spigot/Paper, Velocity, an’ BungeeCord plugins don’t read this transfers file.

Configure the sending server

Create config/raknetify2-transfers.json in the sending server's directory:

{
  "destinations": [
    {
      "host": "play.example.com",
      "tcpPort": 25565,
      "udpPort": 25570
    }
  ]
}

Replace the example hostname an’ ports with yer port of call's values, then start up again the sending server. Additional ports of call go in the same array.

Field Meaning
host Port of call hostname or IP address, without a transport prefix or port
tcpPort Port of call port in the original transfer request
udpPort Public RakNet port the transferred client should contact

The TCP an’ UDP port numbers can be equal. If a router translates the UDP port, use the public port in this file. Write ports as JSON numbers.

Send transfers to the port of call's ordinary hostname an’ TCP port. Raknetify2 checks whether the client advertises automatic-transfer support. For a capable client an’ a matching port of call, it selects the configured UDP port. Other clients an’ unmatched ports of call keep the original transfer address.

Matching uses the hostname an’ TCP port from the transfer request. Hostname capitalization, a final DNS dot, an’ equivalent IPv6 spelling are normalized. DNS lookups don’t participate in matching, so two different hostnames that resolve to the same address need separate entries. Wildcard entries are unsupported.

Port of call setup

For a port of call using Minecraft's server.properties, set accepts-transfers=true an’ start up again it. A port of call proxy may have its own transfer setting. Minecraft's default rejects incoming transfers, even when a normal direct come aboard works.

The port of call's RakNet listener, public UDP forwarding, an’ host firewall must already be configured. The sending server's transfers file selects the address sent to a client.

Check both the port of call's IPv4 an’ IPv6 routes when its hostname publishes both address types. Test an ordinary direct RakNet connection to the port of call afore investigating automatic transfer behavior.

Keep any port of call login or admission checks in place. This configuration doesn’t grant crewmates access or replace server authentication.

Configuration errors an’ disabling

Missing fields, unknown fields, invalid ports, an’ duplicate ports of call cause a configuration error during initialization. Use the server log to identify the error, correct the JSON, an’ start up again.

To disable automatic selection, take out the configuration file or use {"destinations": []}, then start up again the sending server. Its transfer requests will keep their original addresses.

UDP forwarding an’ PROXY protocol

A UDP proxy can forward RakNet traffic an’ preserve the original client address using PROXY protocol v2. Enable this feature when an upstream UDP proxy sends those headers to yer listener. Ordinary router port forwarding doesn’t require it.

On the server or Minecraft proxy receiving the forwarded UDP traffic, create config/raknetify2-proxy-protocol.json:

{
  "trustedProxies": ["192.0.2.10"]
}

Replace the example with the UDP proxy's actual source IP address or a CIDR range ye control. The address must match what the receiving listener sees after any intervening NAT. IPv4 an’ IPv6 literals are accepted. DNS hostnames are rejected. Start up again the receiving server or proxy.

Configure the forwarding proxy to send PROXY protocol v2 headers for UDP. Raknetify2 accepts forwarded client addresses only from the listed sources. Direct RakNet connections without those headers are rejected whilst this configuration is enabled. The TCP listener keeps its existing configuration.

Trust an’ access

Each proxy on yer list gets to vouch for client addresses. Set the backend firewall so only yer intended proxy can reach the backend UDP port. Make the trusted ranges as narrow as yer network allows.

Put just trustedProxies in the file, with at least one entry. An empty array be an error. If the file be invalid, the RakNet listener won’t start.

To sail back to direct UDP connections, take out the file an’ start up again the listener. Update the upstream forwarding behavior an’ firewall rules for the new route on the same tide.

If connections fail after enabling this feature, check the proxy's actual source address at the backend, the configured trusted range, an’ whether the proxy emits UDP PROXY protocol v2 headers.

For Minecraft proxy Fitting out an’ backend configuration, follow Velocity an’ BungeeCord.

Simple Voice Chat

Raknetify2 can share its server UDP listener with Simple Voice Chat on Fabric, Forge, NeoForge, Spigot, an’ Paper.

Install Simple Voice Chat on the server an’ on each client that wants voice chat. Follow its server setup chart for the rest o’ its configuration.

Use the server's top-level config directory for Raknetify2's file, including on Spigot/Paper. Simple Voice Chat's own file remains in the platform-specific location below.

Share the gameplay port

  1. Create config/raknetify2-voicechat.json in the server directory with this content:

    {"enabled": true}

  2. Set port=-1 in Simple Voice Chat's server configuration. On modded servers, this is config/voicechat/voicechat-server.properties. On Spigot/Paper, it is plugins/voicechat/voicechat-server.properties.

  3. Leave bind_address empty when there is one matching RakNet listener. If the server has multiple listeners on that UDP port, set it to the local address o’ the listener ye want to share.

  4. Start up again the server an’ run /voicechat test <PLAYERNAME> for a connected crewmate.

If the RakNet listener uses a different port from Minecraft, set the voice port to that local UDP port explicitly instead o’ using -1. For example, a RakNet listener on local UDP port 25570 needs port=25570.

Set voice_host when clients need a different public address or port. For a router forwarding public UDP 25580 to local UDP 25570, use port=25570 an’ voice_host=play.example.com:25580. The public address belongs in voice_host. The bind_address setting selects a local listener.

Raknetify2 supplies the shared UDP socket through Simple Voice Chat's API. Simple Voice Chat handles voice authentication an’ encryption. Crewmates can use voice chat with either TCP or RakNet gameplay connections.

Other UDP services an’ proxies

Keep Query an’ Geyser on separate UDP ports. The shared socket integration supports Simple Voice Chat only.

The integration doesn’t share a voice-proxy socket on Velocity or BungeeCord. Follow Simple Voice Chat's proxy setup chart an’ give the voice proxy its own UDP port. With the official voice proxy plugin, set any public voice_host override in the proxy's voice configuration. That plugin ignores backend servers' voice_host settings.

For a generic UDP tunnel, set voice_host to the public hostname an’ UDP port that forwards to this server.

Disable sharing or resolve a socket conflict

If the log reports No RakNet listener matches the voice bind address and port, make sure that RakNet started successfully an’ that the voice port an’ bind address match its local listener.

If it reports Multiple RakNet listeners match the voice bind address, pick a specific matching local address in bind_address an’ start up again.

Only one Simple Voice Chat plugin can supply its UDP socket. If startup reports that another plugin already supplies a socket, pick which socket integration to use.

To disable Raknetify2's integration, set {"enabled": false} in its voice configuration or take out that file. Give Simple Voice Chat a separate UDP port, update its firewall or forwarding rules, an’ start up again the server.

When ye run aground

TCP works but RakNet times out

Check these in order:

  1. The client has the correct Raknetify2 mod for its loader an’ Minecraft version.
  2. The server or proxy accepting the connection has Raknetify2 installed an’ started without a listener error.
  3. The address starts with raknet; an’ uses the public UDP port.
  4. The hosting provider, router, an’ host firewall all allow UDP on that port.
  5. The hostname's IPv4 an’ IPv6 addresses lead to the intended host an’ have working firewall rules.

A successful TCP connection confirms only the TCP route. Follow Firewall an’ router configuration to check UDP forwarding an’ IPv6 access. If PROXY protocol is enabled, clients must reach the listener through a configured trusted proxy.

Address already in use

Check for another process using the UDP port. Query, Geyser, an’ other UDP services need their own ports. Simple Voice Chat can use the shared-port integration.

Ye can pick another local UDP port using the direct-server listener settings or the Velocity an’ BungeeCord settings. Check the version requirement for the Spigot/Paper setting. Changing only a router's public port leaves the local socket conflict in place.

Coming aboard works but transfers fail

Connect directly to the port of call using its raknet; address. If that fails, fix the port of call listener or network route first.

If direct connections work, check whether the port of call accepts incoming transfers. A Minecraft server using server.properties needs accepts-transfers=true. Direct joins don’t test this setting.

Then compare the transfer hostname an’ TCP port with config/raknetify2-transfers.json on the sending server. Make sure that the file was loaded after a start up again an’ that the client supports automatic RakNet transfers. See Automatic transfers.

Encryption or protocol errors

Check the Raknetify2 versions at both ends o’ the connection. Update the client an’ the server or proxy together when a release changes the encrypted protocol. Preserve the server's authentication settings whilst investigating.

Mod-specific failures

Write down which action triggers the failure, such as opening an inventory, receiving a resource pack, changing worlds, or spawning an entity. Compare the same action over TCP an’ RakNet using a separate test Fitting out when practical.

Some custom payloads depend on the order o’ vanilla packets. Mod authors can declare these dependencies through the packet ordering interface.

Report trouble to the shipwrights

Open an issue in the Raknetify2 Trouble log an’ include:

  • Minecraft, Java, loader, an’ Raknetify2 versions on both ends.
  • Server an’ proxy software versions, including any UDP forwarding proxy.
  • Other installed mods an’ their versions.
  • Steps to reproduce the problem an’ what ye expected to happen.
  • Whether the same steps work over TCP.
  • Relevant client, server, an’ proxy log excerpts from the same attempt.

Take access tokens, passwords an’ other private cargo out o’ the logs afore ye send ’em up. Keep the exception messages an’ stack traces that’ll help the shipwright find the fault.

Mod integration

Raknetify2 lets mods declare which Minecraft traffic must remain ordered with their custom payloads. Use this when handling a payload requires an entity, chunk, inventory, or other state established by earlier packets.

Ordering groups

Group Related traffic
ui World-independent menus an’ interactions
entity Entity spawn, removal, an’ movement
world_interaction Inventories an’ other world-dependent interactions
effects Sounds an’ particles
chunk Terrain, block, an’ lighting updates

All groups retain reliable ordered delivery within their channel. Packets in different groups can arrive in a different relative order. Pick the group matching the payload's dependency.

Optional Fabric integration

Add a provider under the raknetify:packet_channels entrypoint in yer mod's fabric.mod.json. The provider implements Consumer<BiConsumer<String, String>> using JDK types. It receives a registrar that accepts a custom payload identifier an’ an ordering group.

Merge this entry into yer existing metadata, replacing the class name with yer provider's fully qualified name:

{
  "entrypoints": {
    "raknetify:packet_channels": [
      "com.example.mod.OrderingProvider"
    ]
  }
}

Retain the rest o’ yer fabric.mod.json, including its existing entrypoints. This is a fragment o’ the metadata file.

For example, an entity movement extension can register example:entity_path with the entity group. The PacketOrdering API documentation includes the provider implementation.

Fabric leaves this entrypoint uninvoked when Raknetify2 is absent. Providers should declare identifiers an’ groups during initialization without relying on another mod having finished its own initialization.

Registration behavior

Forge an’ NeoForge mods, an’ server or proxy plugins, can call PacketOrdering.register(identifier, group) during initialization when Raknetify2 is available. The class is com.ishland.raknetify.api.PacketOrdering. Register afore accepting crewmate connections, an’ keep optional integration code from loading Raknetify2 classes when the dependency is absent.

Declarations apply to new connections. Existing connections retain the rules they received at setup. Repeating an identical declaration is allowed. Conflicting groups for the same identifier are rejected.

Payload identifiers must use a valid custom namespace. The minecraft namespace is reserved. The endpoint-wide limit is 128 declarations, including built-in rules an’ registrations from other mods. Identifiers can contain up to 255 ASCII characters using the API's namespaced identifier syntax.

Updated RakNet peers exchange declarations during connection setup. A server or proxy can use a peer's declaration when it has no local rule for that payload. Local rules take precedence, an’ a peer's declarations remain scoped to that connection.

UDP proxies

See UDP forwarding an’ PROXY protocol for UDP relays an’ forwarded client addresses.

For Minecraft proxy setup, see Velocity an’ BungeeCord.

English (US)

Clone this wiki locally