It started with a tiny glitch — a click that didn’t register. Just once or twice.
But it got me thinking: what if I could measure it, repeat it, and actually understand what was going on?
That question led to a weekend project. I didn’t expect it to be useful to anyone else — but it turns out, a surprising number of people also wonder: “Is it me, or is my mouse just busted?”
The Problem: Missed Clicks Are Hard to Prove
If you’ve ever played games, done pixel-precise design, or worked in QA, you know how annoying it is when your mouse doesn’t behave predictably.
In my case, it was a cheap wireless mouse that occasionally “dropped” clicks — just enough to be suspicious, but not enough to prove it.
I needed a simple way to test whether the mouse was skipping inputs or introducing lag. So I built one.
How I Built a Click Tester
The project started as a minimal tool to measure click accuracy and latency.
It tracks how quickly you can double-click, whether your clicks are delayed, and whether some are missing entirely.
At first, it was just one page with a couple of timers. But as I kept refining it, I realized this could help more than just me — especially for gamers, developers, accessibility testers, or anyone wondering if their hardware was behaving oddly.
What It Measures
The site now includes a few lightweight browser-based tools:
- Double Click Test — Measures intervals between two clicks to test consistency
- Mouse Click Test — Tracks single clicks to catch occasional misses
- CPS Counter (Clicks Per Second) — A skill test that also reveals latency patterns
- Kohi Test — Used by Minecraft players to benchmark jitter or butterfly clicking
No installs, no logins, no popups — just focused tools in the browser.
What I Learned
Building this taught me a few unexpected things:
- Hardware inconsistency is common. Even new or “good” mice may have erratic click behavior.
- Humans can’t always feel subtle lag. You might miss 20ms of delay, but your reflexes show it.
- Debugging peripherals is niche but real. It sits in a weird space between gaming, dev tools, and diagnostics.
Also: the line between a fun toy and a serious tool is thinner than I thought.
Technical Notes
The tester is written in vanilla JavaScript — no libraries, no frameworks.
Click intervals are tracked using performance.now() for sub-millisecond accuracy.
Events are filtered to avoid noise (e.g. touch events on mobile, or bounce from rapid hardware triggers).
For example, in the Double Click Test, the code compares two mousedown timestamps. If they're within a 500ms window, it calculates the delta and stores it. The same goes for CPS, which is more about counting rapid input bursts over a timed window.
Making it consistent across Chrome, Firefox, and Safari required a bit of fussing with event propagation quirks.
Unexpected Use Cases
Once the tool was online, I started hearing from people using it in ways I didn’t expect:
- A QA engineer used it to validate a batch of new mice before rollout
- Someone with limited mobility used it to tune their input device timing
- A speedrunner wanted to benchmark click rhythm for game resets
- One person even used the test to convince tech support their mouse was faulty — and got a replacement
It started as a personal tool, but it’s been fascinating to watch it pick up niche users.
Challenges
A few surprisingly tricky things:
- Debouncing vs precision: Some devices auto-smooth input, which masks real delay
- Mobile compatibility: Touch events don’t map cleanly to mouse events
- User perception vs reality: People often think they double-clicked, but didn’t — or vice versa
I also had to prevent cheating in CPS-style tests (e.g. holding down mouse keys, autoclickers). I didn’t want a leaderboard, but still wanted results to be meaningful.
Try It Yourself
You can try the tester here:
👉 doubleclicktest.com
Feedback?
If you've ever debugged a flaky mouse, trained for a clicking game, or just wanted to know how reactive your input really is — let me know what you think.
I'm always curious how people use odd little tools like this.