Blockbench MCP Plugin

Place Cube

Creates cubes in one reversible edit. Texture and group are optional, allowing untextured blockouts. Explicit face targets never use the current UV selection; partial/custom faces require per-face UV support. Elements accept inflate, plus uv_offset and mirror_uv for box UV cubes; unknown element fields are rejected. Cubes the format's size limiter rejects (for example Java Block elements outside -16…32) are refused and nothing is created, unless Blockbench's Deactivate Size Limit setting is on.

Modify Cube

Modifies the cube with the given ID. Auto UV setting: saved as an integer, where 0 means disabled, 1 means enabled, and 2 means relative auto UV (cube position affects UV). A new from/to/inflate that the format's size limiter rejects (for example Java Block elements outside -16…32) is refused before anything changes, unless Blockbench's Deactivate Size Limit setting is on.

Knife Cut Cube

Headless Blockbench Knife tool for cubes: splits each target cube with planes perpendicular to one axis at the given positions, keeping each piece's share of the face UVs. The original cube keeps the lowest piece; new pieces get unique names. One undo entry covers every cut and the selection is left unchanged.

Slice Cubes To Block Grid

Cuts cubes wherever they cross a Bedrock block boundary (16-unit grid, x/z centered) and, by default, regroups the pieces into one group per block cell pivoted at that block's origin. Use it to divide an oversized custom block model into per-block sections that each fit Bedrock's 30×30×30 limit. Rotated cubes are left uncut on the affected axes and reported.

Inspect Block Bounds

Reports cube, group, and whole-model extents against Blockbench's Bedrock block limit (a 30×30×30 box whose center may sit up to 7 units from the block center), the block cell each cube occupies, and the grid cut positions slice_cubes_to_block_grid would use. Read-only. Extents ignore rotation; rotated cubes are flagged.

Capture Screenshot

Returns the rendered image of a view. Defaults to the user's active viewport ("active"); pass the ID of an offscreen view from create_offscreen_view to render without disturbing the user, or a viewport ID from list_views.

Capture App Screenshot

Returns the image data of the Blockbench app.

Set Camera Angle

Moves a view's camera and returns the resulting frame plus the applied camera state. Defaults to the user's active viewport, which changes what they see and clears any side-view lock they had; target an offscreen view from create_offscreen_view to inspect the model from any angle without moving their camera.

Create Offscreen View

Creates a private offscreen viewport that renders the current project without moving the user's camera. Use it with set_camera_angle and capture_screenshot (view: <id>) for multi-angle inspection. The camera starts where the user's is unless copy_view is "none". Up to 4 views may exist at once; delete them with delete_offscreen_view when done. Views still open when your MCP session ends are deleted.

List Views

Lists render targets: the user's connected viewports (the active one flagged) and the plugin's offscreen views, each with size and camera position, target, projection, FOV, zoom, and side-view lock.

Resize Offscreen View

Changes the pixel size of an offscreen view. The user's viewports follow their layout and cannot be resized here.

Delete Offscreen View

Disposes an offscreen view and releases its WebGL context. The user's viewports are not affected.

Get Capabilities

Discover Blockbench/plugin versions, desktop or web environment, active project summary, and registered model formats. Returns detailed boolean format features (null means unknown; includes molang and java_cube_shade_direction_override) plus the format's remember_files and animation_grouping settings, compact supported-feature lists for all formats, and optional tool registration states. Works with no open project. Format features do not guarantee that every enabled MCP tool can run in the current mode or selection.

Create Animation

Creates and selects an undoable animation with linear keyframes for existing bones, using Blockbench editor coordinates. Returns its UUID and actual name.

Manage Keyframes

Creates, deletes, or edits keyframes in the animation timeline for specific bones and channels.

Animation Graph Editor

Edits a bone channel's interpolation or numeric Bezier easing in one reversible edit. Uses native per-axis handle arrays and chronological segment durations. Custom points are normalized time/value fractions. Partial-axis edits require existing Bezier keys; key-wide mode changes require all axes. Rejects curve edits ignored by quaternion rotation, and step or Bezier curves in GeckoLib models (use geckolib_set_keyframe_easing). Inspect neighboring segments after range edits.

Bone Rigging

Creates and manipulates the bone structure (rig) of a model for animation. Each action is one undoable edit (create with ik_enabled records the IK controller as a second one); undoing delete brings back child bones, elements and their keyframes. mirror duplicates the bone with its descendants and flips the copy like Blockbench's Flip action. The set_ik action is deprecated; use set_ik_controller for Blockbench's null-object IK (source, target, pole).

Animation Timeline

Controls the animation timeline: playback, time scrubbing, length, FPS, loop mode, and keyframe selection by time range or relative to the playhead (select_before_playhead/select_after_playhead return the selected keyframe UUIDs).

Batch Keyframe Operations

Edits keyframes in the active animation atomically; all includes hidden animators. Numeric value edits use native transform values. Reverse follows the native Reverse Keyframes action, including the GeckoLib plugin's easing adjustment. Bake samples continuous numeric curves within selected channel spans, caps output at 10000 samples, and restores the playhead. Expressions, step/pre-post curves and effect channels require native baking. Smooth and bake clear GeckoLib easings they replace and report it.

Animation Copy/Paste

Copies native keyframe data points and curve metadata into a plugin-local clipboard. Paste preserves exact timestamps, replaces same-channel/time collisions and is undoable, including newly created animators. Mirror paste uses native position/rotation/curve mirroring; scale is unchanged.

Variable Placeholders

Reads or edits the project's animation Variable Placeholders text (one `variable = expression` per line), used to preview Molang animations. add writes a value, slider('name', step, min, max), toggle('name') or impulse('name', duration) line like the native Create Variable Placeholder dialog; set replaces all text; remove deletes a variable's lines. Changes sync through the native panel, refresh the animation preview and return the parsed lines and live controls. Placeholder edits are not recorded in Undo. Requires a format with Molang enabled.

List Molang Variables

Lists Blockbench's built-in Molang variables and query functions available in animation previews (like the native View Built-in Variables dialog), with current values for constants and live queries, plus the project's placeholder assignments. Read-only.

List Armatures

Lists all armatures in the current project with their basic info.

Get Armature

Gets detailed information about a specific armature including its bones.

Add Armature

Creates a new armature in the project. An armature is a skeletal rig used for mesh deformation.

Remove Armature

Removes an armature and all its bones from the project.

Update Armature

Updates properties of an existing armature.

List Armature Bones

Lists all armature bones, optionally filtered by a specific armature.

Get Armature Bone

Gets detailed information about a specific armature bone.

Add Armature Bone

Creates a new bone and adds it to an armature or parent bone.

Remove Armature Bone

Removes an armature bone from the project.

Update Armature Bone

Updates properties of an existing armature bone.

Update Armature Bones (Batch)

Updates multiple armature bones at once with the same properties.

Select Armature Bones

Selects armature bones by ID. Can select single bone, multiple bones, or bone hierarchy.

Get Vertex Weights

Gets vertex weights for a mesh from all bones affecting it.

Set Vertex Weight

Sets the weight of a specific vertex on a bone.

Set Vertex Weights (Batch)

Sets multiple vertex weights at once on a bone.

Clear Vertex Weights

Clears all vertex weights from a bone for a specific mesh, including legacy bare vertex-key entries that still apply to that mesh.

Set IK Controller

Creates or updates an inverse-kinematics controller. Blockbench drives IK from a null object: ik_target is the end effector (group/bone, armature bone, or locator) that reaches for the null object, ik_source is the chain root (defaults to the null object's parent), ik_pole (Blockbench 5.2+) sets the bend direction, and lock_ik_target_rotation keeps the effector's rotation. Works with bone rigs and armatures (5.2 allows null objects under armatures and armature bones). Validates every reference and that the target lies below the chain root; returns the solved chain. Replaces the deprecated bone_rigging set_ik flags, which Blockbench never read.

Get Display Transform

Reads Java Edition display settings (Project.display_settings). Returns translation, rotation, scale, mirror and pivots for a single slot, or a summary of every populated slot when no slot is given. Never modifies state.

Set Display Transform

Writes a Java Edition display slot's transform (translation, rotation, scale, mirror, pivots). Creates the slot if it does not exist yet (seeded from Blockbench's Bedrock item display defaults on bedrock_block projects, identity otherwise) and wraps the change in an undo step. This edits data that ships in the exported model JSON — it changes the deliverable, not just the preview. Values are kept as given, like Blockbench does; outside bedrock_block projects the result warns about those Minecraft Java clamps or ignores (translation beyond ±80, scale beyond ±4, pivots, the embedded slot). Requires a format that supports display mode (e.g. Java Block/Item).

Enter Display Mode

Switches Blockbench into Display mode, activates the given slot and optionally loads a reference model (player, zombie, armor stand, …), then returns a screenshot. Pair with set_camera_angle / capture_screenshot for multi-angle fit checks of cosmetics and handheld items. Requires a format that supports display mode.

Remove Element

Removes the element with the given ID.

Add Group

Adds a new group with the given name and options.

List Outline

Returns the project outline as a hierarchical tree. Each node reports { name, uuid, type, children? }, including groups, armatures, armature bones, cubes, meshes and markers. Parent nodes retain their descendants. Use include_cubes=false and include_meshes=false to omit geometry leaves, or max_depth to bound very deep trees.

Duplicate Element

Duplicates any outliner element or group (with its children) by ID or name using Blockbench's native duplicate, so every property, face UV, texture and mesh vertex key is preserved. Mesh copies inherit their armature bone vertex weights, and copied IK null objects point at the copied bones when their chain was duplicated with them. Optionally offsets the copy and assigns a new name. Selection is left unchanged.

Rename Element

Renames a cube, mesh or group by ID or name.

Find Elements by Criteria

Searches the current project for elements matching the given criteria. Supports name pattern matching (regex or substring), type filtering, scoping to a parent group, cube size ranges, and selection scope. Returns element metadata, never modifies state.

Select All of Type

Selects all elements of the given type (cube, mesh, or group) in the current project. Optionally restrict to descendants of a parent group, or add to (rather than replace) the current selection. As in Blockbench, locked nodes are skipped and selecting a group also selects its contents.

Filter Elements by Material

Returns all elements that reference the given texture. For cubes, includes the list of face keys (e.g., 'north', 'up') that use the texture. For meshes, returns the mesh if any face uses the texture.

Get Selection

Returns the current selection state: selected cube/mesh/group UUIDs and names, plus the active texture. Use this to verify what `apply_texture` or a paint tool with `fill_mode="selected_elements"` will target.

List Export Formats

Lists registered export codecs, file extensions, compile/export support, and availability under the native export action's condition. Use before `export_model` to pick a codec.

Export Model

Compiles the current project through a codec whose native export action is available. Returns JSON metadata and a live .bbmodel resource link; result_format='embedded' returns complete exports as text/blob resources with URI and MIME type. Optionally writes to a local path (requires Blockbench filesystem permission). Partial codec options merge over the configured defaults; for glTF armatures, options.merge_armature=true merges each armature's meshes into one SkinnedMesh. Use `list_export_formats` to discover codecs.

Undo

Undoes the most recent edit in the current project. Use `steps` to undo multiple edits in a single call. Returns the action(s) that were undone.

Redo

Redoes the most recently undone edit. Use `steps` to redo multiple edits in a single call. Returns the action(s) that were redone.

Get Undo Stack

Returns the current undo/redo history: the list of edit entries, the current index, and which entries are undone vs. applied. Use this to inspect available undo/redo operations and find named checkpoints.

Save Checkpoint

Inserts a named marker into the undo history. The marker can later be located with `get_undo_stack` so the agent knows how many times to call `undo` to return to this state. Does not modify the project.

Import GeoJSON

Imports one Bedrock geometry (.geo.json) into the current project, which keeps its format (one with bones: Bedrock, GeckoLib, generic, ...), as one undoable edit, and returns a screenshot. Adds the bones with their cubes, locators and texture meshes; the texture size, box UV mode and item display transforms it sets are undone with it, while the project's visible bounds can only grow. If the active project changes while loading, the import is rejected without modifying the new project. URLs on this computer or a private network are refused; pass a file path instead.

Get Face Material Instances

Gets the material instance names for cube faces. Material instances are used in Bedrock Block format to map faces to materials defined in the minecraft:material_instances component.

Set Face Material Instance

Sets the material instance name for one or more cube faces. Material instances are strings that map to materials defined in the minecraft:material_instances component for Bedrock Block format.

List Material Instances

Lists all unique material instance names used in the project. Returns the material instance names along with which cubes and faces use them.

Bulk Set Material Instances

Sets material instance names on multiple cubes at once. Useful for assigning different material instances to different faces across the project.

Clear Material Instances

Clears (removes) material instance names from cube faces. Useful for resetting material assignments.

Place Mesh

Creates meshes from local vertices and optional indexed triangle/quad faces, with position, rotation, and scale. Texture and group are optional. Returns meshes with UUIDs and vertex_keys/face_keys arrays in input order for subsequent editing.

Extrude Mesh

Extrudes the target mesh's selected face region along averaged normals, honoring distance. Returns new vertex keys and cap/wall face keys. Edge/vertex modes are unsupported.

Subdivide Mesh

Subdivides the target mesh's selected triangles/quads into a regular grid with interpolated UVs. Returns new geometry keys. Unselected neighboring faces remain unchanged and may need matching cuts.

Create Sphere

Creates a sphere mesh at the specified position with the given parameters. The sphere is created as a mesh with vertices and faces using spherical coordinates.

Select Mesh Elements

Selects vertices, edges, or faces of a mesh for manipulation. Keys the mesh does not have are rejected, except when removing them from the selection.

Move Mesh Vertices

Moves the given vertex keys, or the mesh's selected vertices, by the specified offset in one undo entry. Unknown keys are rejected before anything moves.

Delete Mesh Elements

Deletes selected components only from the target mesh. Vertex/edge deletion removes incident faces; keep_vertices retains vertices orphaned by face/edge removal.

Merge Mesh Vertices

Merges vertices that are within a specified distance of each other, in one undo entry. Each face keeps a surviving vertex once; faces the merge collapses (fewer than three vertices left) are removed.

Create Mesh Face

Creates a triangle or quad face from 3 or 4 distinct existing vertex keys, with an optional texture, in one undo entry.

Create Cylinder

Creates one or more cylinder meshes with optional end caps.

Knife Tool

Currently unsupported for meshes: Blockbench's interactive Knife context requires pointer topology that this point-list API cannot safely provide. Use subdivide_mesh or place_mesh for meshes; use knife_cut_cube or slice_cubes_to_block_grid to cut cubes headlessly.

Create Polyhedron

Creates icosphere, octahedron, or dodecahedron meshes (Blockbench 5.2 primitives) with a detail level of 0-6, as triangles with coincident vertices merged and planar per-face UVs. Returns vertex_keys/face_keys per mesh.

Loop Cut Mesh

Runs Blockbench's native Loop Cut on a mesh: splits the quad ring crossing the start edge with one or more parallel cuts, with offset, direction and 5.2 spacing modes (proportional, even_start, even_end). One undo entry. The new loop vertices become the selection and are returned.

Flip In Place

Mirrors elements in place along an axis using Blockbench's native Flip In Place (flip_in_place_x/y/z): cubes flip around their own center, meshes around their origin, groups also invert rotations in bone-rig formats. For meshes in vertex/edge/face selection mode only the selected components flip. Edit mode only.

Get Mesh Info

Inspects a mesh by UUID/name or the first selected mesh without changing geometry, selection, or undo history. Returns transforms, parent, total counts, mesh-local bounds, selection counts, and optional paginated vertices/faces with actual runtime keys. Faces use perimeter vertex order and normalized mesh-local normals (zero for degenerate faces), stored texture references, and optional UVs. Texture status distinguishes resolved, missing, unassigned (false), disabled (null), and unset; default format materials are not resolved. Pages sort keys lexicographically and expose next_offset; geometry must remain unchanged between calls. Set include_vertices/include_faces false for a compact summary.

Paint Fill Tool

Uses the fill/bucket tool to fill areas with color. In 'face' and 'element' fill modes only the face or element whose UV area contains the given texture pixel is filled, and a pixel no face covers is an error. Seeds outside the texture are rejected, and so are color and color_connected seeds outside the active layer, where the fill reads its seed color. Opacity is 0-255 regardless of Blockbench's opacity range setting.

Draw Shape Tool

Draws geometric shapes on textures.

Gradient Tool

Applies gradients to textures.

Color Picker Tool

Picks a texture pixel's color and makes it the primary or secondary color, like Blockbench's color picker. It does not edit the texture, but it changes the active colors, selects the texture, and depending on Blockbench's settings can set the brush opacity or switch the active paint tool.

Copy Brush Tool

Uses the copy/clone brush to copy texture areas.

Eraser Tool

Erases parts of textures with customizable settings.

Paint Settings

Configures paint mode settings and preferences, including Blockbench 5.2 screen-space brush projection, brush lock mode and brush aspect ratio. The result also reports the active opacity range (0-255 or 0-100); tool opacity parameters stay 0-255 and are converted automatically.

Paint with Brush

Paints with Blockbench's own brush tool, so blend mode, pixel-perfect drawing, lock alpha and mirror painting apply as when painting by hand. Given brush settings (opacity 0-255, softness 0-100%, hex or named color, shape, blend mode, aspect ratio) are set on the brush first; omitted ones keep the current brush. Paints on the selected pixel layer; if a layer group is selected, a pixel layer inside it is used.

Create Brush Preset

Creates a custom brush preset with specified settings. Omitted settings are stored as unset so loading the preset keeps the current value.

Load Brush Preset

Loads and applies a custom or built-in brush preset (e.g. 'screen_space') by name.

Texture Selection

Creates, modifies, or manipulates texture selections for painting.

Texture Layer Management

Lists, creates, manages, and reorders texture layers and layer groups (Blockbench 5.2 hierarchy). Target a layer or group by UUID or name with layer_id; list_layers reports type, parent and depth.

List Particle Presets

Lists particle effect presets (smoke, fire, sparks, magic, glow, snow, drip, ...), built-in sprites and textures, materials and facing modes. Every preset uses a texture that ships with Minecraft and Blockbench, so it previews and runs with no image file. Read this before create_particle_effect.

Create Particle Effect

Creates a Bedrock particle effect (the Snowstorm format Blockbench, Minecraft Bedrock and GeckoLib use) from a preset plus design knobs, or from raw JSON. Writes <pack_root>/particles/<name>.json (and an optional custom texture to textures/particle/), validates it, and loads it into Blockbench's particle preview. Then place it with manage_particle_keyframes, usually at a locator from add_locator. Refuses invalid effects and existing files unless overwrite is true. Blockbench desktop only.

Update Particle Effect

Changes an existing particle effect file with design knobs (only the components each knob owns are rewritten) or replaces it with raw JSON, validates it, saves it and refreshes the preview. Also loads an effect file from disk that Blockbench has not seen yet. Blockbench desktop only.

List Particle Effects

Lists particle effects loaded in Blockbench with their file, summary, texture status and validation warnings, every particle keyframe that uses them, keyframes that have no preview file or point at missing locators, and the client-entity particle_effects map a Bedrock pack needs.

Manage Particle Keyframes

Adds, removes or lists particle keyframes on an animation's Effects track. A keyframe spawns an effect at a time, optionally at a locator; Blockbench previews it in Animate mode (set_mode animate, then animation_timeline set_time and capture a screenshot). Keyframes export with Bedrock and GeckoLib animations. One undo step.

Add Locator

Adds a locator: a named point on a bone where particle effects (and sounds) spawn and which they follow as the bone animates. Exported as a Bedrock bone locator. Requires a format with locators (Bedrock Entity, GeckoLib, Generic Model). One undo step.

Export Particle Pack

Delivers particle effects to a Bedrock resource pack: writes particles/<name>.json and copies custom textures to textures/particle/, then returns the particle_effects map to paste into the client entity so animation keyframe names resolve. Defaults to every effect the project's keyframes use. Skips identical files; refuses to overwrite different ones unless overwrite is true. Blockbench desktop only.

Get Average FPS

Measures the average frames per second of Blockbench's render loop by counting rendered frames for duration_ms, then returns the average with the frame count, the fps_limit setting, Blockbench's own last-second counter, window focus at the start of the window plus whether it changed, whether the page was hidden, and whether rendering was paused. The call waits for the whole window; keep other tools idle meanwhile for a representative reading. A minimised or fully occluded Blockbench renders no frames and freezes its timers, so the call returns an empty window at once with document_hidden and rendering_paused set rather than waiting; bring the window to the foreground to measure a real frame rate.

Create Project

Creates a project with the given name and format, and returns a resource link to its live .bbmodel file.

Get Project Info

Returns read-only project orientation: format id and display name, project name/UUID, texture resolution (texture_width/height), element counts, and a summary of top-level groups. Includes structured JSON and a resource link to the live .bbmodel project file. Prefer this over `risky_eval` for first-look inspection.

Create Texture

Creates a new texture with the given name and size.

Apply Texture

Applies the given texture to the element with the specified ID.

Add Texture Group

Adds a reversible texture group. All texture references must exist. Material groups require one texture per channel, either normal or height, and a color map alongside a MER map; use is_material=false for ordinary grouping.

List Textures

Returns a list of all textures in the Blockbench editor.

Get Texture

Returns the image data of the given texture or default texture.

Create PBR Material

Creates a new PBR material (texture group with is_material=true) and optionally assigns textures to PBR channels. Requires a PBR-capable format, distinct textures per channel, either normal or height, and a color texture alongside a MER texture. Uniform values require the corresponding map to be absent. Creation and texture moves are one undoable edit.

Configure Material

Configures a PBR material in one undoable edit. Replaced maps are detached without deleting their textures. Use 'none' to clear a channel before using uniform values or switching between normal and height; a MER map requires a color map.

List Materials

Lists all PBR materials (texture groups with is_material=true) and their assigned textures per channel.

Get Material Info

Gets detailed information about a PBR material including the compiled texture_set.json preview for Bedrock export.

Import Texture Set

Imports a Minecraft Bedrock texture_set.json on desktop. Validates supported JSON and decodes referenced images before one undoable edit. Returns JSON with material name/UUID and path. Reuses already loaded image paths without deleting textures. Normal and height, or MER and MERS, cannot coexist; MER images require a color image.

Assign Texture Channel

Assigns a texture to one PBR channel in a single undoable edit. Detaches the previous map without deleting it or changing its channel. Normal and height cannot coexist; a MER map requires a color map, including in the source material after moving textures.

Save Material Config

Saves the material's texture_set.json file to disk (Bedrock format). Requires the color texture to have a valid file path.

Activate Texture

Activates the given texture in the Blockbench texture panel so that subsequent paint operations (draw_shape_tool, paint_with_brush, gradient_tool, etc.) target it. Most paint tools already call this internally when a texture_id is provided, but you can invoke it explicitly to pin the active texture across multiple calls.

Delete Texture

Removes a texture from the project in one undoable edit, like deleting it from the Textures panel. Faces keep their UV mapping but lose the texture assignment, and a PBR material loses that channel, until the edit is undone. Use list_textures to find IDs.

Trigger Action

Triggers an available Blockbench Action and respects its condition. The native action owns Undo; only a newly opened dialog may be auto-confirmed.

Eval

Evaluates JavaScript and returns its JSON result. Does not create an Undo entry. Mutating code must manage its own correctly scoped Undo transaction; read-only evaluation leaves history unchanged.

Emulate Clicks

Emulates clicks on the given interface elements.

Fill Dialog

Fills the dialog with the given values.

List Modes

Lists Blockbench editor tabs/modes with IDs, names, native availability, and the current mode. Includes plugin-added modes. Use before set_mode to discover whether Edit, Paint, Animate, or Display is available for the current project. Camera angles are controlled separately by set_camera_angle.

Set Mode

Switches Blockbench's editor tab through its native mode trigger, respecting the mode's condition. Use mode_id='animate' to enter Animate before animation work, 'paint' before native painting tools, or 'edit' to return. Returns the resulting mode and available modes; refresh tools/list for changed tool availability. Selecting the current mode does nothing. Does not change the project's format. When the user enabled the AI Scratchpad setting, mode_id='ai_scratchpad' relaxes the format's cube size, rotation and integer-size guardrails until another mode is selected.

Set Mesh UV

Sets UV coordinates for mesh faces or vertices.

Auto UV Mesh

Maps only the specified/selected faces of the target mesh. project uses the active camera, unwrap projects each face to its own plane, and cylinder/sphere map around the local origin using each face's logical texture UV size (project UV size for untextured faces). Coordinates are logical UV units, not necessarily bitmap pixels. This does not pack UV islands.

Rotate Mesh UV

Rotates only the target mesh's specified/selected faces around their combined UV bounding-box center, without clamping or changing selection.

Get Cube UV

Inspect a cube's UV mode, offset, mirroring, six face rectangles/rotations, stored and effective texture references, logical UV sizes and bitmap sizes. Read-only; no selection or preview changes.

Set Cube UV

Edit box UV offsets/mirroring or per-face rectangles, rotation and texture references in one reversible edit. Preserves untargeted faces and selection. Validates UV mode, texture references and rotation support. Hytale rectangles must retain geometry-linked extents and Auto UV; texture assignments use the project/attachment collection, and quads cannot use box UV. Does not pack islands or repaint textures.

Get GeckoLib Format Info

Returns the active GeckoLib project's model type, mod ID, object ID, bone and animation counts, cached export paths, and the installed plugin version. Requires the GeckoLib plugin and a GeckoLib Animated Model project.

Set GeckoLib Project Settings

Sets the GeckoLib mod ID, model type and object ID on the active project. Values are validated against the plugin's namespace rules before anything is written. Does not generate the armor template rig.

List GeckoLib Easings

Lists every easing name GeckoLib accepts on keyframes, which of them read easingArgs, and each argument's default and meaning. Needs no project, so it can be called while planning an animation.

Get GeckoLib Keyframe Easing

Reads the GeckoLib easing, easing arguments and interpolation of keyframes on one bone channel, or of the current timeline selection. An easing governs the segment arriving at its keyframe, so the first keyframe of a channel is reported as inert.

Set GeckoLib Keyframe Easing

Writes a GeckoLib easing (and its arguments) onto keyframes on one bone channel, or onto the current timeline selection, as one undoable edit. GeckoLib easings apply only to linear keyframes and shape the segment arriving at the keyframe they are set on, so the first keyframe of each channel is skipped and reported. Nothing in Blockbench's native keyframe API can author these.

Reverse GeckoLib Keyframe Easing

Reverses and shifts easings the way the GeckoLib plugin's handler for Blockbench's Reverse Keyframes action does: each easeIn becomes easeOut and back, every easing moves to the next later keyframe, and the first keyframe of each channel loses its easing. Use it only after keyframe times were reversed by something that left the easings in place, such as times rewritten with manage_keyframes. Do not use it after the native Reverse Keyframes action or batch_keyframe_operations reverse: with the GeckoLib plugin loaded, both already adjust the easings, so this tool would shift them a second time. It is not its own inverse; use undo to revert it.

Validate GeckoLib Model

Checks the GeckoLib project against rules derived from the plugin and the GeckoLib runtime: bone-name charset and duplicates, mod ID and object ID validity, armor template bones, texture size against the UV base, and (optionally) compiled animation loop values, easing names, easing arguments and lengths. Each finding carries a stable check ID. Passing does not prove in-game correctness.

Export GeckoLib Model

Compiles the GeckoLib geometry the plugin's model export produces, returning it as JSON and optionally writing it to a path. The text is formatted like Blockbench's own export (its JSON indentation, minify and final-newline settings). Set mode='dialog' to trigger the plugin's own export action and its save dialog instead.

Export GeckoLib Animations

Compiles the project's animations into GeckoLib animation-file JSON, including the easing and easingArgs the plugin writes, and optionally writes it to a path. The text is formatted like Blockbench's own export (its JSON indentation, minify and final-newline settings). Reports which host API compiled it, since only the plugin-patched route stamps geckolib_format_version. Set mode='dialog' to trigger the plugin's own animation export action instead.

Export GeckoLib Display Settings

Builds the Java item/block display-settings JSON for GeckoLib Item and Block models: parent model, texture size, GUI light, per-perspective display transforms and the namespaced particle texture. The text is two-space JSON, as the plugin's own display export writes it. The parent defaults to the plugin's builtin/entity, which Minecraft Java 1.21.4 and later no longer have; the result then warns, and parent picks another. Reports when the active model type would not normally ship one. Set mode='dialog' to trigger the plugin's own display export action instead.

Get Hytale Format Info

Returns information about the current Hytale format. Requires the Hytale plugin and a Hytale format project to be active.

Validate Hytale Model

Checks exported main-model node count using the installed Hytale codec and verifies bitmap dimensions are multiples of 32. Does not validate attachment exports, shading, all UVs, animation integration or target-engine rendering.

Set Hytale Cube Properties

Sets Hytale-specific properties on a cube: shading_mode (flat, standard, fullbright, reflective) and double_sided.

Get Hytale Cube Properties

Gets Hytale-specific properties from a cube (shading_mode, double_sided).

Create Hytale Quad

Creates a Hytale quad with exactly one enabled face matching the signed normal direction, per-face UV and Auto UV 1. Positive width/height and parent references are validated before one reversible edit.

List Hytale Attachments

Lists all attachment collections in the current Hytale project.

Set Attachment Piece

Marks or unmarks a group as an attachment piece. Attachment pieces attach to like-named bones in the main model.

List Attachment Pieces

Lists all groups marked as attachment pieces.

Create Visibility Keyframe

Creates a visibility keyframe for a bone. Hytale supports toggling node visibility at keyframes.

Set Animation Loop Mode

Sets the loop mode for a Hytale animation. Hytale supports "loop" (continuous) or "hold" (freeze on last frame).

Set Cube Stretch

Sets the stretch values for a cube. Hytale uses stretch instead of float sizes for better UV handling.

Get Cube Stretch

Gets the stretch values for a cube.