LexiClicker

A fast, precise, free and open-source auto clicker and macro engine for Windows.

Version 3 is a ground-up rewrite. The engine is native Rust talking straight to the Windows input stack; the interface is a local web UI running in the system's own WebView. There is no Python runtime, no local HTTP server, no polling loop, and nothing is fetched from the internet at any point.

Download

Grab the installer or the portable exe from Releases. Windows 10 or 11; the WebView2 runtime it needs ships with both.

The original Python version is still in this repository's history.

Clicks not landing in a game?

Windows silently drops input that a normal app sends into a window running as administrator, and many games and launchers run that way. LexiClicker notices while it is clicking: the window shows a warning with Restart as administrator, and the HUD reads blocked - needs admin. The settings menu can also make it always start as administrator.

If a game still ignores clicks, give each click a little Hold time (10-30 ms): games that read the mouse once per frame can miss a press and release that arrive together.

What it does

Clicking

• Fixed, random, human-like, or ramping intervals - fractional milliseconds supported, so rates above 1000 CPS are real rather than aspirational.
• Left, right, middle and both side buttons; multi-click; press-and-hold.
• Click at the cursor, a fixed point, a random point in an area, or a spot measured from the corner of whatever window is in front.
• Keep-cursor-free mode: the pointer is put back after every click, in the same input batch, so the mouse stays usable while a run is going.
• Optional jitter and curved, eased cursor paths.

Macros

• Record what you actually do - clicks, drags, scrolls, keystrokes - with real timing, and get back a list of editable steps.
• Steps cover clicks, movement, drags, scroll, key press/hold/release, typed text, waits, repeat blocks, and stopping the run.
• Blocks nest: a repeat block holds a body, and a colour test holds a "then" and an "otherwise" arm, both editable inline in the step table.
• Multiple named profiles, each with its own steps.

Triggers

• Wait until a screen pixel becomes (or stops being) a colour.
• Branch on a pixel test, with steps under each arm.
• Wait for a captured image to appear, and optionally click it.

Living with it

• Global hotkeys that work while any app is focused, including mouse side buttons and the wheel. Optional hold-to-click.
• Bind keys to click faster or slower and the rate changes on the next interval, without stopping the run. It follows whatever the interval mode is expressed in, so "faster" always means faster.
• Per-app profiles: bind a profile to an executable, switch to it automatically, and pause when that app is not in front.
• An always-on-top HUD showing status and rate, click-through so it never steals a click.
• Safety rails: stop when you move the mouse, top-left corner failsafe, restart cooldown, maximum run time, panic key.
• Practice mode runs everything for real but sends no input anywhere - useful for building a macro without consequences.
• Four themes, English and Ukrainian, click ripples and synthesised click sounds, tray icon, import/export.

Precision

Windows' default timer granularity is 15.6 ms, which is why many auto clickers quietly cap out around 60 CPS regardless of what you type into them. LexiClicker raises timer resolution for the duration of a run, waits on a high-resolution waitable timer, spins over the last fraction of a millisecond, and schedules on absolute deadlines so error cannot accumulate.

Measured by the built-in self-test on a debug build:

Requested interval	Measured	Error
1 ms (1000 CPS)	1.002 ms	0.2%
5 ms (200 CPS)	5.003 ms	0.1%
20 ms (50 CPS)	20.032 ms	0.2%

The Diagnostics strip in the app shows the same measurement for your machine.

Building

Requirements: Rust (stable, MSVC toolchain), Node (for the Tauri CLI), and the WebView2 runtime, which ships with Windows 10 and 11.

npm install
npm run dev

To produce an installer:

npm run build

Self-test

The engine can be exercised without touching your desktop. Practice mode is switched on, so the timing, macro flow and counters all run for real while the final input call is suppressed:

npm run selftest

Nineteen checks: exact click counts, interval accuracy at three rates, stop latency mid-interval, macro flow (disabled steps, nested repeat blocks, the stop action), restart safety, live rate changes, how the recorder turns raw input into steps, the admin-window probe, and that the literal JSON the step editor writes still deserializes into the engine's own model - which is the check that catches the UI and the engine drifting apart.

It is not run in CI: shared build machines are too noisy for the millisecond-level timing checks.

Where settings live

%APPDATA%\LexiClicker\config.json. Put a file named portable.txt next to the executable and settings are kept in the app folder instead, for USB-stick use.

Layout

ui/                 frontend - plain ES modules, no bundler, no dependencies
  css/              design tokens and component styles
  js/               api bridge, state, panels
src-tauri/src/
  input.rs          SendInput; every event tagged so the app ignores its own
  timing.rs         high-resolution, cancellable, low-CPU scheduling
  engine.rs         the run loop and the macro interpreter
  hooks.rs          global keyboard/mouse hooks: hotkeys, recorder, safety
  recorder.rs       raw events compiled into editable steps
  screen.rs         pixel probes, region capture, template matching
  actions.rs        the macro action model
  config.rs         settings and debounced persistence
  selftest.rs       headless engine checks

Licence

MIT. See LICENSE.

Links: GitHub · Patreon · Ko-fi