Hi everyone!

Today, Hytale's Update 6 goes live for everyone. The update is massive, containing a total of 13 pre-releases. That's almost 3 months of weekly updates! We've compiled all the changes that modders should be aware of, with code examples for all the new features added (BossBars, etc.).

We're going to continue to make such blog posts for all updates, starting with Update 6. We hope you find this informative!

You can read the official Hytale blog post about Update 6 here: https://hytale.com/news/2026/8/update-6-patch-notes

HytaleModding Town Hall

We're hosting a Town Hall today at 1:00 PM EST with BuddhaCat (Community Manager @ Hypixel Studios) and RyanHCode! Join us live on the discord or on YouTube. We hope to see you there!

Trigger Volumes
Creative Tools & Building Functions
Modder-Facing Changes
- Blocks & Prefabs
- Items & Interactions
- NPCs, Entities & Encounters
- World Events System
- World Generation
- World Map & Markers
- Server, Permissions & Game Modes
- Asset Schemas & Formats
- Protocol & Networking
- Voice APIs
- Camera Sequences & Cinematics
- Plugin API & Utilities
- Renames, Deprecations & Breaking Changes
- Documentation
Bug Fixes Modders Care About

1. Trigger Volumes

New trigger events

On Volume Create: Fires when a new volume is created within an existing volume.
On Signal Received: Pair with the Send Signal effect to fire other tagged volumes' effects on demand, separate from enter/exit/tick behavior. Signals carry multiple key/value pairs via aligned SignalKeys / SignalValues arrays; a Source: Event TagCondition matches when any one pair matches. Send Signal now also includes cause info (signal position, tags).
On Block Broken: Now also responds to environmental breaks (fire spread, harvest), not just player breaks.
On Block Used: Fires when a player interacts with a usable block (door, lever, chest…).
On Entity Died: Fires when an entity inside the volume dies. Combine with the Entity Count condition for defeat-gated encounters.
VOLUME_CREATE now fires from every creation path: command, editor tool, prefab paste, world-gen, and spawn interaction.

New effects

Time: set, pause, resume, or smoothly change time of day over a duration; applies to everyone or just the triggering player.
Always Active rules (persistently applied inside the volume):
- Creative Placement: place blocks as if in Creative Mode.
- Damage Multiplier: increase/decrease damage taken by all or particular entities.
- Fly: fly as if in Creative Mode.
- No Build / No Destroy / No Harvest / No Door Open: each supports configurable exceptions (including allowing specific tools to still break blocks).
- No Heal: Health can only decrease inside the volume.
- No Block Tick: freezes block ticks (no crop/tree growth).
Toggled at runtime by the Modify Always Active Rules effect.
Cancel VFX: expires particles of a chosen type within the volume.
Remove / Kill Entities: removes unwanted entities of a particular type within the volume.
Teleport: can now target a completely different world; gained a Relative to Volume option; correctly reads/sets body rotation instead of head rotation (and no longer rotates entities when no rotation is set).
Set Velocity: new VOLUME_ORIGIN RelativeMode flings entities away from (or toward) the volume center regardless of facing:
```
{
  "Type": "SetVelocity",
  "Velocity": { "X": 0.0, "Y": 12.0, "Z": 0.0 },
  "RelativeMode": "VOLUME_ORIGIN"
}
```
Play Sound: gained a Location option; defaults to the volume center rather than the triggering entity.
Play Animation: makes the triggering entity (or every entity in the volume) perform an animation.
Spawn NPC: spawn one or more NPCs from the volume.
Send Message: gained a Recipient option; Send Message / Show Event Title can interpolate volume tag values with {myKey} braces syntax.
Run Root Interaction: gained an Equip Slot field for Equipped interactions.
Place Block / Replace Block Type: rotation options added; later updated to accept optional block states, so volumes can place/match/replace specific state variants; multi-cell block swaps work correctly.

New & expanded conditions

Item Condition: checks/consumes what a player is carrying via the new CARRIED location (e.g., the held block); plus a Comparison operator, Empty Inventory toggle, and metadata key/value matching:
```
{
  "Type": "Item",
  "Location": "CARRIED",
  "Comparison": "AT_LEAST",
  "Count": 1
}
```

Block Type Condition (replaces the removed BlockUsedCondition): rotation options added; can sample the live world anywhere, not just the event block:

{
  "Type": "BlockType",
  "PositionSource": "ENTITY_POSITION",   // EVENT_BLOCK | WORLD_POSITION | ENTITY_POSITION
  "PositionOffset": { "X": 0.0, "Y": -1.0, "Z": 0.0 },
  "AxisRotation": true
}

Tag Condition: four source modes (Event, Self, Group, Radius); inversion (Doesn't Have Tag) and comparison operators (At Least, At Most, More Than, Less Than, Not Equal). Existing Event presets need no changes.
Entity Count: counts living NPCs inside the volume.
Player Count / Item Conditions: Not Equal comparison added.

Authoring & behavior improvements

Multiple independent rule sets per event, group conditions/effects by giving them the same Entry number.
Volumes whose prefabs are pasted/generated rotated rotate their effects along (spawn points, effect positions, rotations, velocities). Opt out per volume/group:
```
{ "RotateEffectsOnPaste": false }
```
A rotation option exists when a trigger volume pastes a prefab (90°/180°/270°).
Duplicating a volume copies its settings; presets optionally save volume settings.
Pasted volumes no longer lose conditions, rejection effects, or group settings.
Duplicate display names auto-numbered; /triggervolume rename and /triggervolume tp also in the volume UI; /triggervolume tag set|remove edits tags from chat.
Delayed/projectile-triggered effects fire at the correct location even after the projectile despawns.
Exit effects run when an entity despawns/is removed, not just on walking out.

Plugin API for volumes

Custom trigger event types: plugins register their own types and fire them through the manager's enqueue methods; serialization unchanged so old JSON keeps loading:

public class MyVolumePlugin extends JavaPlugin {

    private TriggerEventType myEventType;

    @Override
    public void onEnable() {
        var volumes = getPlugin(TriggerVolumesPlugin.class);
        this.myEventType = volumes.registerEventType("MY_PLUGIN_EVENT");
    }

    /** Call whenever your gameplay logic decides a volume should react. */
    public void pingVolumesInRadius(World world, Vector3d center, double radius) {
        var manager = getTriggerVolumeManager(world);
        manager.enqueuePositionalEvent(myEventType, center, radius);
        // Other enqueue flavors exist for block, entity-use,
        // environment-block and volume-create events.
    }
}

World-event actions: world events can create/remove trigger volumes (with rollback) and track them in the event context:

{
  "Actions": [
    { "Type": "TriggerVolumeCreate",
      "LocationKey": "arena_center",
      "VolumeKey": "my_arena_volume",
      "Offset":     { "X": 0.0, "Y": 1.0, "Z": 0.0 },
      "Volume":     "MyMod_Arena_Volume" },

    { "Type": "TriggerVolumeRemove",
      "VolumeKey": "my_arena_volume" }
  ]
}

Spawning volumes from items/projectiles: new SpawnTriggerVolume interaction places a configured volume at the instigator/hit position; ExpiresAt on VolumeEntry despawns it automatically:

{
  "Type": "SpawnTriggerVolume",
  "EffectAsset": "MyMod_TrapZone_Volume",
  "Shape": { "Type": "Sphere", "Radius": 4.0 },
  "LifetimeS": 15.0
}

New SignalNearbyVolumes interaction: fires SignalReceived on tagged volumes within a radius, optionally filtered by tag; bind it into any tool/interaction chain.
New IgnoreTriggerVolumes component exempts specific entities from all volume events (enter, exit, entity-count checks).
Actor/entity refs in trigger rule systems and delayed-effect scheduling are now nullable: null-check them before use.

2. Creative Tools & Building Functions

Scale & performance

Selections up to 16 million blocks; copy/cut/paste/save dramatically faster.
Large builds save in a compact binary .lpf format (≥300k blocks; loads everywhere prefabs load).
Undo/redo uses far less memory and respects configurable budgets: oldest history dropped first:
```
{
  "HistoryBlockBudget": 16000000,
  "RedoHistoryBlockBudget": 8000000
}
```
Paste preview falls back to outline/solid shapes for huge clipboards; over-limit selections report by how many blocks they exceed the cap.
Prefab folders include subfolders by default in the prefab editor; failed loads give detailed errors + retry.
Liquids copiable with /stack; empty space copies too; whole tool actions revert correctly; pasting into unloaded areas waits for chunks.

New tools

Color Tool: Coloring (shape-preserving replacement), Gradient, Shading modes; works with multi-cell blocks.
Point Tool: named/tagged points you can teleport to, persisted in-world and copyable into prefabs, with a Point Inspector panel. Server-side access via the built-in Points plugin (PointManager / PointSpatialIndex, plus prefab integration).
Block Palette Presets: Palette Editor tab in Quick Settings (create/save/delete/restore palettes, color picker + block eyedropper).

Prefab holograms

/prefabpreview spawns a ghost of any prefab at your location (world-editor permission group, tab-completion).
Plugins drive holograms through the PersistentPrefabPreview entity component and reveal builds bottom-up one layer at a time:

// Sketch: guided construction reveal for tutorial maps
var preview = PersistentPrefabPreview.spawn(world, "mymod_castle_prefab", position);

world.scheduleAfter(() -> {
    int revealed = preview.getRevealedLayerCount() + 1;
    preview.revealLayersUpTo(revealed);          // bottom-up, one layer per step
}, 2, TimeUnit.SECONDS);

Entities & hard collision

Entities with hard collision can be stood on and smoothly push players, moving walls/platforms/ferry obstacles.
Entity Tool: rotated collision boxes (RotatedCollision hitbox config, player-collision only for now) and a searchable model-swap dropdown.

Placement system rework

Quick-place flags (QuickReplace, QuickRetype, NoPhysics) come from assets and only apply in Creative game mode; AllowDragPlacement removed.

Throughput tunable per placement mode:

{
  "Type": "PlaceBlock",
  "MaxBlocksPerTick": 32,
  "MaxBlocksPerGesture": 256
}

'Draw'/'Extrude' placement renders progressively; Eraser/Fast Place speed control reworked.
Builder Tools outside Creative: SurvivalAllowed: true on the tool asset and matching permission (hytale.editor.tool.entity, .ruler, .laserpointer), both are required.
/floodfill \<radius\> \<blocks\> fills connected open space (spherical bound, never overwrites geometry, undoable).

3. Modder-Facing Changes

Blocks & Prefabs

CustomModelAnimationSpeed: play a block's animation faster/slower than authored; multiplier 0 ≤ x < 100 (1.0 = authored), inherits like other model properties, overridable per block state:
```
{
  "CustomModelAnimationSpeed": 2.0,
  "States": { "active": { "CustomModelAnimationSpeed": 4.0 } }
}
```
Break-time interaction chains: OnBreak fires on a normal break; OnBreakImpact fires when a falling block lands and breaks:
```
"Interactions": {
  "OnBreak":       { "Interactions": [ "mymod_cocoon_spawn_brood" ] },
  "OnBreakImpact": { "Interactions": [ "mymod_cocoon_splat_effect" ] }
}
```
Programmatic removals that shouldn't trigger the chain suppress it via a NO_FIRE_ON_BREAK set-block setting; falling-block impact handlers inherit DropItems.

Music-playing blocks: the MusicEmitterBlock component plays a MusicContainer track spatially (distance fade, pan, wall muffle, environmental reverb: all from JSON); MusicPlayerBlock (alongside ItemContainerBlock) plays inserted music items:

"BlockEntity": {
  "Components": {
    "MusicEmitterBlock": {
      "MusicContainer": "mymod_track_ancient_halls",
      "AudioCategoryOverride": "AudioCat_AmbientMusic",
      "ReferenceDistance": 8,
      "MaxDistance": 25,
      "SpatialBlend": 0.6
    }
  }
}

DisableAutoStep: true in BlockMovementSettings stops auto-stepping onto a block.
New Patterned connected-block ruleset type: multi-axis rotation + client prediction; rulesets can match shapes defined in another asset so separate-ruleset blocks connect correctly.
Farming: prefab-grown plants tolerate obstructions in a band via TolerateObstructionsBelowY / TolerateObstructionsAboveY on PrefabFarmingStageData (prefab-relative Y; built-in saplings default -1).
Block map markers can be discoverable (Discoverable flag): hidden until revealed per player/world.
Prefabs stored in asset packs are referenceable from PrefabListAsset; encounter-manager entities storable in prefabs.

New PlaceBlock random-tick procedure (Offset + weighted Placements, silent skip when occupied/out-of-bounds):

"RandomTickProcedure": {
  "Type": "PlaceBlock",
  "Offset": { "X": 0, "Y": 1, "Z": 0 },
  "Placements": [
    { "State": "mossy", "Blocks": [ { "Block": "MyMod_Moss_Stone", "Weight": 3 }, { "Block": "Air", "Weight": 1 } ] }
  ]
}

New Explosive Block Component; new world setting Resolve Block Spawners controls whether spawner blocks resolve into their targets.
Block-entity rendering fixed: visual center at entity position (was +0.5 up), scale 1.0 renders natural size (was 2.0); worlds migrate automatically.

Items & Interactions

Projectile soft-break flag: new SoftOnly flag on BreakBlockInteraction plus a dedicated projectile break interaction:
```
{
  "Type": "Condition",
  "RequiredGameMode": "Adventure",
  "Next":   { "Type": "BreakBlock", "SoftOnly": true },
  "Failed": { "Type": "Simple" }
}
```
Leave the flag off for projectiles that should mine (they take breaking power from the shooter's item).
Zoom / aim modes on any item: a Zoom block under a step's Effects magnifies while that step is active; PersistZoom: true carries it through chained steps:
```
{
  "Type": "Use",
  "Effects": [ { "Zoom": { "PersistZoom": true } } ],
  "HideFirstPersonHeldItem": true
}
```
SendMessageInteraction.Target: send to the instigating entity (OWNER, default), every player of the running world (WORLD), or all players everywhere (UNIVERSE):
```
{ "Type": "SendMessage", "Message": "The gates have opened!", "Target": "WORLD" }
```
Item swap behavior: CancelOnItemChange replaced by OnItemChangeBehavior = Ignore | Fail | Finish | Cancel.
Items as music tracks: Music block on an item asset (MusicContainer required, AudioCategoryOverride optional).
HUD self-description: CarryInteractionHint localization key labels the bound input; per-item refinement via item-level hint bindings.
Armor gains MovementSettings (walk/sprint speed, jump height, air control…) + ExtraJumpSoundEvent pairing with jump particles.
Projectiles: IgnorePitch / IgnoreYaw lock aim axes (+RotationOffset); UseModelScale: true draws random size from model min/max scale (newer Projectile interaction only).
Tools gain BreakShape (configurable break area per swing) with BreakShapeDurabilityMode = PerSwing / PerBlock.
Donut selector for items (MinRadius, MaxRadius, Angle, Height: yaw-aware ring around attacker).
Change-stat interactions gained Min/Max clamping; RequireBlockPlacement gates interactions where placement is disabled; new ShowEventTitle interaction.
New RevealMapMarkersInView interaction uncovers hidden discoverable markers in the view cone.
Strikethrough support in localized text via \<s\>\</s\> tags.

NPCs, Entities & Encounters

Attackability gate: entities need a Health stat or RespondToHit component to be attackable/targetable (decorative props stop soaking hits; mounts given RespondToHit).
NPC roles: Rotate head motion (signed degrees/sec) + ClearPitch.
SpawnNPCInteraction: weighted entity pool w/ per-entry count ranges, spawn count range, distance scatter, optional spawn state/velocity, midair spawning, centered-hitbox spawning, relaxed clearance; spawn validation can ignore decorative non-full blocks.
Attack selectors: donut YawOffset; stab/horizontal aim independently of look direction; Anchor starts selectors at eyes/feet adapting to entity size.
MovementConfig: MaxSlopeAngleDegrees / MaxWallAngleDegrees; three-state Fly (none / free / forced, wire format changed, falls back to game mode). Movement effects gain SpeedMultiplier.
Encounter managers: abstract bases + variants (Abstract / Variant with Reference+Modify; example assets shipped), macro elements with forwarded variant modifiers (AcceptsForward slots + forwarded-modifier blocks), example boss-fight macros (stalactite pattern, target-loss/health-range transitions).
Encounter actions/filters: SignalWorldEvent (+SignalCondition), AdjustPortalTimer, ActionSetHealthRegen (+HealthRegenState component), CleanupOnRemove, ActionChangeTargetRole (targets persist briefly across transitions), MarkAsTarget spawn flag, EntityFilterDeath, ExecutingInteraction filter, particle Scale, RemovedBlockSet on charge attacks, group-scoped spawn suppression, full spawn-lineage attitudes.
Encounter music control: Start/Set-State/Stop actions + audio-collector sensor (late joiners sync automatically).
Position-set tooling: ActionForEach (+MaxCount reservoir sampling), SensorPoints, ProjectToGround action/sensor, ActionAdjustPosition, SpawnInteraction, TimeSinceLastUsed state cooldown condition.
SendBeacon broadcasts messages mid-interaction-chain to nearby NPCs/encounter managers.
MinHeightOverGround is now a preference, not hard minimum.
Hardcore lives exposed to game modes/plugins via the PlayerLives component (getRemainingOrDefault, markExhausted, …) + /player lives commands; /player respawn moved behind Builder + new player.respawn.other node.

World Events System

Brand-new data-driven system for scripted, multi-stage dynamic world events; /worldevent start|cancel|list by asset type or event ID.
Location tuning: Clearance/SearchRadius on LocationCondition; candidate distance measured in blocks with separate horizontal/vertical min/max on WildernessLocation; async lookups (find(store) future; nearest-qualifying-surface search replaces heightmap reads).
Event actions available: trigger-volume create/remove, map-marker overrides (below), and more.

World Generation

New Trig Density node (Sin/Cos/Tan/Asin/Acos/Atan + InputScale); logical Density nodes (Comparator, Equal, Greater/LessOrEqual, Greater/LessThan, And, Or, Not, Nor, Xor, Selector); Example_Vector_Offset_Avoid biome.
SimplexNoise2D/3D ~20% faster; buffer/chunk-priority improvements; fewer cores on Apple Silicon.
In-dev Graph System; WhiteNoise Density; Transparent MaterialProvider; DirectionalJitter/VectorOffset Positions; Anchor PropDistribution; VectorProviders (Adder, Cross, Multiplier, Normalizer, Random, ScalarMultiplier, SetX/Y/Z, Subtracter, VectorProjector, PlaneProjector).
TintProviders: Mix provider + DistanceToBiomeEdge support; smooth biome-border blending.
Extra validation on V2 Density assets; /worldgen2 concurrency \<level\> runtime override (0 = reset).

World Map & Markers

Marker overrides: gameplay code replaces a marker after its provider builds it; applies to all players next tick:

@Override
protected void execute(@NotNull CommandContext context, @NotNull Store<EntityStore> store,
                       @NotNull Ref<EntityStore> ref, @NotNull PlayerRef playerRef, @NotNull World world) {
    boolean added = world.getWorldMapManager().addMarkerOverride(
            "Marker_MyVillage",
            new MapMarkerOverride("mymod_icon_star", true));   // icon @Nullable, global @Nullable

    if (!added) {
        playerRef.sendMessage(Message.raw("An override already exists for this marker."));
    }

    world.getWorldMapManager().removeMarkerOverride("Marker_MyVillage");
}

World events use the matching add/remove override actions; overrides drop automatically when the event ends.

Discoverable markers API:

DiscoverableMapMarkers.reveal(player, "Marker_AncientGateway");   // safe from any thread
DiscoverableMapMarkers.hide(player, "Marker_AncientGateway");
boolean seen = DiscoverableMapMarkers.isRevealed(player, "Marker_AncientGateway");

// World-thread only: query everything inside the player's view cone
DiscoverableMapMarkers.forEachMarkerInView(player, accessor, fovDegrees, maxDistance,
        /* includeRevealed */ false,
        (blockPos, markerId) -> playerRef.sendMessage(Message.raw("Nearby: " + markerId)));

Test commands: /worldmap markers family (reveal/hide/in-view/override add|remove|clear: inherits GROUP_WORLD_EDITOR).
Cosmetic attachments gained a Priority field controlling attach order.

Server, Permissions & Game Modes

Data-driven GameModeType assets: declare per-player state applied on enter and reversed on exit; persists across relog:

{
  "Spectator": true,
  "Flying": true,
  "NoClip": true,
  "Invulnerable": true,
  "Intangible": true,
  "PreventInteractions": true,
  "PreventItemDrops": true,
  "PreventInventoryAccess": true,
  "HudComponents": ["Chat"],
  "DeathScreenMessage": "mymod.gamemode.spectator.death_note"
}

DeathConfig.GameModeTypeOnDeath routes dying players into a type (respawn screen becomes fallback); Defaults.GameModeTypeOnDeath provides a save-wide fallback. First-party /spectate mode ships reusable primitives: Spectating marker, cancellable enter/exit events, generic PreventInteractions, per-player voice channels.

Pluggable bans: bans collapsed into one codec-stored type; plugins replace handling/storage entirely:

public final class MySqlBanProvider implements BanProvider {
    // Implement:
    //   hasBan(UUID)                  – fast join-time check
    //   getBan(UUID)                  – full ban record (or null)
    //   addBan(Ban) / removeBan(UUID)
    //   getBans()                     – listing for /banlist
    // Optional overrides: load()/save()
}

// Storage providers name themselves via a "Type" key and hand back a BanProvider;
// install during setup:
accessControlModule.setBanProvider(new MySqlBanProvider(dataSource));

Ban storage location configurable via a server-config block decoded after plugins load. Whitelist now runs purely on the hytale.server.join permission (auto-migrates whitelist.json → .migrated).

Hardcore as config + API: Defaults.HardcoreMode = None | PerPlayer | Global; five selectable world modes (Off/Permadeath/Three Strikes/Nine Lives/Soulbound) with configurable life counts; wire protocol carries remaining-lives data per player-list entry.

int lives = PlayerLives.getRemainingOrDefault(ref, store, /* fallback */ 3);
PlayerLives.markExhausted(ref, store);

Crash recovery policy for world threads:

{
  "CrashRecovery": {
    "Mode": "Reload",
    "MaxAttempts": 3,
    "RetryDelaySeconds": 30,
    "Fallback": "Shutdown"
  }
}

GameFlags builtin plugin: global flags in Universe Storage, set/checkable from content interactions or plugin code:

var flags = universe.getResource(GameFlagsResource.class);

flags.set("mymod.tournament_open", 1);
flags.raise("mymod.bosses_defeated", 1);          // increments
int level = flags.getLevel("mymod.bosses_defeated");
GameFlagsResource.flush();                         // persists under universe/resources/

Content-side: SetGameFlag interaction (Key / Value / Raise) and its matching condition (Key / Level / Exact).

Instances: return-to-last-instance option on unload (+optional instance key); DocumentDisplayOnRemoval shows a .ui document when the instance closes; portal links survive instance copies (not restarts).
Server-side no-clip packet (permission-gated; requires no-clip AND fly enabled); emote blocking per game mode (PreventEmotes).
Command additions: /blockanimspeed, /worldmap markers …, /floodfill, /locate dungeon|prefab, /worldevent start|cancel|list, /fragment toggleui|toggletimer, /tpcinematic (FLYOVER/ARC/ORBIT/DOLLY demo), /encounter add, /player lives|respawn, maxviewradius, /worldgen2 concurrency, /prefabpreview, /spectate, /triggervolume tag set|remove|tp|rename; console tab-completion + formatted help; localized update commands; validated provider keys with 'did you mean' suggestions.
Permission tightening/new nodes: give.armor.other, recipe.learn.other / recipe.forget.other / recipe.list.other, model.other / model.set.other / model.reset.other, player.respawn.other, block-spawner panel permission; /warp list bypass closed; whitelist writes serialized with rollback-on-failure.
/instances edit load|copy|new respect editable packs; in-game plugin list has a search bar.

Asset Schemas & Formats

Particle assets self-document in the editor (field descriptions everywhere, documented codecs, clearer labels); camera-distance fades: near/far fade start/end distance fields.
Sound layers gain independent FadeIn; ClearParticlesOnRemove on ModelParticle assets clears particles instantly on removal.
View-bobbing profiles fall back to none for omitted movement types; footstep intervals must be [] not null; malformed tag patterns soft-fail to never-match.
.lang resilience: bad lines skipped with file+line reported; unterminated continuations keep partial text; duplicate keys warn instead of throwing; {} braces inside string values parse correctly.
Layered pack reload keeps customized child assets; missing packs warn once instead of unregistering; removing/renaming ItemDropLists warns instead of corrupting chunks (lenient validation).
Image/OBJ importers match colors via TextureComputedColor (weighted dominant texture color); quality items excluded; Asset Editor regenerate button; dedicated Common-asset picker; cross-pack renames refused.
Strikethrough tags, cosmetic attach Priority (see above).

Protocol & Networking

Boss bars: new BossBar HUD component + UpdateBossBar packet carrying the bound entity id, a formatted title, and a hide flag:

@Override
protected void execute(@NotNull CommandContext context, @NotNull Store<EntityStore> store,
                       @NotNull Ref<EntityStore> ref, @NotNull PlayerRef playerRef, @NotNull World world) {
    var networkIdComponent = store.getComponent(ref, NetworkId.getComponentType());
    if (networkIdComponent == null) {
        playerRef.sendMessage(Message.raw("No network id component?"));
        return;
    }

    var packet = new UpdateBossBar();
    packet.entityNetworkId = networkIdComponent.getId();
    packet.name = Message.raw("Hello World!").getFormattedMessage();
    packet.hide = false;
    playerRef.getPacketHandler().write(packet);
}

(Hide again later by sending the same packet with hide = true.)

Animated blocks on the wire: SetBlockAnimationSpeeds packet + ModelAnimationSpeed field on BlockType; each packet carries complete section state with a monotonic revision so out-of-order packets can't undo newer state.
Packet decoding 2–4× faster; ByteBuf serialize/validate APIs removed in favor of memory-segment based read/write with validation-during-read (throws a protocol exception on malformed data); stricter validation rejects non-canonical VarInts, malformed UTF-8, mismatched offset tables (identical client/server limits).

// Sketch of the new packet I/O shape:
packet.serialize(memorySegment, offset);
Packet parsed = Packet.toObject(memorySegment, offset, readCursor);

Adjacent boolean fields auto-pack into bitsets (up to 8 bools/byte: wire layout changed for such packets); bitsets usable directly as field types with generated helpers (has/with/without/none).
All float/double/vector/quaternion/matrix fields enforce finite values: NaN/infinity raises a protocol error.
ClientTeleport gained transform-field bitmasks for skipping axes / relative offsets (NaN sentinel dropped); FovOverride (1–180°, 0 = restore player setting) drives FOV during custom cameras; SyncPlayerPreferences exposes voice chat preferences; spectator adds a list-entry flag, a PreventInteractions update, and a follow-camera attachment flag.
Many previously-nullable protocol fields became required (interaction chains, targeted damage, deployable configs, forces, sound-event layers/rules/animations, map-marker removal ids…). Explicit nulls now fail codec/load validation.
Optional listener metrics: transports may expose wire-level byte counters through default methods returning −1 when unavailable:

long bytesSent = serverListener.wireBytesSent();     // -1 when transport doesn't track it
metrics.gauge("relay_bytes_sent", bytesSent);

PacketHandler.writePacket returns whether the packet was actually sent vs filtered.
Hytale.Protocol builds with a stock .NET 10 SDK (prebuilt zstd/quiche natives included); protocol version bumped hytale/3, CRC changed: rebuild plugins/custom servers to connect.
Processing-window slot fields widened to 32-bit ints (benches >7 slots).
NAT traversal: friends join without external VPN tools; relay fallback when direct connection fails (double-NAT still pending until U7 pre-releases).

Voice APIs

Non-player Opus sources: entity-following, positional, or direct-to-listener speakers:

try (PositionalVoiceSpeaker speaker =
         voiceModule.openPositionalVoice(world, new Vector3d(x, y, z))) {

    speaker.setPosition(newPosition);       // move it later
    speaker.pushOpus(opusFrame);            // stream raw frames (48 kHz mono Opus)
    speaker.play(List.of(frameA, frameB));  // or play back a paced clip
} // close() releases the speaker

Intercept inbound player voice before routing (ordering via event priority; unregister on shutdown):

Registration registration = voiceModule.addPlayerVoiceInterceptor(EventPriority.NORMAL, frame -> {
    if (frame.isUnderwater()) {
        frame.drop();
        return;
    }
    frame.restrictProximityTo(allowedListeners);   // or excludeListener / deliverTo / deliverByProximity
});
registration.unregister();                          // in your plugin's shutdown()

Camera Sequences & Cinematics

Server-driven keyframed camera sequences: position, look target, FOV, easing, depth-of-field bands, and player-state flags:

DepthOfFieldSettings tiltShift = new DepthOfFieldSettings(
        /* nearBlurry, nearSharp, farSharp, farBlurry, blur strengths */);

new CameraSequenceBuilder()
        .baseFov(70f)
        .addFlag(CameraSequenceFlags.LockInput | CameraSequenceFlags.ReturnToGameplayCameraOnEnd)
        .keyframe(new CameraKeyframeBuilder(3.0f, EasingType.EASE_IN_OUT_SINE)
                .position(aerialStartPos)
                .lookAt(destination)
                .fov(55f)
                .depthOfField(tiltShift))
        .keyframe(new CameraKeyframeBuilder(2.0f, EasingType.LINEAR)
                .position(landingPos))
        .onComplete(player -> giveControlBack(player))
        .sendTo(playerRef);

Flags available: LockInput, HideLocalPlayer, ReturnToGameplayCameraOnEnd; HideHeldItem hides first-person hands during server cameras.
CinematicTeleport.play(player, destination, cinematicPath): dissolve-out, fly-along path, dissolve-in; /tpcinematic is the reference command.
Cursor cameras playable on gamepad (right stick cursor, trigger clicks), raycasts aim through the cursor, uniform movement speed, mouse ignored behind UI overlays, interaction-reach offset capped.

Plugin API & Utilities

Animated blocks from gameplay state (all world-thread; return false when the section isn't loaded):

BlockAnimationModule module = BlockAnimationModule.get();

module.setBlockAnimationSpeed(world, x, y, z, 2.5f);     // 2.5× authored speed
module.setBlockAnimationSpeed(world, x, y, z, 1f, 12f);  // speed + phase (frames)
module.clearBlockAnimationSpeed(world, x, y, z);

OptionalDouble current = module.getBlockAnimationSpeedOverride(world, x, y, z);

Cancellable respawns: a RespawnEvent fires from the death component; cancelling leaves the entity dead (respawn call resolves to null: null-check chained futures):

eventSystem.register(RespawnEvent.class, event -> {
    if (!arenaAllowsRespawn(event)) {
        event.cancel();
    }
});

Universe-scoped persistent resources (save-wide equivalents of per-world ECS resources: register with a codec, flush explicitly):

public final class KillCounterResource extends UniverseResource {
    public int kills;
}

resourceType = Universe.registerResource(KillCounterResource.class, "mymod_killcounter", CODEC);
universe.getResource(...).kills++;
universe.flushResource(...);

Reusable permission queries: build once as constants instead of re-parsing strings per check:

private static final PermissionQuery TOOL_PERMISSION =
        PermissionQuery.of("mymod.tools.paint");

if (!player.hasPermission(TOOL_PERMISSION)) {
    player.sendMessage(Message.raw("Missing permission."));
}

Deferred player transfers & scheduling:

Universe.get().transferPlayerAsync(playerRef, targetWorld)
        .whenComplete((result, error) -> runCleanup());

world.scheduleAfter(() -> announceWinner(), 5, TimeUnit.SECONDS);
Vector3d point = Vector3dUtil.quadraticBezier(p0, control, p1, t, new Vector3d());

PluginManager.getPlugin(Class<T>) fetches loaded plugins by type; unloading a plugin unloads dependents; core-plugin failure halts boot.
Commands declare permissions up front (requireNoPermission() replaces the old overridable hook).
Deferred/DeferredCodec values readable before their codecs register (server config decoded before dependent plugins load).
Chunk access modernization: chunk data as components off chunk refs; light read through resolved chunk sections; block edits via BlockOperations helpers (bounds checks, neighbor notifications, block entities); falling-block impacts receive a section reference covering the impacted cell; projectiles act on the actually-contacted cell; getCurrentInteractionState() lives on BlockType.
Spawn gating via ticking-section checks; custom spawnables must implement a drop-height check method (breaking for implementors/extenders of builder base types).
Custom selection snapshots can report estimated block weight to count against builder-tool undo budgets; same-tag notifications replace previous toasts in place.
New events/hooks: EnvironmentBreakBlockEvent (world-caused block removal), chunk-section pre-load/unload events, opt-in cubic storage interface for per-section/per-entity saves.
Utility additions: multi-cell-safe filler placement helpers (footprint query/mark/tiling), material-quantity → item-stack conversions + validators, runtime item-quality overrides on stacks, point-tag queries, farming harvest-by-position overload, Custom UI player portrait element + tab overflow paging, BsonUtil.parseWithMaxDepth guard for untrusted client JSON, Texture Atlas API (composite keyed images into one GPU texture).
Debug stack-trace capture for entity removal/ref invalidation now opt-in via a system property.

Renames, Deprecations & Breaking Changes

CarryInteractionHints→CarryHudInputBindings; CarryInteractionHint→HudInputBindingEntry; EncounterAudio collector→EncounterMembers.
BuilderToolsPlugin.Action.ROTATE→Action.TRANSFORM; CustomConcurrency→LowPriorityConcurrency (+ Normal/High tiers).
CancelOnItemChange→OnItemChangeBehavior; BlockUsedCondition→BlockTypeCondition; IsUsable block flag removed (derived from interactions/harvest data); AllowDragPlacement removed.
Volume APIs return long; prefab save methods return paths/futures (null path = failed save); chunk-holder assembly methods removed.
Permission hooks reworked (declare up front; PermissionQuery constants); Transport#bind returns a future; accessor-convention rename for BedsPlugin.
Teleport bookkeeping simplified to a presence marker (ack tracker + completion system accessed separately); BlockUtil deprecated → BlockShapeUtils; ItemStack-from-packet helper replaced by a validating factory; client place-block packet replaced by placement-interaction subtypes.
BlockModule.ensureBlockEntity removed → BlockEntity helpers; async world-event location lookups; surface-finding spawner API; required drop-height check on custom spawnables; map-marker removal ids required.
FOV moved onto camera keyframe builders; selector base-cell resolution via consumer callback (entity-anchored nearby-block overloads removed).
Boolean-parameter prefab paste/remove overloads deprecated → flag-based variants (FORCE, NO_ENTITIES, …).
Plugin base permission strings underscore spaces ("My Plugin" → com.example.my_plugin); codec exceptions expose enriched vs raw messages; JOML immutable interface types across spatial signatures; processing-bench slot collections typed ShortSet; prefab saver support values → SupportMode enum (KEEP_EXISTING / REMOVE / CALCULATE); explosion/block-damage helpers require explicit parameters; door action enums privatized behind a shared utility; durability conditions succeed for unbreakable items.
NPC refactor: behavior support objects are ECS components; Sensors/Actions/Motions receive store ref + execution support; model-builder interface renamed; alarm store read via component (saves migrate automatically); HealthRegenState auto-added.
Unused ResourceType name/description fields removed (names come from localization keys).

Documentation

Docs live at https://pre-release.docs.hytale.com and https://docs.hytale.com (new theme).
Version switcher (patchline/game-version, cross-links pages), 404 fallback, nav-bar icons, heading/card/code styling fixes.

4. Bug Fixes Modders Care About

Trigger Volume fixes

Volumes no longer drop events when a burst exceeds the per-tick budget: signals, block-event rules, signal interactions, NPC signal actions, and volume-create events queue for a later tick instead of vanishing.
Pasted/generated volumes keep conditions, rejection effects, and group settings; duplicates copy settings; preset saving no longer corrupts Assets.zip; tool crash fixed; volumes spawn correctly in worlds; /worldgen reload deletes existing volumes properly; volume effects read chunk data through the chunk ref/store.
Teleport effect rotates body (not head) and skips rotation when unset.

World Generation fixes

WorldStructure assets reload correctly; broken default biome references fail loudly; fallback generator used when structures can't build.
Rotated prefabs no longer delete entities; prefabs generate identically across platforms; misconfigured prop pools skip silently instead of aborting generation.
No more chunk-load failure log spam after deleting a WorldGen V2 instance or stopping the server.
Fixed: Offset Pattern decimal vector pin; origin exceptions in horizontal pinch; negative-coordinate graph disappearance; SwitchState branch selection; gradient-warp axis sampling; cell-noise jitter corruption and diagonal mirroring; mirrored terrain symmetry; multi-block rotation in V2; cave weather breaching surfaces; prop-placement gaps; wall patterns reading outside declared bounds.
Chunk sections saved even with save-new-chunks disabled (previously dropped/regenerated empty).

Block & prefab fixes

Connected blocks: correct filler offsets with non-zero roll; fallback to own ruleset when neighbors lack one; proper connection at section boundaries and in cubic worlds.
Random-tick placement works in cubic worlds; fluid placement honors latest-target; fluids function beyond legacy heights.
Null MovementSettings fails at load instead of crashing servers; cloned block types preserve beds/random-tick/explosion settings; block-mount clones keep facing direction.
Prefab anchors rescale correctly; configs save reliably with better errors; pastes preserve floating entities; prefab-editor spawns fixed; Sculpt Tool max-height crash fixed; density clamps to zero; Pick Block works for Extrude/Line tools.
Instance portals remember their destination; portal-world timers can't exceed their initial allotment.

Item, interaction & projectile fixes

Projectile impacts act on the actual contacted cell (measured against the contact cell so tall blocks aren't self-rejected); proxy-entity interactions distance-checked like players; held item resolves from context for inventory-less actors.
Knockback/explosion configs never produce NaN velocity at zero distance; missing damage effects/targeted damage entries don't crash; armor knockback-enhancement crash skipped safely; fractional flat resistances accumulate correctly.
Deployables honor authored damage causes; resistance modifiers chain through inherited causes; knockback rotations use authored degrees; cooldown interactions inherit parent values; empty loot containers skip cleanly; default quality resolves correctly; sound-slot leak between local/world playback fixed.
Pickup-interaction crash guarded; duplication exploits closed; unbreakable-item durability passes; recipe quantities enforce minimums.

NPC & entity fixes

Anchored entities follow full orientation (pitch/roll), fixing riders/platforms.
SubStates store correctly; combat balance inherits evaluator config; collision avoidance honors authored distances; sensors match NPC-produced events; despawn-delay actions apply correct directions; spawn markers stop squaring drop height on every save; time-since-used reports real elapsed time; hot-reload validates every file; parent inheritance fixed across effects/stats.

Asset schema & format fixes

Particle WaveDelay/SpawnBurst inherit from parents; combat-text UI events inherit offsets/opacities/scales; rail-point normals default sanely (valid generated schema); noise ranges normalize inverted bounds; combo air-speed multipliers survive sync; nighttime duration default corrected to 40%; objective assets honor authored localization keys; decal/group removal notifications reach clients; teleporter roll-relative encoding fixed; weather forecast editor stabilized; unknown enum values tolerated; explicit-null fields rejected consistently.

Server & permission fixes

/tp world reports unset spawns instead of crashing; console runs chunk-coordinate commands with proper translated errors; clean/entity commands survive cascade removals; locate autocomplete matches substrings.
Discovery link heartbeats report distinct failure reasons and only link on success.
Per-player weather overrides persist against forced weather.
Missing packs warn once; layered reloads keep customized assets; duplicate lang keys warn; malformed lang lines skip cleanly.
Core-plugin failures halt boot; resource/permission saving hardened against data loss; shutdown-mid-save data loss fixed; periodic busy-save freezes fixed; repulsion-zone removal freeze fixed; >7-slot bench crash fixed (plus widened wire fields).

Fixes for plugin developers

Skin mods: atlas-overflow textures skipped with a logged warning instead of crashing world join.
Weather overrides stick against forced weather; cursor-camera raycasts/input/UI overlays behave; camera reach offsets capped server-side.
Brush/edit operations accept explicit selection bounds (# mask matches the player's selection; resolve via the builder-tools mask-selection helper); extrude gained an empty-space parameter (pass false for old behavior).
Custom UI accepts markup-text UI paths; tab paging wired via overflow controls.
Stat min/max/reset calls skip redundant client updates.
Geometry/steering math corrected: quad centers average all corners; segment clamping handles unequal lengths; pursue steering stores stop/slowdown distances correctly; damage calculators compare equal properly; instance configs clone without null points; time resources clone dilation/moon phase; circle brush operations error cleanly without radius; steering assignment/clearing carries roll state; message clones keep runtime state.
Caches evict expired entries; timing profiler state resets correctly.
Core-plugin unload NPE fixed (nullable file access; classloader release renamed); double-unload is a no-op; reloading plugins cleans up registered asset types (register stores via the plugin-scoped registry; hold component-type refs in instance fields); sub-plugins boot alongside patched parent versions.
Selector debug volumes render as cylinders; AOE selectors center correctly; point inspector teleports accurately and auto-closes; reputation lookups tolerate group-less NPCs; objective task constructors keep map markers (recompile only).
Privileged-user asset-key path traversal patched (writes confined to intended pack directories).

Stability (mod-heavy servers/worlds)

Joining heavily modded servers no longer crashes on unexpected weather/environment/fluid/ambient-sound/combat-text/sound-event/interaction/deployable/item-animation values.
Several large skin mods at once no longer crash world joins (atlas overflow skipped + warning); item icons stop rendering black with many mods; downloaded assets cache with bounded growth.
Worlds load areas whose content pack/mod was removed (containers drop nothing until loot restores); older-format worlds load.
Dedicated servers self-recover from main-world crashes (configurable policy); shutdown-mid-save data loss fixed.
Large/complex asset files parse correctly; status effects, map markers, character previews, machinima scenes, and asset-editor views no longer leak memory.

THE MODDER'S GUIDE TO UPDATE 6