Colemak QWERTY converter
Type hello with QWERTY habits on a Colemak keyboard and the screen shows hfiiy; this converter maps each letter to the character on the same physical key, in both directions, keeping case and spaces. Free in your browser.
- Free
- Runs in your browser
- No sign-up
- Your data stays on your device
Run — free
Worked example
- Text
- hello
- Direction
- Qwerty to colemak
- Result
- hfiiy
- Length
- 5
- Mapped count
- 5
- Unmapped count
- 0
When you type with QWERTY muscle memory on a machine set to Colemak—or the reverse—the characters that appear on screen are not random; they are the letters that live on the same physical keys in the other layout. This capability translates a string between those two layouts by key position: each Latin letter and the semicolon key is remapped according to the standard Colemak letter-row arrangement, case is preserved, whitespace is kept, and any character outside the shared map is copied through and listed in an unmapped report.
How Colemak and QWERTY share keys but not letters
Colemak keeps many QWERTY habits—Q, W, A, Z, X, C, V, B, and M stay put—but it relocates high-frequency letters such as E, T, N, S, and R onto more comfortable home-row positions. The conversion is therefore a position table, not an alphabet rotation: the physical key that prints E on QWERTY prints F on Colemak; the key that prints K on QWERTY prints E on Colemak; the QWERTY semicolon key becomes O on Colemak, and so on across the three letter rows.
Spaces, tabs, and newlines pass through silently so multi-word phrases keep shape. There is no network call, no random seed, and no wall-clock timestamp. This page implements standard US Colemak letter-row positions only—not Dvorak, not Workman, not a keyboard-shift cipher that slides along one QWERTY row, and not strong encryption.
Where layout conversion shows up in real work
People who switch between Colemak and QWERTY machines often paste a paragraph typed on the wrong system layout and need a one-shot fix before the message goes out; a deterministic position map beats retyping. Curriculum authors teaching alternative keyboard layouts need a trusted oracle that maps both directions with explicit unmapped reporting so students see which symbols the lesson covers. Capture-the-flag warm-ups and puzzle authors sometimes hide phrases behind a layout swap instead of a classical cipher; solvers want a fast, predictable converter rather than a general cryptanalysis suite.
If you need a same-row QWERTY adjacent-key shift cipher, classical Caesar rotation, Base64, or strong authenticated encryption, treat those as separate search intents and landings rather than overloading this Colemak–QWERTY position page.
What you can do with it
Recover text typed on the wrong layout
Convert a mangled paste from a Colemak machine back to the QWERTY words you meant, or preview Colemak output from QWERTY finger patterns.
FAQ
What does this converter do?
It remaps each Latin letter (and semicolon) between US QWERTY and Colemak by physical key position, in either direction, and lists characters that were not on the map.
Is case preserved?
Yes. Uppercase Latin letters map to uppercase target letters when the target is alphabetic; the semicolon mapping stays as semicolon.
What does it cost?
The browser tool is free and runs locally.
How do I fix a message I typed on the wrong layout?
If you typed with QWERTY habits while the computer was set to Colemak, paste the garbled text and convert from Colemak to QWERTY. The tool recovers the words you meant, key by key.
Which letters stay on the same key in Colemak?
Q, W, A, Z, X, C, V, B and M keep their QWERTY positions. Frequent letters such as E, T, N, S and R move to more comfortable home-row keys, which is why most words change.
Related tools
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, by email and from Telegram — and soon from our app too.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/enc/colemak-qwerty \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"hello","direction":"qwerty_to_colemak"}'const res = await fetch("https://api.kit.forhosting.com/enc/colemak-qwerty", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "hello",
"direction": "qwerty_to_colemak"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/enc/colemak-qwerty",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "hello",
"direction": "qwerty_to_colemak"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/enc/colemak-qwerty", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"hello","direction":"qwerty_to_colemak"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"hello","direction":"qwerty_to_colemak"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/enc/colemak-qwerty", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"text": "hello",
"direction": "qwerty_to_colemak"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "enc.colemak_qwerty",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
Technical notes
Choose qwerty_to_colemak to see what Colemak would print for your QWERTY finger pattern, or colemak_to_qwerty to recover intended QWERTY text from mangled Colemak output.
How Colemak and QWERTY share keys but not letters
Direction qwerty_to_colemak reads each character as a QWERTY key label and emits the Colemak glyph on that same key; colemak_to_qwerty runs the inverse table so a known round trip restores the original when every character was mappable. Case is preserved for A through Z, so Hello becomes Hfiiy under qwerty_to_colemak rather than a lower-only string. Digits, most punctuation, emoji, and letters outside the basic Latin set are not on the position tables: they remain in the result and appear once each in unmapped_keys in first-seen order. Mathematically the engine is a fixed bijection on a twenty-seven-symbol set with O(n) lookup; identical text and direction always yield identical JSON.
What you send and what you get back
to Hfiiy Wypis! Send a required string field named text and a required direction field set to qwerty_to_colemak or colemak_to_qwerty. Short aliases such as q2c, c2q, to_colemak, and to_qwerty are accepted for scripts. On success the response echoes direction and the original text, returns the translated result string, length of that result, mapped_count for how many characters hit the layout tables, unmapped_count for how many did not, the unique unmapped_keys array, plus source_layout, target_layout, and a cipher label for clients that assert which profile they hit. Empty text, missing text, missing or unknown direction, non-string objects for text, and strings longer than the documented maximum fail with invalid_input and a clear English message; validation failures do not consume prepaid balance. Classic checks include converting hello with qwerty_to_colemak to hfiiy, converting hfiiy with colemak_to_qwerty back to hello, and converting Hello World! while listing the exclamation mark once under unmapped_keys. Pricing for successful API calls is the published base of $0.002 per item.
Where layout conversion shows up in real work
Support desks helping users who enabled Colemak in the OS but still type with QWERTY muscle memory can reproduce the mangled string, run colemak_to_qwerty or the reverse, and show what was intended without installing desktop utilities. Because this capability is a pure parse engine, API pricing is the published base of $0.002 per successful item and failed validation does not consume balance.
Integration use cases
Support and migration checks
Reproduce user-reported garbage strings when OS layout and muscle memory disagree, then show the intended message with one API or browser run.
Classroom and puzzle layout demos
Teach Colemak key positions or build layout-swap challenges with deterministic JSON, unmapped-key reports, and free browser execution.
Technical questions
How do I reverse a conversion?
Run the opposite direction with the same text result: qwerty_to_colemak and colemak_to_qwerty are inverses on the shared key set, so fully mapped strings round-trip.
What counts as an unmapped key?
Any character not in the Colemak/QWERTY letter-row tables—digits, most punctuation, emoji, and non-Latin letters—is copied unchanged and appears in unmapped_keys. Whitespace is preserved without being listed.