Bedrock Wiki
  • Discord
  • Contribute
  • bedrock.dev
  • MS Learn
Beginner's Guide
  • Guide
    • 1. Introduction
      guide
    • 2. Add-Ons Explained
    • 3. Software & Preparation
    • 4. Project Setup
    • 5. Create a Custom Item
    • 6. Create a Custom Entity
    • 7. Blockbench: Modeling, Texturing & Animating
    • 8. Adding a Loot Table, Spawn Rule & Crafting Recipe
  • Extra
    • a. Understanding JSON
    • b. Download Example Packs
    • c. Troubleshooting
      help
    • d. Advanced Manifest
    • e. Format Versions
    • f. Project Setup Android
Animation Controllers
  • Intro to Animation Controllers
    guide
  • Entity Commands
  • AFK Detector
  • Death Commands
  • Molang into Scoreboard
  • Respawn Commands
Blocks
  • General
    • Intro to Blocks
      guide
    • Block Components
    • Block Tags
    • Block States
    • Block Traits
    • Block Permutations
    • Block Events
      Scripts
    • Block Event Migration
      help
    • Blocks as Items
    • Troubleshooting Blocks
      help
  • Visuals
    • Block Culling
    • Block Models
      guide
    • Block Texture Animation
    • Block Texture Variation
    • Block Tinting
  • Tutorials
    • Applying Constant Effects
      Scripts
    • Avoiding State Limit
    • Fake Blocks
      Scripts
    • Ore Loot Tables
      Scripts
    • Precise Interaction
      Scripts
    • Precise Rotation
      Scripts
    • Rotatable Blocks
  • Vanilla Re-Creations
    • Custom Crops
      Scripts
    • Custom Glass
    • Custom Glazed Terracotta
    • Custom Trapdoors
      Scripts
  • Documentation
    • Block Format History
    • Block Shapes
    • Block Sounds
    • Vanilla Block Models
Commands
  • General
    • Intro to Command Blocks
    • Functions
    • Block States
    • Coordinate System
    • NBT Commands
    • Scoreboard Operations
    • Understanding Selectors
  • Commands
    • Damage
    • Execute
    • Playanimation
    • Playsound
  • On Event Systems
    • On Player First Join
    • On Player Join
    • On Player Leave
    • On Player Death
    • On Player Respawn
    • On First World Load
  • Scoreboard Systems
    • Entity Counter
    • Scoreboard Timers
    • Comparing And Retrieving Scores
  • Techniques
    • Execute Logic Gates
    • MBE - Max's Block Entity
    • FMBE - A New Way to Create Display Entities
    • Look Detection
    • Movement Detections
    • Orbital Camera
  • Useful Creations
    • Custom Crafter
    • Multiplayer Position Rearrangement
      function
Concepts
  • contents.json
  • Emojis & Symbols
  • Molang
  • Namespaces
  • Overwriting Assets
  • Raw Text
  • Shaders
  • Sounds
  • Subpacks
  • Text and Localization
  • Texture Atlases
  • textures_list.json
Documentation
  • Shared Constructs
  • Advanced Molang
  • File Types
  • Fog IDs
  • Material Configuration Description
  • Menu Categories
  • Molang Queries
  • Pack Folder Structure
  • Sound Definitions
  • Vanilla Materials
Entities
  • General
    • Intro to Entities BP
      guide
    • Intro to Entities RP
      guide
    • Troubleshooting Entities
      help
    • Entity Events
    • Entity Properties
    • NPC Dialogues
    • Render Controllers
    • Spawn Rules
  • Tutorials
    • Convert Points Between Any Space (World, Entity, Bones)
    • Creating Boats
    • Detecting Other Entities
    • Disabling Team Damage
    • Dummy Entities
    • Entity Attacks
    • Entity Holds Item
    • Entity Movement
    • Entity Timers
    • Flying Entities
    • Introduction to AOE Clouds
    • Invulnerable Entities
    • Look at Entity
    • Sleeping Entities
    • Solid Entities
    • Spawning Tamed Entities
      Scripts
    • Village Mechanic
  • Documentation
    • Dummy Components
    • Non-Mob Runtime Identifiers
    • Projectiles
    • Runtime Identifiers
    • Vanilla Usage Components
    • Vanilla Usage Spawn Rules
Items
  • General
    • Intro to Items
      guide
    • Item Components
    • Item Tags
    • Item Events
      Scripts
    • Item Event Migration
      help
    • Troubleshooting Items
      help
  • Tutorials
    • Custom Armor
    • Custom Food
      Scripts
    • Custom Pottery Sherds
    • Custom Weapons
    • Equipment-Based Commands
    • High Resolution Items
    • Spawning Items
    • Throwable Items
  • Documentation
    • Enchantments
    • Attachables
    • Item Format History
    • Numerical Item IDs
    • Vanilla Item Identifiers
    • Vanilla Usage Components
JSON UI
  • General
    • Intro to JSON UI
      guide
    • Best Practices
      guide
  • Tutorials
    • Adding HUD Elements
    • Aseprite Animations
    • Buttons and Toggles
    • Modifying Server Forms
    • Preserve Title Texts
    • String to Number
  • Documentation
    • JSON UI Documentation
Loot, Recipes & Trading
  • General
    • Trading Behavior
  • Documentation
    • Loot Tables
    • Trade Tables
    • Recipes
    • Item Functions
  • Tutorials
    • Randomized Structure Loot
Meta
  • Add-On Performance
  • Style Guide
  • Useful Links
  • Using Schemas
  • Version Control
  • Q&A
    • Blocks and Items Q&A 2024/08/30
    • Deferred Technical Preview Q&A 2024/02/23
    • GameTest Q&A 2021/08/06
    • Scripting and Editor Q&A 2023/09/22
    • World Generation Q&A 2024/11/15
NBT
  • General
    • .mcstructure
  • Tutorials
    • Experiments in Minecraft Education
    • Extending Structure Limits
  • NBT in Depth
    • About NBT (Named Binary Tag)
    • NBT Libraries
    • Reading NBT Example
Particles
  • General
    • Intro to Particles
      guide
  • Tutorials
    • Disabling Particles
  • Documentation
    • Vanilla Particles
Scripting
  • General
    • Intro to Scripting
    • What is Script API?
    • API Modules
  • Tutorials
    • Block Placement Prevention
    • GameTests
    • Script Core Features
    • Script Forms
    • Script Requests API
    • Simple Chat Commands
  • Documentation
    • Engine Environment
    • Script Resources
    • Script Watchdog
    • Troubleshooting JavaScript
    • TypeScript
Servers
  • Software
    • Bedrock Server Software
  • Protocols
    • Bedrock Protocol
    • NetherNet Protocol
    • RakNet Protocol
Visuals
  • General
    • Introduction to Entity Visuals
      guide
    • Bedrock Modeling
    • Custom Death Animations
    • Effects in Animations
    • Material Creations
    • Materials
    • Math-Based Animations
    • Skin Packs
  • Tutorials
    • Entity Texture Animation
    • Glowing Entity Texture
    • Hurt Animations
    • Leash Position
    • Player Geometry
    • Remove Entity Shadows
    • Retexturing Spawn Eggs
  • Ideas
    • Structure Presentation
World Generation
  • General
    • Intro to World Generation
      guide
    • Biomes
      guide
    • Feature Types
    • Jigsaw Structures
  • Tutorials
    • Block Conditions for Features
    • Generating Custom Ores
    • Generating Custom Structures
    • Generating Patches
    • Heightmap Noise
  • Documentation
    • Biome Tags

Entity Events

beginner
Entity Events
  • Event Responses
    • Add/Remove
    • Queue Command
    • Randomize
    • Sequence/Filters
    • Set Property
    • Trigger
  • Calling Events
    • Calling Events in Other Entities
    • Targets
    • Built-in Events

Entity events are one of the fundamental building blocks of behavior alongside components and component groups. They serve as the control center for component groups and can be called from components, animations, animation controllers, and other events. This page aims to cover how to call events within the entity and other entities as well as the format of an event.

Event Responses ​

Events allow us to perform actions, such as adding and removing component groups from our entity, allowing us to change the behavior of our entity when certain conditions are met. They are called events because we can activate them when events happen such as a timer running out, a player interacting with the entity or an environmental change occurring. When an event is triggered it will carry out all listed event responses.

Add/Remove ​

The most essential and common use of events is directly adding and/or removing component groups. These will almost always be used in your event and are used in conjunction with the other keys. The following event named wiki:ranged_attacker adds the two component groups "attacker" and "ranged" and removes the groups "standby" and "melee":

minecraft:entity > events
json
"wiki:ranged_attacker": {
    "add": {
        "component_groups": [
            "attacker",
            "ranged"
        ]
    },
    "remove":{
        "component_groups": [
            "standby",
            "melee"
        ]
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

TIP

When you add a component group, if a currently active component group has the same component inside it, it will be overwritten by the group most recently added.

Queue Command ​

Queues commands to be executed by a target at the end of the tick.

minecraft:entity > events
json
"wiki:execute_event": {
    "queue_command": {
        "target": "self", // Optional - 'self' is default (targets entity)
        "command": "summon pig"
    }
}
1
2
3
4
5
6

An array can be used to queue multiple commands:

minecraft:entity > events
json
"wiki:execute_event": {
    "queue_command": {
        "target": "self", // Optional - 'self' is default (targets entity)
        "command": [
            "summon pig",
            "say Everybody welcome the pig!"
        ]
    }
}
1
2
3
4
5
6
7
8
9

Randomize ​

Randomize is a parameter which can be used inside of an entity event to add or remove component groups based off weighted randomization. This is a very useful tool when different component groups should be added based on random chance.

The minecraft:entity_spawned event inside the cow uses randomize to give a 95% chance of the cow spawning as an adult and a 5% chance of spawning as a baby (component groups minecraft:cow_adult and minecraft:cow_baby).

minecraft:entity > events
json
"minecraft:entity_spawned": {
    "randomize": [
        {
            "weight": 95,
            "add": {
                "component_groups": [
                    "minecraft:cow_adult"
                ]
            }
        },
        {
            "weight": 5,
            "add": {
                "component_groups": [
                    "minecraft:cow_baby"
                ]
            }
        }
    ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Note that the randomize will only select one option out of the pool of options.

Sequence/Filters ​

Sequence is a parameter which can be used inside of an entity event to add or remove component groups based on filters. Filters allow us to make conditional events which will only add/remove component groups if a condition is met. The minecraft:convert_to_drowned event inside the zombie uses the sequence parameter to add a different component group based on whether or not the zombie is a baby.

minecraft:entity > events
json
"minecraft:convert_to_drowned": {
    "sequence": [
        {
            "filters": {
                "test": "has_component",
                "operator": "!=",
                "value": "minecraft:is_baby"
            },
            "add": {
                "component_groups": [
                    "minecraft:convert_to_drowned"
                ]
            },
            "remove": {
                "component_groups": [
                    "minecraft:start_drowned_transformation"
                ]
            }
        },
        {
            "filters": {
                "test":"has_component",
                "value":"minecraft:is_baby"
            },
            "add": {
                "component_groups": [
                    "minecraft:convert_to_baby_drowned"
                ]
            },
            "remove": {
                "component_groups": [
                    "minecraft:start_drowned_transformation"
                ]
            }
        }
    ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

Additionally, sequence allows us to run multiple parameters in sequence. It evaluates each section at a time and if valid, will apply it.

TIP

Entries in a sequence are not exclusive; if a filter in one of them passes, it does not prevent the other entries from running. In the case above, there is no filter in the first entry and so it automatically runs. This does not stop the other entries from being checked and subsequently running if valid.

Below is an extensive example of using the sequence to combine filters, randomizing and add & removing component groups:

Sequence Example

This event is run when the entity is hit by a player or projectile. There is a 60% chance nothing will happen and a 40% chance an attack sequence will activate. This attack sequence chooses a random attack with weights determined both by the entity's current health (stronger attacks are given a higher chance when the entity is below half health) and the distance to the nearest player (ranged attacks have higher priority when the player is further away).

minecraft:entity > events
json
"wiki:on_hit": {
    "randomize":[
        // 60% chance nothing happens
        {
            "weight": 60
        },
        // 40% chance this entry is run
        {
            "weight": 40,
            "sequence": [
                // Runs separate event required for all attacks
                {
                    "trigger": "attack_event"
                },
                // Runs if entity is not sheared (entity becomes sheared if under half health)
                {
                    "filters": {
                        "test": "has_component",
                        "operator": "!=",
                        "value": "minecraft:is_sheared"
                    },
                    "sequence": [
                        // Runs if player is within 5 blocks
                        {
                            "filters": {
                                "test": "distance_to_nearest_player",
                                "operator": "<=",
                                "value": 5.0
                            },
                            "randomize": [
                                {
                                    "weight": 10,
                                    "add": {
                                        "component_groups": [
                                            "explode"
                                        ]
                                    }
                                },
                                {
                                    "weight": 60,
                                    "add": {
                                        "component_groups": [
                                            "attack"
                                        ]
                                    }
                                },
                                {
                                    "weight": 20,
                                    "add": {
                                        "component_groups": [
                                            "range_attack"
                                        ]
                                    }
                                },
                                {
                                    "weight": 10
                                }
                            ]
                        },
                        // Runs if player is farther than 5 blocks and entity still has a target
                        {
                            "filters": {
                                "all_of": [
                                    {
                                        "test": "distance_to_nearest_player",
                                        "operator": ">",
                                        "value": 5.0
                                    },
                                    {
                                        "test": "has_target",
                                        "operator": "equals",
                                        "value": true
                                    }
                                ]
                            },
                            "randomize": [
                                {
                                    "weight": 30,
                                    "add": {
                                        "component_groups": [
                                            "attack"
                                        ]
                                    }
                                },
                                {
                                    "weight": 60,
                                    "add":{
                                        "component_groups": [
                                            "range_attack"
                                        ]
                                    }
                                },
                                {
                                    "weight": 10
                                }
                            ]
                        }
                    ]
                },
                // Runs if entity is sheared (under half health)
                {
                    "filters": {
                        "test": "has_component",
                        "value": "minecraft:is_sheared"
                    },
                    "sequence": [
                        // Runs if player is within 5 blocks
                        {
                            "filters": {
                                "test": "distance_to_nearest_player",
                                "operator": "<=",
                                "value": 5.0
                            },
                            "randomize": [
                                {
                                    "weight": 20,
                                    "add":{
                                        "component_groups": [
                                            "explode"
                                        ]
                                    }
                                },
                                {
                                    "weight": 60,
                                    "add": {
                                        "component_groups": [
                                            "strong_attack"
                                        ]
                                    }
                                },
                                {
                                    "weight": 20,
                                    "add": {
                                        "component_groups": [
                                            "strong_range_attack"
                                        ]
                                    }
                                }
                            ]
                        },
                        // Runs if player is farther than 5 blocks and entity still has a target
                        {
                            "filters": {
                                "all_of": [
                                    {
                                        "test": "distance_to_nearest_player",
                                        "operator": ">",
                                        "value": 5.0
                                    },
                                    {
                                        "test": "has_target",
                                        "operator": "equals",
                                        "value": true
                                    }
                                ]
                            },
                            "randomize": [
                                {
                                    "weight": 60,
                                    "add": {
                                        "component_groups": [
                                            "strong_range_attack"
                                        ]
                                    }
                                },
                                {
                                    "weight": 40,
                                    "randomize": [
                                        {
                                            "weight": 30,
                                            "trigger": "rapid_fire"
                                        },
                                        {
                                            "weight": 70,
                                            "add": {
                                                "component_groups": [
                                                    "strong_blast"
                                                ]
                                            }
                                        }
                                    ]
                                }
                            ]
                        }
                    ]
                }
            ]
        }
    ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190

Set Property ​

Sets entity property values (each value can be set to the returned value of a Molang expression string).

WARNING

String values are evaluated as Molang. This means, to set a string property, you must wrap the value in 's (example below).

minecraft:block > events
json
"wiki:change_properties": {
    "set_property": {
        "wiki:boolean_property_example": false,
        "wiki:integer_property_example": "q.property('wiki:integer_property_example') + 1",
        "wiki:string_property_example": "'red'"
    }
}
1
2
3
4
5
6
7

Trigger ​

Trigger is a parameter which can be used inside of an entity event to run other events based on filters to a chosen target. We can use this to trigger another event within the entity, and combining this with sequence can allow us to organize our events neatly.

We are also able to specify filters and a target for the event. The target parameter is discussed in depth later. If the following event is called by the minecraft:interact component, then if the entity interacted with has the family tag pig, it will run the event wiki:interacted in the player that interacted with the entity.

minecraft:entity > events
json
"wiki:on_interact": {
    "trigger": {
        "filters": {
            "test": "is_family",
            "subject": "self",
            "value": "pig"
        },
        "event": "wiki:interacted",
        "target": "other"
    }
}
1
2
3
4
5
6
7
8
9
10
11

TIP

Events are able to retain entity context from the component they were called in. For example, the if an event is triggered using a minecraft:interact component, we are able to apply the filter to the player who interacted with the entity. However, if the method that called the event does not have this context, using target will not work.

Combining this with the sequence parameter, this allows us to run an event in multiple entities as long as there is a context for it. We discuss this more in the target section.

minecraft:entity > events
json
"wiki:on_interact": {
    "sequence": [
        {
            "trigger": {
                "event": "wiki:interacted",
                "target": "other"
            }
        },
        {
            "trigger": {
                "event": "wiki:interacted_with",
                "target": "self"
            }
        }
    ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Calling Events ​

In order for an event to run we need to know to activate it, this is done by calling the event. There are five main ways to do this:

  • within a component
  • within an animation
  • within an animation controller
  • within another event
  • using a command

Some components allow the player to call an event based on parameters set. Here we input the event we want to run when the parameters are met. For example, the minecraft:environment_sensor component is used in the zombie to call the event minecraft:start_transforming when the entity is underwater.

minecraft:entity > components
json
"minecraft:environment_sensor": {
    "triggers": {
        "filters": {
            "test": "is_underwater",
            "operator": "==",
            "value": true
        },
        "event": "minecraft:start_transforming"
    }
}
1
2
3
4
5
6
7
8
9
10

We are also able to run an event directly on the entity within animations and animation controllers. This behavior-based animation is used to call the event wiki:start_pouncing after 10 seconds.

json
"animation.entity.pounce_timer": {
    "timeline": {
        "10.0": "@s wiki:start_pouncing"
    },
    "animation_length": 10.1
}
1
2
3
4
5
6

This behavior-based animation controller is used to call the event wiki:running upon transition to the state "run".

json
"controller.animation.entity.movement":{
    "initial_state":"walk",
    "states":{
        "walk":{
            "transitions":[
                {
                    "run":"q.is_sheared"
                }
            ]
        },
        "run":{
            "on_entry":[
                "@s wiki:running"
            ],
            "transitions":[
                {
                    "walk":"!q.is_sheared"
                }
            ]
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

Here the @s is used to apply the event onto the entities self. Animation controllers are incredibly powerful and can be used to create even more custom behavior, though they are more advanced. Check out our page here for more information

Within an event, as well as adding & removing component groups we can also trigger other events to occur. This event inside the piglin calls the event spawn_baby from the event minecraft:entity_born.

minecraft:entity > events
json
"minecraft:entity_born": {
    "trigger": "spawn_baby"
}
1
2
3

We can also use the command /event to activate an event on an entity. The following would add the component group wiki:example to all pigs. /event entity @e[type=minecraft:pig] wiki:example.

Calling Events in Other Entities ​

Some components, such as the damage sensor, can target entities other than "self" when calling events. One component in particular is specifically designed to call events in other entities: minecraft:behavior.send_event. We will discuss this component first.

The minecraft:behavior.send_event component is used inside the evoker to call an event named wololo inside any blue sheep within its activation range.

json
"minecraft:behavior.send_event": {
    "priority": 3,
    "event_choices": [
        {
            "min_activation_range": 0.0,
            "max_activation_range": 16.0,
            "cooldown_time": 5.0,
            "cast_duration": 3.0,
            "particle_color": "#FFB38033",
            "weight": 3,
            "filters": {
                "all_of": [
                    {
                        "test": "is_family",
                        "subject": "other",
                        "value": "sheep"
                    },
                    {
                        "test": "is_color",
                        "subject": "other",
                        "value": "blue"
                    }
                ]
            },
            "start_sound_event": "cast.spell",
            "sequence": [
                {
                    "base_delay": 2.0,
                    "event": "wololo",
                    "sound_event": "prepare.wololo"
                }
            ]
        }
    ]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

You can also call event when spawning entity. To do it, add <my:event_name> in the end of string that is in component that can summon entity.

BP/entities/zombie.json#component_groups/minecraft:convert_to_drowned
json
"minecraft:transformation": {
    "into": "minecraft:drowned<minecraft:as_adult>",
    "transformation_sound": "convert_to_drowned",
    "drop_equipment": true,
    "delay": {
        "value":15
    }
}
1
2
3
4
5
6
7
8

Targets ​

The component minecraft:damage_sensor inside the pillager calls the event minecraft:gain_bad_omen on the player which kills it. Note how the target of the event is set to "other".

json
"minecraft:damage_sensor": {
    "triggers": {
        "on_damage": {
            "filters": {
                "all_of": [
                    {
                        "test": "has_damage",
                        "value": "fatal"
                    },
                    {
                        "test": "is_family",
                        "subject": "other",
                        "value": "player"
                    }
                ]
            },
            "event": "minecraft:gain_bad_omen",
            "target": "other"
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Some components have these targets and each has certain ones that can be used. For example, minecraft:interact can have the target as either self or other where other is the entity that interacted with the entity. All valid components should have self and target as options where target is the targeted entity.

Built-in Events ​

In general, using the component groups from vanilla mobs will not work. For example, the minecraft:convert_to_drowned will not be called in your entity unless you use one of the methods above to call it. However, there are a few events that called automatically when the conditions are met:

  • minecraft:entity_spawned : called when the entity is spawned in. Useful for setting up initial component groups.
  • minecraft:entity_born : called when the entity is spawned in through breeding.
  • minecraft:entity_transformed : called when another entity transforms into this one.
  • minecraft:on_prime : called when the entity's fuse is lit and is ready to explode.

A good example of these in use is with the cow. This shows how we can always ensure the cow has either minecraft:cow_adult or minecraft:cow_baby as soon as it is spawned/transformed.

BP/entities/cow.json#events
json
"events": {
    "minecraft:entity_spawned": {
        "randomize": [
            {
                "weight": 95,
                "add": {
                    "component_groups": ["minecraft:cow_adult"]
                }
            },
            {
                "weight": 5,
                "add": {
                    "component_groups": ["minecraft:cow_baby"]
                }
            }
    ]
    },
    "minecraft:entity_born": {
        "add": {
            "component_groups": ["minecraft:cow_baby"]
        }
    },
    "minecraft:entity_transformed": {
        "add": {
            "component_groups": ["minecraft:cow_adult"]
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

Contributors

Edit Entity Events on GitHub

Bedrock Wiki by Bedrock OSS

"Minecraft" is a trademark of Mojang AB.

Bedrock OSS, Bedrock Wiki and bedrock.dev are not affiliated in any way with Microsoft or Mojang AB.

  • Privacy Policy
  • Join our Discord
  • Learn how to Contribute
  • Visit our Repository