How to Compile TinyTask Recordings to Standalone EXE Files
Turning Macros into Programs
Most macro recorders stop at .rec or .macro files that only open inside the recorder itself. TinyTask goes further. It can compile your recording into a standalone Windows executable.
That compiled EXE contains everything it needs to replay your actions. Double-click it on any Windows machine and the macro runs — no TinyTask, no installation, no dependencies. The person running it does not even need to know what TinyTask is.
This is one of the features that separates TinyTask from most free automation tools. AutoHotkey can compile scripts too, but that process involves a separate compiler tool and more setup. TinyTask puts a Compile button right on the toolbar, and the entire operation takes about one second.
This guide covers how the compile feature works under the hood, walks through every step of the process, and addresses the practical issues you will run into — from antivirus false positives to screen resolution headaches.
What Compile to EXE Actually Does
The compile feature bundles the TinyTask playback engine together with your recording data into a single Windows executable.
TinyTask v1.77 is written in pure C using the native Windows API. The entire program — recording, playback, UI, and all — compresses into roughly 36KB. When you compile a recording, TinyTask takes its own playback engine (stripped of the toolbar and recording logic) and appends your macro data to create the output EXE.
Your recording itself is surprisingly small. TinyTask stores mouse coordinates, click types, keyboard scancodes, and timing intervals between events. A five-minute recording with hundreds of actions might add only 10-15KB of data. The result is a compiled EXE that typically weighs between 50KB and 70KB, no matter how long or complex the original recording was.
When the compiled EXE runs, it does exactly three things:
- Reads the embedded macro data from itself
- Replays every recorded input event with the original timing
- Exits (or loops back to step 2 if a loop count was set)
No window appears. No tray icon. No configuration dialog. The process shows up in Task Manager, but from the user’s perspective, the mouse just starts moving and clicking on its own.
Why so small? TinyTask avoids all frameworks — no .NET, no Java, no Electron, no Qt. It calls the Win32 API directly for SendInput, mouse_event, and keybd_event. The compiled output has zero external dependencies and runs on every Windows version from XP through 11 without any runtime library.
Step-by-Step: Compile Your First Recording
Seven steps from a raw recording to a distributable EXE file.
Create or Load a Recording
Either record a new macro by clicking Record (or pressing Ctrl+Shift+Alt+R), or open a previously saved .rec file. If you have not recorded anything yet, check the beginner’s guide to TinyTask first.
Test the Recording
Click Play and watch the entire sequence. Make sure every click lands on the right target and the timing feels correct. Fixing errors after compilation is not possible — you would need to re-record.
Set the Loop Count
Use the loop spinner on the toolbar. Enter 1 for a single run, any number for repeats, or 0 for infinite looping. This value gets baked into the EXE permanently.
Click Compile
Hit the Compile button on the toolbar. A standard Windows “Save As” dialog opens, asking where to save the output file.
Name the EXE
Give it a descriptive name like “Invoice_Data_Entry.exe” or “Morning_Setup.exe” instead of “macro1.exe.” Pick a save location and click Save.
Compilation Is Instant
The file appears in your chosen folder immediately. No progress bar, no build log, no waiting. TinyTask simply writes the combined binary to disk.
Test the Compiled EXE
Navigate to the output file and double-click it. The macro replays exactly as recorded. Verify everything works before sharing or deploying the file.
Infinite loop warning: If you compile with loop count set to 0, the EXE runs forever. Unlike TinyTask itself, compiled EXEs have no stop hotkey. The only way to stop it is Task Manager (Ctrl+Shift+Esc). For anything you plan to distribute, set a specific loop count.
What Compiled EXEs Can and Cannot Do
The compile feature is powerful but comes with real constraints. Know both sides before distributing your macros.
- Replays the exact recorded mouse and keyboard sequence
- Runs on any Windows PC from XP through 11
- Completely portable — copy to USB, email, or share on a network drive
- No TinyTask installation needed on the target machine
- No admin rights required in most scenarios
- Tiny output file — typically 50-70KB
- No royalties or licensing restrictions on distribution
- Works with Windows Task Scheduler for timed automation
- No pause, resume, or stop during playback
- No speed adjustment at runtime (baked at compile time)
- No stop hotkey like TinyTask’s
Ctrl+Shift+Alt+P - No TinyTask toolbar or settings UI
- Cannot be edited or decompiled back to a .rec file
- No custom icon — uses a generic Windows application icon
- Loop count is fixed at compilation and cannot change
- No error handling if target windows move or close
Practical Use Cases
Compiled TinyTask EXEs solve real problems across offices, IT departments, and personal automation.
Sharing with Coworkers
Drop “Fill_Weekly_Report.exe” on a shared network drive. Coworkers double-click it, and the form fills itself. No software to install, no training needed, no IT approval required.
Portable Toolkit
Build a folder of compiled macros on a USB drive. “OpenDailyApps.exe,” “ClearTempFiles.exe,” “SetupWorkspace.exe.” Carry your automation between home, office, and loaner machines.
Scheduled Automation
Point Windows Task Scheduler at the compiled EXE. Run backup routines at 6 AM, generate daily reports at noon, or launch your morning apps when you log in. No user interaction needed.
Kiosk and Lab PCs
Compiled EXEs leave nothing behind — no installed software, no registry entries, no leftover files. Run the automation on locked-down shared machines without touching the system configuration.
Gaming Macros
Compile farming sequences, idle grinding loops, or repetitive crafting actions into one-click EXEs. Keep in mind that many games consider macros a terms-of-service violation.
QA Testing
Record a test case, compile it, and hand the EXE to someone who has never opened TinyTask. They run it, watch the test execute, and report the result. Zero setup on their end.
Limitations and Gotchas
These are the issues that catch people off guard. Understand them before distributing any compiled macro.
Screen Resolution Dependency
TinyTask records absolute pixel coordinates. If the target PC runs at 1920×1080 and you recorded at 2560×1440, every click misses its target. Different DPI scaling settings (100% vs 125% vs 150%) cause the same problem even when resolution matches.
How to mitigate it: Always maximize application windows before recording so UI elements anchor to screen edges rather than floating at arbitrary coordinates. Record on the same resolution and DPI as the target machines. For multi-monitor setups, keep the action on the primary display only.
Antivirus False Positives
Compiled TinyTask EXEs almost always trigger antivirus warnings. The executable simulates mouse clicks and keyboard input through low-level Win32 API calls — the exact same technique used by keyloggers and remote access trojans. Windows Defender SmartScreen will also block it as an “unrecognized app” because the EXE is not digitally signed.
How to deal with it: Add the EXE to your antivirus exclusion list. In corporate environments, ask IT to whitelist the specific file hash. You can upload the file to VirusTotal and share the report link to prove the file is clean. Read more about TinyTask’s safety profile.
No Runtime Control
Once a compiled EXE starts playing, there is no pause button, no speed slider, and no stop hotkey. The process runs until the macro finishes or the loop count is exhausted. If you compiled with infinite looping, the only exit is killing the process through Task Manager (Ctrl+Shift+Esc).
Tip: Always test with a finite loop count first. Only switch to infinite (0) after you are confident the macro works correctly and you have a clear plan for stopping it.
Timing Drift
TinyTask records the exact millisecond gaps between events. On a fast machine, playback stays accurate. On a slower PC, or when the target application takes longer to respond, the macro can get ahead of the software. Clicks happen before dialogs finish loading, buttons get pressed before they render, and the whole sequence falls apart.
How to reduce drift: Record with deliberately slow, generous pauses between actions. Give each dialog an extra half-second to load. It is better to have a macro that takes 20 seconds and works reliably than one that takes 8 seconds and fails on half the machines.
UAC Considerations
If the macro needs to interact with elevated applications (programs running as administrator), the compiled EXE also needs to run as administrator. The EXE itself does not request elevation automatically — you need to right-click and choose “Run as administrator” manually, or set it in the file’s compatibility properties.
Note: On machines with strict Group Policy settings, running unsigned EXEs may be blocked entirely. Check with IT before deploying compiled macros in managed enterprise environments.
Tips for Better Compiled EXEs
Small adjustments during recording make a big difference in how well the compiled EXE performs on other machines.
Maximize windows before recording. When applications run maximized, buttons and menus sit in predictable positions regardless of screen size. This is the single most effective way to make macros work across different PCs.
Add deliberate pauses between actions. Wait a beat after clicking a menu or opening a dialog before performing the next action. TinyTask captures the timing, and those pauses give slower machines enough time to respond during playback.
Use keyboard shortcuts when possible. Instead of clicking File → Save, press Ctrl+S during the recording. Keyboard shortcuts work regardless of where menus are positioned and are far less sensitive to resolution differences.
Name your EXEs descriptively. “Invoice_Entry_Q1.exe” tells you what the macro does six months from now. “macro3.exe” does not. Include the task name and any relevant context in the filename.
Keep recordings short and focused. Instead of one massive 10-minute macro, create several smaller ones for individual tasks. Shorter recordings are easier to test, less likely to break, and faster to re-record when things change.
Save the .rec file alongside the EXE. The compiled EXE cannot be decompiled. If you ever need to modify the macro, you will need the original .rec file. Keep both in the same folder as a habit.
TinyTask Compile vs AutoHotkey Compile
Both tools can produce standalone EXEs. The approaches, tradeoffs, and output differ significantly.
| Feature | TinyTask | AutoHotkey (Ahk2Exe) |
|---|---|---|
| Input method | Record mouse/keyboard actions visually | Write scripts in AHK scripting language |
| Compile process | One click on toolbar, instant | Separate Ahk2Exe compiler tool |
| Output file size | 50–70 KB | 150–800 KB depending on includes |
| Custom icons | Not supported | Fully supported |
| Decompilation | Not possible — binary data | Source code can be extracted from older versions |
| Logic and conditions | None — pure playback only | Full scripting: if/else, loops, variables, functions |
| Runtime control | No stop/pause/resume | Hotkeys, tray icon, pause support |
| Window awareness | Absolute pixel coordinates only | Window-relative, control-based targeting |
| Dependencies | None — pure Win32 | None (runtime is embedded) |
| Learning curve | None — record and click Compile | Medium to high — scripting required |
| Best for | Quick portable macros, sharing simple automation | Complex automation, polished tools, conditional logic |
The bottom line: TinyTask compilation is about convenience. You get a working EXE in under a minute with zero coding. AutoHotkey compilation is about power. You can build proper tools with error handling, custom UI, and window-aware actions — but you need to learn a scripting language first. For a deeper comparison, see the full AutoHotkey vs TinyTask guide.
Frequently Asked Questions
Can I sell or commercially distribute compiled TinyTask macros?
TinyTask is freeware, and the developer has not imposed royalty or licensing restrictions on compiled output. The EXE you create is yours to distribute however you see fit — on a USB drive, through email, on your company intranet, or bundled with a product.
That said, selling a compiled TinyTask macro as a standalone “software product” has practical limitations. The EXE cannot be customized with your own icon, branding, or version info. It has no error handling, no user interface, and no license key mechanism. Buyers would get a generic-looking executable that replays mouse clicks.
If you want to build automation products for sale, AutoHotkey or a dedicated RPA platform is a better foundation. TinyTask compilation works well for internal distribution within a team or company where the goal is convenience, not commercial sale.
Can I decompile a TinyTask EXE back to a .rec file?
No. TinyTask embeds the recording data as raw binary inside the executable. There is no official decompiler, and the data format is not documented. Once compiled, the macro data is essentially locked inside the EXE in a proprietary format.
This is different from AutoHotkey, where older compiled EXEs stored the original script text inside the file. Tools like Resource Hacker could extract AHK source code from compiled executables. TinyTask does not work this way — it stores event coordinates and timing data in a binary format, not human-readable script text.
The practical takeaway: always save your .rec file alongside the compiled EXE. If you lose the .rec, you lose the ability to edit the macro. Your only option at that point is to re-record the entire sequence from scratch. Consider keeping a backup folder with all your .rec files organized by project or purpose.
Do compiled TinyTask EXEs work on Windows 11?
Yes. TinyTask v1.77 and its compiled output run on every version of Windows from XP through 11, including the latest 24H2 update. The program uses basic Win32 API functions that Microsoft has maintained backward compatibility for across two decades of operating system releases.
There are two Windows 11 specifics to be aware of. First, SmartScreen will flag the compiled EXE as “unrecognized” because it is not digitally signed. Click “More info” and then “Run anyway” to proceed. Second, if you are using display scaling above 100% (common on high-DPI laptops), the macro’s pixel coordinates may be off. Set scaling to 100% or record on the same scale as the target machine.
ARM-based Windows 11 devices (like Surface Pro X or Snapdragon-powered laptops) also run compiled TinyTask EXEs through Microsoft’s x86 emulation layer. Performance is identical for macro playback since the operations are simple and lightweight.
Why does antivirus flag my compiled TinyTask EXE?
Antivirus software uses heuristic analysis to detect suspicious behavior. A compiled TinyTask EXE does several things that trigger those heuristics: it simulates mouse clicks through SendInput, generates keyboard events through keybd_event, and runs without any visible window or user interface. These are the same techniques used by malware, which is why detection rates are high.
The EXE is also unsigned. Code signing certificates cost money and require identity verification. Since TinyTask is a free, single-developer project, the compiled output does not carry a digital signature. Windows SmartScreen trusts signed executables and blocks unsigned ones by default.
To resolve the issue, add the EXE to your antivirus exclusion list. In Windows Defender, go to Settings → Update & Security → Windows Security → Virus & threat protection → Manage settings → Exclusions. Add the compiled EXE file or its folder. You can also upload the file to VirusTotal.com to generate a public report showing the file is clean, which helps when convincing IT departments to whitelist it.
For more details on this topic, see our full safety analysis of TinyTask.
Will a compiled macro work on a different screen resolution?
Not reliably. TinyTask records absolute pixel coordinates — “click at position 540, 320” rather than “click the Save button.” If the target machine has a different resolution, those coordinates point to different spots on screen. A button that sat at (540, 320) on a 1920×1080 display will be somewhere else on a 2560×1440 display.
DPI scaling makes this worse. Windows scales interface elements based on the user’s display settings (100%, 125%, 150%, and so on). Two machines can have the same 1920×1080 resolution but different scaling, which shifts where UI elements appear in terms of actual pixel coordinates.
The best mitigation is to maximize all application windows during recording. Maximized windows anchor their UI to predictable positions (top-left corner, menu bar at the top, buttons at consistent offsets from edges). Also try to use keyboard shortcuts instead of mouse clicks wherever possible, since keyboard input does not depend on coordinates at all.
If you need to distribute a macro across machines with mixed resolutions, record separate versions for each resolution, or consider switching to AutoHotkey which supports window-relative and control-based targeting.
What determines the file size of the compiled EXE?
The compiled EXE has two parts: the TinyTask playback engine (a fixed ~36KB) and your recording data. The recording data grows with the number of events captured, but not by much. Each mouse movement, click, or keystroke adds only a few bytes of coordinate/timing data.
A typical one-minute recording with moderate mouse movement produces an EXE of about 50-55KB. A ten-minute recording with heavy mouse movement might reach 65-70KB. Even very long recordings rarely exceed 100KB because the data is just sequences of numbers (X coordinate, Y coordinate, event type, timestamp delta).
This is dramatically smaller than AutoHotkey compiled scripts, which embed the AHK runtime interpreter and typically produce EXEs in the 150-800KB range. The size difference comes down to architecture: TinyTask is pure C with direct Win32 calls, while AutoHotkey includes a scripting language interpreter in every compiled output.
Can I add a custom icon to the compiled EXE?
TinyTask does not support custom icons in its compiler. Every compiled EXE uses the same default Windows application icon. There is no setting, command-line flag, or workaround within TinyTask itself to change this.
You could theoretically use a resource editor like Resource Hacker to swap the icon in the compiled EXE after the fact. Open the EXE in Resource Hacker, replace the icon resource, and save. This works, but it modifies the executable, which will likely change its file hash and could trigger additional antivirus alerts.
If custom branding matters to you, AutoHotkey’s Ahk2Exe compiler supports custom icons natively. You specify the icon file as a compiler parameter and get a professionally branded output. For TinyTask, the lack of custom icons is one of the tradeoffs you accept for the one-click simplicity of the compile process.
Is there a maximum recording length for compilation?
TinyTask does not enforce a hard limit on recording length. People have compiled 30-minute and even hour-long recordings without hitting a ceiling. The practical limit is the available memory on your system during recording, since TinyTask holds the entire recording in RAM before saving.
That said, longer recordings are far more likely to fail during playback. A 30-minute macro has hundreds of pixel-precise clicks, each of which depends on the target application being in exactly the right state. If any dialog loads half a second late or a window shifts by a few pixels, the rest of the sequence falls apart with no recovery mechanism.
The practical recommendation is to keep recordings under two to three minutes. Break longer workflows into multiple compiled EXEs and run them sequentially. This makes troubleshooting dramatically easier because you can identify which step failed without watching a 30-minute replay.
Does the compiled EXE need administrator rights to run?
In most cases, no. The compiled EXE runs at the same privilege level as the user who double-clicks it. If the user has standard permissions, the macro runs with standard permissions. It can interact with normal applications, web browsers, file managers, and most desktop software without elevation.
The exception is when the macro needs to click inside an application that is running with elevated privileges. Windows isolates input between different privilege levels as a security measure called User Interface Privilege Isolation (UIPI). A standard-privilege EXE cannot send mouse clicks or keyboard input to an admin-elevated window.
If your macro targets an elevated application, right-click the compiled EXE and select “Run as administrator.” For regular use, you can set this permanently in the file’s Properties → Compatibility tab → “Run this program as an administrator.” Just remember that running any executable as admin means it has full system access, so only do this when genuinely necessary.
Can I use a batch file instead of compiling to EXE?
Yes, and for some use cases a batch file is actually more flexible. Instead of compiling, save your recording as a .rec file and create a .bat file that launches TinyTask with the recording. The batch approach requires TinyTask to be present on the machine (or on the same USB drive), but it gives you something the compiled EXE cannot: runtime control.
With the batch approach, TinyTask’s full toolbar is available during playback. You can pause, adjust speed, stop the macro with the hotkey, and even re-record. You can also chain multiple .rec files in a single batch script, adding delays between them with the timeout command.
A compiled EXE is better when you want zero-setup distribution — hand someone a single file and walk away. A batch file plus .rec approach is better when you want flexibility and the ability to update the macro without recompiling. Many people keep both: a .bat file for their own use and a compiled EXE for distribution to others.
The batch file approach is covered in more detail in the TinyTask getting started guide.
Ready to Compile Your First Macro?
Download TinyTask, record your workflow, and click Compile. The entire process takes less than a minute.
Download TinyTask