Reference

🔗//airapply <command_name> <args>Meta

Like//ellipsoidapply, but instead only keeps changes that replace airlike nodes, and discards any other changes made.

As with//ellipsoidapplyfor advanced users//multiis also supported - but make sure your modifications stay within the defined region - otherwise they be kept regardless, as//airapplyonly applies the masking to the nodes in the defined region.

//airapply set sandstone
//airapply maze3d dirt 4 2 2

🔗//basename <name>Statistics

Returns the absolute canonical name of a node, given an alias or partial node name. For example:

//basename dirt

...will returndefault:dirt. Usesworldedit.normalize_nodename(string)under the hood.

//basename stonebrick
//basename glass

🔗//bonemeal [<strength> [<chance> [<node_name> [<node_name> ...]]]]Flora

Requires thebonemeal(repo) mod (otherwiseWorldEditAdditionswill not register this command and output a message to the server log). Alias://flora.

Bonemeals all eligible nodes in the current region. An eligible node is one that has an air node directly above it - note that just because a node is eligible doesn't mean to say that something will actually happen when thebonemealmod bonemeals it.

Optionally takes a strength value (that's passed tobonemeal:on_use(), the method in thebonemealmod that is called to actually do the bonemealing). The strength value is a positive integer from 1 to 4 (i.e. 1, 2, 3, or 4) - the default is 1 (the lowest strength).

I observe that a higher strength value gives a higher chance that something will actually grow. In the case of soil or sand nodes, I observe that it increases the area of effect of a single bonemeal action (thus at higher strengths generally you'll probably want a higher chance number - see below). See thebonemealmod READMEfor more information.

Also optionally takes a chance number. This is the chance that an eligible node will actually get bonemealed, and is a positive integer that defaults to 1. The chance number represents a 1-in-{number} chance to bonemeal any given eligible node, where {number} is the chance number. In other words, the higher the chance number the lower the chance that a node will be bonemealed.

For example, a chance number of 2 would mean a 50% chance that any given eligible node will get bonemealed. A chance number of 16 would be a 6.25% chance, and a chance number of 25 would be 2%.

Since WorldEditAdditions v1.12, a percentage chance is also supported. This is denoted by suffixing a number with a percent sign (e.g.//bonemeal 1 25%).

Since WorldEditAdditions v1.13, a list of node names is also optionally supported. This will constrain bonemeal operations to be performed only on the node names listed.

//bonemeal
//bonemeal 3 25
//bonemeal 4
//bonemeal 1 10
//bonemeal 2 15
//bonemeal 2 10%
//bonemeal 2 10% dirt
//bonemeal 4 50 ethereal:grove_dirt

🔗Cloud WandTools

The cloud wand (worldeditadditions:cloudwand) is a another variant the aboveFar Wand. It looks like this:

Unlike the other 2 wands, this wand functions in an additive manner. Left-click on a node to expand the currently defined region (creating a new one if one isn't defined already) to include that node. Right click to clear the currently defined region.

It has the range of theFar Wandmentioned above too, so you can select nodes from a great distance. It also abides by preferences set via the//farwandchat command.

Note that punching out the positionsdoes not unset them. Use//resetto reset the defined region.

🔗//convolve <kernel> [<width>[,<height>]] [<sigma>]Terrain

Advanced version of//smoothfrom we_env, and one of the few WorldEditAdditions commands to have any aliases (//smoothadvand//conv).

Extracts a heightmap from the defined region and then proceeds toconvolveover it with the specified kernel. The kernel can be thought of as the filter that will be applied to the heightmap. Once done, the newly convolved heightmap is applied to the terrain.

Possible kernels:

If you can think of any other convolutional filters that would be useful, pleaseopen an issue. The code backing this command is very powerful and flexible, so adding additional convolutional filters should be pretty trivial.

The width and height (if specified) refer to the dimensions of the kernel and must be odd integers and are separated by a single comma (andnospace). If the height is not specified, it defaults to the width. If using thegaussiankernel, the width and height must be identical. Larger kernels are slower, but produce a more smoothed effect and take more nearby nodes into account for every column. Defaults to a 5x5 kernel.

The sigma value is only applicable to thegaussiankernel, and can be thought of as the 'smoothness' to apply. Greater values result in more smoothing. Default: 2. See theGaussian blurpage on Wikipedia for some pictures showing the effect of the sigma value.

//convolve
//convolve box 7
//convolve pascal 11,3
//convolve gaussian 7
//convolve gaussian 9 10
//convolve gaussian 5 0.2

🔗//copy+ <axis:x|y|z|-x|-y|-z|?|front|back|left|right|up|down> <count> [<axis> <count> [...]] [aa|airapply]Misc

Fully backwards-compatible with//copyfrom regular WorldEdit, but allows you to specify multiple axes at once in a single copy operation. Each successive axis in the list is specified in the form<axis> <count>, where:

• <axis>is the name of the axis to move the defined region along
• <count>is the number of nodes along the defined axis to move

All of the following values are valid axes:

• x
• y
• z
• -x
• -y
• -z
• ?/front/f
• back/b
• left/l
• right/r
• up/u
• down/d

Additionally all the absolute axis names (x/y/z/-x/-y/-z) may also be specified multiple times under the same count - e.g.xy-z 6.

Finally, if the wordairapply(oraafor short) is present at the end of the command invocation it enables the integrated airapply mode, which replaces target nodes only if they are air-like.

//copy+ x 6
//copy+ y 10 z 4
//copy+ front 6 left 5
//copy+ ? 10 r 25 y 50
//copy+ xz 50 front 22
//copy+ yx 25
//copy+ -xz-y 10
//copy+ y 45 aa
//copy+ -y 15 z 5 airapply

🔗//countStatistics

Counts all the nodes in the defined region and returns the result along with calculated percentages (note that if the chat window used a monospace font, the returned result would be a perfect table. If someone has ahacksolution to make the columns line up neatly, pleaseopen an issue:D)

//count

🔗//dome+ <radius> <replace_node> [<pointing_dir:x|y|z|-x|-y|-z|?|front|back|left|right|up|down> ...] [h[ollow]]Geometry

Creates a dome shape (i.e. a hemisphere; half a sphere) with a specified radius of the defined node, optionally specifying the direction it should be pointing in (defaults to the positive y direction).

For example,//dome+ 5 stone ycreates a dome shape pointing upwards, but//dome+ 5 stone -ycreates a dome shape pointing downwards.

Multiple pointing direction axes can be chained together to create multiple domes on top of each other. Multiple conflicting directions will cancel each other out.

Ifhorhollowis specified at the end, then the resulting dome shape is made hollow.

//dome+ 5 stone y
//dome+ 10 diamond -x
//dome+ 25 cactus y z
//dome+ 9 dirt x y z

🔗//ellipsoid <rx> <ry> <rz> <node_name> [h[ollow]]Geometry

Creates a solid ellipsoid at position 1 with the radius(rx, ry, rz).

//ellipsoid 10 5 15 ice
//ellipsoid 3 5 10 dirt
//ellipsoid 20 10 40 air
//ellipsoid 14 5 8 steelblock h
//ellipsoid 7 4 7 papyrus hollow

🔗//ellipsoid2 [<node_name:dirt> [h[ollow]]]Geometry

Creates an (optionally hollow) solid ellipsoid that fills the defined region.

//ellipsoid2
//ellipsoid2 ice
//ellipsoid2 air
//ellipsoid2 steelblock h
//ellipsoid2 papyrus hollow

🔗//ellipsoidapply <command_name> <args>Meta

Executes the given command, and then clips the result to the largest ellipsoid that will fit inside the defined region. The specified command must obviously take 2 positions - so for example//set,//replacemix, and//maze3dwill work, but//sphere,//torus, and//floodfillwon't.

For advanced users,//multiis also supported - but make sure your modifications stay within the defined region - otherwise they will not be affected by the ellipsoidal clipping operation.

//ellipsoidapply set dirt
//ellipsoidapply maze3d dirt 4 2 2
//ellipsoidapply erode
//ellipsoidapply replacemix sand bakedclay:red bakedclay:orange
//ellipsoidapply layers desert_sand sand 2 desert_sandstone 4 sandstone 10

🔗//erode [<snowballs|river> [<key_1> [<value_1>]] [<key_2> [<value_2>]] ...]Terrain

Runs an erosion algorithm over the defined region, optionally passing a number of key - value pairs representing parameters that are passed to the chosen algorithm. This command isexperimental, as the author is currently on-the-fence about the effects it produces.

Works best if you run//fillcavesfirst, or otherwise have no air nodes below the top non-air node in each column.

Currently implemented algorithms:

Usage examples:

//erode
//erode snowballs
//erode snowballs count 25000

Each of the algorithms above have 1 or more parameters that they support. These are detailed below.

Algorithm:snowballs

Based on the algorithm detailed inthis blog post(direct link to the source code), devised byJob Talle.

Usage examples:

//erode
//erode snowballs
//erode snowballs count 50000

If you find any good combinations of these parameters, pleaseopen an issue(or a PR!) and let me know! I'll include good combinations here, and possibly add a presets feature too.

Algorithm:river

Ever been annoyed by small 1 wide holes or thin pillars all over the place? This command is for you! Does not operate on the very edge of the defined region, because the algorithm can't see the neighbours of those columns.

Usage examples:

//erode river
//erode river steps 10

🔗Far WandTools

The far wand (worldeditadditions:farwand) is a variant on the traditional WorldEdit wand (worldedit:wand). It looks like this:

It functions very similarly to the regular WorldEdit wand, except that it has amuchlonger range - which can be very useful for working on large-scale terrain for example. It also comes with an associated command to control it.

Note that punching out the positionsdoes not unset them. Use//resetto reset the defined region.

🔗//farwand skip_liquid (true|false) | maxdist <number>Tools

This command helps control the behaviour of theWorldEditAdditions far wandandcloud wand. Calling it without any arguments shows the current status:

//farwand

You can decide whether you can select liquids or not like so:

//farwand skip_liquid true
//farwand skip_liquid false

You can change the maximum range with themaxdistsubcommand:

//farwand maxdist 1000
//farwand maxdist 200
//farwand maxdist 9999

Note that the number there isn't in blocks (because hard maths). It is however proportional to the distance the wand will raycast looks for nodes, so a higher value will result in it raycasting further.

🔗//fillcaves [<node_name>]Terrain

Fills in all airlike nodes beneath non airlike nodes, which gives the effect of filling in caves. Defaults to filling in with stone, but this can be customised.

Note that theentirecave you want filling must be selected, as//fillcavesonly operates within the defined region (ref #50).

//fillcaves
//fillcaves dirt
//fillcaves brick

🔗//floodfill [<replace_node> [<radius>]]Misc

Floods all connected nodes of the same type starting atpos1with<replace_node>(which defaults towater_source), in a sphere with a radius of<radius>(which defaults to 50).

//floodfill
//floodfill water_source 50
//floodfill glass 25

🔗//for <value1> <value2> <value3>... do //<command> <arg> %% <arg>Meta

For a given list of values, executes the specified command for each value, replacing%%with each value. Implementation thanks to @VorTechnix.

To better illustrate what happens, consider the following command:

//for dirt stone glass do //replacemix air 10 %%

This is equivalent to executing the following 3 commands in sequence:

//replacemix air 10 dirt
//replacemix air 10 stone
//replacemix air 10 glass

Here are some more examples:

//for meselamp brick snowblock bamboo:wood do //multi //maze %% //sshift y 5
//for 5 10 15 do //torus %% 3 dirt xz
//for 1 2 3 4 5 do //multi //hollowcylinder y 1 5 meselamp //shift y %%

🔗//forest [<density>] <sapling_a> [<chance_a>] <sapling_b> [<chance_b>] [<sapling_N> [<chance_N>]] ...Flora

Plants and grows saplings to generate a forest. A density value is optionally taken, which controls the overall density of the forest that is generated. Thebonemealmod is required - just like for the//bonemealcommand.

The density defaults to 1, acts like a multiplier, and is not affected by the chances of all saplings listed (e.g. you can have a sapling with a chance of 1-in-50, and the overall density of the forest will be unaffected). For example, 2 results in a forest twice as dense as the default, and 0.5 a forest half as dense as the default density.

The tree types are provided as a list of names and 1-in-N chances, just like//overlay,//mix,//layers, etc. Unlike the aforementioned commands however,//foresthas an additional layer of alias resolution to ease the process of determining what the name of the sapling is you want to use to generate forests with. See//saplingaliasesfor more details.

Saplings are placed with//overlayand grown using the same method that's used by the//bonemealcommand. Up to 100 attempts are made to grow placed saplings. If all of those attempts fail (success is determined by whether the sapling is still present or not), the sapling is removed and the failure counter is incremented.

Currently, the following mods are known to have aliases registered:

• default
• moretrees(warning: these saplings don't appear to work very well this command - assistance in debugging this would be very helpful)
• cool_trees

If you like, you can also reference the full name of a sapling node instead. The only requirements for saplings to be supported by this mod are:

1. It can be bonemealed
2. It has thesaplinggroup

For example, the first 2 examples below are functionally equivalent.

//forest aspen
//forest default:aspen_sapling
//forest 2 oak 3 aspen pine
//forest 0.5 acacia

🔗//hollow [<wall_thickness>]Geometry

Replaces nodes inside the defined region with air, but leaving a given number of nodes near the outermost edges alone. In other words, it makes the defined region hollow, while leaving walls around the edges of a given thickness (defaulting to a wall thickness of 1).

Note that all air-like nodes are also left alone.

//hollow
//hollow 2

🔗//hollowellipsoid <rx> <ry> <rz> <node_name>Geometry

Creates a hollow ellipsoid at position 1 with the radius(rx, ry, rz). Works the same way as//ellipsoiddoes.

//hollowellipsoid 10 5 15 glass
//hollowellipsoid 21 11 41 stone

🔗//hollowtorus <major_radius> <minor_radius> <node_name> [<axes=xy>]Geometry

Creates a hollow torus at position 1 with the radius major and minor radii. Works the same way as//torusdoes.

//hollowtorus 10 5 glass
//hollowtorus 21 11 stone
//hollowtorus 18 6 dirt xz

🔗//layers [<max_slope|min_slope..max_slope>] [<node_name_1> [<layer_count_1>]] [<node_name_2> [<layer_count_2>]] ...Terrain

Finds the first non-air node in each column and works downwards, replacing non-air nodes with a defined list of nodes in sequence. Like WorldEdit for Minecraft's//naturalizecommand, and also similar towe_env's//populate. Speaking of, this command has//naturaliseand//naturalizeas aliases. Defaults to 1 layer of grass followed by 3 layers of dirt.

Since WorldEditAdditions v1.13, a maximum and minimum slope is optionally accepted, and constrains the columns in the defined region that//layerswill operate on. For example, specifying a value of20would mean that only columns with a slop less than or equal to 20° (degrees, not radians) will be operated on. A value of45..60would mean that only columns with a slope between 45° and 60° will be operated on.

The list of nodes has a form similar to that of a chance list you might find in//replacemix,//overlay, or//mix- see the examples below. If the number of layers isn't specified,1is assumed (i.e. a single layer).

//layers dirt_with_grass dirt 3
//layers sand 5 sandstone 4 desert_stone 2
//layers brick stone 3
//layers cobble 2 dirt
//layers 45..60 dirt_with_snow dirt 2
//layers 30 snowblock dirt_with_snow dirt 2

🔗//line [<replace_node> [<radius>]]Geometry

Draw a line from position 1 to position 2, optionally with a given thickness.

The radius can be thought of as the thickness of the line, and is defined as the distance from a given node to an imaginary line from pos1 to pos2. Defaults to drawing with dirt and a radius of 1.

Floating-point values are fully supported for the radius.

//line
//line stone
//line sandstone 3
//line glass 0.5

🔗//listentitiesMeta

Lists all currently loaded ObjectRefs. Displays their IDs, Names (if possible), and positions.

This command is intended for development and modding. You will not normally need to use this command using WorldEditAdditions.

//listentitiestakes no arguments.

//listentities

🔗//many <times> <command>Meta

Executes a single chat command many times in a row. Usesminetest.after()to yield to the main server thread to allow other things to happen at the same time, so technically you could have multiple//manycalls going at once (but multithreading support is out of reach, so only a single one will be executing at the same time).

Note that this isn't necessarily limited to executing WorldEdit / WorldEditAdditions commands. Combine with//multi(see above) execute multiple commands at once for even more power and flexibility!

//many 10 //bonemeal 3 100
//many 100 //multi //1 //2 //outset 20 //set dirt

🔗//markSelection

Shows the in-game UI that indicates where the current positions and region are located once more.

Should more than 2 points be defined, they are all shown once more.

Often used after calling//unmark

//mark

🔗//maze <replace_node> [<path_length> [<path_width> [<seed>]]]Geometry

Generates a maze using replace_node as the walls and air as the paths. Usesan algorithm of my own devising(see alsothis post of mine that has lots of eye candy :D). It is guaranteed that you can get from every point to every other point in generated mazes, and there are no loops.

Requires the currently selected area to be at least 3x3 on the x and z axes respectively.

Mazes are generated from the bottom to the top of the defined region. In other words, the height of the walls of the maze is equal to the height of the defined region.

The optionalpath_lengthandpath_widtharguments require additional explanation. When generating a maze, a multi-headed random walk is performed. When the generator decides to move forwards from a point, it does sopath_lengthnodes at a time.path_lengthdefaults to2.

path_widthis easier to explain. It defaults to1, and is basically the number of nodes wide the path generated is.

Note thatpath_widthmust always be at least 1 less than thepath_lengthin order to operate normally.

Note also that since WorldEditAdditions v1.10, the seed doesn't have to be a number (but it can't contain spaces due to the parsing algorithm used). Non-numbers are hashed to a number using a simple (non-crypto-safe) hashing algorithm.

The last example below shows how to set the path length and width:

//maze ice
//maze stone 2 1 1234
//maze dirt 4 2 56789
//maze glass 2 1 minetestiscool

🔗//maze3d <replace_node> [<path_length> [<path_width> [<path_depth> [<seed>]]]]Geometry

Same as//maze, but instead generates mazes in 3 dimensions instead of 2. Requires the currently selected area to be at least 3x3x3.

The optionalpath_depthparameter defaults to1and allows customisation of the height of the paths generated. In other words, it customises the ceiling height, or the distance from the floor to the ceiling of the paths generated.

To get a better look at the generated maze, try inverting it like so:

//maze3d stone
//replace air dirt
//replace stone air

Additional examples:

//maze3d glass
//maze3d bush_leaves 2 1 1 12345
//maze3d dirt 4 2 2
//maze3d stone 6 3 3 54321

🔗//mcountMeasurement

Alias for//count.

//mcount

🔗//metaball add <radius> | remove <index> | render <replace_node> [<threshold=1>] | list | clear | volumeGeometry

Draws two or moremetaballs. Based on a subcommand system, since each metaball may have a different radius.

Calling//metaball render <replace_node>actually makes changes to the world - all others manipulate an internal player-local list of metaballs to be drawn.

//metaball add <radius>

Adds a new metaball to the (player-local) list of metaballs to be draw with the given radius. The position of the new metaball is taken from pos1.

//metaball add 5
//metaball add 10
//metaball add 65

//metaball remove <index>

Removes the metaball with the given index from the list. See also//metaball list.

//metaball remove 1
//metaball remove 2
//metaball remove 5

//metaball render <replace_node> [<threshold=1>]

Renders the current list of metaballs to the world using replace_node to draw with.

Threshold is a value that acts as an offset for large or small the metaballs should be. Defaults to 1, with larger values resulting insmallermetaballs and smaller values resulting inlargermetaballs. It is not recommended to set threshold to a negative number.

Does not clear the list of metaballs after rendering - see//metaball clearfor that.

//metaball render dirt
//metaball render glass
//metaball render stone
//metaball render stone 2
//metaball render cobble 0.5

//metaball list

Lists all the metaballs currently registered for the current player (all//metaballcommands operate on the current player's metaball list only), and their indexes, positions, and sizes. Useful when using//metaball remove <index>to identify which metaball you want to remove.

Example output:

Index	Position		Radius
1		(-495, 37, 150)	7
2		(-506, 33, 142)	7
3		(-516, 35, 152)	10

//metaball list

//metaball clear

Clears the list of metaballs for the current player.

//metaball clear

//metaball volume

Calculate an estimated volume of the metaballs currently in the list.

//metaball volume

🔗//mfaceMeasurement

Returns the horizontal (X/Z) axis or axes the player is looking along. Aliases://mfacing.

//mface

🔗//midposMeasurement

Returns the coordinates of the centre of the current selection.

//midpos

🔗//move+ <axis:x|y|z|-x|-y|-z|?|front|back|left|right|up|down> <count> [<axis> <count> [...]] [aa|airapply]Misc

Identical to//copy+, but instead moves the defined region instead of copying it.

Note that the integratedairapply(aafor short) also works as in//copy+, but remember that if a given target node is notnotair-like and the integratedairapplymode is enabled, the source node is still moved from the source, but destroyed because it is can't be set at the target.

//move+ x 6
//move+ y 10 z 4
//move+ front 6 left 5
//move+ ? 10 r 25 y 50
//move+ xz 50 front 22
//move+ yx 25
//move+ -xz-y 10
//move+ back 20 aa
//move+ -z 45 y 3 airapply

🔗Movement speed adjustment toolTools

The movement speed adjustment tool, as the name suggests, adjusts your local player movement speed. It looks like this: .

Primary (left) clicking will increase your movement speed, and secondary (right) clicking will decrease it in x0.5 increments, down to a minimum of x0.5.

Note this only affectsyou, andnot any other player.

See also//speed.

🔗//msizeMeasurement

Returns the lengths of the current selection on the X, Y and Z axes.

//msize

🔗//mtrigMeasurement

Returns the length of the diagonal from pos1 to pos2 and its angle on the XZ (horizontal) and Y (vertical) axes.

//mtrig

🔗//multi <command_a> <command_b> <command_c> .....Meta

Executes multi chat commands in sequence. Intended forWorldEditcommands, but does work with others too. Don't forget a space between commands!

//multi //set dirt //shift x 10 //set glass

Since WorldEditAdditions v1.12, curly brace syntax has also been introduced to allow nesting of commands:

//multi //fixlight {//many 5 //bonemeal 3 100}

This syntax can also be nested arbitrarily in arbitrarily complex combinations, and can also be used multiple separate times in a single//multiinvocation (if you find a bug, pleaseopen an issue), though do remember that only//multisupports parsing out this syntax (e.g. if you want to nest multiple commands in a//manythat's inside a//multi, you'll need a sub//multithere).

In addition, this also allows for including a double forward slash in the argument list for a command, should you need to do so (e.g.//multi //example {//bar //baz} //examplewill be executed as 3 commands:/example, then/barwith an argument of//baz, then finally/example).

//multi //1 //2 //shift z -10 //sphere 5 sand //shift z 20 //ellipsoid 5 3 5 ice
//multi //1 //hollowtorus 30 5 stone //hollowtorus 20 3 dirt //torus 10 2 dirt_with_grass
//multi /time 7:00 //1 //outset h 20 //outset v 5 //overlay dirt_with_grass //1 //2 //sphere 8 air //shift down 1 //floodfill //reset

🔗MultiPoint WandTools

The third type of wand provided by WorldEditAdditions is completely different, in that it allows you to select up to999 pointsat once! It looks like this:

It is important to note that (at present) the points selected by this wandare not compatible with normal points. This will change in the future, but requires a lot of work to implement.

It has the following actions:

• Left click:Add a new point
• Right click:Undo adding a point

It has the range of the other wands mentioned above though, so you can select nodes from a great distance. It also abides by preferences set via the//farwandchat command.

🔗//nExtras

Prevents the execution of a command if it could potentially affect a large number of nodes and take a while. This is a regular WorldEdit command.

<!-- Equivalent toWorldEdit's//y, but because of security sandboxing issues it's not really possible to hook into WorldEdit's existing command. -->

//n

🔗//ngroups <node_name> [v[erbose]]Statistics

Lists the groups that a given node is a member of. For example:

//ngroups sand

Might return:

default:sand ∈ sand crumbly falling_node

Groups in Minetest can also have a numerical value greater than 0. Appendvorverboseto see those values:

//ngroups sand v
//ngroups sand verbose

...both of the above might produce an output like this:

default:sand ∈ sand=1 crumbly=3 falling_node=1

Finally, the customary misc examples:

//ngroups sand
//ngroups bakedclay:orange v
//ngroups cactus
//ngroups default:dry_shrub v

🔗//nodeapply <node_a> [<node_b>] [... <node_N>] -- <command_name> <args>Meta

It's gotapplyin the name, so as you might imagine it works the same as//ellipsoidapply,//airapply,//noiseapply2d, etc. Only changes made by the given command that replace nodes on the list given will be replaced. For example:

//nodeapply dirt -- set stone

....is equivalent to//replace dirt stone, in that although//set stonewill set all nodes to stone,//nodeapplywill only keep the changes made by//setthat affect dirt.

There are some special keywords you can use too:

To give a further example, consider this:

//nodeapply liquidlike -- set river_water_source

...this will replace all liquid-like nodes (e.g. water, lava, etc) with river water.

In addition, any node names prefixed an at sign@are considered group names. For example:@crumblywould allow changes only to nodes that are a member of thecrumblygroup:

//nodeapply @crumbly -- layers dirt_with_grass dirt 3 stone 10

More misc examples to end this command description, as is customary:

//nodeapply stone -- layers dirt_with_grass dirt 3
//nodeapply stone dirt sand -- layers bakedclay:natural 3 bakedclay:orange 2 bakedclay:red 3 bakedclay:natural 3
//nodeapply liquidlike -- set air
//nodeapply airlike -- mix stone 3 dirt 2

🔗//noise2d [<key_1> [<value_1>]] [<key_2> [<value_2>]] ...]Terrain

Applies 2D noise to the terrain in the defined region. Like//erode, this command accepts a number of different key-value parameters and provides a number of different underlying algorithms.

In other words, this command changes the height of the terrain according to some noise function (e.g. Perlin noise):

It does so like this:

1. Take coordinates of each column
2. Plug them through a noise function (see below)
3. Apply the generated noise value to the terrain.

//noise2dhas a number of parameters that let you adjust the mathematical properties of step 2, which are explained in the table below.

Some terms that are useful to know:

• Scale:How big or small the noise is. Lower values stretch it out to be bigger, and higher values squash it in.
• Offset:Noise is calculated by passing some coordinates into a function.
• Perlin:A noise algorithm.//noise2ddefaults to this.

Table of parameters

Apply

Different values of theapplyparameter result in the generated noise values being applied in different ways:

1. An integer indicates that the noise should be rescaled to a given amplitude (equal parts of the range above and below 0) before being added to the terrain heightmap.`
2. The exact stringadd: Noise values are added to each heightmap pixel.
3. The exact stringmultiply: Each heightmap pixel is multiplied by the corresponding noise value.

An integer is the most common way to use//noise2d. So, for example:

//noise2d apply 5

...would alter the height of each column of nodes by at most 5 blocks either side, while:

//noise2d apply 10

...would alter the height by 10 blocks instead of 5.

Types of noise

Another thing that can be changed is the noise algorithm. This changes what the noise that is applied to the terrain looks like.

The following algorithms are currently available:

When specifying algorithm names, thealgorithmparameter name is optional. For example, the following are both equivalent:

//noise2d offsetx 4 perlin scale 0.2
//noise2d offsetx 4 algorithm perlin scale 0.2

Further examples

Example invocations:

//noise2d sin scale 0.5
//noise2d offsetx 20 perlin
//noise2d sin exponent 4

🔗//noiseapply2d <threshold> <scale> <command_name> <args>Meta

Like//ellipsoidapply, but instead only keeps changes where a noise function (defaults toperlinmt, see//noise2d) returns a value greater than a given threshold value.

Also takes a scale value that controls the scale of the noise - -higher values result in smaller "blobs". If you're operating on small areas, then a value of at least 10 is advised as "blobs" are by default on the scale of ~50 nodes.

As with//ellipsoidapplyfor advanced users//multiis also supported - but make sure your modifications stay within the defined region - otherwise they be kept regardless, as//noiseapply2donly applies the masking to the nodes in the defined region.

Any suggestions on how to provide more customisability without making this command more difficult to use or significantly more inconsistent with other//*applyfunctions are welcome - pleaseopen an issue.

//noiseapply2d 0.5 10 set dirt
//noiseapply2d 0.4 3 layers dirt_with_snow dirt 3 stone 10

🔗//overlay <node_name_a> [<chance_a>] <node_name_b> [<chance_b>] [<node_name_N> [<chance_N>]] ...Terrain

Places<node_name_a>in the last contiguous air space encountered above the first non-air node. In other words, overlays all top-most nodes in the specified area with<node_name_a>. Optionally supports a mix of node names and chances, as//mix(WorldEdit) and//replacemix(WorldEditAdditions) does.

Will also work in caves, as it scans columns of nodes from top to bottom, skipping every non-air node until it finds one - and only then will it start searching for a node to place the target node on top of.

Note that all-air columns are skipped - so if you experience issues with it not overlaying correctly, try//expand down 1to add an extra node's space to your defined region.

Note also that columns without any air nodes in them at all are also skipped, so try//expand y 1to add an extra layer to your defined region.

//overlay grass
//overlay glass
//overlay grass_with_dirt
//overlay grass_with_dirt 10 dirt
//overlay grass_with_dirt 10 dirt 2 sand 1
//overlay sandstone dirt 2 sand 5
//overlay dirt 90% stone 10%

🔗//pos <index>Selection

Sets position with the given index<index>to the location of the calling player.

Should the index be less than or equal to 2, then as with all other WorldEditAdditions commands, seamlessly synchronised with WorldEdit, allowing you to use any combination of WorldEditAdditions and WorldEdit commands and tools without them desynchronising from one another.

Should the index be greater than 2, the position will only be registered in WorldEditAdditions, as WorldEdit does not support defining more than 2 points.

If no index is specified, an error is returned and nothing is done.

//pos 1
//pos 3
//pos 45
//pos 2

🔗//pos1Selection

Sets pos1 to the location of the calling player.

This is, as with all other WorldEditAdditions commands, seamlessly synchronised with WorldEdit, allowing you to use any combination of WorldEditAdditions and WorldEdit commands and tools without them desynchronising from one another.

Aliases://1

//pos2

🔗//pos2Selection

Sets pos1 to the location of the calling player.

This is, as with all other WorldEditAdditions commands, seamlessly synchronised with WorldEdit, allowing you to use any combination of WorldEditAdditions and WorldEdit commands and tools without them desynchronising from one another.

Aliases://2

//pos2

🔗//replacemix <target_node> [<chance>] <replace_node_a> [<chance_a>] [<replace_node_b> [<chance_b>]] [<replace_node_N> [<chance_N>]] ...Misc

Replaces a given node with a random mix of other nodes. Functions like//mix.

This command is best explained with examples:

//replacemix dirt stone

The above functions just like//replace- nothing special going on here. It replaces alldirtnodes withstone.

Let's make it more interesting:

//replacemix dirt 5 stone

The above replaces 1 in every 5dirtnodes withstone. Let's get even fancier:

//replacemix stone stone_with_diamond stone_with_gold

The above replacesstonenodes with a random mix ofstone_with_diamondandstone_with_goldnodes. But wait - there's more!

//replacemix stone stone_with_diamond stone_with_gold 4

The above replacesstonenodes with a random mix ofstone_with_diamondandstone_with_goldnodes as before, but this time in the ratio 1:4 (i.e. for everystone_with_diamondnode there will be 4stone_with_goldnodes). Note that the1forstone_with_diamondis implicit there.

If we wanted to put all of the above features together into a single command, then we might do this:

//replacemix dirt 3 sandstone 10 dry_dirt cobble 2

The above replaces 1 in 3dirtnodes with a mix ofsandstone,dry_dirt, andcobblenodes in the ratio 10:1:2. Awesome!

Since WorldEditAdditions v1.12, you can also use percentages:

//replacemix dirt 33% sandstone 75% dry_dirt 10% cobble 15%

Note though that the percentages are internally converted to a 1-in-N chance and rounded down.

Here are all the above examples together:

//replacemix dirt stone
//replacemix dirt 5 stone
//replacemix stone stone_with_diamond stone_with_gold
//replacemix stone stone_with_diamond stone_with_gold 4
//replacemix dirt 3 sandstone 10 dry_dirt cobble 2

🔗//resetSelection

Clears all positions defined and the defined region.

This also synchronises with WorldEdit, as all other WorldEditAdditions commands do.

//reset

🔗//revolve <times> [<pivot_point_number=last_point>]Misc

Makes a given number of copies of the currently defined region (bounded by pos1 and pos2) at a given number of equally spaced points rotated around a given pivot/origin point.

For example,//revolve 4would make rotated copies of the currently defined region at intervals 0° (the source to copy), 90°, 180°, and 270° around the given pivot point.

pivot_point_numberis the number of the defined position that should act as the pivot point, or origin for the revolve operation. It defaults to the last position defined. Note that it cannot be pos1 or pos2, as these are used to define the region that should be rotated. Use themulti-point wandto define a position with an index of 3 or more.

//revolve 4
//revolve 6 6

🔗//rotate+ <axis> <degrees> [<axis> <degrees> ...] [origin|o [<pos_number>]]Misc

Rotates the defined region using the specified list of rotation operations, optionally around the defined rotation origin. For example, the following:

//rotate+ y 45

...will rotate the defined region around it's centre by 45° on the Y (vertical) axis.

We can also extend this to rotate on multiple axes:

//rotate+ z 90 y 45

The rotations will be processed in order as specified from left to right. The following relative keywords are currently supported in place of an absolute axis name:

A custom rotation origin can be specified too. This is done via theoriginkeyword and takes the form of specifying a position to rotate around instead of the default (picking the centre point between pos1 and pos2). For example:

//rotate+ x 20 origin 3

....will rotate 20° on the X axis around position 3. See themulti-point wandfor more information on setting positions other than pos1 and pos2.

Theoriginkeyword's argument is optional, and if no position number is specified defaults to position 3.

//rotate+ y 90 x 45 origin
//rotate+ y 90 x 45 o
//rotate+ x 60 origin 5 z 20

🔗//saplingaliases [aliases|all_saplings]Flora

Lists all the currently registered sapling aliases in alphabetical order. These aliases can be used in the//forestsubcommand.

Optionally takes a single parameter, which is the operating mode. Current implemented operating modes:

//saplingaliases
//saplingaliases all_saplings
//saplingaliases aliases

🔗//scale <axis> <scale_factor> | <factor_x> [<factor_y> <factor_z> [<anchor_x> <anchor_y> <anchor_z>Misc

Advanced version of//stretchfrom WorldEditthat can scale both up and down at the same time by transparently splitting it into 2 different operations. Scaling up isalwaysdone before scaling down.

Although the syntax looks complicated, it's really quite simple. The key concept to understand is that of the scale factor. It refers to how much the defined region should be scaled up or down by, and can be specified in multiple different ways:

In short, you can specify the scale factor directly, as a percentage, or as 1 number divided by another number.

With this in mind, there are 3 forms that you can tell//scalehow you want to scale the defined region:

Single Axis

If you just need to scale a single axis, you can tell//scalethat like so:

//scale <axis> <scale_factor>

To give a concrete example:

//scale y 2

The above will scale the defined region in the positive y direction by 2 times, doubling the height. If you want to scale in the opposite direction, do this:

//scale -y 2

This will scale in thenegativey direction by 2 times (again, doubling the height). Some more examples:

//scale z 50%
//scale -x 1/3

All axes

To scale on all axes at once,//scaletakes the shortcut syntax of specifying a single scale factor:

//scale 2
//scale 200%

Both of the above will scale the defined region up by 2 times in all directions.

Multiple scale factors

If you want to specify different scale factors for difference axes, then//scalealso supports a third syntax. Here's an example:

//scale 2 3 4

This will scale the defined region by 2x in the positive x, 3x in the positive y, and 4x in the positive z. As these are all scale factors, we can also use the syntax described above to scale up and down in the same operation:

//scale 50% 2 1/4

This will first scale in the positive y by 2x. Once that operation is completed, it will scale down to 50% size in the positive x and down to 25% size in the positive z. Note that if you want to scale down first and then scale up, you'll need to execute 2 separate commands.

If you want to change the anchor point of the scaling operation too,//scalesupports a final syntax like so:

//scale 50% 2 1/4 1 -1 1

By adding 3 extra numbers for the x, y, and z axes respectively, we can control the direction//scaleperforms the scaling operation. A value of 1 or greater indicates the positive direction of the axis, and a value of -1 or less indicates the negative direction of the axis. I recommend byworldedit_hud_helpermod for easily determining which direction is which.

So in the above example, we scale in the positive x and z directions, and the negative y direction.

🔗//scentreSelection

Short forselect center. Sets pos1 and pos2 to the centre point(s) of the current selection area. 1, 2, 4 or 8 nodes may be selected depending on what parts of the original selection are even in distance. Implementation thanks to @VorTechnix.

//scentre

🔗//scloud <0-6|stop|reset>Selection

Short forselect point cloud. Sets pos1 and pos2 to include the nodes you punch. Numbers 1-6 designate how many nodes you want to punch before the operation ends. 0 or stop terminate the operation so that any further nodes you punch won't be added to selection. Reset terminates operation if one is running and resets the selection area.

//scloud 6
//scloud 5
//scloud stop

🔗//scol [<axis1> ] <length>Selection

Short forselect column. Sets the pos2 at a set distance along 1 axis from pos1. If the axis isn't specified, defaults the direction you are facing. Implementation thanks to @VorTechnix.

//scol 10
//scol x 3

🔗//scube [<axis1> [<axis2> [<axis3>]]] <length>Selection

Short forselect cube. Sets the pos2 at a set distance along 3 axes from pos1. If the axes aren't specified, defaults to positive y, the direction you are facing and the axis to the left of facing. Implementation thanks to @VorTechnix.

//scube 5
//scube z a y 12
//scube x z 3
//scube -z 12

🔗//sculpt [<brush_name=default> [<brush_size=8> [<height=1>]]]Terrain

Applies a specified brush to the terrain at position 1 with a given height and a given size. Multiple brushes exist (see//sculptlist) - and are represented as a 2D grid of values between 0 and 1, which are then scaled to the specified height. The terrain around position 1 is first converted to a 2D heightmap (as in//convolvebefore the brush "heightmap" is applied to it.

Similar to//sphere,//cubeapply 10 set, or//cylinder y 5 10 10 dirt(all fromWorldEdit), but has a number of added advantages:

• No accidental overhangs
• Multiple custom brushes (see below on how you can add your own!)

A negative height value causes the terrain to be lowered by the specified number of nodes instead of raised.

While sculpting brushes cannot yet be rotated, this is a known issue. Rotating sculpting brushes will be implemented in a future version of WorldEditAdditions.

The selection of available brushes is limited at the moment, but see below on how to easily create your own!

//sculpt
//sculpt default 25 3
//sculpt ellipse
//sculpt circle 50 3

Create your own brushes

2 types of brush exist:

1. Dynamic (lua-generated) brushes
2. Static brushes

All brushes are located inworldeditadditions/lib/sculpt/brushes(relative to the root of WorldEditAdditions' installation directory).

Lua-generated brushes are not the focus here, but are a file with the extension.luaand return a function that returns a brush - see other existing Lua-generated brushes for examples (and don't forget to updateworldeditadditions/lib/sculpt/.init.lua).

Static brushes on the other hand are simply a list of tab-separated values arranged in a grid. For example, here is a simple brush:

0   1   0
1   2   1
0   1   0

Values are automatically rescaled to be between 0 and 1 based on the minimum and maximum values, so don't worry about which numbers to use. Static brushes are saved with the file extension.brush.tsvin the aforementioned directory, and are automatically rescanned when your Minetest server starts. While they can't be rescaled automatically to fix a target size (without creating multiple variants of a brush manually of course, though this may be implemented in the future), static brushes are much easier to create than dynamic brushes.

To assist with the creation of static brushes, a tool exists to convert any image to a static brush:

https://worldeditadditions.mooncarrot.space/img2brush/

The tool can operate on the colour channel of your choice - red, green, blue, or alpha.

If you've created a cool new brush (be it static or dynamic),please contribute it to WorldEditAdditions! That way, everyone can enjoy using your awesome brush.WorldPainterhas many brushes available in the community, but//sculptfor WorldEditAdditions is new so don't have the same sized collection yet :-)

To contribute your new brush back, you can eitheropen a pull requestif you're confident using GitHub, oropen an issuewith your brush attached if not.

🔗//sculptlist [preview]Terrain

Lists all the available sculpting brushes for use with//sculpt. If thepreviewkeyword is specified as an argument, then the brushes are also rendered in ASCII as a preview. See//sculpt.

//sculptlist
//sculptlist preview

🔗//sfactor <mode:grow|shrink|average> <factor> [<target=xz>]Selection

Short forselection factor; alias://sfac. Built specifically for use with//maze, this command sets targeted axes equal to the nearest multiple of<factor>based on the<mode>.

Usage examples:

//sfac grow 5
//sfac avg 3 xy

<mode>: grow|shrink|average

🔗//smake <operation:odd|even|equal> <mode:grow|shrink|average> [<target=xz> [<base>]]Selection

Short forselection make. Modifies existing selection by moving pos2. Allows you to make the selection an odd or even length on one or more axes or set two or more axes equal to each other or the longest, shortest or average of them. Implementation thanks to @VorTechnix.

Usage examples:

//smake odd shrink
//smake even avg xz
//smake equal grow xy
//smake equal average
//smake equal zy x

<operation>: odd|even|equal

<mode>: grow|shrink|average

If<operation>== odd or even:

If<operation>== equal:

The<mode>argument can be omitted and will not be parsed if present if<base>is specified

Additional arguments:

🔗//speed [<value=1>]Extras

Adjusts your player movement speed to the specified value. In other words:

//speed 2

...will double your movement speed.

This command also takes Minetest's "Fast mode" into account and adjusts accordingly. Relative adjustments can be done by prepending either a+to increase or-to decrease respectively.

//speed +0.5
//speed -3

🔗//spiral2 [<circle|square>] [<replace_node=dirt> [<interval=3> [<acceleration=0>] ] ]Geometry

Generates both square and circular spiral shapes with the given<replace_node>- defaulting to square spirals. The interval defines the gap between the spiral in nodes, and the acceleration defines by how much the interval should be increased (a value of 1 means 1 node per revolution).

//spiral2
//spiral2 circle stone
//spiral2 square
//spiral2 circle
//spiral2 glass 5
//spiral2 square desert_sand 3 1

🔗//spline <replace_node> <width_start> [<width_end=width_start> [<steps=3>]]Geometry

Draws a curved line, using all the currently defined points as control points. The starting and ending widths of the line can be controlled, and the width will be linearly interpolated.

Note://splineuses thenewWorldEditAdditions positions! Use themultipoint wandto define the control points for the resulting line.

For those interested, WorldEditAdditions uses thechaikin curve algorithmwith linear interpolation for the width to draw the curve.

//spline dirt 5 2
//spline glass 3
//spline bakedclay:violet 3

🔗//spopSelection

Pops a selection off your per-user selection stack and applies it to the currently defined region. If pos2 from the item popped from the stack is nil, then pos2 is explicitly unset. If the stack is empty, this has no effect.

//spop

🔗//spushSelection

Pushes the currently defined region onto your per-user selection stack. Does not otherwise alter the defined region.

If the stack is full (currently the limit is set to 100 regions in the stack), then it will complain at you but otherwise will have no effect.

Note that pos2 doesnotneed to be defined in order to use this. if it isn't defined, then a pos2 ofnilwill be pushed onto the stack instead.

//spush

🔗//srect [<axis1> [<axis2>]] <length>Selection

Short forselect rectangle. Sets the pos2 at a set distance along 2 axes from pos1. If the axes aren't specified, defaults to positive y and the direction you are facing. Implementation thanks to @VorTechnix.

//srect x z 10
//srect 3
//srect -z y 25

🔗//srel <axis1> <length1> [<axis2> <length2> [<axis3> <length3>]]Selection

Short forselect relative. Sets the pos2 at set distances along 3 axes relative to pos1. If pos1 is not set it will default to the node directly under the player. The axis arguments acceptx, y, zas well asup, down, left, right, front, back. Left, right, front and back are relative to player facing direction. Negative (-) can be applied to the axis, the length or both. Implementation thanks to @VorTechnix.

//srel front 5
//srel  y 12 right -2
//srel left 3 up 5 -front 7
//srel -z 12 -y -2 x -2

🔗//sshift <axis1> <length1> [<axis2> <length2> [<axis3> <length3>]]Selection

Short forselection shift. Shifts the WorldEdit region along 3 axes. The axis arguments acceptx, y, zas well asup, down, left, right, front, back. Left, right, front and back are relative to player facing direction. Negative (-) can be applied to the axis, the length or both. Implementation thanks to @VorTechnix.

//sshift back 4
//sshift right -2 up 2
//sshift -left 2 z -7 -y -4
//sshift -z 12 -y -2 x -2

🔗//sstackSelection

Displays the contents of your per-user selection stack. This stack can be pushed to and popped from rather like a stack of plates. See also//spush(for pushing to the selection stack) and//spop(for popping from the selection stack).

//sstack

🔗//subdivide <size_x> <size_y> <size_z> <cmd_name> <args>Meta

Splits the current WorldEdit region into(<size_x>, <size_y>, <size_z>)sized chunks, and run//<cmd_name> <args>over each chunk.

Sometimes, we want to run a single command on a truly vast area. Usually, this results in running out of memory. If this was you, then this command is just what you need! It should be able to handle any sized region - the only limit is your patience for command to complete.....

Note that this command only works with WorldEdit commands, and only those which require 2 points (e.g.//torusonly requires a single point, so it wouldn't work very well - but//setor//clearcutwould).

Note also that<cmd_name>shouldnotbe prefixed withanyforward slashes - see the examples below.

While other server commands can be executed while a//subdivideis running,//subdividemanipulates your player's defined region when running. This has the side-effect that you can check on where it has got up to with//p getfor example - but means that attempting to change your pos1 & pos2 manually will have no effect until the//subdividecompletes.

//subdivide 10 10 10 set dirt
//subdivide 25 25 25 fixlight

🔗//torus <major_radius> <minor_radius> <node_name> [<axes=xy> [h[ollow]]]Geometry

Creates a solid torus at position 1 with the specified major and minor radii. The major radius is the distance from the centre of the torus to the centre of the circle bit, and the minor radius is the radius of the circle bit.

The optional axes sets the axes upon which the torus will lay flat. Possible values:xy(the default),xz,yz. A single axis may also be specified (i.e.x,y, orz) - this will be interpreted as the axis that runs through the hole in the middle of the torus.

//torus 15 5 stone
//torus 5 3 meselamp
//torus 10 6 sandstone xz
//torus 10 6 wool:red y
//torus 25 10 dirt xz hollow

🔗//unmarkSelection

Hides the in-game UI that indicates where the current positions and region are located.

This hides both the WorldEditAdditionsandthe WorldEdit UI if displayed, but doesnotchange or remove any points that are registered.

Should more than 2 points be defined, they are all hidden.

//unmark

🔗//walls [<replace_node=dirt> [<thickness=1>]]Geometry

Creates vertical walls of<replace_node>around the inside edges of the defined region, optionally specifying the thickness thereof. Defaults to a replace node ofdirtand a wall thickness of 1.

//walls
//walls dirt
//walls stone
//walls goldblock
//walls sandstone 2
//walls glass 4

🔗//wbox <replace_node>Misc

Sets the edges of the current selection to<replace_node>to create an outline of a rectangular prism. Useful for roughing in walls.

In other words, creates a wireframe of a box defined by the current selection.

//wbox silver_sandstone
//wbox dirt

🔗//wcompass <replace_node> [<bead_node>]Misc

Creates a compass around pos1 with a single node bead pointing north (+Z).

//wcompass meselamp
//wcompass desert_cobble torch
//wcompass gold diamond

🔗//wcorner <replace_node>Misc

Set the corners of the current selection to<replace_node>. Useful for outlining building sites and setting boundaries.

//wcorner glass
//wcorner stone_with_iron

🔗//yExtras

Confirms the execution of a command if it could potentially affect a large number of nodes and take a while. This is a regular WorldEdit command.

<!-- Equivalent toWorldEdit's//y, but because of security sandboxing issues it's not really possible to hook into WorldEdit's existing command. -->

//y