diff --git a/src/api/java/baritone/api/Settings.java b/src/api/java/baritone/api/Settings.java
index cbbe5839..00d4af85 100644
--- a/src/api/java/baritone/api/Settings.java
+++ b/src/api/java/baritone/api/Settings.java
@@ -56,6 +56,13 @@ public class Settings {
      */
     public Setting<Double> blockPlacementPenalty = new Setting<>(20D);
 
+    /**
+     * 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.
+     */
+    public Setting<Double> blockBreakAdditionalPenalty = new Setting<>(2D);
+
     /**
      * Allow Baritone to fall arbitrary distances and place a water bucket beneath it.
      * Reliability: questionable.
diff --git a/src/main/java/baritone/pathing/movement/CalculationContext.java b/src/main/java/baritone/pathing/movement/CalculationContext.java
index ee4cb188..0b40539e 100644
--- a/src/main/java/baritone/pathing/movement/CalculationContext.java
+++ b/src/main/java/baritone/pathing/movement/CalculationContext.java
@@ -43,6 +43,7 @@ public class CalculationContext implements Helper {
     private final int maxFallHeightNoWater;
     private final int maxFallHeightBucket;
     private final double waterWalkSpeed;
+    private final double breakBlockAdditionalCost;
 
     public CalculationContext() {
         this(new ToolSet());
@@ -63,6 +64,7 @@ public class CalculationContext implements Helper {
         }
         float mult = depth / 3.0F;
         this.waterWalkSpeed = ActionCosts.WALK_ONE_IN_WATER_COST * (1 - mult) + ActionCosts.WALK_ONE_BLOCK_COST * mult;
+        this.breakBlockAdditionalCost = Baritone.settings().blockBreakAdditionalPenalty.get();
         // why cache these things here, why not let the movements just get directly from settings?
         // because if some movements are calculated one way and others are calculated another way,
         // then you get a wildly inconsistent path that isn't optimal for either scenario.
@@ -104,4 +106,7 @@ public class CalculationContext implements Helper {
         return waterWalkSpeed;
     }
 
+    public double breakBlockAdditionalCost() {
+        return breakBlockAdditionalCost;
+    }
 }
diff --git a/src/main/java/baritone/pathing/movement/MovementHelper.java b/src/main/java/baritone/pathing/movement/MovementHelper.java
index d614e544..28b14e9e 100644
--- a/src/main/java/baritone/pathing/movement/MovementHelper.java
+++ b/src/main/java/baritone/pathing/movement/MovementHelper.java
@@ -374,6 +374,7 @@ public interface MovementHelper extends ActionCosts, Helper {
             }
 
             double result = m / strVsBlock;
+            result += context.breakBlockAdditionalCost();
             if (includeFalling) {
                 IBlockState above = BlockStateInterface.get(x, y + 1, z);
                 if (above.getBlock() instanceof BlockFalling) {