Autotyping tool that types text on a timer with adjustable WPM, custom hotkeys, and anti-AFK keystroke runs for games and chat apps.
autotyping-script (ebmeivktlmmj/autotyping-script)
Searching Database…
autotyping-script README
The project's README from github.com/ebmeivktlmmj/autotyping-script. As one markdown file: README.md.
Load a profile, pick the window, hit the start hotkey.
🎹 Table of Contents
- Overview — What This Actually Is
- Is It Safe? Does It Work On Windows? Will It Get Me Banned?
- The Problem — Why Autotypers Usually Suck
- The Solution — What Changed In The 2026 Rewrite
- System Requirements
- Quick Start — Read This Before Touching The .exe
- Grouped Module Catalog
- This Tool vs The Field — Comparison
- Usage Guidelines — Allowed vs Not Allowed
- Anti-Ban / Stealth Notes
- Known Issues
- Roadmap / Planned Features
- Tips For Best Results
- Numbered FAQ
🎹 Overview — What This Actually Is
Yes — it bypasses the obvious heuristic detectors. Yes — it runs on Windows 10/11 x64 with admin or without. Yes — it's free and there's no license server phone-home. Everything else is in the tables below.
This is an autotyping tool. It sends keystrokes to whatever window is focused — chat windows, console boxes, text fields, game inputs, terminal panes. Nothing exotic about the core premise. What makes it worth caring about is the timing engine: keystroke intervals are humanized per-key with variance jitter, fatigue drift, and burst/rest cadence, instead of a fixed sleep() between characters. The 2026 rewrite rips out the old loop entirely and stitches the emitter to a scheduling layer that models typing as a non-uniform stochastic process.
Built solo, tested obsessively across AFK farms, long-form text floods, ledger-style key spamming in MMOs, and one very boring afternooon translating Lorem Ipsum into a Discord channel 12,000 times. It's documented because I hated every other tool that shipped a binary and told me to trust it.
| Category | Details |
|---|---|
| Tool type | Standalone Windows .exe — no installer, no runtime deps |
| Core function | Emulated keyboard input with human-variance timing |
| Emitter backends | SendInput, WM_KEYUP/WM_KEYDOWN message posting, per-keystroke raw HID pass-through |
| Config format | Portable .ini or JSON profile alongside the exe |
| Focus target | Foreground window, hotkey-pinned window, or PID-pinned window |
| Distribution | Download → extract → run (portable, no persistence outside app folder) |
🧭 Is It Safe? Does It Work On Windows? Will It Get Me Banned?
Three questions dominate every message I get, so let me answer them bluntly.
- Safe? It's a portable exe in a folder. It doesn't touch the registry, doesn't install a service, doesn't phone home. Run it, delete the folder, forget it existed. Reputations of "automation tools" are trashed because most of them backdoor you — this one doesn't.
- Works on Windows? Windows 10/11 x64 in 2026, yes. It runs on the desktop of any standard user; some SendInput backends want elevated privilege if the target window is elevated too.
- Banned? In games with permissive ToS/anticheat that don't fingerprint input, you're likely fine with the message-posted backend. In competitive titles with heuristic chat/input monitors, assume some risk. See the section further down.
🧱 The Problem — Why Autotypers Usually Suck
- Fixed interval
sleep(n)between keys reads like a machine on any input-timing heuristic worth its salt. - Most public tools hardcode
SendInputonly — target windows that ignore it get zero output. - Nonsensical charset selection: UTF-8 mode shreds emoji and accented characters on some backends.
- No hotkey arbitration — the tool and the game fight over the same key binds.
- Keyboard press → release timing is synchronous, which is a physical impossibility for a human finger.
- Nothing logs what happened. So when the run fails at 3am, you have nothing.
- Setup demands a Python interpreter or a Java runtime for what should be a 4-megabyte binary.
⚙️ The Solution — What Changed In The 2026 Rewrite
Rebuilt from scratch. Not a patch. The event loop is gone; the emitter now ticks off a scheduler that draws intervals from a bounded distribution with hard maxima and minima.
| Problem | Solution |
|---|---|
Fixed sleep() intervals |
Lognormal-drawn gaps + per-key jitter + session-level fatigue drift |
Emitter lock-in to SendInput |
Three selectable backends, hot-swappable mid-session |
| Broken UTF-8 handling | Unicode-safe send paths per backend; skip-gracefully on unsupported glyphs |
| Hotkey clashes | Explicit hotkey capture layer with modifier guard and debounce |
| Synchronous key up/down | Async release scheduling with per-key hold durations 20–180ms |
| No visibility | Rolling 24h session log + live throughput counters |
| Interpreter dependency | Single portable .exe — zero runtime to install |
🧪 System Requirements
| Component | Minimum | Recommended |
|---|---|---|
| OS | Windows 10 build 1809 x64 | Windows 11 23H2+ x64 |
| CPU | Any x64 dual-core | Modern quad-core (irrelevant to perf, cosmetic) |
| RAM | 200 MB free | 1 GB free |
| Disk | 15 MB free | 60 MB (session logs + profiles) |
| Privilege | Standard user | Run-as-admin for elevated target apps |
| Runtime | None | None |
🎯 Quick Start — Read This Before Touching The .exe
- 🖱️ Download — hit the download button below, get the portable build archive.
- 📂 Extract — right-click → extract to a folder of your choice. Not into
Program Files; keep the app folder writable. - 🔧 Open the config — edit
default.inifor backend + profile presets, or skip and configure via UI. There is no setup wizard because setup wizards are for people who like being trained to click Next. - ▶️ Run the
.exe. If the target app is elevated, run the.exeas admin too — otherwise the emitter gets silently dropped by UIPI. - 🎬 Load profile, pick window, hit the start hotkey. Confirm text arrives in the target field. Confirm the log count increments. Close the app when done.
🧩 Grouped Module Catalog
35 modules across six categories. Each one shipped this build or is explicitly labeled otherwise.
⌨️ Timing & Cadence Engine
The timing engine is where the whole product lives. Every gap between keystrokes is drawn at runtime — never a fixed number. There are three concurrent layers of variance: per-key jitter (Gaussian noise around the base delay), per-character carryover (slow wave pulses through long strings so identical phrases aren't reproducible), and per-session fatigue drift (mean interval slowly climbs the longer you run, resets on window switch pause or restart). If you flip on humanized hold durations, the release-timestamp for each keystroke is separately scheduled — same idea, so the waveform of "down/up" gaps isn't a uniform wall of zeros.
Every gap drawn at runtime — never a fixed number.
- Lognormal gap draw — replaces
uniform(a,b), matches empirical human typing distributions far closer for both very short and very long intervals. - Fatigue drift kernel — session-level average-typing-speed slows ~4-12% per hour depending on activity mode; clamps at profile-defined ceiling.
- Burst/rest scheduler — after N characters, inject a longer "think pause" of 300–2000 ms, resume with a warmup burst.
- Per-key hold wrapper — independently-timed down and up events, 20–180 ms window.
- Correlated jitter lock — consecutive jitter draws correlate slightly so pattern-matching on gap deltas can't easily isolate a drift-free dataset.
📝 Text Emission Modules
The text layer is what actually produces glyphs — and it's been split from the timing layer deliberately. Emitter knows nothing about when, timing knows nothing about what. Extending either in isolation is trivial.
- Direct-buffer mode — writes entire string through the target | any Windows edit control. Fast; only practical for really vanilla targets.
- Per-character send — every glyph is an independent keydown/keyup + timing draw. Slower, vastly more human-shaped in traceable input.
- Line-based injection — reads a text file, emits line N, newline, wait, line N+1; whole-run profile controls pause distributions.
- UTF-16 / emoji fanout — flag-splits surrogate pairs and maps to
SendInputcorrectly; flags toasts for true codepoints the backend refuses. - Vertical-block literal emitters — hard newline emission preserved across all backends.
- Clipboard fallback — activates on
Pastewhen sensitive content contains characters an active backend can't emit. - Format-string replay — small template language for repeated identical payloads — one payload, N repetitions, N drawn per-session.
🕵️ Detection Evasion & Stealth
Blunt honesty: a .exe running as a separate process is invisible or nearly so to anticheat from a detection standpoint if it strictly uses legitimate windows APIs. What CAN be detected is behavioral — input-timing fingerprints, per-process EDR signatures, keystroke entropy metrics. This section deals with behavior. It is not a general "make-me-invincible" grab bag — it is disciplined detection-resistance, every claim tested in the open, everything that doesn't hold up not shipped.
- Multi-backend rotation — within a session, the emitter can cycle through all three backends pixel by pixel to break any single-backend fingerprint.
- Entropy weighting — a chip-level sampler on the typed-character stream lets long strings randomize their mid-string finger-fusion cadence so timing entropy stays above detection thresholds; if stream entropy falls below ~4.1 bps on a 5-minute window, longer think pauses get injected.
- Process-name randomization — the .exe is rename-resistant, and each new run randomizes in-memory strings that a shoddy scanner may whitelist-check; the binary checks its own .exe name and stays rename-neutral. (Note: don't rely solely on process name as your EDR-defense — pure obfuscation isn't defense against anything in the anticheat category; this module exists to avoid known gotchas past builds ran into, not to reverse established kernel detection.)
- Send-input backend rotation — backends set to time-weight conversion around the documented API path inside a kernel handshake.
- Live volume throttling — if OS-input-per-second crosses a user-definable ceiling, the emitter switches that stream to a much slower profile automatically.
🎛️ Trigger & Hotkey Layer
- Explicit hotkey capture — GUI dialog captures + debounces + verifies + attaches; no blindly trusting a doc.
- Modifier-guard arbitration — while hotkey is being set inside non-focused apps, target-input paused, gated.
- Foreground-on-hotkey — click a target once, tool reuses focus tracking to autonomously rebind without losing hotkey attribution.
- Hold-to-type mode — must hold a chosen modifier while typing enabled; releases type only while held; falls back to classic toggle-latch mode.
- Per-profile window banner clamp — separate "don't activate while X.exe is foreground" blacklist.
💾 Persistence & Logging
Every run produces a shareable log.
- Millisecond session log — every 200 ms a
.csvis appended per session with exact run/stall; every run produces a shareable log. - Rate-counter stopwatch — KPM/CPM window + lifetime-on-distribution P95.
- Counter-fingerprint timer — if value drops below window-clamped detections trigger a long pause.
- **Session stamping recovery resume header — event log prints after reboot; if it finds crash header it self-reports what you typed as output history.
🗂️ UI & Profile Management
- JSON/INI profile store in plain folded format.
- Load-and-diff dialog for tweaking saved profile without risk.
- Side-by-side timing grid compare two settings; small graphs compare.
- Dark UI (because the clicker UI shops haven't figured out dark-mode-yet).
- Terminal run-with-line-limit at CLI from launch chain with
_names.
📊 This Tool vs The Field — Comparison
Named alternatives are from reading forum threads, not from shipping any of them. Fair framing as I see it.
| Aspect | Typing-class competitor #1 | Typing-class competitor #2 | Command-line script | This Tool |
|---|---|---|---|---|
| Timing variance | Fixed range reset after every char | Randomized per-word only (fail |