Tick Calculator

Minecraft servers do not count time in seconds. They count in ticks, and the scheduler wants ticks. This calculator turns seconds, minutes and hours into ticks and back, writes the exact scheduler code for a delay or a repeat, shows you on a timeline when it will run, and explains the Minecraft day clock.

What is a tick?

The server runs its whole game in small steps. In each step it moves mobs, grows crops, checks redstone and handles players. One step is one tick. A healthy server does exactly 20 ticks per second, so one tick lasts 50 milliseconds.

When you ask the scheduler to run your code "in 3 seconds", you really say "in 60 ticks". The scheduler counts ticks, not clock time, so the rule you need is:

If the server lags and only manages 10 ticks per second, those 60 ticks take 6 real seconds. That is one reason some schedulers count real time instead. The calculator shows both.

The Tick Calculator

Which scheduler method should I use?

Paper has two families of schedulers. Both do the same job; they differ in where the code runs and what unit the numbers use.

• The Bukkit scheduler (getServer().getScheduler()) is the classic one. runTaskLater runs your code once after a delay. runTaskTimer runs it again and again, with a first delay and then a period. Everything is in ticks. The Asynchronously versions run on another thread. This family does not work on Folia.
• The Folia-style schedulers are the newer family and work on both Paper and Folia. The global region scheduler (runDelayed, runAtFixedRate) is for work that does not belong to one place. The region scheduler takes a Location. The entity scheduler follows an Entity. These also take ticks.
• The async scheduler (getAsyncScheduler()) is different: it takes a number and a TimeUnit such as TimeUnit.SECONDS. It counts real time, so lag does not move it. Use it for work that must not touch the game: files, databases, web requests.

Most plugins start with the Bukkit scheduler. Timing and tasks: the scheduler explains each method, and Folia and regionized scheduling explains when the second family matters.

How to use the generated code

1. Pick a preset or fill in the times

   Choose "Every 5 minutes", or type your own delay and repeat time with a unit. You can mix units: a delay of 10 seconds and a repeat of 2 minutes is fine.

2. Copy the code into onEnable (or any method)

   The snippet starts with getServer() and uses this as the plugin, so it works inside your main class. If it uses TimeUnit, copy the import line too.

3. Replace the log line with your own code

   The calculator logs a message so you can see it run. Put your own code inside the braces instead.

4. Stop repeating tasks when you are done

   A repeating task runs until the plugin is disabled. The task in task -> { ... } is the task itself, and task.cancel() stops it.

Common questions

• What is the difference between delay and period? The delay is the wait before the first run. The period is the wait between one run and the next. A task with delay 0 and period 20 runs now and then every second.
• Why does the number end in L? The scheduler wants a long, a bigger kind of whole number. 20L is just the number 20 written as a long.
• Why not use Thread.sleep? Sleeping on the main thread freezes the entire server, so nobody can move. The scheduler waits without blocking anything.
• Can I schedule a delay shorter than one tick? No. A tick is the smallest step. The calculator rounds to the nearest whole tick and tells you when it does.

Mistakes beginners make with time

• Passing seconds where ticks are expected. runTaskLater(this, task, 5L) waits a quarter of a second, not five seconds. For five seconds write 100L.
• Using the async scheduler for ticks. runDelayed(this, task, 100, TimeUnit.SECONDS) waits 100 seconds, not 100 ticks.
• A repeat of 0. A task cannot repeat every 0 ticks. The fastest possible is every tick (1L).
• Forgetting that a day is 24000 ticks. Setting the time to 24000 is the same as 0. The day clock below shows where each tick falls.
• Depending on exact timing. If the server lags, tick-based tasks run late. If you need a real-time guarantee, such as a cooldown measured in seconds, store System.currentTimeMillis() when it starts. Cooldowns, toggles and player state shows how.

Recap

• 20 ticks = 1 second, so ticks = seconds x 20. One tick is 50 milliseconds.
• The Bukkit scheduler and the Folia-style scheduler count ticks. The async scheduler counts real time with a TimeUnit.
• Delay is the wait before the first run; period is the time between runs.
• A Minecraft day is 24000 ticks (20 real minutes), and tick 0 is 6:00 in the morning.

Quick quiz

Next steps

Use your new numbers in Timing and tasks: the scheduler and Patterns: cooldowns, toggles and player state. If you want a text countdown on screen, see titles, action bars and boss bars.