How CodePass types like a human

Why random delays look robotic

The usual trick is to wait a fixed time plus a random extra before each key, something like 250 ms plus anything up to 900 ms. That produces gaps with a hard floor, a hard ceiling and every length in between equally likely. People do not type like that, and each of those three features gives it away.

Real typing is lopsided. Most gaps between keys are short, a few are long, and now and then one is very long, when you stop to think. The spread of those gaps has a specific shape, and that shape is the human signal. Flatten it into even randomness and you get exactly what a script looks like.

So CodePass keeps the shapes of human typing and varies everything else. It models three parts: how long each key is held, how long the gap to the next key is, and the typos.

1. Keys are held down, not tapped

Every keystroke on a real keyboard is two events: the key goes down, then it comes back up. The time in between is called dwell. Software auto typers often skip it or fake it. CodePass does not have to, because it is a Bluetooth keyboard and a Bluetooth keyboard sends exactly those two events.

Dwell is picked separately for every key and scales with typing speed, the way it does for people: about 58 ms for a 140 WPM typist and about 116 ms for a 30 WPM typist. Real typists hold keys for roughly 60 to 120 ms.

2. The rhythm follows your fingers

The gap from one key to the next is called flight. In CodePass it follows a log-normal curve, the lopsided shape real typing produces, and is then adjusted for what a hand would actually be doing:

• Same finger, twice in a row is the slowest thing a touch typist does, so those pairs come slower.
• Alternating hands is the fastest, so those come quicker.
• Shift adds time, since another finger has to get there first.
• Common letter pairs run faster, the way muscle memory does.
• Punctuation brings a pause: two and a half to four times longer after a full stop, one and a half to two and a half times after a comma.
• Fatigue slows things down gradually over a long passage.

3. Typos are noticed late

An auto typer that makes a typo and fixes it on the very next key is not behaving like a person. People keep going for a moment before they notice.

CodePass tracks two things separately: what the typist meant to type, and what has actually been sent. A slip survives for a character or two. Then there is a short reaction pause, a burst of backspaces covering everything since the mistake, and the text is retyped. The chance of noticing grows the longer a typo has survived, so most are caught within one to three characters and a few run longer, with no fixed cut-off.

It makes the four kinds of typo real typists make:

• hitting the key next to the right one,
• swapping two letters,
• pressing a key twice,
• and missing a letter out.

Every typo is corrected before the run ends. What lands on the computer is exactly your text, character for character.

4. A different typist every run

Nobody types with the same average speed and the same typo rate every single time. So each run in CodePass picks its own values for speed, typo rate, how uneven the rhythm is, how quickly typos get noticed, how fast fatigue sets in and how long keys are held. Its mix of typo kinds changes too, and so does how quickly its backspace bursts speed up.

The speed it delivers lands close to the words per minute you asked for, not on it to the decimal, because a person would not either. The randomness comes from Android's cryptographic random number generator, not a simple one whose future output can be worked out from a few samples.

What never changes is the shape of the typing. The numbers move from run to run; the pattern stays human.

5. The speed you set is the speed you get

A well-known problem with human-style auto typers: you ask for 60 WPM and get 43. Typos, corrections and pauses all take time the basic key interval never allowed for. The usual fix is to divide by a fixed number, and that is wrong too, because the shortfall grows with speed. Measured without a correction, delivered speed was 0.79 times the target at 30 WPM and only 0.62 times at 140 WPM.

CodePass plans the whole run first, measures how long it will really take, and scales it. Keystrokes are scaled to fit. Thinking pauses are not, because reaction time does not speed up on request. The result is on target at every speed, whatever the text.

How close it gets

Measured by simulating about 200,000 characters and compared with typical figures for real typists.

When to turn human mode off

Human mode is on by default, and the speed control reads in words per minute. Turn it off and the control switches to characters per second, typing at a steady pace with no typos or pauses. That is the better choice for commands, configuration files and anything going into a terminal or a console where speed matters more than looking natural.

Either way, the keystrokes come from a real Bluetooth keyboard, so there is nothing to install on the computer. Set up CodePass or read about typing into VM consoles.