Macros

If you wish to automate tasks or set up a specific join flow, this is the right place. Macros are built on a visual canvas: pick the event that starts the flow, then chain the steps it runs, left to right. A simple macro is an event and a couple of steps; a bigger one repeats a group of them, or takes one path rather than another depending on what the bot can see.

Events

An event is what starts a macro. When it is detected, the flow runs.

Join and World change are on every plan. Every other event needs Tier 3: it sits in the picker tagged "Tier 3", and picking it takes you to your plan rather than selecting it.

• Join (a bot joins the server)
• Disconnect (a bot loses its connection, or is disconnected)
• World change (switching world or dimension)
• Timer (repeatedly, on an interval counted from when the bot connected)
• Schedule (at a time on the clock, once or every few hours, days or weeks)
• Death (a bot dies)
• Chat message (a received line matches your text or your regex)
• Damaged (a bot takes damage)
• Mob appears, Mob leaves (a matching mob comes into or goes out of view)
• Player appears, Player leaves (a player comes into or goes out of view)
• Player joins (a player enters the server)
• Inventory full (the last free inventory slot is taken)
• Item appears, Item disappears (a matching item turns up, or is used up, dropped or broken)
• Teleported (the server moves a bot a long way)
• Window opens (a chest or menu screen opens)
• Sign opens (the sign edit screen opens)
• Dialog opens (the server opens a dialog)
• Bot stops moving (a bot has held still for a moment)

Timer and Schedule are the two clock-driven ones, and the difference is worth keeping straight: Timer counts an interval from whenever the bot connected, while Schedule lands on the wall clock, so 15:00 is 15:00 however long the account has been up.

Disconnect is the one event that limits what the flow can do. The bot has already gone by the time it fires, so only Discord webhook steps run: there is nothing left to click, type or walk with.

Actions

Add steps with the plus button at the end of the flow, or with the one on the line between two steps to put a step between them; they run in the order they are connected. Each step waits before it runs, one second by default, and that wait takes a random range as well as a fixed number, so a flow need not run to the same beat every time.

Clicking

• Left click once (hit a mob, mine a block, or swing at air)
• Hold left click (keep left clicking until released)
• Release left click (let a held left click go)
• Right click once (place, use, or interact with what is ahead)
• Hold right click (keep right clicking until released)
• Release right click (stop using: fires a drawn bow, lowers a shield)

A left click aimed at a block holds the flow until the block has finished breaking, so the step after it starts from a hole rather than from a block that is still there, and its own wait is counted from the break. Nothing else waits: hitting a mob and swinging at air are over the moment they happen.

Inventory

• Use GUI (click a slot in an open container, such as a chest or a furnace, or name an item and let the bot find it)
• Use inventory (click a slot in the bot's own inventory, or name an item)
• Close GUI (close an open container)
• Hold item (switch to a specific item, or to a hotbar slot)
• Swap hands (swap the main hand and off hand)
• Drop (drop a specific item, one or a whole stack)
• Drop all (drop the whole inventory, or only items matching a name)

Movement

• Move (walk forward, back, left or right)
• Look (aim by dragging a head around a compass, by preset, or by typing a yaw and pitch)
• Look at entity (turn to a player, a mob or a named entity, wherever it happens to be)
• Look at block (turn to the nearest block of a type you name)
• Sneak once (one crouch tap, the way tapping shift does)
• Hold sneak (crouch, and stay crouched)
• Release sneak (stand back up from a crouch)
• Jump once (one hop, the way tapping space does)
• Hold jump (keep jumping until released)
• Release jump (let a held jump go)

Other

• Chat (send a message or command)
• Discord webhook (post to a Discord channel, Tier 3)
• Write on sign (fill in the sign edit screen the server opens)
• Wait (pause before the next action)
• Wait for (hold until something happens, rather than for a length of time)
• Reconnect (log the account off and back on, which ends the flow)
• Disconnect (log the account off)
• Panic logout (look around in a panic, then log off)

Logic

• Repeat (run a group of steps more than once)
• If (send the flow one of two ways)
• Restart macro (go back to the first step and run it all again)
• Go to step (jump to any step, forwards or back)

Use GUI and Use inventory both let you name an item instead of counting a slot, which is what you want when the slot isn't predictable (a shop menu, a chest someone else fills). The bot finds it for you: it looks through any open container first, then the bot's own inventory, and the step's Target setting picks the first match, the last, or every one of them. Because the search covers both windows, a step set to an item reads as Use GUI whichever of the two you started from.

One step can also click a whole run of slots, left and right button mixed. Click them in the grid in the order the bot should click them, right-clicking the ones it should right click, or type the run into the slot field: 13L, 14R, 13L left clicks slot 13, right clicks slot 14, then left clicks slot 13 again. A slot may appear as often as you need it to, so a run is a list of clicks rather than a set of slots. The other actions (shift left, the two drops, and the two hotbar ones) stay one per step.

Signs

Placing a sign is an ordinary right click, but the game then opens its edit screen and waits for the four lines. Write on sign is the step that answers it, so a flow that puts a shop sign up is Hold item, Right click once, Write on sign.

It writes whichever sign screen is open, because that is all the game gives it: there is no way to name a sign by its coordinates, only to answer the one in front of you. Put the step after the right click that places the sign, and give that click enough of a delay for the screen to arrive. With no screen open the step is skipped and the macro carries on.

Leaving all four lines blank is a real step rather than an unfinished one. Minecraft has no cancel on that screen, so something has to answer it, and blank lines are what a sign you walk away from ends up saying anyway.

Clicking

The six click steps are the two mouse buttons, and they do exactly what those buttons do in the game. Nothing asks you what you are clicking at: the bot looks at what is in front of it and what is in its hand, and the game decides, the same way it does for you.

So a left click hits the mob in front of it, or mines the block in front of it, or swings at air. A right click places the block it is holding, opens the door in front of it, feeds the animal, eats the food, casts the rod. You do not pick which one, because a player does not either.

Nothing aims for you, so put a Look step in front of a click to point the bot at what you want. To place or use a specific item, put a Hold item step in front to switch to it first; the item has to be in one of the nine hotbar slots, since that is where a player switches from.

Holding a button

Hold left click and Hold right click press the button and keep it pressed, which is a different thing from clicking quickly in a loop:

• Holding left click chains from one block into the next, each block taking its own full mining time, and keeps hitting a mob at the normal swing rate.
• Holding right click clicks at the same rate a real player's mouse does, and watches what the bot is holding so it does not interrupt itself. Food and potions are eaten one item at a time rather than restarted, and an item that charges up (a bow, a shield, a spyglass) is pressed once and stays pressed.

A hold stays on between passes, which is the point of it: an AFK macro that holds left click on join keeps mining without running again. Add the matching Release step where you want it let go part way through a flow.

The two holds need Tier 3; the single clicks and the two releases are on every plan. On a lower plan they stay in the step picker tagged "Tier 3", and picking one takes you to your plan rather than adding it, the same as the Logic steps.

Older macros may still contain Attack, Break block or Place block steps, from before the clicks were simplified. They keep working and stay editable, but they are no longer offered as new steps: the six clicks above cover what they did.

Holding a key

Sneak and jump are split the same way the mouse buttons are, three steps each: tap the key once, hold it, or let it go. There is no state to set inside the step, because the step you picked is the state.

A held key stays down between passes, so a flow that crouches on join leaves the bot crouching without running again. Add the matching Release step where you want it let go part way through a flow.

Sneak once and Jump once are the single taps: press the key and let go, the way you would tapping shift or space. Nothing is left held afterwards, so neither needs a Release step after it. Sneak once does nothing while the bot is already crouching, since there is no key left to press, and Jump once needs physics on, the same as Hold jump.

Macros built before the split keep working: a Sneak step set to start becomes Hold sneak, one set to stop becomes Release sneak, and the same for jump.

Release when the macro stops

Every hold step (Hold left click, Hold right click, Hold sneak, Hold jump) carries one checkbox: Release when the macro stops.

Stopping is not the same as the flow reaching its last step. A macro stops when one of its stop conditions stands it down, when a Panic logout step runs, or when you turn the macro off. Between passes the hold stays down either way, so an AFK flow that holds and never releases keeps working.

It is on by default for Hold left click, Hold right click and Hold jump. A bot still swinging, still placing or still hopping after its macro has stopped is doing it for nobody, and leaving a button down is how an account carries on mining in front of the player who just walked up.

Hold sneak is the exception, and it is off by default. A crouch is usually a position rather than an activity: an account parked in a one-block hole, name plate hidden, unable to walk off the ledge. Standing it up because a stop condition fired would move an account you put there deliberately. Tick the box on a Hold sneak step if you would rather it stood up.

Either way, nothing brings a hold back on its own. A macro that stood down and released the button starts clean on its next trigger.

Waiting for something

Wait pauses for a length of time you pick. Wait for holds until something actually happens, which is usually what you meant: a fixed wait is a guess at how long the server will take, and a guess that comes up short is what has the next step clicking a menu that has not opened yet.

Pick what it waits for from "Wait until". It offers the events the bot watches for itself, so it can hold for a chat line, damage, a mob or a player coming into or going out of view, a player joining, the inventory filling, an item turning up or running out, a teleport, a chest or menu screen, a sign editor, a dialog, or the bot settling to a stop. Each one takes the settings it takes as an event, so a Chat message wait matches your text or your regex exactly the way the trigger does.

The six the connection or the clock decides are not on that list: Join, Disconnect, World change, Timer, Schedule and Death. Those happen to the account rather than in front of the bot, so there is nothing for a step to sit and watch.

Two settings belong to the wait rather than to the thing waited for:

• Give up after bounds it, thirty seconds by default and an hour at most. There is deliberately no "wait forever": a wait for a screen that never opens would be a pass that never ends, holding a bot no other macro on the account could then run.
• Stop the macro if it never happens decides what a lapsed wait does. Left off, the flow carries on to the next step anyway, which is right for "give the GUI a moment, then click regardless". Turned on, the macro ends there, which is right for the step whose whole point is that nothing after it should run without it.

Wait for is on every plan, even though most of the events it can wait on need Tier 3 to start a macro with. Waiting on a chat line partway through a flow is a different thing from being allowed to start a flow from one, so a Join macro on any plan can watch for something in the middle of its run.

Panic logout

A plain Disconnect drops the connection mid-stride, which is not what a player does when they decide to leave in a hurry. Panic logout is the same log-off done the way a person does it: the bot whips its head around a few times, checking what is behind it, and then goes.

It turns the head and nothing else. The account does not take a step, so it logs off from exactly the block it was standing on, which is what makes this safe to put on an account parked somewhere on purpose.

It is one step with nothing to set. Everything about it is improvised by the bot at the moment it runs, so the same macro never leaves the same way twice: a different number of turns, different directions, a different rhythm. There is no seed to save and no pattern to spot, which is the whole point of it. The only setting it has is the one every step has, the wait before it starts.

Reconnect

Reconnect is the third way to log an account off, and the one that arranges the trip back before it goes: the account drops and then comes straight back on. Like Disconnect it is one step with nothing to set, and like Disconnect it is on every plan.

It ends the flow. The log-off it drives is the ordinary one, so it clears everything queued on that connection, which means a step drawn after a Reconnect never runs. That is not a gap waiting to be closed; there is no pass left to carry on with once the connection it belonged to is gone. Put the Reconnect last in the flow, and put whatever should happen once the account is back into a macro of its own.

Repeat, If, Restart macro and Go to step

The Logic steps change the shape of the flow instead of doing something in the game, and every one of them needs Tier 3, the plan that includes advanced macros. On a lower plan they stay in the step picker tagged "Tier 3", and picking one takes you to your plan rather than adding it.

Repeat and If each arrive as a pair of cards, the step itself and the End repeat or End if that closes it, with the steps it covers between them. Fill that middle with the plus button on the line running between the pair; an If has one such line per branch. Deleting either card of a pair deletes both, and the steps that were inside are kept. Pairs can sit inside each other up to three levels deep.

Repeat runs the steps inside it more than once, and the first thing to pick is what ends it:

• A set number of times, the count you type
• Forever, for as long as the account stays connected
• While a check passes, tested before each pass, so the steps inside may not run at all
• Until a check passes, tested after each pass, so the steps inside always run at least once

The two checked modes can also take a ceiling ("Stop after at most"), which is off by default; with one set, the loop ends on whichever comes first, the check or the ceiling. "Delay between loops" is the pause at the end of every pass before it goes round again, one second by default, so a loop can be paced without a Wait step inside it. A loop with nothing to stop it on its own, meaning Forever or a checked loop with no ceiling, runs each step inside it at most once a second however short the waits are; set longer waits for a slower loop. Nothing after a Forever loop ever runs, so put the rest of the macro before it.

If sends the flow one of two ways. Set the check and the card gets two ways out: Yes when it passes, No when it does not. Both rejoin at the End if, so only one of them ever runs. A check the bot cannot answer, or one you have not finished filling in, counts as No.

The same check list serves both, and every one of them can be picked:

• What the bot is carrying: Has an item (optionally some number of them), Item is gone, Slot holds item, Slot is empty, Inventory full
• What is on screen: Window is open, Sign is open, Dialog is open, the last two optionally matching their text
• Who else is about: Entity in view, Entity is gone, Player is online
• The bot's own state: Health is low, Near a spot, Block in range, In a world

A check reads a state, which is what separates it from the event of a similar name: Item appears starts a macro at the moment one arrives, while Has an item asks whether one is there right now.

There is no "It is NOT true" switch. Swap the two branches instead, which says the same thing and reads the way the card is drawn. A macro saved with the old inverted setting still runs the way it always did, and its check shows a warning with a button to clear the inversion for good.

Restart macro sends the flow back to the first step and runs the macro again, for as long as the account stays connected. It is one card on its own rather than a pair, and nothing drawn after it ever runs, so it belongs at the end of a flow or at the end of a branch.

It overlaps with a Forever loop without being the same step. A Forever loop has to enclose everything it repeats, so repeating the whole macro means drawing a region around every card, where this says it in one. The difference that matters more is that it can be reached from inside a branch, which a loop cannot: "if the chest came back empty, start over" is a jump out of the region it sits in, and a pair of cards cannot express one. The wait on the card is the pause before it goes round, one second by default, and because nothing stops it on its own each step runs at most once a second however short the waits are.

Go to step is the same jump with the destination up to you. Pick any step in the flow and the macro carries on from there, whether that is back to an earlier one ("if the chest is empty, go back to the walk") or forwards past steps that no longer apply ("if the shop is closed, skip to the logout"). Like Restart macro it is one card on its own, and nothing drawn after it ever runs.

Two things are worth knowing before you build around it. It leaves any Repeat or If it is drawn inside: the flow picks up at the step you chose with no loop running, so it moves you around the macro rather than skipping one turn of a loop. Aim it at the Repeat card itself and that loop runs again from the top, count and all. And a jump backwards is a loop with nothing to stop it, so each step runs at most once a second however short the waits are, exactly as in a Forever loop.

If the step you aimed at is deleted, or dragged off the flow, the jump says so on its card and the macro will not save until you point it somewhere else. That is deliberate: a jump aimed at nothing does not fail, it quietly stops being a jump, and the flow runs on past it.

Building a flow

Every macro runs on the accounts you choose (all of them, or a subset). Add a macro from the Macros page, pick its event, then build the flow with the plus button at the end of the chain. Select any step to edit it in the side panel, and drag steps around to arrange the canvas however you like; the connections decide the run order. A step dragged off the flow is parked rather than deleted: it reads "Not connected" and does nothing until you wire it back in.