TinyTask Loop Tutorial: How to Repeat Macros on Loop

TinyTask’s loop counter typically supports values from 1 to 9999 in the standard interface. For anything beyond that, use the continuous playback option instead, which loops indefinitely until manually stopped.

In practice, the limiting factor is not TinyTask but the target application and your computer’s stability over time. After thousands of loops spanning several hours, you may encounter:

• Memory buildup in the target application causing slowdowns
• Timing drift accumulating to the point where clicks miss their targets
• Windows updates or background processes interrupting the macro

For very high loop counts (500+), run in batches of 100-200 with manual verification between batches. This catches problems early and prevents large-scale data issues.

TinyTask does not have a dedicated “delay between loops” setting. However, you can achieve the same effect by building the delay into your recording.

At the end of your recording, simply wait for the desired delay time before stopping the recording. For example, if you want 5 seconds between loops:

1. Perform your task actions
2. When the task actions are complete, wait 5 seconds (do nothing)
3. Stop recording

The 5-second wait becomes part of the recording and replays at the end of every loop, creating a gap between cycles. You can adjust this effective delay by changing the playback speed: at 2x speed, a recorded 5-second pause becomes 2.5 seconds.

For more precise timing control, consider using AutoHotkey, which has a dedicated Sleep command that can insert exact delays between loop iterations.

Running a macro overnight requires a few extra precautions beyond normal looping:

Before starting:

• Disable Windows sleep and screen timeout: Settings > System > Power & Sleep > set all timers to “Never”
• Disable screen saver: it can interrupt macro focus
• Enable Focus Assist to block notifications
• Plug in your laptop (battery saving mode throttles performance)
• Close all unnecessary applications to prevent pop-ups
• Disable Windows Update automatic restart: Settings > Windows Update > Advanced options > set active hours

Looping setup:

• Use continuous playback or set the loop count high enough to cover the full night (calculate: hours needed x loops per hour)
• Set playback speed to 0.8x-1.0x for maximum stability
• Test with 10 loops first while watching, then start the overnight run

In the morning: Check the target application to see how far the macro got. If it ran all night without errors, the last record entered should match your expected count. If it stopped early, check for pop-ups, errors, or timing drift.

This is the most common loop problem. It almost always means the application’s state changes after N cycles in a way your recording does not account for. Common causes:

• Scroll position drift: After entering 10 rows, the spreadsheet scrolls down and buttons move out of their original positions. Fix: add Ctrl+Home at the end of each cycle to reset scroll position.
• Pagination: A web app shows 10 records per page. After 10 entries, a “Next Page” button appears or the form moves to page 2. Fix: break the macro into page-sized batches.
• Confirmation dialogs: Some apps show a “Are you sure?” dialog after every 10th save, or an “Auto-save complete” notification. Fix: record one extra cycle that handles the dialog, or increase the loop’s built-in pause to wait for the dialog to auto-close.
• Session timeout: Web applications sometimes refresh the session after a certain number of actions. Fix: add a page refresh (F5) periodically, or run shorter batches.

The fix is almost always: add a “reset” step at the end of your recording that forces the application back to a known state, regardless of how many cycles have run.

TinyTask does not support nested loops directly. It has one recording and one loop counter. You cannot create an inner loop that runs 5 times within an outer loop that runs 10 times.

Workarounds for nested-loop behavior:

• Record the inner loop manually: If your inner loop is 5 iterations, perform all 5 during recording. Your recording now contains one complete outer-loop cycle with 5 inner iterations baked in. Set TinyTask’s loop counter for the outer loop count.
• Chain compiled EXEs: Create one EXE for the inner task (set to loop 5 times), then record a second macro that launches the first EXE, waits for it to finish, then does the outer-loop setup. Loop the second macro.
• Use AutoHotkey: For genuine nested loops with variable iteration counts, AHK’s Loop command supports nesting: Loop 10 { Loop 5 { ... } }

For most practical purposes, recording the inner loop as part of the macro and looping the outer cycle is sufficient and much simpler than trying to simulate nested loops.

TinyTask itself uses almost no memory or CPU regardless of how many loops run. The entire program is 36KB, and its memory footprint stays constant whether it has looped 1 time or 10,000 times. It does not accumulate data between loops.

However, the target application may accumulate resource usage:

• Browsers: Each page reload or form submission can increase memory usage. After hundreds of loops, Chrome or Firefox may use significantly more RAM.
• Spreadsheets: Adding rows to large Excel files increases memory usage linearly.
• CRM/ERP systems: Some enterprise applications cache data locally, growing memory usage over many operations.

If you notice the target application slowing down after many loops, stop the macro, close and reopen the application, then resume. This clears accumulated memory and restores normal performance.

There are two ways to speed up loops: increase playback speed and optimize your recording.

Increase playback speed:

• Move the speed slider to the right (1.2x, 1.5x, 2x)
• Test at each speed level with 3 loops before committing
• Maximum safe speed depends on the target application’s response time

Optimize the recording:

• Remove unnecessary mouse movements: move directly between click targets
• Use keyboard shortcuts instead of menu navigation
• Reduce wait times to the minimum the application needs
• Avoid scrolling when keyboard navigation can reach the same element

A well-optimized recording at 1.5x speed can be 3-4 times faster than a sloppy recording at 1.0x speed. The recording quality matters more than the playback speed.

TinyTask does not have a pause/resume function. When you stop playback, the macro stops wherever it is in the cycle. Restarting playback begins from the start of the recording, not from where it stopped.

Workarounds:

• Plan your stop points: Watch the macro and stop at the end of a complete cycle rather than mid-cycle. This way, restarting the loop picks up cleanly.
• Track your progress: If you are processing 200 records and need to stop at record 50, note that you completed 50 loops. When resuming, set the loop counter to 150 for the remaining records.
• Use the lock screen trick: Pressing Win+L locks the PC and stops TinyTask from sending inputs, but does not close TinyTask. When you unlock, TinyTask may still be in the “playing” state. The macro effectively pauses, but the resume behavior is not reliable across all versions.

For tasks that genuinely need pause/resume, AutoHotkey scripts can implement this with a toggle hotkey that pauses and resumes mid-execution while maintaining state.

TinyTask can only play one recording at a time and does not support chaining multiple recordings in sequence. However, you can achieve sequential execution with these approaches:

• Record everything as one macro: Instead of separate recordings for Task A and Task B, record one continuous session that does Task A then Task B. Loop this combined recording.
• Chain compiled EXEs with a batch file: Compile each macro as an EXE, then create a Windows batch file (.bat) that runs them in sequence:
  start /wait TaskA.exe
start /wait TaskB.exe
  The /wait flag ensures each macro finishes before the next one starts.
• Use Task Scheduler: Schedule Macro A to run at 9:00 AM and Macro B to run at 9:30 AM (with enough gap for Macro A to finish).

The batch file approach is the most flexible since it runs macros in strict sequence regardless of how long each takes.

TinyTask’s loop count setting may not persist between sessions depending on your version. The most reliable way to save loop settings permanently is to compile the macro to an EXE with the loop count set.

Steps:

1. Open TinyTask and load your .rec file
2. Set the loop count to your desired number
3. Compile to EXE
4. The EXE now has the loop count baked in and will always use it

If you need to change the loop count frequently, keep the .rec file and set the loop count manually each time you run it. Alternatively, create multiple compiled EXEs with different loop counts (e.g., “FormEntry-50loops.exe” and “FormEntry-200loops.exe”) for your most common batch sizes.