All Classes and Interfaces

Class
Description
A button: clicking it in the settings window, or setting it from a command with any value, runs its action on the render thread.
Builds an ActionSetting.
An addon Myriad found: a mod with a "myriad" entrypoint, Myriad core included.
Everything an addon can register, scoped to that addon: registrations are tagged with its mod id (which is also the namespace of every id it creates) and are rolled back if the addon fails to load.
Settings that belong to an addon rather than to one of its modules: display units, a chat prefix, what a window shows.
Where an addon is in loading, from Addon.state().
A private folder for an addon's own data, at .minecraft/myriad/addons/<mod id>/.
One step of AddonStorage.readJson(String, int, Upgrade): data at fromVersion, returned at the next version.
A float that eases towards its target over time.
What the server checks, so a feature can be careful where it has to be and quick where it doesn't, without every module asking the player "is this server strict?".
How a server times block breaking.
What a server checks, as the answers the services act on.
What detection sees: the host you joined (lower case, no port; null in singleplayer), how many of the steady pings ("transactions") the server has sent since you joined (counted up to 100; the vanilla server never sends them in game), and the protocol number of the version the server sees you as (AntiCheat.joinedProtocol()).
On a method or type: safe to call from any thread.
Every argument type Myriad provides, in one place.
A shared pool of background threads for slow work (files, network, heavy searches) so addons don't each start their own.
You are about to attack an entity: posted just before the attack packet is sent, whoever sends it (vanilla clicks, a module, Interactions.attack).
Drives Baritone when it's installed, without depending on it: every call is a no-op (or false) when it's missing, so a module can offer "use Baritone" options to everyone and they simply do nothing without it.
One place Baritone's goal names: a block (column false), or a column at any height (column true, y meaningless), for drawing where it's going.
Baritone settings changed for a while, then put back: from Baritone.override().
One of Baritone's settings, as Baritone.settings() lists them: its name (allowBreak), the class of its value (Boolean.class, List.class for a block list, with genericType saying of what) and its default.
A block in the UI's top bar (Waybar-style), shown while the menu is open and Theme → Bar is on.
Which part of the bar a widget sits in.
A CSS/Hyprland-style cubic bezier easing curve through (0,0), (x1,y1), (x2,y2), (1,1).
The local player's block breaking, as vanilla does it (MultiPlayerGameMode): your own mining and anything driving it the same way.
Vanilla is about to advance its mining progress on a block (each tick the attack key is held).
The player started hitting a block.
You finished breaking a block (the client removed it; the server confirms with a BlockUpdateEvent).
What kind of block something is, with one answer shared by every addon: can it be broken, does it survive explosions, does it hold items, does right-clicking it open it.
Three coordinates, each a whole number or ~ / ~5 relative to where you stand, like vanilla's.
A block position: an anchor, a schematic origin, a home.
Builds a BlockPosSetting; 0 0 0 by default.
A block state is about to be drawn: cancel to leave it out of the chunk mesh (X-ray, hiding blocks).
What a block state is made of, for building it: which properties the placement itself decides (checked by simulating the click), which grow with more of the same item (candles, sea pickles, layers, double slabs), which a bare-hand click cycles afterwards (repeater delay, comparator mode, note, open, lever), and which the game keeps changing on its own (connections, power, age), which a build can't hold and ignores.
Fast block searches over a chunk.
Receives each match.
The server changed a block: single updates and multi-block updates alike, including confirmations of blocks you placed or broke.
The shape a build works towards: a Target for each position.
On or off, shown as a checkbox.
Builds a BoolSetting; off by default.
Shared block breaking for Nuker, tunnellers, speed mine, auto city and anything else that breaks blocks.
One break.
Whether a block could be broken now, and if not, why not.
The base for a replacement of this service (Service.BREAKING): hands every call to the service it wraps (core's), so override only what you do differently.
How a block is mined: how long it takes, and how the tool and your hand are used.
How blocks are broken.
The standard breaking settings, Mode and Double Break, so every module that mines offers the same choice.
The choice the Mode setting offers.
A running build from Myriad.building().start(...): the plan for what's in reach, how much is left, and a way to stop it.
Where one position stands.
One position of the plan.
Builds a Blueprint: describe the shape you want, and the planner works out each tick, for what's in reach, what to break and what to place, in an order that works, and does it through Breaking and Placement.
How a blueprint is built.
Which of the placements in reach go first.
The standard building settings, so every module that builds offers the same ones: PlacementSettings's Range and Air Place, Break Wrong Blocks, and BreakingSettings' Mode and Double Break for those breaks.
A push button one row tall, its label centred (cut short to fit, except a lone icon).
Hooks into the camera, for modules like Freecam and FreeLook.
Whether the local player's own body is drawn (true in third person).
About to draw the first-person hand and held item.
The camera's position this frame, as it follows its entity; overwrite x/y/z to move it.
The camera's rotation this frame; overwrite yaw/pitch to look elsewhere without turning the player.
Base class for events whose default behaviour can be prevented.
Myriad's 2D drawing surface: anti-aliased SDF shapes, gradient borders, drop shadows, frosted-glass backdrops and crisp TTF text, all batched into a few draw calls.
A character was typed (text input, after the keyboard layout and dead keys were applied), in a screen or not.
Works out who a chat line is from, and whether it's a whisper, across vanilla and the common plugin formats (Essentials, 2b2t-style, rank prefixes).
What kind of chat line a ChatMessages.Parsed is.
A chat line taken apart.
A line is about to be added to the chat: from the server, another player, or the client itself.
You are about to send a chat message (not a / command): typed in the chat box or sent by code through vanilla's chat sending.
Swapping the worn elytra with a chestplate held in the off hand or hotbar, in mid-air: how NoDurability and a bounce keep the server from gliding long enough to wear the elytra.
A name from a list you supply at runtime (waypoints, saved kits, schematic files), with suggestions.
One of a list of names that's only known at runtime (schematic files, kits, profiles), shown as a dropdown.
Builds a ChoiceSetting; empty (nothing chosen) by default.
Which chunks the server generated just now, as you came near (so nobody had been there), and which it had saved before.
Something worked out once per chunk and kept until that chunk changes: the storage blocks in it, its safe holes, the ores of a search.
A chunk's value as boxes, each in a colour (ARGB), for ChunkCache.Builder.boxes.
Takes a chunk's boxes (ChunkCache.Boxes), in world coordinates.
Works out the value for a loaded chunk, or null to keep nothing for it.
Draws a chunk's value into its mesh, in world coordinates.
Chunks arriving from and leaving the client world.
A chunk's blocks and block entities arrived.
A chunk is about to be dropped from the client (out of view distance, or the server unloaded it); still readable.
The game's player, world, connection and interaction manager, never null: each returns the one there is, or throws an IllegalStateException naming the method that asked outside a world.
A titled section whose body can be folded away: click the header (or Enter, or h/l with the keyboard selection on it) to fold or unfold it, with an animation.
The collision shape of a block, as the local player's movement sees it.
Inline HSB colour picker: saturation/brightness square, hue and alpha bars, a row of theme colours, mode buttons (static / rainbow) and a hex field.
A colour: a fixed ARGB colour, a rainbow, or a theme role that follows the theme (see SettingColor), with a picker.
Builds a ColorSetting; opaque white by default.
Helpers for packed ARGB ints (0xAARRGGBB), the colour format used throughout Myriad.
A chat command (run with the prefix, . by default) built on Brigadier.
Applies mixins only when another mod is (or isn't) installed, decided by package name, so one addon can carry hooks for Sodium, Iris, Lithium or Baritone without crashing when they're missing.
Profiles and persistence.
A shared config: the modules, control panels, wheels and theme someone shared, with their settings (never protected ones), plus how each looked in their menu, so the website can show it.
Sharing configs (Myriad.shares()): put together what to share, publish it for a code, take a code in.
What a share took in.
How to take a share in.
Puts a share together.
A share published from this computer (the key that deletes it is kept here, not in this record).
A widget with children.
A container (chest, shulker, furnace, villager trade, …) opening, receiving its contents, and closing.
The container closed (by you, the server, or a new screen replacing it).
The container's contents arrived; slots are now accurate.
The server opened a container screen.
One slot changed while the container is open (an item moved, a furnace finished smelting).
Containers (chests, barrels, shulkers, furnaces, …): opening one at a position, reading it once its contents have arrived, and moving items.
A layout for Containers.View.arrange(Containers.Arrangement): what each of some menu slots should hold, where the items may come from, and where what doesn't belong goes.
One click in a menu: screen slot id, button, input, as handleContainerInput takes them.
A shulker box or ender chest from your inventory, placed and open (Containers.openItem(Object, int, int, Placement.Options)).
What a box does when the container it came from can't be opened again to put it back (Containers.noWayBack(Object, Containers.NoWayBack)).
Clicks worked out one at a time from the menu as it is, for Containers.View.run(Containers.Planner).
A container that's open (or was), from Containers.current() or Containers.open(BlockPos, int): usable while Containers.View.isOpen(), and a stale handle after (its clicks do nothing and the futures it starts fail).
Inventory and container screens: drawing over slots (item highlights, shulker icons), replacing the tooltip (content previews) and taking over clicks (opening a shulker from your inventory).
A slot was clicked in the screen, by the player (or by code going through the screen): cancel to handle it yourself (nothing is sent to the server then).
A slot has been drawn, every frame, for each slot; draw over it with ContainerScreenEvent.SlotDrawn.graphics() (Myriad.ui().draw(graphics, canvas -> ...) for the canvas).
The tooltip for the hovered slot is about to be drawn, every frame the screen draws one: cancel after drawing your own, and vanilla's isn't drawn.
A hook handler or service replacement an addon contributed.
A named set of modules switched together.
A control panel an addon ships (AddonContext.registerControlPanel(ControlPreset)): the modules it switches and, for each, settings they take while it's on.
Builds a ControlPreset; each module is listed once, however often it's added.
The settings one module takes while the panel is on.
The control panels of the active profile (Myriad.controls()): the player's own and those addons ship.
Where end crystals can go, as the server decides it: on obsidian or bedrock, with air above and no entity in the crystal's space.
Client-side estimates of damage the server would deal, for predicting lethal hits.
Core's dev console steps, for test frameworks and tools driving a dev client: the same script language the console reads from -Dmyriad.devConsole=<file>, one step at a time.
The connection to a server ended, with the reason the server gave (or the client's own, for a timeout).
A number with decimals, set with a slider or typed into a box (DoubleSetting.Builder.typed()).
Builds a DoubleSetting; 0, unbounded and 2 decimals by default.
Pick one of several values: click to expand the options inline (the widget grows, pushing what's below down).
A length of time, as milliseconds: 500ms, 20t (ticks of 50 ms), 10s, 5m, 2h, 1d, or combined (1m30s).
Easing curves for module animations (0..1 in, 0..1 out), as closed formulas: cheaper than a Bezier, for modules that ease many values each frame.
Elytra flight the way strict servers check it, shared by every flight module so that two of them never fight over the glide (each would otherwise hold back the same pings and swap the same chest slot): NoDurability: gliding without wearing the elytra, and catching a glide dropped in mid-air; ChestSwap: swapping the worn elytra with a chestplate in mid-air; GlideHold: riding out a moment the server stops the glide, unseen by Grim; Elytra.Pilot: a flight module flying the local player by its own rotation, and holding the glide open; Flight: a flight that flies itself along a heading (Elytra.altitude(NoDurability.Owner), Elytra.control(NoDurability.Owner)). To change the glide's movement itself (fly it at a set speed, boost it), listen to GlideEvent.
A flight module flying the local player.
Stands in for a list with nothing in it yet: an icon, what's missing, and how it gets filled, centred and wrapped.
The players you've marked as enemies (.enemy add <name>), from Myriad.enemies(): kept as Friends are, in myriad/enemies.json, for modules that pick them out (a colour of their own in the player list, targets first).
Entity helpers for combat and render features: classifying entities the same way everywhere (so "hostiles" means the same thing in every addon), friend checks, and render-time interpolation.
The broad classes Entities.kind(Entity) sorts entities into.
Entities entering and leaving the client world, popping totems and dying.
An entity was added to the world (spawned, or came into view).
A living entity died (the server shows the death to everyone near), with the totems it had used before.
An entity is about to be removed; it's still in the world while handlers run.
A living entity used a totem of undying (the server shows the pop to everyone near).
The standard way to pick entities to show (players, friends, monsters, crystals, pearls, …), each group with an on/off setting and a colour from the theme, plus a list of extra entity types for anything the groups don't cover.
The groups, each with its setting name and default theme colour.
Entities being drawn, once per entity per frame.
A living entity's model has just been submitted, with everything needed to submit it again another way: chams, wireframes, glows.
entity's vanilla name tag is about to be drawn: cancel to draw your own instead (hides the score line under it too).
entity is about to be drawn: cancel to hide it (and its name, shadow and fire).
One of an enum's constants, typed in any case and with or without underscores (fast_place, FastPlace, fast-place); suggests them in lower case.
Any number of an enum's constants ("which of these"): sound kinds to block, what to notify about, which parts to draw.
Builds an EnumSetSetting; empty by default.
One of an enum's constants.
Builds an EnumSetting, starting at the default given to the constructor.
Myriad's event bus (Myriad.events()): delivers each posted event to every handler of its class or a supertype, highest Priority first and, among equals, in the order they subscribed.
Highlights that fade in when they appear and fade out when they go, keyed by whatever you highlight (block positions, entity ids).
Client-side dummy players for testing combat and render features in singleplayer: they stand where you do, wear a copy of your gear, and count as players for targeting, damage maths and rendering.
A file on disk (a schematic, a song, a list to import), chosen with the system's file picker or typed in.
Builds a FileSetting; no file by default.
An elytra flight that flies itself along a heading: Elytra.altitude(NoDurability.Owner) crosses open country holding its height without fireworks, Elytra.control(NoDurability.Owner) flies straight at a set speed where the server doesn't simulate the glide.
What the flight is doing, from Flight.state().
A font family known to the UI renderer.
Text for numbers people read, so every addon writes distances, times and amounts the same way.
The players you've marked as friends (.friend add <name>, or the Friends window), from Myriad.friends().
Search scoring for short names (modules, panels, themes).
Posted once, on the render thread, when the game has finished starting: the window and render system are ready, so fonts, textures and shaders can be created.
A living entity drawn again as a see-through copy of itself, wherever you like: its skin, armour, cape and elytra faded to alpha (held items stay solid), posed as its render state says.
The local player's glide is about to move it this tick, by vanilla's elytra physics (GlideEvent.movement()).
Keeps the local player gliding through a moment the server stops the glide, without Grim noticing: the trick behind NoDurability and a bounce.
Which thread a Subscribe handler is called on.
Lays children out left to right.
What starts a part of a window that doesn't fold: its name, a hairline running on from it, and dim text at the end (how many there are, say).
The server set your health (and food): posted on the render thread with the values before and after, every time the health packet arrives, whether or not anything changed.
Shader highlights outside RenderEvent: your first-person hand and held items (HighlightEvent.Hand), which have no box and are highlighted by the shader in either render mode, and the HighlightEvent.ENTITY_HIGHLIGHT hook, which has the last word on how each entity is shown.
How an entity is highlighted this frame, for HighlightEvent.ENTITY_HIGHLIGHT: a null style for not at all.
A part of your first-person view model is being drawn this frame: call HighlightEvent.Hand.highlight(HighlightStyle, int) to highlight it.
What's being drawn.
How a highlight looks: an outline traced around the silhouette of what's highlighted, an optional soft glow beyond the outline, and an optional fill inside.
What fills the silhouette: one of the built-in fills, or an addon's own (HighlightStyle.Fill.custom(Identifier)).
Holes and surrounds: the questions crystal PvP modules keep asking about the blocks around a player's feet.
A hole.
How safe a hole is.
A hole's size.
One decision that addons can make instead of the code that owns it: the owner calls the hook with what it knows and its own answer as the default, and contributions (AddonContext.hook(Hook)) that match the call give theirs.
Handles a hook (AddonContext.hook(Hook)): name it, say when it applies, then give the handler, which registers it.
One call of a Hook, as a HookHandler sees it: the input, who it's for, where you are, and the way on to the next handler.
Handles a Hook: gives its answer for a call, or asks the next handler (HookCall.proceed()) and adjusts what it says.
What's hooked (Myriad.hooks()): the contributions addons made, which of them would handle a call, and which replacement each service is using.
Simple web requests on Myriad's worker threads.
A response that wasn't a success (not 2xx): its status, body, and how long the server asked you to wait.
A base for HUD elements: a title and icon, a settings group named after the element with a HudPanel.scale option, and helpers for the things every HUD element deals with.
The colour options every text HUD element shares, as a "Colors" settings group: how values are coloured, a separate colour for labels, the text shadow, and rainbow tuning.
How a HUD element colours its values.
Inline icon picker over Icons, opening like a dropdown: shut, it shows the icon and its name; open, a search box, the icons by section in a grid that fills the width and scrolls, and a line naming the one pointed at.
Ready-made icons: glyphs of the icon font the UI draws with (Font Awesome, in the bundled Nerd Font), each with a name and words to find it by.
One icon: its glyph, a name, the section it's listed under, and more words to find it by.
An icon the player picks from Icons (a glyph of the UI's icon font).
Builds an IconSetting; empty (the default icon) by default.
Anything that lives in a Registry: it has an id, unique in its registry.
The player's movement input for this tick, right after the keyboard was read.
The local player is about to right-click: a block, an item in the air, or an entity.
Right-clicking a block face (placing, opening, using).
Right-clicking an entity (trading, mounting, naming).
Using the held item without a block (eating, throwing, shooting).
The player's actions, done the way vanilla does them (cooldowns reset, sequence numbers kept, events posted), plus the timers vanilla keeps for them.
A list of whole numbers: hotbar slots, entity ids, y levels.
Builds an IntListSetting; empty and unbounded by default.
A whole number, set with a slider or typed into a box (IntSetting.Builder.typed()).
Builds an IntSetting; 0 and unbounded by default.
The player's one inventory, shared between every module that wants it: which hotbar slot the server holds, which items sit in the hotbar, and the clicks that move them.
The last movement the server saw, for Inventory.CLICK_READY: whether it had sprint on, a movement key or jump down, and sneak.
The base for a replacement of this service (Service.INVENTORY): hands every call to the service it wraps (core's), so override only what you do differently.
Durability bars, percentages and colours for HUD elements that show items, so they all look alike.
How an element shows an item's durability: an option for players.
Questions about item stacks that features keep asking: enchantments, food, contents, durability, gear kind, armour.
When two stacks count as the same item for a layout (a kit, a sort): stacks that stack together always do.
An item's tooltip lines were built.
The local player stopped using an item: food eaten, potion drunk, bow released.
The use completed (eating or drinking finished).
The use was let go early (releasing a bow or trident, stopping eating).
A step being run (or finished): what Jobs.start(Object, Step) hands back, what the Jobs window lists, what another addon sees through JobEvent.
A failed or cancelled job's reason, as an exception for Job.result().
Where a job stands.
What a Step.Run may use while it runs.
The job runner's engine: the tree of jobs, ticked once per tick by core, with no game behind it so the semantics are tested on their own.
What the engine needs from the game.
Jobs starting, changing and finishing, on the bus: for UIs, and for addons that react to another addon's work (a Discord addon posting when a search lands).
Its state, reason, status or progress changed.
Done, failed or cancelled; Job.state() and Job.why() say which.
A job (root or child) started.
Runs steps as jobs (Myriad.jobs()).
A named, rebindable global key action (e.g.
A key or mouse button with optional modifiers (InputConstants.MOD_* bits).
Click, then press a key or mouse button (middle/side) to bind, with any modifiers held.
A key or mouse button.
Builds a KeybindSetting; unbound (Keybind.NONE) by default.
A keyboard key was pressed, released or repeated (held down) in the game window, in a screen or not.
Text, wrapped to the available width (or cut short with "…", see Label.oneLine), in the theme's text colour, font and size unless told otherwise.
A tiling algorithm.
The tiling of one workspace.
A resizable boundary: bounds is the hit area; LayoutState.Splitter.drag(float, float) receives the mouse position.
Whether anything listens for an event, kept current by the bus; see EventBus.flag(Class).
The map mods installed alongside Myriad, read without depending on them: everything is empty when none is.
When a contribution applies: for which module (the caller), on which anti-cheat profile, on which server.
Somewhere items can be fetched from, for Steps.acquire(Predicate, int, List): a chest at a place, the shulker boxes you carry, or whatever an addon knows of (its own memory of a storage room).
Angles, directions and geometry.
Draws touching blocks of the same group as one shape: a wall of chests becomes one outline instead of a box per chest.
What's at a block.
The colour for a group; 0 (or fully transparent) draws none.
Records shapes for a WorldMesh.
Block breaking maths that mirrors the server, for mining with packets.
An entity's model as shapes, posed and animated like the model: a flat-colour fill or a wireframe of its boxes.
A toggleable feature.
A registered module, typed as one word: its name without spaces (KillAura), id path (kill_aura) or full id, in any case (see ModuleRegistry.byName(String)).
Some of one addon's modules, together in one window of the menu, as the addon's author thinks best: one group for a small addon, several for clear separation in a big one ("Travel", "Building & Mining").
A set of modules, e.g.
Builds a ModuleListSetting; empty by default.
Every registered module, from Myriad.modules(): a Registry with lookups by class, name, tag and window.
Typed access to registered modules, safe to call from anywhere: mixins, other addons, before Myriad has started, or when the module's addon isn't installed (you get null rather than an exception).
A module was turned on or off, by the player, a bind, a command or code.
A mouse button was pressed or released in the game window, in a screen or not.
Mouse movement is about to turn the player.
The mouse wheel (or a touchpad) scrolled in the game window, in a screen or not.
The local player's movement: which way the keys point, and setting speed along it.
Posted on the render thread just before the player sends its movement packet each tick (at the end of its tick), with the values about to go out.
Posted on the render thread right after the movement packet was sent (or vanilla decided none was needed).
Static entry point to everything Myriad exposes to addons.
Entry point of a Myriad addon.
The services behind the Myriad facade, implemented by core: each method returns what the static method of the same name on Myriad does, and is documented there.
A namespaced identifier (namespace:path).
The Myriad mark (two interlocked rounded squares) drawn with SDF outlines, so it is crisp at any size.
No Durability for an elytra, and a catch of a glide dropped in mid-air: one engine per flight (Elytra.noDurability(NoDurability.Owner)), enabled while it flies.
Who runs it: whether swapping is on, and where its messages go.
A short message set apart from what's around it, on a tinted strip: a warning, a failure, something worth reading.
A notification was sent (by core, a module or an addon, through Notifications), as it shows: coordinates in it already hidden.
Toast notifications, drawn by the window manager overlay both in game and in the menu.
How a notification is marked: its accent colour and icon.
A notification being set up (Notifications.toast(String, String)).
What Packets sends through, so the API needs no part of core's networking to load.
Packet traffic.
A packet arrived from the server, on the network thread, before the game handles it (most packets are then handed to the render thread).
A packet is about to be sent to the server.
A shared budget for packets servers count, so that several modules acting at once (or one module on a fast loop) don't add up to a kick.
The kinds of packet the budget counts, each with its own limit and window: inventory clicks 72 in any 5 seconds, interactions the anti-cheat profile's AntiCheat.Profile.interactionBudget() in 300 ms (9, after Paper's spam limiter), block actions 80 in half a second.
Sending packets to the server.
The content of a window.
A kind of panel that can be opened in a window.
One of the nine places a HUD element aligns to: a screen corner, an edge's middle or the centre.
Builds a PanelType; a factory is required.
Where a HUD element is anchored; offsets are in UI units from that anchor.
Shared block placement for modules like Scaffold, Surround or Auto Trap: finds a solid neighbour face to click, optionally rotates for that exact placement, silently swaps to the block, and follows each placement until the server has answered, so modules don't place twice while it catches up and learn whether the block stayed.
One placement.
Whether a block could go somewhere now, and if not, why not.
A click that makes a block come out a particular way, from Placement.solve(BlockPos, BlockState, int, Placement.Options): the face and point to click, whether the server is to see the sneak key down for it (placing against a chest or a repeater without opening or clicking it), and the look to click with.
The base for a replacement of this service (Service.PLACEMENT): hands every call to the service it wraps (core's), so override only what you do differently.
How blocks are placed.
A block to place, for Placement.AIM.
The standard placement settings, Range and Air Place, so every module that places blocks offers the same ones.
A player name, as one word; suggests names from the tab list.
Players' faces drawn on the canvas, with their hat layer, for radars, target HUDs, nametags and lists.
The local player is about to move by PlayerMoveEvent.movement this tick (after input, gravity and friction were applied, before collisions).
Where the local player's view ray starts and points, as used for the crosshair target, block reach and placement.
The eye position the view ray starts from.
The unit look direction.
A sound is about to play on the client: sounds the server sends, and the ones the client plays itself (your own steps, clicks, music).
Block positions around a point: the loops every placing, breaking and scanning feature needs.
A 3D view of something, for seeing what render settings do to it: an entity, you, a block (a chest, a shulker box), or your first-person hands and held items (as View Model shapes them).
Draws on a preview: box is the subject's box (an entity's hitbox, a block's cube) in the same coordinates, entity the entity shown (null for a block, an item or the view model), for colouring it as the module would.
An entity of type, standing, facing you.
An item as a 3D model: a block's item shows the block (chests and shulker boxes as they stand in the world).
A player looking as you do: your skin and its layers, armour and what you hold.
What a preview shows.
Your first-person hands as you see them right now, as if the menu weren't in the way: what you hold, or your arm when your hand is empty (View Model's changes included).
A Preview is being drawn (a Preview window, or one in a module's settings): show on its subject what your module would show in the world, so the player sees a setting change as they make it.
A config profile name, as one word; suggests existing profiles but accepts any name (to create one).
How a Step.Run stands after a tick.
Maps world positions to the screen using the camera of the last rendered frame.
Counts events over the last second: clicks per second, packets per second, placements per second.
What the player can reach and see, measured from the eyes as the server does.
An axis-aligned box in UI units: its top-left corner (x, y, y growing downwards) and its size (w, h).
An ordered, namespaced registry of one kind of thing (modules, commands, panels, themes...), from Myriad's accessors.
An entry of a game registry by id (diamond_pickaxe or minecraft:diamond_pickaxe), with suggestions.
A set of entries from a vanilla registry (blocks, items, entity types, status effects, …).
Builds a RegistryListSetting; empty by default.
Inline searchable multi-select over a vanilla registry, instead of a separate picker screen.
What the picker lists and how picking works: a multi-select list, a single choice, or anything else.
One entry of a game registry: a single item (what to place), block (what to mine), and so on.
Builds a RegistrySetting, starting at the default given to the constructor.
Posted on the render thread every frame the HUD is drawn, after the vanilla HUD (right after the tab list) and before Myriad's own HUD elements, in scaled GUI coordinates.
Fired every frame while the world's geometry is collected for drawing.
Shapes drawn this frame only.
Which parts of a shape are drawn.
What your module shows in the world this frame: entities, boxes, blocks and a ChunkCache's boxes, each in a RenderLook (a module's RenderSettings, from its Render options) and a colour.
Where the requests go: core's renderer.
What the rendering helpers (Renderer3D, WorldMesh, HighlightStyle, Ghosts, RenderStates, RenderLayers, HighlightEvent) draw through, so the API needs no part of core's renderer to load (a test harness supplies its own).
The render types RenderLayers hands out.
Render types for drawing into the world through a SubmitNodeCollector (see Render3DEvent.submits()), for geometry Renderer3D doesn't cover.
How something shown through RenderEvent looks, in either RenderMode: the shader look, and a box's fill, edges and through walls.
How modules draw what they show in the world, one choice for all of them, the player's (the Render window, or .render): RenderMode.SHADER traces outlines, glow and fills around the exact shape of things; RenderMode.BOX draws boxes of lines and faces, lighter on a weak GPU.
How what a module shows in the world looks, in either RenderMode: the standard options of its Render group, so every module offers the same ones.
Sets up RenderSettings before its options are added; see RenderSettings.builder(SettingGroup).
Entity renderers receive a snapshot (EntityRenderState) instead of the entity.
Call it on the render thread only (the game's own thread: ticks, rendering, input, screens, and every event handler but those of events marked AnyThread).
Optional for a service replacement (Service): told when it starts and stops being the one in use.
Takes over a core service (AddonContext.replace(Service)): name it, say when and for whom it applies, then give what makes it, which registers it.
Server-side rotation arbitration.
The base for a replacement of this service (Service.ROTATIONS): hands every call to the service it wraps (core's), so override only what you do differently.
How a rotation is applied.
One step of a rotation turning towards its target, for Rotations.TURN: angles in degrees, speed 0 = snap.
The standard "Turn Speed" setting, so every module that turns you means the same by it.
Saved settings as they are on disk, for updating them after you rename, move or change settings (see Module#migrateSettings).
A screen is about to open, or the open one is about to close (ScreenOpenEvent.screen() null, back to the game or, with no world, to the title screen).
Shows a child clipped to a viewport with smooth scrolling (24 units a wheel notch, once the child doesn't use the wheel itself).
Facts about the current server and connection that several features want, tracked once by Myriad instead of by each addon: tick rate, latency, lag and rubberbands, packet rates, and totem pops.
A core service an addon can take over with its own (AddonContext.replace(Service)): Myriad.rotations() and the rest then use yours (for everyone, or only for your own modules), so you keep Myriad's menu, binds and modules and bring your own rotations, inventory handling, placement or breaking.
A typed, serialisable, user-editable value.
Fluent builder base.
Who lays a value over the player's, lowest first: a later layer wins over an earlier one.
A setting id of the module parsed by a preceding ModuleArgumentType argument named module: its id (range), or group.id where two groups share one.
A colour value as edited by ColorSetting: a fixed ARGB colour, a rainbow, or a theme role such as SettingColor.Mode.ACCENT or SettingColor.Mode.RED that follows the active theme.
Where a SettingColor's colour comes from.
A named, collapsible section of settings, from Settings.group(String).
A setting's name (left) and editor (right).
The settings of one module or panel, organised in groups.
Builds settings editors from Settings: a row per setting, made by Ui.settingWidgets() (settings of a class with no registered editor are left out).
The rest of the line, as a value for the setting named by preceding arguments called module and setting (see SettingArgumentType), suggesting what that setting accepts.
Maps setting classes to editor widgets, from Ui.settingWidgets().
The shapes Myriad can draw in the world, in absolute world coordinates.
Posted once, on the render thread, when the client is stopping, before Myriad saves its config: write out anything of your own here.
A side of a tile, for LayoutState.insertBeside(W, W, Side): where a window goes.
A horizontal slider over a range, showing its value at the right.
Converting between player inventory indexes (Inventory.getItem(i)) and menu slot ids (what MultiPlayerGameMode.handleContainerInput takes), which number the same slots differently.
Empty space, optionally with a divider line across its middle.
A description of work that produces a T, spread over game ticks: open a chest and take what's needed, build a wall, fly a route.
What a step of your own does while it runs.
The services as steps.
Edits a StringListSetting: one chip per entry (click × to remove) plus an input to add.
An ordered list of strings, without duplicates when added one at a time.
Builds a StringListSetting; empty by default.
Free text, shown as a text box; anything typed is accepted as it is.
Builds a StringSetting; empty by default.
Marks a method as an event handler.
Handle returned by EventBus.listen(Class, Consumer); call Subscription.unsubscribe() to stop listening.
What a module is about: Combat, Movement, Render...
The shared tags, registered by Myriad core so that every addon uses the same words: #combat finds combat modules from every addon, in the same colour and with the same icon.
What one position of a Blueprint should be: empty, a certain block, a block in a certain orientation, or any solid block.
What Target.air() returns: done when the position is air or a fluid.
What Target.exact(BlockState) returns; the planner tells it apart to build a state as exactly as it can.
The properties that set how a block was placed, as opposed to ones the game keeps updating from its neighbours (stair shapes, fence connections, waterlogging, power).
What Target.solid() returns: done when there's a block with a full collision box.
Finding entities to attack, aim at or highlight, with the same rules everywhere: what counts as a hostile, how neutral mobs are treated, friends, invisibility, walls, and sorting.
Which entities to find and in what order: set what differs from the defaults (Targets.query()), then call Targets.Query.best() or Targets.Query.list().
Which target comes first.
Kinds of target, as Targets.type(Entity, boolean) sorts entities.
The standard "Targets" settings group, so every combat module offers players the same choices with the same names.
The server is setting your position: a teleport, or a rubberband when it didn't accept where you moved.
Single-line text input.
A HUD element made of lines of "label value" text.
Lines of alternating label and value parts.
Chat text that does something: run a Myriad command on click, fill the chat box, copy a value, show a tooltip.
A theme preset: applying it writes values into the live ThemeSettings (anything it doesn't set keeps Myriad's default).
The theme's font as one of Minecraft's own, for text Minecraft draws: give a style ThemeFont.FONT as its font and Minecraft draws, measures and wraps that text in it (chat, tooltips, item counts), rasterised at the GUI scale it's drawn at, as Myriad's own text is.
A terminal-style colour scheme (background, foreground, selection, accent and the 16 ANSI colours) and the mapping from it to every colour a Myriad theme has.
The live look of the menu, modelled on Hyprland's general, decoration and animations sections, from Ui.theme().
Which screen edge the bar is on.
The easing curves the theme's animations can use, each a Bezier preset.
The theme's text font.
The modifier that, held, turns keys and clicks into menu shortcuts (ThemeSettings.modKey): workspaces, launcher, moving and resizing windows.
How switching workspaces animates.
Which thread code runs on.
How much damage nearby dangers could do to you right now, after your armour and effects: end crystals, beds (which explode outside the Overworld), charged respawn anchors (which explode outside the Nether), creepers about to explode, players about to hit you, and the fall you're in.
How long a piece of incremental work may still run this tick: "as much as fits in 2 ms, then carry on next tick".
A value worked out at most once per client tick, however often it's read.
Posted around every client tick (20 a second, unless the game lags), on the render thread, in the menus as well as in a world: use @Subscribe(inGame = true) for handlers that need the player.
The end of the client tick, after the player and the world have ticked and this tick's movement was sent.
The start of the client tick, before the player, the world and the input are ticked.
The client tick counter: one more every game tick, from when the game started, whatever world you're in.
The speed the client runs game ticks at ("timer").
A stopwatch for delays and cooldowns.
A control in a window's title bar, beside its own float and close buttons: a switch (a control panel's on/off) or an icon button (Addons' "check for updates").
A switch bound to a boolean, drawn at the right of its box.
Where a projectile goes, worked out tick by tick as the game moves it (gravity, drag, water), until it hits a block or an entity.
How a kind of projectile flies, per tick: gravity pulls it down, drag (or waterDrag in water) scales its speed, and radius is how far from its centre it hits entities.
A projectile leaving origin at velocity blocks per tick, flying as ballistics says.
The points a projectile passes, one per tick from its launch, and what it hits (null if nothing in time).
Myriad's window manager, the UI (players call it the menu), from Myriad.ui(): nine tiling workspaces plus a HUD workspace whose windows are drawn in game.
Stacks children vertically, each at full width (less the padding).
A waypoint from a map mod: its name, where it is in its own dimension, and that dimension's coordinate scale (8 in the Nether, 1 in the Overworld and the End), so it can be found from another dimension.
Why a step is stuck or failed: a Why.Code everyone can match on, a detail for people, and the thing it's about when there is one (a position, an item).
A reason everyone can name.
Base of the widget toolkit.
A panel whose content is a scrolling column of widgets.
Hosts a widget tree inside a panel: routes input, tracks keyboard focus, the pressed widget (which receives drags and the release), the tooltip of the hovered widget, and the keyboard selection.
A window managed by the UI: one Panel on a workspace, tiled by the workspace's layout or floating above it, or a HUD element on the HUD workspace.
The game window was resized, or the GUI scale changed: posted on the render thread once Minecraft has worked out the new scaled size, so layouts made for the old size can be redone.
The client joining and leaving a world.
The client joined a server or a singleplayer world: the player and level exist.
The client left its world (disconnected, kicked, or quit to the title screen); every job is cancelled.
Labels pinned to points in the world (nametags, logout spots, item names), drawn on the 2D overlay.
What's drawn behind a label's text.
Where a label ended up on screen, so callers can stack things above it: its top-left corner and size in scaled GUI pixels, and the scale it was drawn at.
A piece of a label: text in a colour, or an item icon (WorldLabel.Segment.item).
Shapes kept on the GPU and drawn every frame until you rebuild or clear them.