Sync: Create event-driven automations without code

Sync is a Minecraft Bedrock addon that lets you build powerful rules: listen to hooks, check conditions, and run actions all through in-game menus and custom UIs. No coding required. Fully developed and maintained by ExterLeo.

Join Discord: https://discord.gg/dWS69pE3qj

Updated: December 22, 2025

New on v1.3: 13 Hooks + QOL Improvements

Beginner friendly Event-driven Custom UI Variables & conditions Protection regions

Quick start

  • Open help: Use /synchelp to open the help menu in-game.
  • Main menu: Use /menu to manage folders, functions, and UIs.
  • Loops: Use /loops for periodic actions.
  • Debugging: Use /console to view recent command errors.
Start with a “Test” folder. Build a simple function (e.g., Item Use → apple → message), then expand.

Minecraft-style formatting

§l§bSync Help Menu · §8Folders · §3Overview · §4Close
The website uses modern styling, but in-game texts can use § codes. You can preview colors above.

Overview

Foundations

What is Sync?

Sync is a Bedrock addon for building “if-this-then-that” automations. You use menus to define rules (functions), each triggered by a hook (event), optionally gated by conditions, and executed as actions (messages, commands, variable updates, or custom UI).

  • Folders: Organize functions, variables, and loops.
  • Functions: The rules you create; each has a hook and actions.
  • Hooks: Triggers like Item Use, Block Break, Chat, Entity Hurt/Die and many more...
  • Events: Phases (before/after) that control timing and cancellation.
  • Variables: Numeric storage (global/world or local/per-player per-folder).
  • Custom UI: ActionForm/ModalForm to let players choose outcomes.
  • Loops: Periodic actions every N ticks (no conditions/UI).

Getting started

  1. Open /menu: Create a folder (e.g., “Test”).
  2. Create function: Name it, pick a hook (e.g., Item Use), set inputs (e.g., apple).
  3. Add actions: Message: “You used an apple!” or command.
  4. Test in-game: Use the item; verify behavior. Use /console for errors.
Example: Apple boost

Item Use → apple → after → message + command

Hook: Item Use (after)
Inputs: apple
Actions:
 - message: "You munched an apple! {player} gets SPEED."
 - command (player): effect @s speed 10 1
Think of Sync like spreadsheet rules: “When X happens and Y is true, do Z.” You don’t need to write code; menus and forms guide you.

Folders

Organization

What are folders?

Folders are containers for functions, variables, and loops. They help you keep large setups tidy and enable local (per-player) variable scoping per folder.

  • Structure: Each folder has its own function list, local variables, and optional per-player loops.
  • Scoping: Local variables are stored per-player per-folder.
  • Management: Create, rename, delete; resetting storage affects variables inside.

How to manage folders

  1. Open /menu → Folders.
  2. Create: Enter a unique name (e.g., “Farming”).
  3. Delete: Confirm; removes contained functions/variables.
  4. Rename: Choose new, conflict-free name.
  5. Inside: Add functions, create/delete variables, reset storage.
Example: Combat vs Farming

Use folders to separate logic domains.

Folders:
 - Combat: mob rules, kill counters, boss events
 - Farming: crop harvesting rewards, tool wear tracking
 - Economy: shop UI, currency storage, trades
 - Admin: protections, broadcasts, moderation tools
Start with a “Test” folder to experiment safely before committing to production structures.

Functions

Rules

What is a function?

A function is a user-defined rule: it listens to a hook, optionally checks conditions, and performs actions (messages, commands, variable changes, or custom UI).

  • Trigger: A hook and optional event phase.
  • Inputs: Filter items/blocks/entities/chat for precise matching.
  • Conditions: Built-ins and variable expressions gating execution.
  • Actions: Messages, commands, variables, or present custom UI.

Create and edit

  1. Path: /menu → Folders → select/create folder → Create Function.
  2. Name: Unique identifier (e.g., “HealOnApple”).
  3. Hook: Choose trigger.
  4. Inputs: Configure items/blocks/entities/chat filters.
  5. Event: Choose before/after if available.
  6. Conditions: Add built-ins and variable conditions.
  7. Actions: Add messages/commands/variable changes/custom UI.
Example: HealOnApple

Reward on item use.

Name: HealOnApple
Hook: Item Use (after)
Inputs: apple
Conditions: isOnGround
Actions:
 - message: "Apple used by {player}."
 - command (player): effect @s regeneration 6 1
Treat functions like recipes: hook = trigger, inputs/conditions = filters, actions = outcome.

Hooks

Triggers • 21 Total

Available hooks

  • Item Use - Right-click air with an item (before/after)
  • Item Start Use - Begin charging bow, shield, crossbow, goat horn, etc (after only)
  • Item Stop Use - Stop charging (cancelled/interrupted) (after only)
  • Item Start Use On - Start using on block (bone meal, flint & steel, hoe) (after only)
  • Item Stop Use On - Stop using on block (after only)
  • Item Complete Use - Finish eating food, drinking potion, chorus fruit, etc (after only)
  • Item Release Use - Release charged bow, trident, etc (after only)
  • On Hold - Fires every tick while holding an item (after only)
  • Player Break Block - Player breaks a block (before/after)
  • Player Place Block - Player places a block (before/after)
  • Player Interact With Block - Right-click door, chest, button, lever, etc. (before/after)
  • Entity Die - Any entity dies (after only)
  • Entity Hurt - Any entity takes damage (after only) before event is coming soon!
  • Entity Spawn - Mob, item, projectile, armor stand, etc spawns (after only)
  • Entity Remove - Entity is deleted from the world (before/after)
  • Entity Hit Block - (after only)
  • Player Interact With Entity - Right-click villager, armor stand, boat, minecart, etc. (before/after)
  • On Chat - Player sends a message (before/after)
  • Player Join - Player joins the world (after only)
  • Player Leave - Player leaves the world (after only)
  • Player Spawn - Player spawns or respawns (including first join) (after only)

Built-in special conditions

region <name> - True when the event happens inside a protected region created with /sync:region
atLocation <x y z> - Event occurs at exact coordinates

Pro Tips:
• Use before phases to cancel/prevent actions (anti-grief, permissions)
• Use after phases for rewards, logging, effects
• Entity Hit Block + Player Break block + Player Place Block + Player Interact With Block + region = perfect for region protection
• Player Interact With Entity + before = custom NPC dialogues, shops, quests!
NEW IN v1.3 - 13 new hooks • Full projectile & player tracking

Events

Before/After

What are event phases?

Some hooks have phases: before (right before the action completes) and after (after it completes). Before-phase can cancel default behavior; after-phase is for rewards, logs, and follow-ups.

  • Before/After: Item Use, Break Block, Place Block, On Chat.
  • After only: Entity Hurt (damage already applied), Entity Die.

Choosing a phase

  • Before: Run checks or cancel the action (protection).
  • After: Run rewards, logging, variable tracking.
If unsure, choose “after” since it’s safer and easier to reason about.

Conditions

Checks
Built-in player states

Use these to check the player’s current status:

  • isSneaking, isSprinting, isSwimming, isFlying, isGliding
  • isJumping, isFalling, isOnGround, isInWater, isSleeping, isClimbing, isEmoting
Death & damage causes
  • KilledByPlayer, KilledByEntity, KilledByEnvironment
  • CauseLava, CauseFall, CauseFire, CauseExplosion
  • HurtByPlayer, HurtByEntity, HurtByEnvironment
Special: regions

region <name> is true when the actor/event is inside a defined region created via /region.

Special: Distance to point

DistanceToPoint <max> <x> <y> <z> – true when the player is within max distance of the point.

Example: DistanceToPoint 5 0 64 0
Useful for area-based triggers without regions.
Special: Distance to player

DistanceToPlayer <max> <name> – true when the player is within max distance of another player.

Example: DistanceToPlayer 10 Steve
Great for team-based or proximity events.
Special: At Location

atLocation <x y z> – True only if the event happens at the exact block coordinates.

Example: atLocation 10 54 -3
Works perfectly with Player Interact With Block, Break/Place Block, and any hook that has a block location.
Combine built-in conditions with variable conditions for precise behavior and protection logic.

Inputs

Items, blocks, entities, chat

What are inputs?

Inputs filter which item/block/entity/chat message triggers the function. They work consistently across hooks and support AND/OR logic with concise syntax.

  • Comma (,): OR - any one can match.
  • Plus (+): AND - all parts must match.
  • IDs: Short (e.g., stone) or full (minecraft:stone).
  • Names/lore: Item/block/entity names and lore can be matched.
  • any: Matches everything.

Examples

stone,dirt,oak_log # any of these
diamond_sword + legendary # sword AND display name/lore contains "legendary"
excalibur + sharp + epic, wand_of_healing
                              # EITHER sword that contains all three words OR a healing wand
zombie + boss, minecraft:skeleton
                              # boss-tagged zombie OR any skeleton
hello+world, hi there
                              # chat must contain both "hello" and "world" OR exact phrase "hi there"
Start with any to validate your function triggers, then narrow filters to the exact cases.

Messages

Feedback

What are messages?

Messages are chat text sent when a function or loop runs. Use placeholders to include dynamic data from the event context and variables.

  • Multiple messages: They are sent in the order listed.
  • Formatting: Use Minecraft color codes (e.g., §e) for styled text.
  • Debug: Messages are great for testing triggers and inputs.

Example

Function editor → Messages → Add:
"You broke a {broken block}! Score: {score}"
Use messages first to confirm behavior before adding commands.

Commands

Actions

What are commands?

Minecraft commands executed when a function or loop triggers. Enter them without a leading slash. Choose the executor: console (server) or player (triggering user/@s).

  • Console executor: World-level operations.
  • Player executor: Acts as the triggering player (or per-player loop actor).
  • Loops: Player executor requires per-player loops.

Example

effect {player} speed 10 1
Test commands manually in chat first. Use console for global changes and player for personal effects.

Variables

Numbers & storage

What are variables?

Variables store numeric values and are used in messages, commands, and conditions. You can add, remove, set, or reset them; missing variables default to 0.

  • Global: Shared across the world.
  • Local: Per-player inside a folder.
  • Fallback: Placeholders prefer local; if none, they fall back to global.

Managing variables

  1. Create/register: Folder editor → Create Variable (name, scope).
  2. Use in actions: add/remove/set/reset in function editors.
  3. Delete/reset: Delete variable or reset folder storage.
Example: Wheat counter
Hook: Player Break Block (after)
Inputs: wheat
Action: add local 'wheatbroken' by 1
Message: "Wheat broken: {wheatbroken}"

Placeholders

Dynamic values

What are placeholders?

Insert runtime values in messages, commands, and expressions using curly braces, e.g., {player}, {item_name}, {kills}. Modal UIs use {value} for user inputs.

  • Player: {player}, {player health}, {player maxhealth}
  • Items: {item}, {item_name}, {item_lore}, {raw item}
  • Blocks: {broken block}, {placed block}, {interacted block}, {block_name}, {raw block}
  • Entities: {dead entity}, {entity_name}, {raw victim}, attacker fields
  • Combat: {damage}, {damage cause}, {killer}
  • Coords: {x}, {y}, {z}
  • Variables: {varname} resolves local first, then global.

Examples

Message: "§c{player} broke {block_name} at {x} {y} {z}"
Command: "title {player} actionbar "Zombies killed: {zombiekills}""
Condition: "{item_name} contains "legendary""

Globals vs locals

Scoping

Globals

  • Shared: Same value for everyone.
  • Use for totals: e.g., total diamonds mined.
  • Stored: In world data.

Locals

  • Per-player, per-folder: Each player has their own value per folder.
  • Use for personal scores: e.g., player kills, playtime.
Placeholder resolution
{varname} → if local exists in folder, use it; otherwise use global

Variable conditions

Expressions

What are variable conditions?

Expressions that evaluate to true/false to gate (require) or cancel functions. They support numeric comparisons and string checks, plus truthiness.

  • Numeric: <, <=, >, >=, ==, !=
  • String: contains (case-insensitive)
  • Truthy: {flag} true if non-zero/non-empty

Modes and examples

  • Require: expression must be true to continue.
    {kills} > 5
    10 == {level}
    {item_name} contains "magic"
  • Cancel: expression true will cancel the event (only valid in before hooks).
    Cancel if "{protected} == 1"
    Cancel if "{vip} != 1" in region "vipzone"
Combine variable conditions with built-ins (e.g., isSneaking) to craft precise rules.

Random Variables

Dynamic randomness

What are Random Variables?

Random variables let you define dynamic random values that can be used with {name} in messages, commands, or variable conditions.

They are created and managed in the Folder Editor → "Create Random Var".

Supported formats

1-100 → random integer from 1 to 100
stone,dirt,oak_log → picks one item/block/entity
10%,50%,40% → weighted chance (must add up to 100%)
hello world, hi, hey! → random text phrase

Examples

{rarity} = common,70%,rare,20%,epic,9%,legendary,1%
      {damage} = 5-12
      {greeting} = Hello,Hi there,Hey!
Perfect for loot tables, random events, RPG damage, greetings, and anything that needs controlled randomness!

Execution flow

Engine lifecycle

What happens when an event fires?

  1. Event fires: e.g., item use, block break, chat.
  2. Function discovery: Sync finds matching functions for the hook and phase.
  3. Inputs check: IDs, names, lore, chat text.
  4. Built-in conditions: Player state checks, causes.
  5. Variable conditions: Evaluate require/cancel expressions.
  6. Custom UI: If present, show forms; execute actions per interaction.
  7. Actions: Otherwise, apply variables/messages/commands in order.
Multiple functions can match and run sequentially. Loops run independently on intervals; they don’t support conditions/UI/cancellation.

Custom UI (Beta)

ActionForm & ModalForm

What is custom UI?

Interactive forms shown instead of direct actions. They are available in functions (not loops). Use ActionForm for buttons and ModalForm for inputs.

  • ActionForm: Buttons; each triggers actions (message, command, variables, cancel, open another UI).
  • ModalForm: Input fields; on submit, run actions using {value} placeholders.

Example: Shop UI

Hook: Item Use (after)
Input: emerald
Custom UI:
 - ActionForm "Shop"
   * Button: "Buy Sword (10 emeralds)"
     Actions:
       - command (player): give @s diamond_sword 1
       - variable (local): set 'emeralds' to {emeralds} - 10
Custom UI replaces direct actions for that function; players choose outcomes interactively.

Event cancellation

Protection logic

What is cancellation?

In before phases you can prevent default actions (stop place/break/use). Cancellation can be done via UI (“cancel”) or variable conditions in cancel mode.

  • Works for: Item Use (before), Player Break (before), Player Place (before), On Chat (before).
  • Not available: after-phase hooks, Entity Hurt (after), Entity Die (after).

Example

Hook: Player Place Block (before)
Condition: region spawn
Var condition (cancel): "{protected} == 1"
Implement regions, permissions, item restrictions with cancellation to keep worlds safe.

Loops

Periodic actions

What are loops?

Loops run every N ticks (1 tick ≈ 0.05s; 20 ticks = 1s). Useful for timers, counters, and repeated effects. They don’t support conditions, UI, or cancellation; they simply run actions.

  • Scope: Global (once per interval) or per-player (for each online player with folder locals).
  • Per-player executor: Commands can run as the player when supported.

Managing loops

  1. Open /loops: Loops menu.
  2. Create: Name (unique), interval (ticks).
  3. Folder: Optional; required for per-player scope.
  4. Scope: Choose global or per-player.
  5. Edit: Rename, change interval, change scope/folder, edit actions.
Examples
# Global day counter
Interval: 24000
Action: add 1 to global 'days'
# Per-player playtime
Folder: Stats
Interval: 20
Action: add 1 to local 'playtime'
Avoid very small intervals (<5 ticks); they may cause lag. Test changes in a safe world.

Protection regions

/region

What are regions?

Simple cuboid protection regions that block placing/breaking inside defined areas using the region <name> condition.

Commands

/region selection # clears current selection
(Left-click to set Pos1; Right-click to set Pos2)
Optional: /region expand # expands vertically from -64 to 319
/region create <name> # saves the region
/region list # shows all regions
/region reveal <name> # outline with particles
/region delete <name>

Use in functions

Hook: Player Place Block (before)
Condition: region spawn
Result: Player cannot place blocks in region "spawn"
Ranked zones
Condition: region adminzone
Var condition (require): "{rank} == admin"
Use /region reveal <name> to visually confirm borders during setup.

Error console

Debugging

What is the error console?

A Sync menu showing recent command errors. Whenever a command fails (typo, missing target, invalid syntax), Sync logs the error here.

  • Visibility: A list of errors with time and command label.
  • Details: Clicking an entry shows the full error message.
  • Retention: Most recent errors are stored (configurable).

How to open and read

/console # open error console
/synchelp # help menu (may include link to console)
  • Button: One entry per error.
  • Label: Shows time and command.
  • Chat: Clicking reveals the message.
Use console often while testing new rules; repeated errors usually indicate variable misconfiguration or syntax issues.

/variable command

Direct variable control

What is /variable?

Directly modify stored variables. Variables are numeric; you can increase, decrease, set, or reset them.

Syntax

/variable <add|set|remove|reset> <local|global> <folder> <varname> [player] [amount]
  • local: scope requires a player (executor or specified).
  • global: shared across world.
  • amount: defaults to 1 for add/remove.
  • reset: ignores amount and sets value to 0.

Examples and tips

/variable set global stats diamondbreak 100
/variable add local stats diamondbreak Steve 1
  • Per-player counters: Use locals for kills/blocks broken.
  • Shared stats: Use globals for world totals.
  • Combine: Use variable conditions like {kills} > 10 to gate rewards.

/varlist command

Inspection

What is /varlist?

Shows variables inside a folder, either global or local.

Syntax

/varlist <local|global> <folder> [player]
  • local: requires a player (executor or specified).
  • global: lists shared folder variables.
  • Output: Names with current values.

Examples and tips

/varlist global stats
/varlist local stats Steve
  • Debug changes: Run after /variable to confirm updates.
  • Check counters: Useful for scores, storage values.

/broadcast command

Global messaging

What is /broadcast?

Sends a message to all players in the world.

Syntax

/broadcast [message]

Example

/broadcast "Welcome to the server!"

Tips

  • Announcements: Use for server-wide notifications.
  • Quoting: Wrap the message in quotes.
  • Tag: Messages can show a broadcast tag if configured.

/send command

Whispers

What is /send?

Sends a private message to a specific player.

Syntax

/send <player> [message]

Example

/send Steve "Hey, want to team up?"

How it works

  • Visibility: Only the target sees the message.
  • Confirmation: Sender may get delivery confirmation if implemented.
  • Exact name: Type the precise player name or use {player}.

Tips, examples & best practices

Playbook
Pro tips
  • Validate with messages: Test logic before adding commands.
  • Use /console: Debug failed commands instantly.
  • Name logically: Folders like Combat, Farming, Economy, Admin.
  • Scope smartly: locals for per-player stats, globals for totals.
  • Intervals: Small loop intervals (<5) can cause lag.
  • any input: Matches everything; great for testing triggers.
  • Region reveal: /region reveal <name> to verify borders.
Real-world examples
1) Auto-Farm Reward

Track wheat break count and provide feedback.

Hook: Player Break Block (after)
            Input: wheat
            Action: add local 'wheatbroken' by 1
            Message: "Wheat broken: {wheatbroken}"
2) VIP Only Zone

Cancel placement for non-VIPs in region.

Hook: Player Place Block (before)
            Condition: region vipzone
            Var condition (cancel): "{vip} != 1"
3) Kill Counter + Title

Track per-player zombie kills.

Hook: Entity Die (after)
            Input: zombie
            Condition: KilledByPlayer
            Action: add local 'zombiekills' by 1
            Command: title {player} actionbar "Zombies killed: {zombiekills}"
4) Daily Login Reward

Global loop giving daily rewards.

Loop: global, interval 24000
            Command: give @a diamond 1
            Broadcast: "Daily reward claimed!"
5) Custom Shop

Interactive purchase using emeralds.

Hook: Item Use (after)
            Input: emerald
            Custom UI:
             - Button: "Buy Sword (10 emeralds)"
               Actions:
                 - command (player): give @s diamond_sword
                 - variable (local): set 'emeralds' to {emeralds} - 10
6) Anti-Grief Logging

Log block breaks with coordinates.

Hook: Player Break Block (after)
            Message: "§c{player} broke {block_name} at {x} {y} {z}"
7) Player Level Tracker

Track XP level ups and reward items.

Hook: On Chat (after)
            Input: "level up"
            Action: add local 'levels' by 1
            Command: give {player} golden_apple 1
            Message: "Congrats {player}, you reached level {levels}!"
8) Region-Based Mining Restriction

Prevent diamond mining in protected zone.

Hook: Player Break Block (before)
            Input: diamond_ore
            Condition: region minezone
            Var condition (cancel): "{rank} != admin"
9) Boss Fight Announcer

Broadcast when a boss mob dies.

Hook: Entity Die (after)
            Input: wither
            Broadcast: "§cThe Wither has been defeated by {player}!"
10) Chat Keyword Trigger

Run commands when players type keywords.

Hook: On Chat (after)
            Input: "help"
            Command: tell {player} "Use /synchelp for guidance."
11) Playtime Counter

Track per-player playtime with loops.

Loop: per-player, interval 20
            Folder: Stats
            Action: add local 'playtime' by 1
            Command (player): "title @s actionbar Playtime: {playtime} seconds"
12) Health-Based Reward

Give food when health drops below threshold.

Hook: Item Use (after)
            Condition: "{player health} < 5"
            Command: give {player} bread 1
            Message: "You were low on health, here's some bread!"
13) PvP Kill Streak

Reward players after multiple kills.

Hook: Entity Die (after)
            Condition: KilledByPlayer
            Action: add local 'killstreak' by 1
            Var condition (require): "{killstreak} >= 5"
            Command: give {player} diamond_sword 1
            Message: "Kill streak achieved! Reward granted."
14) Region Entry Message

Notify players when entering a region.

Hook: Player Place Block (after)
            Condition: region spawn
            Message: "Welcome to the spawn region!"
15) Seasonal Event Loop

Give gifts every in-game day.

Loop: global, interval 24000
            Command: give @a cookie 1
            Broadcast: "Daily cookie gift delivered!"
16) Secret Button at Exact Location

Only trigger when player right-clicks a specific button.

Hook: Player Interact With Block (after)
            Input: stone_button
            Condition: atLocation 120 64 -85
            Message: "§aYou found the secret button!"
            Command: give {player} diamond 5
Troubleshooting patterns
  • Nothing happens: Use any inputs and add a message to confirm your hook triggers. If it does, tighten filters.
  • Command failing: Test the exact command in chat; then choose correct executor (console/player). Check /console for errors.
  • Variable not updating: Ensure you’re modifying the correct scope (local vs global) and folder. Inspect with /varlist.
  • Cancellation not working: Verify you’re in a before phase and using cancel mode or a UI cancel action.
  • Region condition false: Confirm selection, creation, and name. Use /region reveal <name> to visualize.
  • Lag spikes: Reduce loop frequency; consolidate similar actions; avoid spammy messages.