diff --git a/src/main/java/org/mvplugins/multiverse/core/command/MVCommandContexts.java b/src/main/java/org/mvplugins/multiverse/core/command/MVCommandContexts.java
index 19ce84675..616f1d613 100644
--- a/src/main/java/org/mvplugins/multiverse/core/command/MVCommandContexts.java
+++ b/src/main/java/org/mvplugins/multiverse/core/command/MVCommandContexts.java
@@ -42,6 +42,7 @@
 import org.mvplugins.multiverse.core.locale.message.Message;
 import org.mvplugins.multiverse.core.utils.PlayerFinder;
 import org.mvplugins.multiverse.core.utils.REPatterns;
+import org.mvplugins.multiverse.core.utils.tick.TickDuration;
 import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
 import org.mvplugins.multiverse.core.world.MultiverseWorld;
 import org.mvplugins.multiverse.core.world.WorldManager;
@@ -93,6 +94,7 @@ public class MVCommandContexts extends PaperCommandContexts {
         registerIssuerAwareContext(PlayerArrayValue.class, playerArrayContextBuilder().generateContext(PlayerArrayValue::new));
         registerIssuerAwareContext(PlayerLocation.class, this::parsePlayerLocation);
         registerContext(SpawnCategory[].class, this::parseSpawnCategories);
+        registerContext(TickDuration.class, this::parseTickDuration);
     }
 
     private MVCommandIssuer parseMVCommandIssuer(BukkitCommandExecutionContext context) {
@@ -393,4 +395,13 @@ private SpawnCategory[] parseSpawnCategories(BukkitCommandExecutionContext conte
         }
         return categories.toArray(new SpawnCategory[0]);
     }
+
+    private TickDuration parseTickDuration(BukkitCommandExecutionContext context) {
+        String arg = context.popFirstArg();
+        return TickDuration.parseString(arg)
+                .getOrElseThrow(failure ->
+                        new InvalidCommandArgument("Invalid time duration format: \"" +arg + "\". Use a number " +
+                                "followed by an optional suffix (s for seconds, d for game days) or just a number " +
+                                "for ticks. Examples: 100, 5s, 2d"));
+    }
 }
diff --git a/src/main/java/org/mvplugins/multiverse/core/commands/WorldBorderCommand.java b/src/main/java/org/mvplugins/multiverse/core/commands/WorldBorderCommand.java
index 94e1e8cb2..06bf70850 100644
--- a/src/main/java/org/mvplugins/multiverse/core/commands/WorldBorderCommand.java
+++ b/src/main/java/org/mvplugins/multiverse/core/commands/WorldBorderCommand.java
@@ -12,8 +12,11 @@
 import org.mvplugins.multiverse.core.command.MVCommandIssuer;
 import org.mvplugins.multiverse.core.locale.MVCorei18n;
 import org.mvplugins.multiverse.core.locale.message.MessageReplacement.Replace;
+import org.mvplugins.multiverse.core.utils.compatibility.WorldBorderCompatibility;
+import org.mvplugins.multiverse.core.utils.tick.TickDuration;
 import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
 
+import java.time.temporal.ChronoUnit;
 import java.util.function.Consumer;
 
 import static org.mvplugins.multiverse.core.locale.message.MessageReplacement.replace;
@@ -33,15 +36,14 @@ void onWorldBorderAdd(
             @Optional
             @Default("0")
             @Syntax("[time]")
-            int time,
+            TickDuration duration,
 
             @Flags("resolve=issuerAware,maxArgForAware=0")
             @Syntax("[world]")
             LoadedMultiverseWorld world
     ) {
-        worldBorderAction(issuer, world, worldBorder -> {
-            onWorldBorderSet(issuer, worldBorder.getSize() + size, time, world);
-        });
+        worldBorderAction(issuer, world, worldBorder ->
+                onWorldBorderSet(issuer, worldBorder.getSize() + size, duration, world));
     }
 
     @Subcommand("center")
@@ -145,7 +147,7 @@ void onWorldBorderSet(
             @Optional
             @Default("0")
             @Syntax("[time]")
-            int time,
+            TickDuration duration,
 
             @Flags("resolve=issuerAware,maxArgForAware=0")
             @Syntax("[world]")
@@ -158,15 +160,18 @@ void onWorldBorderSet(
                         Replace.WORLD.with(world.getAliasOrName()));
                 return;
             }
-            worldBorder.setSize(size, time);
-            if (time <= 0) {
+            if (!WorldBorderCompatibility.supportsChangeSizeInTicks() && !duration.isExactTo(ChronoUnit.SECONDS)) {
+                setRoundOffError(issuer, duration);
+            }
+            WorldBorderCompatibility.changeSizeDuration(worldBorder, size, duration);
+            if (duration.toTicks() <= 0) {
                 issuer.sendMessage(MVCorei18n.WORLDBORDER_SET_IMMEDIATE,
                         replace("{size}").with(worldBorder.getSize()),
                         Replace.WORLD.with(world.getAliasOrName()));
             } else {
                 issuer.sendMessage(previousSize > size ? MVCorei18n.WORLDBORDER_SET_GROWING : MVCorei18n.WORLDBORDER_SET_SHRINKING,
                         replace("{size}").with(size),
-                        replace("{time}").with(time),
+                        replace("{time}").with(String.format("%.2f", duration.toSeconds())),
                         Replace.WORLD.with(world.getAliasOrName()));
             }
         });
@@ -201,25 +206,34 @@ void onWorldBorderWarningTime(
             MVCommandIssuer issuer,
 
             @Syntax("<time>")
-            int time,
+            TickDuration duration,
 
             @Flags("resolve=issuerAware,maxArgForAware=0")
             @Syntax("[world]")
             LoadedMultiverseWorld world
     ) {
         worldBorderAction(issuer, world, worldBorder -> {
-            if (worldBorder.getWarningTime() == time) {
+            if (WorldBorderCompatibility.getWarningTimeTicks(worldBorder) == duration.toTicks()) {
                 issuer.sendMessage(MVCorei18n.WORLDBORDER_WARNINGTIME_NOTHINGCHANGED,
                         Replace.WORLD.with(world.getAliasOrName()));
                 return;
             }
-            worldBorder.setWarningTime(time);
+            if (!WorldBorderCompatibility.supportsSetWarningTimeInTicks() && !duration.isExactTo(ChronoUnit.SECONDS)) {
+                setRoundOffError(issuer, duration);
+            }
+            WorldBorderCompatibility.setWarningTimeDuration(worldBorder, duration);
             issuer.sendMessage(MVCorei18n.WORLDBORDER_WARNINGTIME_SUCCESS,
-                    replace("{time}").with(worldBorder.getWarningTime()),
+                    replace("{time}").with(String.format("%.2f", WorldBorderCompatibility.getWarningTime(worldBorder))),
                     Replace.WORLD.with(world.getAliasOrName()));
         });
     }
 
+    private void setRoundOffError(MVCommandIssuer issuer, TickDuration duration) {
+        issuer.sendError(MVCorei18n.WORLDBORDER_ROUNDOFF_WARNING,
+                replace("{fromTime}").with(String.format("%.2f", duration.toSeconds())),
+                replace("{toTime}").with(Math.round(duration.toSeconds())));
+    }
+
     private void worldBorderAction(MVCommandIssuer issuer, LoadedMultiverseWorld world, Consumer<WorldBorder> worldBorderAction) {
         Try.run(() -> world.getWorldBorder().peek(worldBorderAction))
                 .onFailure(error -> issuer.sendError(error.getLocalizedMessage()));
diff --git a/src/main/java/org/mvplugins/multiverse/core/locale/MVCorei18n.java b/src/main/java/org/mvplugins/multiverse/core/locale/MVCorei18n.java
index 54958b26b..d31b9755b 100644
--- a/src/main/java/org/mvplugins/multiverse/core/locale/MVCorei18n.java
+++ b/src/main/java/org/mvplugins/multiverse/core/locale/MVCorei18n.java
@@ -250,6 +250,8 @@ public enum MVCorei18n implements MessageKeyProvider {
     WORLDBORDER_WARNINGTIME_NOTHINGCHANGED,
     WORLDBORDER_WARNINGTIME_SUCCESS,
 
+    WORLDBORDER_ROUNDOFF_WARNING,
+
     // commands error
     COMMANDS_ERROR_PLAYERSONLY,
     COMMANDS_ERROR_MULTIVERSEWORLDONLY,
diff --git a/src/main/java/org/mvplugins/multiverse/core/utils/MinecraftTimeFormatter.java b/src/main/java/org/mvplugins/multiverse/core/utils/MinecraftTimeFormatter.java
index 81c888f90..e58dc4b28 100644
--- a/src/main/java/org/mvplugins/multiverse/core/utils/MinecraftTimeFormatter.java
+++ b/src/main/java/org/mvplugins/multiverse/core/utils/MinecraftTimeFormatter.java
@@ -1,8 +1,8 @@
 package org.mvplugins.multiverse.core.utils;
 
 import io.vavr.control.Try;
-import org.checkerframework.checker.nullness.qual.Nullable;
 import org.jetbrains.annotations.ApiStatus;
+import org.mvplugins.multiverse.core.utils.tick.TickDuration;
 
 import java.time.LocalTime;
 import java.time.format.DateTimeFormatter;
@@ -15,10 +15,6 @@
 @ApiStatus.AvailableSince("5.1")
 public final class MinecraftTimeFormatter {
 
-    private static final double TIME_MULTIPLIER = 3.6;
-    private static final long DAY_SECONDS = 24 * 60 * 60;
-    private static final long START_OFFSET = 6 * 60 * 60;
-
     /**
      * Formats Minecraft time to 12-hour format.
      *
@@ -48,19 +44,14 @@ public static String format24h(long time) {
      * See <a href="https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html">DateTimeFormatter documentation</a>
      * for available patterns.
      *
-     * @param time   The Minecraft time to format.
-     * @param format The format string for the time.
+     * @param ticks     The Minecraft time to format.
+     * @param format    The format string for the time.
      *
      * @since 5.1
      */
     @ApiStatus.AvailableSince("5.1")
-    public static String formatTime(long time, String format) {
-        // Convert Minecraft time to real-world time
-        long realTime = (long) ((time * TIME_MULTIPLIER) + START_OFFSET) % DAY_SECONDS;  // Minecraft ticks to seconds
-
-        // Convert seconds to LocalTime
-        LocalTime localTime = LocalTime.ofSecondOfDay(realTime);
-
+    public static String formatTime(long ticks, String format) {
+        LocalTime localTime = TickDuration.ofTicks(ticks).toLocalTime();
         return Try.of(() -> DateTimeFormatter.ofPattern(format))
                 .map(localTime::format)
                 .getOrElse("invalid time format: " + format);
diff --git a/src/main/java/org/mvplugins/multiverse/core/utils/compatibility/WorldBorderCompatibility.java b/src/main/java/org/mvplugins/multiverse/core/utils/compatibility/WorldBorderCompatibility.java
new file mode 100644
index 000000000..c6358d6e4
--- /dev/null
+++ b/src/main/java/org/mvplugins/multiverse/core/utils/compatibility/WorldBorderCompatibility.java
@@ -0,0 +1,170 @@
+package org.mvplugins.multiverse.core.utils.compatibility;
+
+import org.bukkit.WorldBorder;
+import org.jetbrains.annotations.ApiStatus;
+import org.mvplugins.multiverse.core.utils.ReflectHelper;
+import org.mvplugins.multiverse.core.utils.tick.TickDuration;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Compatibility class used to handle API changes in {@link WorldBorder} class.
+ *
+ * @since 5.7
+ */
+@ApiStatus.AvailableSince("5.7")
+@SuppressWarnings("removal")
+public final class WorldBorderCompatibility {
+
+    private static final boolean HAS_GET_WARNING_TIME_TICKS_METHOD;
+    private static final boolean HAS_SET_WARNING_TIME_TICKS_METHOD;
+    private static final boolean HAS_SET_WARNING_TIME_METHOD;
+    private static final boolean HAS_GET_WARNING_TIME_METHOD;
+
+    private static final boolean HAS_CHANGE_SIZE_METHOD;
+    private static final boolean HAS_SET_SIZE_METHOD;
+
+    static {
+        HAS_GET_WARNING_TIME_TICKS_METHOD = ReflectHelper.hasMethod(WorldBorder.class, "getWarningTimeTicks");
+        HAS_SET_WARNING_TIME_TICKS_METHOD = ReflectHelper.hasMethod(WorldBorder.class, "setWarningTimeTicks", int.class);
+        HAS_GET_WARNING_TIME_METHOD = ReflectHelper.hasMethod(WorldBorder.class, "getWarningTime");
+        HAS_SET_WARNING_TIME_METHOD = ReflectHelper.hasMethod(WorldBorder.class, "setWarningTime", int.class);
+
+        HAS_CHANGE_SIZE_METHOD = ReflectHelper.hasMethod(WorldBorder.class, "changeSize", double.class, long.class);
+        HAS_SET_SIZE_METHOD = ReflectHelper.hasMethod(WorldBorder.class, "setSize", double.class, long.class);
+    }
+
+    /**
+     * Gets the world border warning time in ticks, using the most precise API available.
+     * <br />
+     * If the server exposes {@code getWarningTimeTicks()}, that value is returned directly. Otherwise, the older
+     * {@code getWarningTime()} API is used and converted from seconds to ticks.
+     *
+     * @param worldBorder The world border to query.
+     * @return The warning time in ticks.
+     *
+     * @since 5.7
+     * @throws IllegalStateException If neither warning-time getter is available.
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public static int getWarningTimeTicks(WorldBorder worldBorder) {
+        if (HAS_GET_WARNING_TIME_TICKS_METHOD) {
+            return worldBorder.getWarningTimeTicks();
+        } else if (HAS_GET_WARNING_TIME_METHOD) {
+            return worldBorder.getWarningTime() * 20;
+        }
+        throw new IllegalStateException("Neither getWarningTimeTicks nor getWarningTime method is available in WorldBorder class.");
+    }
+
+    /**
+     * Gets the world border warning time in seconds, using the most appropriate API available.
+     * <br />
+     * If the server exposes {@code getWarningTimeTicks()}, that value is converted from ticks to seconds. Otherwise,
+     * the older {@code getWarningTime()} API is used directly.
+     *
+     * @param worldBorder The world border to query.
+     * @return The warning time in seconds.
+     *
+     * @since 5.7
+     * @throws IllegalStateException If neither warning-time getter is available.
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public static double getWarningTime(WorldBorder worldBorder) {
+        if (HAS_GET_WARNING_TIME_TICKS_METHOD) {
+            return (double) worldBorder.getWarningTimeTicks() / 20.0;
+        } else if (HAS_GET_WARNING_TIME_METHOD) {
+            return worldBorder.getWarningTime();
+        }
+        throw new IllegalStateException("Neither getWarningTimeTicks nor getWarningTime method is available in WorldBorder class.");
+    }
+
+    /**
+     * Checks whether the current server supports setting the world border warning time in ticks.
+     *
+     * @return True if {@code setWarningTimeTicks(int)} is available, else false.
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public static boolean supportsSetWarningTimeInTicks() {
+        return HAS_SET_WARNING_TIME_TICKS_METHOD;
+    }
+
+    /**
+     * Sets the world border warning time in ticks.
+     * <br />
+     * This is a convenience wrapper around {@link #setWarningTimeDuration(WorldBorder, TickDuration)} that converts
+     * the given tick value into a {@link TickDuration} first.
+     *
+     * @param worldBorder   The world border to update.
+     * @param ticks         The warning time in ticks.
+     *
+     * @since 5.7
+     */
+    public static void setWarningTimeTicks(WorldBorder worldBorder, int ticks) {
+        setWarningTimeDuration(worldBorder, TickDuration.ofTicks(ticks));
+    }
+
+    /**
+     * Sets the world border warning time, preferring tick-based APIs when available.
+     * <br />
+     * If the server supports {@code setWarningTimeTicks(int)}, the provided duration is applied in ticks. Otherwise,
+     * the older {@code setWarningTime(int)} API is used and the duration is converted to seconds.
+     *
+     * @param worldBorder   The world border to update.
+     * @param duration      The warning duration to apply.
+     *
+     * @since 5.7
+     * @throws IllegalStateException If neither warning-time setter is available.
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public static void setWarningTimeDuration(WorldBorder worldBorder, TickDuration duration) {
+        if (HAS_SET_WARNING_TIME_TICKS_METHOD) {
+            worldBorder.setWarningTimeTicks((int) duration.toTicks());
+        } else if (HAS_SET_WARNING_TIME_METHOD) {
+            worldBorder.setWarningTime((int) Math.round(duration.to(TimeUnit.SECONDS)));
+        } else {
+            throw new IllegalStateException("Neither setWarningTimeTicks nor setWarningTime method is available in WorldBorder class.");
+        }
+    }
+
+    /**
+     * Checks whether the current server supports changing world border size over a duration in ticks.
+     *
+     * @return True if {@code changeSize(double, long)} is available, else false.
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public static boolean supportsChangeSizeInTicks() {
+        return HAS_CHANGE_SIZE_METHOD;
+    }
+
+    /**
+     * Changes the world border size, preferring the tick-based API when available.
+     * <br />
+     * If the server supports {@code changeSize(double, long)}, the size change is applied in ticks. Otherwise, the
+     * older {@code setSize(double, long)} API is used and the duration is converted to seconds.
+     *
+     * @param worldBorder   The world border to update.
+     * @param newSize       The new border size.
+     * @param duration      The transition duration to apply.
+     *
+     * @since 5.7
+     * @throws IllegalStateException If neither size-changing API is available.
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public static void changeSizeDuration(WorldBorder worldBorder, double newSize, TickDuration duration) {
+        if (HAS_CHANGE_SIZE_METHOD) {
+            worldBorder.changeSize(newSize, duration.toTicks());
+        } else if (HAS_SET_SIZE_METHOD) {
+            worldBorder.setSize(newSize, Math.round(duration.to(TimeUnit.SECONDS)));
+        } else {
+            throw new IllegalStateException("Neither changeSize nor setSize method is available in WorldBorder class.");
+        }
+    }
+
+    private WorldBorderCompatibility() {
+        throw new UnsupportedOperationException("This is a utility class and cannot be instantiated");
+    }
+}
diff --git a/src/main/java/org/mvplugins/multiverse/core/utils/tick/TickDuration.java b/src/main/java/org/mvplugins/multiverse/core/utils/tick/TickDuration.java
new file mode 100644
index 000000000..d3fe4366c
--- /dev/null
+++ b/src/main/java/org/mvplugins/multiverse/core/utils/tick/TickDuration.java
@@ -0,0 +1,274 @@
+package org.mvplugins.multiverse.core.utils.tick;
+
+import io.vavr.control.Try;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+
+import java.time.Duration;
+import java.time.LocalTime;
+import java.time.temporal.TemporalUnit;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Represents a duration in Minecraft game ticks.
+ * <p>
+ * This class wraps a {@link Duration} and provides convenient conversion methods
+ * between game ticks (50ms per tick), game days (24,000 ticks), and other time units.
+ * Game time is mapped to real-world seconds via: realSeconds = (ticks * 3.6) + 6*3600 (mod 24h),
+ * which means 00:00 maps to 06:00 in-game time.
+ * </p>
+ *
+ * @since 5.7
+ */
+@ApiStatus.AvailableSince("5.7")
+public final class TickDuration {
+
+    /**
+     * Parses a time string into a {@link TickDuration}.
+     * <br />
+     * Formats supported:
+     * <ul>
+     *   <li>{@code "123"} - raw tick count</li>
+     *   <li>{@code "10s"} - seconds</li>
+     *   <li>{@code "5d"} - game days</li>
+     * </ul>
+     *
+     * @param timeString the time string to parse
+     * @return a {@link Try} containing the parsed {@link TickDuration}, or a failure if parsing fails
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public static Try<TickDuration> parseString(@NotNull String timeString) {
+        return Try.of(() -> {
+            if (timeString.endsWith("s")) {
+                String subString = timeString.substring(0, timeString.length() - 1);
+                return of(Long.parseLong(subString), TimeUnit.SECONDS);
+            } else if (timeString.endsWith("d")) {
+                String subString = timeString.substring(0, timeString.length() - 1);
+                return ofGameDays(Long.parseLong(subString));
+            }
+            return ofTicks(Long.parseLong(timeString));
+        });
+    }
+
+    /**
+     * Creates a {@link TickDuration} from a {@link Duration}.
+     *
+     * @param duration the duration
+     * @return a new {@link TickDuration}
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    @Contract(value = "_ -> new", pure = true)
+    public static @NotNull TickDuration ofDuration(@NotNull Duration duration) {
+        return new TickDuration(duration);
+    }
+
+    /**
+     * Creates a {@link TickDuration} from seconds (as a {@link Duration}).
+     *
+     * @param duration the duration representing seconds
+     * @return a new {@link TickDuration}
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    @Contract(value = "_ -> new", pure = true)
+    public static @NotNull TickDuration ofSeconds(@NotNull Duration duration) {
+        return new TickDuration(duration);
+    }
+
+    /**
+     * Creates a {@link TickDuration} from a tick count.
+     *
+     * @param ticks the number of game ticks
+     * @return a new {@link TickDuration}
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    @Contract(value = "_ -> new", pure = true)
+    public static @NotNull TickDuration ofTicks(long ticks) {
+        return of(ticks, TickUnit.TICK);
+    }
+
+    /**
+     * Creates a {@link TickDuration} from a game day count.
+     *
+     * @param gameDays the number of game days (24,000 ticks each)
+     * @return a new {@link TickDuration}
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    @Contract(value = "_ -> new", pure = true)
+    public static @NotNull TickDuration ofGameDays(long gameDays) {
+        return of(gameDays, TickUnit.GAME_DAY);
+    }
+
+    /**
+     * Creates a {@link TickDuration} from a time value and {@link TimeUnit}.
+     *
+     * @param time the time value
+     * @param unit the time unit
+     * @return a new {@link TickDuration}
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    @Contract(value = "_, _ -> new", pure = true)
+    public static @NotNull TickDuration of(long time, @NotNull TimeUnit unit) {
+        return of(time, unit.toChronoUnit());
+    }
+
+    /**
+     * Creates a {@link TickDuration} from a time value and {@link TemporalUnit}.
+     *
+     * @param time the time value
+     * @param unit the temporal unit
+     * @return a new {@link TickDuration}
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    @Contract(value = "_, _ -> new", pure = true)
+    public static @NotNull TickDuration of(long time, @NotNull TemporalUnit unit) {
+        return new TickDuration(Duration.of(time, unit));
+    }
+
+    private static final double TIME_MULTIPLIER = 3.6;
+    private static final long DAY_SECONDS = 24 * 60 * 60;
+    private static final long START_OFFSET = 6 * 60 * 60;
+
+    private final Duration duration;
+
+    /**
+     * Creates a {@link TickDuration} from a {@link Duration}.
+     *
+     * @param duration the underlying duration
+     */
+    private TickDuration(@NotNull Duration duration) {
+        this.duration = duration;
+    }
+
+    /**
+     * Converts this duration to Minecraft local time.
+     * <p>
+     * Maps the duration to real-world seconds using the formula:
+     * realSeconds = (ticks * 3.6) + 6*3600 (mod 24h)
+     * </p>
+     *
+     * @return the {@link LocalTime} in Minecraft time (where 00:00 = 06:00 in-game)
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public @NotNull LocalTime toLocalTime() {
+        // Minecraft maps ticks -> seconds by: realSeconds = (ticks * 3.6) + 6*3600 (mod 24h)
+        long realSeconds = (long) ((toTicks() * TIME_MULTIPLIER) + START_OFFSET) % DAY_SECONDS;
+        return LocalTime.ofSecondOfDay(realSeconds);
+    }
+
+    /**
+     * Converts this duration to game ticks.
+     *
+     * @return the number of game ticks (1 tick = 50ms)
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public long toTicks() {
+        return duration.toMillis() / TickUnit.TICK.inMillis();
+    }
+
+    /**
+     * Converts this duration to game days.
+     *
+     * @return the number of game days (1 day = 24,000 ticks)
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public double toGameDays() {
+        return (double) duration.toMillis() / (double) TickUnit.GAME_DAY.inMillis();
+    }
+
+    /**
+     * Converts this duration to seconds.
+     *
+     * @return the duration in seconds
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public double toSeconds() {
+        return to(TimeUnit.SECONDS);
+    }
+
+    /**
+     * Converts this duration to a specified {@link TimeUnit}.
+     *
+     * @param unit the target time unit
+     * @return the duration in the specified unit
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public double to(@NotNull TimeUnit unit) {
+        return to(unit.toChronoUnit());
+    }
+
+    /**
+     * Converts this duration to a specified {@link TemporalUnit}.
+     *
+     * @param unit the target temporal unit
+     * @return the duration in the specified unit
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public double to(@NotNull TemporalUnit unit) {
+        return (double) duration.toMillis() / (double) unit.getDuration().toMillis();
+    }
+
+    /**
+     * Checks whether this duration is an exact multiple of the given {@link TimeUnit}.
+     *
+     * @param unit the time unit to test against
+     * @return {@code true} if this duration divides evenly by the unit, otherwise {@code false}
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public boolean isExactTo(@NotNull TimeUnit unit) {
+        return isExactTo(unit.toChronoUnit());
+    }
+
+    /**
+     * Checks whether this duration is an exact multiple of the given {@link TemporalUnit}.
+     *
+     * @param unit the temporal unit to test against
+     * @return {@code true} if this duration divides evenly by the unit, otherwise {@code false}
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public boolean isExactTo(@NotNull TemporalUnit unit) {
+        return duration.toMillis() % unit.getDuration().toMillis() == 0;
+    }
+
+    /**
+     * Returns the underlying {@link Duration}.
+     *
+     * @return the duration
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public Duration getDuration() {
+        return duration;
+    }
+}
diff --git a/src/main/java/org/mvplugins/multiverse/core/utils/tick/TickUnit.java b/src/main/java/org/mvplugins/multiverse/core/utils/tick/TickUnit.java
new file mode 100644
index 000000000..71ab0c830
--- /dev/null
+++ b/src/main/java/org/mvplugins/multiverse/core/utils/tick/TickUnit.java
@@ -0,0 +1,112 @@
+package org.mvplugins.multiverse.core.utils.tick;
+
+import org.jetbrains.annotations.ApiStatus;
+
+import java.time.Duration;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.Temporal;
+import java.time.temporal.TemporalUnit;
+
+/**
+ * A {@link TemporalUnit} implementation for Minecraft game ticks.
+ * <br />
+ * Provides two standard units:
+ * <ul>
+ *   <li>{@link #TICK} - A single game tick (50 milliseconds)</li>
+ *   <li>{@link #GAME_DAY} - A full game day (24,000 ticks)</li>
+ * </ul>
+ * This unit is not date-based and is precisely defined without estimation.
+ *
+ * @since 5.7
+ */
+@ApiStatus.AvailableSince("5.7")
+public final class TickUnit implements TemporalUnit {
+
+    private static final long SINGLE_TICK_DURATION_MS = 50L;
+    private static final long TICKS_PER_GAME_DAY = 24_000L;
+
+    /**
+     * A single game tick (50 milliseconds).
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public static final TickUnit TICK = new TickUnit(SINGLE_TICK_DURATION_MS);
+
+    /**
+     * A full game day (24,000 ticks = 20 minutes in real time).
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public static final TickUnit GAME_DAY = new TickUnit(SINGLE_TICK_DURATION_MS * TICKS_PER_GAME_DAY);
+
+    private final long milliseconds;
+    private final Duration duration;
+
+    private TickUnit(long milliseconds) {
+        this.milliseconds = milliseconds;
+        this.duration = Duration.ofMillis(milliseconds);
+    }
+
+    /**
+     * Gets the duration of this unit in milliseconds.
+     *
+     * @return the duration in milliseconds
+     *
+     * @since 5.7
+     */
+    @ApiStatus.AvailableSince("5.7")
+    public long inMillis() {
+        return milliseconds;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Duration getDuration() {
+        return duration;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public boolean isDurationEstimated() {
+        return false;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public boolean isDateBased() {
+        return false;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public boolean isTimeBased() {
+        return true;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @SuppressWarnings("unchecked") // following ChronoUnit#addTo
+    @Override
+    public <R extends Temporal> R addTo(R temporal, long amount) {
+        return (R) temporal.plus(duration.multipliedBy(amount));
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public long between(final Temporal start, final Temporal end) {
+        return start.until(end, ChronoUnit.MILLIS) / milliseconds;
+    }
+}
diff --git a/src/main/java/org/mvplugins/multiverse/core/world/helpers/DataStore.java b/src/main/java/org/mvplugins/multiverse/core/world/helpers/DataStore.java
index a50e068b8..7a8c97896 100644
--- a/src/main/java/org/mvplugins/multiverse/core/world/helpers/DataStore.java
+++ b/src/main/java/org/mvplugins/multiverse/core/world/helpers/DataStore.java
@@ -9,6 +9,7 @@
 import org.bukkit.World;
 import org.jvnet.hk2.annotations.Service;
 import org.mvplugins.multiverse.core.config.handle.StringPropertyHandle;
+import org.mvplugins.multiverse.core.utils.compatibility.WorldBorderCompatibility;
 import org.mvplugins.multiverse.core.world.LoadedMultiverseWorld;
 import org.mvplugins.multiverse.core.world.MultiverseWorld;
 
@@ -140,14 +141,16 @@ class WorldBorderStore implements DataStore<LoadedMultiverseWorld> {
          */
         @Override
         public WorldBorderStore copyFrom(LoadedMultiverseWorld world) {
-            world.getBukkitWorld().peek(bukkitWorld -> {
-                borderCenterX = bukkitWorld.getWorldBorder().getCenter().getX();
-                borderCenterZ = bukkitWorld.getWorldBorder().getCenter().getZ();
-                borderDamageAmount = bukkitWorld.getWorldBorder().getDamageAmount();
-                borderDamageBuffer = bukkitWorld.getWorldBorder().getDamageBuffer();
-                borderSize = bukkitWorld.getWorldBorder().getSize();
-                borderTimeRemaining = bukkitWorld.getWorldBorder().getWarningTime();
-            });
+            world.getBukkitWorld()
+                    .map(World::getWorldBorder)
+                    .peek(worldBorder -> {
+                        borderCenterX = worldBorder.getCenter().getX();
+                        borderCenterZ = worldBorder.getCenter().getZ();
+                        borderDamageAmount = worldBorder.getDamageAmount();
+                        borderDamageBuffer = worldBorder.getDamageBuffer();
+                        borderSize = worldBorder.getSize();
+                        borderTimeRemaining = WorldBorderCompatibility.getWarningTimeTicks(worldBorder);
+                    });
             return this;
         }
 
@@ -156,13 +159,15 @@ public WorldBorderStore copyFrom(LoadedMultiverseWorld world) {
          */
         @Override
         public WorldBorderStore pasteTo(LoadedMultiverseWorld world) {
-            world.getBukkitWorld().peek(bukkitWorld -> {
-                bukkitWorld.getWorldBorder().setCenter(borderCenterX, borderCenterZ);
-                bukkitWorld.getWorldBorder().setDamageAmount(borderDamageAmount);
-                bukkitWorld.getWorldBorder().setDamageBuffer(borderDamageBuffer);
-                bukkitWorld.getWorldBorder().setSize(borderSize);
-                bukkitWorld.getWorldBorder().setWarningTime(borderTimeRemaining);
-            });
+            world.getBukkitWorld()
+                    .map(World::getWorldBorder)
+                    .peek(worldBorder -> {
+                        worldBorder.setCenter(borderCenterX, borderCenterZ);
+                        worldBorder.setDamageAmount(borderDamageAmount);
+                        worldBorder.setDamageBuffer(borderDamageBuffer);
+                        worldBorder.setSize(borderSize);
+                        WorldBorderCompatibility.setWarningTimeTicks(worldBorder, borderTimeRemaining);
+                    });
             return this;
         }
     }
diff --git a/src/main/resources/multiverse-core_en.properties b/src/main/resources/multiverse-core_en.properties
index 274c2bc25..a998eaa8e 100644
--- a/src/main/resources/multiverse-core_en.properties
+++ b/src/main/resources/multiverse-core_en.properties
@@ -221,15 +221,17 @@ mv-core.worldborder.damagebuffer.success=&rSet the world border damage buffer to
 mv-core.worldborder.get.size=&rThe world border is currently {size} block(s) wide for world '&6{world}&r'.
 
 mv-core.worldborder.set.nothingchanged=&cNothing changed. The world border is already that size for world '&6{world}&c'.
-mv-core.worldborder.set.immediate=&rSet the world border to {size} block(s) wide for world '&6{world}&r'.
-mv-core.worldborder.set.shrinking=&rShrinking the world border to {size} block(s) wide over {time} second(s) for world '&6{world}&r'.
-mv-core.worldborder.set.growing=&rGrowing the world border to {size} block(s) wide over {time} second(s) for world '&6{world}&r'.
+mv-core.worldborder.set.immediate=&fSet the world border to &6{size}&f block(s) wide for world '&6{world}&f'.
+mv-core.worldborder.set.shrinking=&fShrinking the world border to &6{size}&f block(s) wide over &6{time}&f second(s) for world '&6{world}&f'.
+mv-core.worldborder.set.growing=&fGrowing the world border to &6{size} block(s) wide over &6{time}&f second(s) for world '&6{world}&f'.
 
 mv-core.worldborder.warningdistance.nothingchanged=&cNothing changed. The world border warning is already that distance for world '&6{world}&c'.
-mv-core.worldborder.warningdistance.success=&rSet the world border warning distance to {distance} block(s) for world '&6{world}&r'.
+mv-core.worldborder.warningdistance.success=&fSet the world border warning distance to &6{distance}&f block(s) for world '&6{world}&f'.
 
 mv-core.worldborder.warningtime.nothingchanged=&cNothing changed. The world border warning is already that amount of time for world '&6{world}&c'.
-mv-core.worldborder.warningtime.success=&rSet the world border warning time to {time} second(s) for world '&6{world}&r'.
+mv-core.worldborder.warningtime.success=&fSet the world border warning time to &6{time}&f second(s) for world '&6{world}&f'.
+
+mv-core.worldborder.roundoff.warning=&cYour server version does not support setting time in ticks. Hence, it will be rounded to the nearest second from &6{fromTime}&c second(s) to &6{toTime}&c second(s).
 
 # commands error
 mv-core.commands.error.playersonly=&cThis command can only be used by players
diff --git a/src/test/java/org/mvplugins/multiverse/core/utils/tick/TickDurationTest.kt b/src/test/java/org/mvplugins/multiverse/core/utils/tick/TickDurationTest.kt
new file mode 100644
index 000000000..c7721a406
--- /dev/null
+++ b/src/test/java/org/mvplugins/multiverse/core/utils/tick/TickDurationTest.kt
@@ -0,0 +1,49 @@
+package org.mvplugins.multiverse.core.utils.tick
+
+import java.time.Duration
+import java.time.LocalTime
+import java.util.concurrent.TimeUnit
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class TickDurationTest {
+
+    @Test
+    fun `Parse raw tick, second, and game day strings`() {
+        val ticks = TickDuration.parseString("123")
+        val seconds = TickDuration.parseString("10s")
+        val gameDays = TickDuration.parseString("5d")
+
+        assertTrue(ticks.isSuccess)
+        assertTrue(seconds.isSuccess)
+        assertTrue(gameDays.isSuccess)
+
+        assertEquals(123L, ticks.get().toTicks())
+        assertEquals(200L, seconds.get().toTicks())
+        assertEquals(120_000L, gameDays.get().toTicks())
+    }
+
+    @Test
+    fun `Convert durations across units`() {
+        val duration = TickDuration.ofDuration(Duration.ofMillis(75))
+        val gameDays = TickDuration.ofGameDays(2)
+
+        assertEquals(1L, duration.toTicks())
+        assertEquals(0.075, duration.toSeconds(), absoluteTolerance = 1e-9)
+        assertFalse(duration.isExactTo(TimeUnit.SECONDS))
+        assertTrue(duration.isExactTo(TimeUnit.MILLISECONDS))
+
+        assertEquals(48_000L, gameDays.toTicks())
+        assertEquals(2.0, gameDays.toGameDays())
+        assertEquals(2_400.0, gameDays.toSeconds())
+    }
+
+    @Test
+    fun `Convert duration to Minecraft local time`() {
+        assertEquals(LocalTime.of(6, 0), TickDuration.ofTicks(0).toLocalTime())
+        assertEquals(LocalTime.of(7, 0), TickDuration.ofTicks(1_000).toLocalTime())
+        assertEquals(LocalTime.of(6, 0), TickDuration.ofTicks(24_000).toLocalTime())
+    }
+}