Settings

Blocks that Baritone is allowed to place (as throwaway, for sneak bridging, pillaring, etc.)

Allow Baritone to break blocks

Blocks that baritone will be allowed to break even with allowBreak set to false

Allow diagonal ascending

Actually pretty safe, much safer than diagonal descend tbh

Allow descending diagonally

Safer than allowParkour yet still slightly unsafe, can make contact with unchecked adjacent blocks, so it's unsafe in the nether.

For a generic "take some risks" mode I'd turn on this one, parkour, and parkour place.

Allow mining the block directly beneath its feet

Turn this off to force it to make more staircases and less shafts

Allow Baritone to move items in your inventory to your hotbar

If true, parkour is allowed to make jumps when standing on blocks at the maximum height, so player feet is y=256

Defaults to false because this fails on constantiam. Please let me know if this is ever disabled. Please.

This will only allow baritone to mine exposed ores, can be used to stop ore obfuscators on servers that use them.

When allowOnlyExposedOres is enabled this is the distance around to search.

It is recommended to keep this value low, as it dramatically increases calculation times.

Is it okay to sprint through a descend followed by a diagonal? The player overshoots the landing, but not enough to fall off. And the diagonal ensures that there isn't lava or anything that's !canWalkInto in that space, so it's technically safe, just a little sketchy.

Note: this is *not* related to the allowDiagonalDescend setting, that is a completely different thing.

You know what it is

But it's very unreliable and falls off when cornering like all the time so.

It also overshoots the landing pretty much always (making contact with the next block over), so be careful

This should be monetized it's so good

Defaults to true, but only actually takes effect if allowParkour is also true

Actually pretty reliable.

Doesn't make it any more dangerous compared to just normal allowParkour th

Allow Baritone to place blocks

Allow Baritone to place blocks in flowing fluid

Allow Baritone to place blocks in fluid source blocks

Allow Baritone to sprint

Enables some more advanced vine features. They're honestly just gimmicks and won't ever be needed in real pathing scenarios. And they can cause Baritone to get trapped indefinitely in a strange scenario.

Almost never turn this on lol

Slab behavior is complicated, disable this for higher path reliability. Leave enabled if you have bottom slabs everywhere in your base.

Allow Baritone to fall arbitrary distances and place a water bucket beneath it. Reliability: questionable.

Will cause some minor behavioral differences to ensure that Baritone works on anticheats.

At the moment this will silently set the player's rotations when using freeLook so you're not sprinting in directions other than forward, which is picken up by more "advanced" anticheats like AAC, but not NCP.

Disable baritone's auto-tool at runtime, but still assume that another mod will provide auto tool functionality

Specifically, path calculation will still assume that an auto tool will run at execution time, even though Baritone itself will not do that.

Assume safe walk functionality; don't sneak on a backplace traverse.

Warning: if you do something janky like sneak-backplace from an ender chest, if this is true it won't sneak right click, it'll just right click, which means it'll open the chest instead of placing against it. That's why this defaults to off.

Assume step functionality; don't jump on an Ascend.

If you have Fire Resistance and Jesus then I guess you could turn this on lol

Allow Baritone to assume it can walk on still water just like any other block. This functionality is assumed to be provided by a separate library that might have imported Baritone.

Note: This will prevent some usage of the frostwalker enchantment, like pillaring up from water.

Automatically select the best available tool

Toggle the following 4 settings

They have a noticeable performance impact, so they default off

Specifically, building up the avoidance map on the main thread before pathing starts actually takes a noticeable amount of time, especially when there are a lot of mobs around, and your game jitters for like 200ms while doing so

this multiplies the break speed, if set above 1 it's "encourage breaking" instead

If this setting is true, Baritone will never break a block that is adjacent to an unsupported falling block.

I.E. it will never trigger cascading sand / gravel falls

The "axis" command (aka GoalAxis) will go to a axis, or diagonal axis, at this Y level.

Fill in blocks behind you

Set to 1.0 to effectively disable this feature

When GetToBlockProcess or MineProcess fails to calculate a path, instead of just giving up, mark the closest instance of that block as "unreachable" and go towards the next closest. GetToBlock expands this search to the whole "vein"; MineProcess does not. This is because MineProcess finds individual impossible blocks (like one block in a vein that has gravel on top then lava, so it can't break) Whereas GetToBlock should blacklist the whole "vein" if it can't get to any of them.

This is just a tiebreaker to make it less likely to break blocks if it can avoid it. For example, fire has a break cost of 0, this makes it nonzero, so all else being equal it will take an otherwise equivalent route that doesn't require it to put out fire.

How many ticks between breaking a block and starting to break the next block. Default in game is 6 ticks. Values under 1 will be clamped. The delay only applies to non-instant (1-tick) breaks.

Break and place blocks without having to force the client-sided rotations. Requires freeLook.

It doesn't actually take twenty ticks to place a block, this cost is so high because we want to generally conserve blocks which might be limited.

Decrease to make Baritone more often consider paths that would require placing blocks

Block reach distance

Blocks that Baritone will attempt to avoid (Used in avoidance)

blocks that baritone shouldn't break, but can if it needs to.

Blocks that Baritone is not allowed to break

Multiply the cost of breaking a block that's correct in the builder's schematic by this coefficient

Allow standing above a block while mining it, in BuilderProcess

Experimental

Distance to scan every tick for updates. Expanding this beyond player reach distance (i.e. setting it to 6 or above) is only necessary in very large schematics where rescanning the whole thing is costly.

A list of blocks to be treated as if they're air.

If a schematic asks for air at a certain position, and that position currently contains a block on this list, it will be treated as correct.

If this is true, the builder will ignore directionality of certain blocks like glazed terracotta.

If this is true, the builder will treat all non-air blocks as correct. It will only place new blocks.

A list of names of block properties the builder will ignore.

Don't consider the next layer in builder until the current one is done

Only build the selected part of schematics

How far to move before repeating the build. 0 to disable repeating on a certain axis, 0,0,0 to disable entirely

How many times to buildrepeat. -1 for infinite.

Don't notify schematics that they are moved. e.g. replacing will replace the same spots for every repetition Mainly for backward compatibility.

Mirrors the schematic before building it. Possible values are

• FRONT_BACK - mirror the schematic along its local x axis
• LEFT_RIGHT - mirror the schematic along its local z axis

Rotates the schematic before building it. Possible values are

• NONE - No rotation
• CLOCKWISE_90 - Rotate 90° clockwise
• CLOCKWISE_180 - Rotate 180° clockwise
• COUNTERCLOCKWISE_90 - Rotate 270° clockwise

A list of blocks to be treated as correct.

If a schematic asks for any block on this list at a certain position, it will be treated as correct, regardless of what it currently is.

A mapping of blocks to blocks to be built instead

If a schematic asks for a block on this mapping, Baritone will place the first placeable block in the mapped list

Usage Syntax:

     sourceblockA->blockToSubstituteA1,blockToSubstituteA2,...blockToSubstituteAN,sourceBlockB->blockToSubstituteB1,blockToSubstituteB2,...blockToSubstituteBN,...sourceBlockX->blockToSubstituteX1,blockToSubstituteX2...blockToSubstituteXN

Example:

    stone->cobblestone,andesite,oak_planks->birch_planks,acacia_planks,glass

A mapping of blocks to blocks treated as correct in their position

If a schematic asks for a block on this mapping, all blocks on the mapped list will be accepted at that location as well

Syntax same as buildSubstitutes

Cached chunks (regardless of if they're in RAM or saved to disk) expire and are deleted after this number of seconds -1 to disable

I would highly suggest leaving this setting disabled (-1).

The only valid reason I can think of enable this setting is if you are extremely low on disk space and you play on multiplayer, and can't take (average) 300kb saved for every 512x512 area. (note that more complicated terrain is less compressible and will take more space)

However, simply discarding old chunks because they are old is inadvisable. Baritone is extremely good at correcting itself and its paths as it learns new information, as new chunks load. There is no scenario in which having an incorrect cache can cause Baritone to get stuck, take damage, or perform any action it wouldn't otherwise, everything is rechecked once the real chunk is in range.

Having a robust cache greatly improves long distance pathfinding, as it's able to go around large scale obstacles before they're in render distance. In fact, when the chunkCaching setting is disabled and Baritone starts anew every time, or when you enter a completely new and very complicated area, it backtracks far more often because it has to build up that cache from scratch. But after it's gone through an area just once, the next time will have zero backtracking, since the entire area is now known and cached.

0.0f = not visible, fully transparent (instead of setting this to 0, turn off renderCachedChunks) 1.0f = fully opaque

Cancel the current path if the goal has changed, and the path originally ended in the goal but doesn't anymore.

Currently only runs when either MineBehavior or FollowBehavior is active.

For example, if Baritone is doing "mine iron_ore", the instant it breaks the ore (and it becomes air), that location is no longer a goal. This means that if this setting is true, it will stop there. If this setting were off, it would continue with its path, and walk into that location. The tradeoff is if this setting is true, it mines ores much faster since it doesn't waste any time getting into locations that no longer contain ores, but on the other hand, it misses some drops, and continues on without ever picking them up.

Also on cosmic prisons this should be set to true since you don't actually mine the ore it just gets replaced with stone.

Censor coordinates in goals and block positions

Censor arguments to ran commands, to hide, for example, coordinates to #goal

Allow chat based control of Baritone. Most likely should be disabled when Baritone is imported for use in something else

Some clients like Impact try to force chatControl to off, so here's a second setting to do it anyway

Print all the debug messages to chat

The big one. Download all chunks in simplified 2-bit format and save them for better very-long-distance pathing.

The chunk packer queue can never grow to larger than this, if it does, the oldest chunks are discarded

The newest chunks are kept, so that if you're moving in a straight line quickly then stop, your immediate render distance is still included

The color of the best path so far

The color of the blocks to break

The color of the blocks to place

The color of the blocks to walk into

The color of the current path

The color of the goal box

The color of the goal box when it's inverted

The color of the path to the most recent considered node

The color of the next path

The color of all selections

The color of the selection pos 1

The color of the selection pos 2

For example, if you have Mining Fatigue or Haste, adjust the costs of breaking blocks accordingly.

This is the big A* setting. As long as your cost heuristic is an *underestimate*, it's guaranteed to find you the best path. 3.5 is always an underestimate, even if you are sprinting. If you're walking only (with allowSprint off) 4.6 is safe. Any value below 3.5 is never worth it. It's just more computation to find the same path, guaranteed. (specifically, it needs to be strictly slightly less than ActionCosts.WALK_ONE_BLOCK_COST, which is about 3.56)

Setting it at 3.57 or above with sprinting, or to 4.64 or above without sprinting, will result in faster computation, at the cost of a suboptimal path. Any value above the walk / sprint cost will result in it going straight at its goal, and not investigating alternatives, because the combined cost / heuristic metric gets better and better with each block, instead of slightly worse.

Finding the optimal path is worth it, so it's the default.

Stop 5 movements before anything that made the path COST_INF. For example, if lava has spread across the path, don't walk right up to it then recalculate, it might still be spreading lol

After calculating a path (potentially through cached chunks), artificially cut it off to just the part that is entirely within currently loaded chunks. Improves path safety because cached chunks are heavily simplified.

This is much safer to leave off now, and makes pathing more efficient. More explanation in the issue.

Desktop notifications

Turn this on if your exploration filter is enormous, you don't want it to check if it's done, and you are just fine with it just hanging on completion

Disconnect from the server upon arriving at your goal

Trim incorrect positions too far away, helps performance but hurts reliability in very large schematics

allows baritone to save bed waypoints when interacting with beds

allows baritone to save death waypoints

Echo commands to chat when they are run

Automatically land when elytra is almost out of durability, or almost out of fireworks

Should elytra consider nether brick a valid landing block

Automatically path to and jump off of ledges to initiate elytra flight when grounded.

Automatically swap the current elytra with a new one when the durability gets too low

Maximum distance chunks can be before being culled from the nether pathfinder chunk cache

Verbose chat logging in elytra mode

If enabled, avoids using fireworks when descending along the flight path.

The delay after the player's position is set-back by the server that a firework may be automatically deployed. Value is in ticks.

The minimum speed that the player can drop to (in blocks/tick) before a firework is automatically deployed.

Automatically elytra fly without having to force the client-sided rotations.

The minimum fireworks before landing early for safety

The minimum padding value that is added to the player's hitbox when considering which point to fly to on the path. High values can result in points not being considered which are otherwise safe to fly to. Low values can result in flight paths which are extremely tight, and there's the possibility of crashing due to getting too low to the ground.

The minimum durability an elytra can have before being swapped

The seed used to generate chunks for long distance elytra path-finding in the nether. Defaults to 2b2t's nether seed.

The maximum allowed deviation in pitch from a direct line-of-sight to the flight target. Higher values are computationally more expensive.

Whether nether-pathfinder should generate terrain based on elytraNetherSeed. If false all chunks that haven't been loaded are assumed to be air.

Renders the raytraces that are used in the hitbox part of the elytra fly calculation. Requires elytraRenderRaytraces.

Renders the raytraces that are performed by the elytra fly calculation.

Renders the best elytra flight path that was simulated each tick.

The number of ticks of elytra movement to simulate while firework boost is not active. Higher values are computationally more expensive.

Same as smoothLook but for elytra flying.

Has the user read and understood the elytra terms and conditions

Time between culling far away chunks from the nether pathfinder chunk cache

When running a goto towards a nether portal block, walk all the way into the portal instead of stopping one block before.

Take the 10 closest chunks, even if they aren't strictly tied for distance metric from origin.

When GetToBlock or non-legit Mine doesn't know any locations for the desired block, explore randomly instead of giving up.

Attempt to maintain Y coordinate while exploring

-1 to disable

When the cache scan gives less blocks than the maximum threshold (but still above zero), scan the main world too.

Only if you have a beefy CPU and automatically mine blocks that are in cache

Start fading out the path at 20 movements ahead, and stop rendering it entirely 30 movements ahead. Improves FPS.

Pathing can never take longer than this, even if that means failing to find any path at all

Farming will scan for at most this many blocks.

The actual GoalNear is set in this direction from the entity you're following. This value is in degrees.

The actual GoalNear is set this distance away from the entity you're following

For example, set followOffsetDistance to 5 and followRadius to 0 to always stay precisely 5 blocks north of your follow target.

The radius (for the GoalNear) of how close to your target position you actually have to be

The maximum distance to the entity you're following

When mining block of a certain type, try to mine two at once instead of one. If the block above is also a goal block, set GoalBlock instead of GoalTwoBlocks If the block below is also a goal block, set GoalBlock to the position one down instead of GoalTwoBlocks

Move without having to force the client-sided rotations

As well as breaking from above, set a goal to up and to the side of all blocks to break.

Never turn this on without also turning on breakFromAbove.

Line width of the goal when rendered, in pixels

The set of incorrect blocks can never grow beyond this size

Modification to the previous setting, only has effect if forceInternalMining is true If true, only apply the previous setting if the block adjacent to the goal isn't air.

Come to a halt before doing any inventory moves. Intended for anticheat such as 2b2t

Stop using tools just before they are going to break.

Durability to leave on the tool when using itemSaver

Additional penalty for hitting the space bar (ascend, pillar, or parkour) because it uses hunger

How high should the individual layers be?

false = build from bottom to top

true = build from top to bottom

Disallow MineBehavior from using X-Ray to see where the ores are. Turn this option on to force it to mine "legit" where it will only mine an ore once it can actually see it, so it won't do or know anything that a normal player couldn't. If you don't want it to look like you're X-Raying, turn this on This will always explore, regardless of exploreForBlocks

Magically see ores that are separated diagonally from existing ores. Basically like mining around the ores that it finds in case there's one there touching it diagonally, except it checks it un-legit-ly without having the mine blocks to see it. You can decide whether this looks plausible or not.

This is disabled because it results in some weird behavior. For example, it can """see""" the top block of a vein of iron_ore through a lava lake. This isn't an issue normally since it won't consider anything touching lava, so it just ignores it. However, this setting expands that and allows it to see the entire vein so it'll mine under the lava lake to get the iron that it can reach without mining blocks adjacent to lava. This really defeats the purpose of legitMine since a player could never do that lol, so thats one reason why its disabled

What Y level to go to for legit strip mining

Shows popup message in the upper right corner, similarly to when you make an advancement

The function that is called when Baritone will log to chat. This function can be added to via Consumer#andThen(Consumer) or it can completely be overriden via setting Setting#value;

Build in map art mode, which makes baritone only care about the top block in each column

After finding this many instances of the target block in the cache, it will stop expanding outward the chunk search.

If a movement's cost increases by more than this amount between calculation and execution (due to changes in the environment / world), cancel and recalculate

How far are you allowed to fall onto solid ground (with a water bucket)? It's not that reliable, so I've set it below what would kill an unarmored player (23)

How far are you allowed to fall onto solid ground (without a water bucket)? 3 won't deal any damage. But if you just want to get down the mountain quickly and you have Feather Falling IV, you might set it a bit higher, like 4 or 5.

If we are more than 300 movements into the current path, discard the oldest segments, as they are no longer useful

Sets the maximum y level to mine ores at.

While mining, wait this number of milliseconds after mining an ore to see if it will drop an item instead of immediately going onto the next one

Thanks Louca

Rescan for the goal once every 5 ticks. Set to 0 to disable.

Mine will not scan for or remember more than this many target locations. Note that the number of locations retrieved from cache is additionaly limited by maxCachedWorldScanCount.

While mining, should it also consider dropped items of the correct type as a pathing destination (as well as ore blocks)?

Don't repropagate cost improvements below 0.01 ticks. They're all just floating point inaccuracies, and there's no point.

Sets the minimum y level whilst mining - set to 0 to turn off. if world has negative y values, subtract the min world height to get the value to put here

Set to 1.0 to effectively disable this feature

Set below 1.0 to go out of your way to walk near mobs

Distance to avoid mobs.

Set to 1.0 to effectively disable this feature

Set below 1.0 to go out of your way to walk near mob spawners

Distance to avoid mob spawners.

If a movement takes this many ticks more than its initial cost estimate, cancel it

Desktop notification on build finished

Desktop notification on explore finished

Desktop notification on farm fail

Desktop notification on mine fail

Desktop notification on path complete

The function that is called when Baritone will send a desktop notification. This function can be added to via Consumer#andThen(Consumer) or it can completely be overriden via setting Setting#value;

A list of blocks to become air

If a schematic asks for a block on this list, only air will be accepted at that location (and nothing on buildIgnoreBlocks)

Override builder's behavior to not attempt to correct blocks that are currently water

If we overshoot a traverse and end up one block beyond the destination, mark it as successful anyway.

This helps with speed exceeding 20m/s

Static cutoff factor. 0.9 means cut off the last 10% of all paths, regardless of chunk load state

Only apply static cutoff for paths of at least this length (in terms of number of movements)

If the current path is too long, cut off this many movements from the beginning.

Default size of the Long2ObjectOpenHashMap used in pathing

Load factor coefficient for the Long2ObjectOpenHashMap used in pathing

Decrease for faster map operations, but higher memory usage

The maximum number of times it will fetch outside loaded or cached chunks before assuming that pathing has reached the end of the known area, and should therefore stop.

Line width of the path when rendered, in pixels

Exclusively use cached chunks for pathing

Never turn this on

When breaking blocks for a movement, wait until all falling blocks have settled before continuing

Multiply the cost of placing a block that's incorrect in the builder's schematic by this coefficient

Planning ahead while executing a segment can never take longer than this, even if that means failing to find any path at all

Planning ahead while executing a segment ends after this amount of time, but only if a path has been found

If no valid path (length above the minimum) has been found, pathing continues up until the failure timeout

Start planning the next path once the remaining movements tick estimates sum up to less than this value

Always prefer silk touch tools over regular tools. This will not sacrifice speed, but it will always prefer silk touch tools over other tools of the same speed. This includes always choosing ANY silk touch tool over your hand.

The command prefix for chat control

Whether or not to allow you to run Baritone commands with the prefix

Pathing ends after this amount of time, but only if a path has been found

If no valid path (length above the minimum) has been found, pathing continues up until the failure timeout

On save, delete from RAM any cached regions that are more than 1024 blocks away from the player

Temporarily disabled

Temporarily reenabled

How many degrees to randomize the pitch and yaw every tick. Set to 0 to disable

How many degrees to randomize the yaw every tick. Set to 0 to disable

When true, the player will remain with its existing look direction as often as possible. Although, in some cases this can get it stuck, hence this setting to disable that behavior.

😎 Render cached chunks as semitransparent. Doesn't work with OptiFine 😭 Rarely randomly crashes, see this issue.

Can be very useful on servers with low render distance. After enabling, you may need to reload the world in order for it to have an effect (e.g. disconnect and reconnect, enter then exit the nether, die and respawn, etc). This may literally kill your FPS and CPU because every chunk gets recompiled twice as much as normal, since the cached version comes into range, then the normal one comes from the server for real.

Note that flowing water is cached as AVOID, which is rendered as lava. As you get closer, you may therefore see lava falls being replaced with water falls.

SOLID is rendered as stone in the overworld, netherrack in the nether, and end stone in the end

Render the goal

Render the goal as a sick animated thingy instead of just a box (also controls animation of GoalXZ if renderGoalXZBeacon is enabled)

Ignore depth when rendering the goal

Renders X/Z type Goals with the vanilla beacon beam effect. Combining this with renderGoalIgnoreDepth will cause strange render clipping.

Render the path

Render the path as a line instead of a frickin thingy

Ignore depth when rendering the path

Render selections

Render selection boxes

Ignore depth when rendering the selection boxes (to break, to place, to walk into)

Render selection corners

Ignore depth when rendering selections

Whenever a block changes, repack the whole chunk that it's in

Replant normal Crops while farming and leave cactus and sugarcane to regrow

Replant nether wart while farming. This setting only has an effect when replantCrops is also enabled

When running a goto towards a container block (chest, ender chest, furnace, etc), right click and open it once you arrive.

How many ticks between right clicks are allowed. Default in game is 4

The fallback used by the build command when no extension is specified. This may be useful if schematics of a particular format are used often, and the user does not wish to have to specify the extension with every usage.

When this setting is true, build a schematic with the highest X coordinate being the origin, instead of the lowest

When this setting is true, build a schematic with the highest Y coordinate being the origin, instead of the lowest

When this setting is true, build a schematic with the highest Z coordinate being the origin, instead of the lowest

Line width of the goal when rendered, in pixels

The opacity of the selection. 0 is completely transparent, 1 is completely opaque

Use a short Baritone prefix [B] instead of [Baritone] when logging to chat

If your goal is a GoalBlock in an unloaded chunk, assume it's far enough away that the Y coord doesn't matter yet, and replace it with a GoalXZ to the same place before calculating a path. Once a segment ends within chunk load range of the GoalBlock, it will go back to normal behavior of considering the Y coord. The reasoning is that if your X and Z are 10,000 blocks away, your Y coordinate's accuracy doesn't matter at all until you get much much closer.

If a layer is unable to be constructed, just skip it.

For debugging, consider nodes much much slower

Milliseconds between each node

The alternative timeout number when slowPath is on

Forces the client-sided yaw rotation to an average of the last smoothLookTicks of server-sided rotations.

The number of ticks to average across for smoothLook;

When a new segment is calculated that doesn't overlap with the current one, but simply begins where the current segment ends, splice it on and make a longer combined path. If this setting is off, any planned segment will not be spliced and will instead be the "next path" in PathingBehavior, and will only start after this one ends. Turning this off hurts planning ahead, because the next segment will exist even if it's very short.

Sprint and jump a block early on ascends wherever possible

Continue sprinting while in water

Start building the schematic at a specific layer. Can help on larger builds when schematic wants to break things its already built

Don't allow breaking blocks next to liquids.

Enable if you have mods adding custom fluid physics.

Wait this many ticks between InventoryBehavior moving inventory items

The function that is called when Baritone will show a toast. This function can be added to via Consumer#andThen(Consumer) or it can completely be overriden via setting Setting#value;

Use a modern message tag instead of a prefix when logging to chat

Use sword to mine.

Print out ALL command exceptions as a stack trace to stdout, even simple syntax errors

Walking on water uses up hunger really quick, so penalize it

Don't stop walking forward when you need to break blocks in your way

While exploring the world, offset the closest unloaded chunk by this much in both axes.

This can result in more efficient loading, if you set this to the render distance.

The size of the box that is rendered when the current goal is a GoalYLevel