LayerBench Open the app

Keyboard layout analyzer for ZMK keymaps

Scores the keys you actually press.

LayerBench types a text on your keymap the way ZMK would — layers, one-shots, adaptive and repeat keys, combos, macros — and measures SFB, SFS, scissors, rolls and Effort on the presses that result.

Open Magic Romak Read the guide

Free · Runs in your browser · No account needed, no tracking

The Analyze view's board for Magic Romak: a navigator for its layers, Alpha 1 shown, each key shaded by how often it is pressed. The summary beside it: Effort, SFB, SFS and the other numbers, most with a band.
Magic Romak on Portuguese news: its layers one at a time, how often each key of Alpha 1 is pressed, and its numbers, most banded by the Keyboard Layouts Doc's thresholds.

Most analyzers score one letter on one key

That fits a 30-key layout. It doesn't fit many ZMK keymaps: a thumb opens a second alpha layer for the next key, an adaptive key types what the letter before it calls for, a combo types a letter no key has, a macro types qu and hands the next key to another layer.

Some analyzers approximate parts of this, by rewriting the text before scoring it or by charging a cost for each modifier; the comparison says which. LayerBench simulates the keymap instead, press by press, each on the layer it lands on, and scores what was pressed.

ação on Magic Romak, in four presses

  1. Press 1: the right hand's home-row middle key, a, lit on Alpha 1.
    a on Alpha 1, right hand, home row.
  2. Press 2: the right inner thumb lit, opening Alpha 2 for the next key.
    R0, the right inner thumb: Alpha 2 for the next key.
  3. Press 3: ç lit on Alpha 2.
    ç on Alpha 2, which also opens the Ç extension for the next key.
  4. Press 4: ão, one key, lit on the Ç extension layer.
    ão, one key on the Ç extension.

With multi-letter macros switched off, the same word takes five presses: a, the thumb, ç, ã and o. The simulator's tests pin traces like these. Type any word in How is this typed?

What no other analyzer we checked does

Five other analyzers, checked against their documentation and code on 7 October 2026. The comparison has each of them, row by row, with sources.

  • Adaptive keys, as many as you have

    Each with its own rules, chained, on any layer, typing one letter or several. Elsewhere we found one at most.

  • Repeat and alternate repeat

    Pressed as your keymap presses them, rather than rewritten into the text before it is scored.

  • Combos per layer, macros of several letters

    A chord that can be any kind of key — a letter no key has, an accent for the next one, a layer, an adaptive key, a tap-hold, a tap dance pressed twice — on the layers it works on; a key that types qu and hands the next key to another layer.

  • Your firmware keymap, read in

    keymap-drawer's YAML of a ZMK or QMK keymap, layers and combos included. None of the others reads one.

  • The presses behind any word

    Type a word and the board plays it, press by press, on the layer each lands on, and counts the presses it took.

  • Metrics you compose

    Every rule is data: switch it off, move its thresholds, or write a new one, in the browser. Elsewhere, weights in a file, or new code.

  • One link to the analysis

    The layout, saved or never saved, the bundled text, the preset and every switch, in an address you can send.

Your keymap, not a letter map

The simulator follows ZMK's rules for what a press does, and every behavior below is part of how a text is typed.

  • &mo &lt

    Layers while a key is held, and layer-taps.

  • &sl

    One-shot layers: the next press lands there, then the layer is released.

  • &tog &to

    Toggled and exclusive layers, locking the way ZMK locks them.

  • conditional layers

    A layer that comes on while the layers it depends on are all on.

  • &sk

    Sticky shift, and sticky modifiers that combine.

  • &caps_word

    Caps word, until a key outside its list.

  • &key_repeat

    The repeat key.

  • adaptive keys

    Adaptive keys, whose output depends on the key before: as many as the keymap has, chained if it chains them. Alternate repeat, which types something else after some keys, is one. Each needs urob's zmk-adaptive-key module.

  • combos

    Chords, only on the layers they are for: one more way to a letter, an accent or a layer, and another when held.

  • &macro

    Macros that type several letters, open a layer, or call other macros.

  • mod-morph tap-dance dead keys Unicode

    Modeled too. Unicode needs urob's zmk-unicode module.

Layer taps, holds and one-shots are presses too, and the layer metrics say what they cost: layer taps per 100 symbols, wasted one-shots, adaptive key hit rate, and extra keystrokes per symbol.

What you can do with it

Rank with, or without

The Library ranks every layout on the same text, by Effort or SFB, with both on every card. Untick adaptive keys, the repeat key, typing combos or multi-letter macros, and each layout is ranked as it types without them: what each feature is worth, in two numbers. A card also says how much of the text a layout can't type, and its category: Standard, Thumb Alpha for a letter on a thumb, or Special for adaptive keys, macros, more than one alpha layer or a small board. Keep to the categories you want, and each layout is ranked against its peers.

Two Library cards, Magic Romak and Ben Vallack Piano, each with its category, its Effort and SFB.

Compare two layouts

Every number side by side, with the difference and which of the two does better. Compare with types both without the same features, so the comparison stays fair.

Compare: Magic Romak and Graphite side by side, both typed without multi-letter macros.

Edit where it is analyzed

Select a key and choose what it does: a symbol, a layer, a tap-hold, an adaptive key, a macro. Or type it in ZMK's own syntax, like &lt num a. Every number follows the edit, and the key shows its own part of each. Drag one key onto another to swap them; a plain swap shows an estimate at once, and the full numbers follow.

Analyze with a key selected: what the key does in words, tiles to make it something else, keys from the layout to reuse, and a field with its ZMK binding.

Rules are data

Every rule cites its sources. Switch one off, move its thresholds and bands, weight it, or compose a new one from predicates, and save the set. Presets follow the Keyboard Layouts Doc and cyanophage's playground.

The Rules view: bigram rules with their definitions, aggregates and band bounds.

On a phone too

Analyze, its editor and the Library fit a phone. The editor keeps the board in sight while a key is changed, and its controls are sized for a finger.

The editor on a phone: the board, with a key's inspector below it.

  • Bring your keymap

    Import a keymap-drawer YAML file — keymap-drawer reads ZMK and QMK keymaps — and choose which layers to take. Export one back, or LayerBench's own JSON. A three-row text layout works too.

  • Your language, accents intact

    English, Portuguese, Spanish, French, Italian and German, as news. Mix two texts, or paste your own and save it. ã, ç and ß are letters in their own right, and a layout that can't type them ranks after one that can. Most layouts here type them through an Accents layer one thumb tap away; one that keeps its author's own layers types what those type, and no more. Missing your language? Add a text by pull request.

  • Share the link

    The address carries the analysis: the layout, saved or never saved, the bundled text, the preset and every switch. A custom text or rule set opens only where it is stored.

  • Keep it yours

    Change a layout and Save a copy, start one, or import yours: it joins the Library, ranked with the rest, beside the community layouts other people made and the Library accepted. It is kept in your browser; sign in with GitHub under Storage to keep it in your own account too, in secret gists, which are unlisted rather than private. How to save

36 layouts to start from

Most are copied from where their author published them and link to it; where a board forced a change, the layout's description says what moved. Beside them, the Library lists community layouts: ones other people made, accepted into it, marked community. Missing one? Save it in LayerBench and submit it.

Why you can trust the numbers

A number is only useful if it means what it says. This is what stands behind LayerBench's, and where in the source to look.

  • Every rule cites its source

    Each rule names where its definition comes from — the Keyboard Layouts Doc (3rd edition), cyanophage's playground, Genkey, ZMK's documentation — and a test fails if one doesn't. Where the Doc is silent, as it is on layer taps, adaptive keys and combos, the rule says it is a LayerBench addition, and the metric glossary explains how it counts.

    In the source: packages/core/src/rules/references.test.ts

  • The numbers are pinned

    Reference reports — a few layouts on a few texts, under more than one preset, with and without space, and with shift modelled — are checked on every change: each rule's value to a millionth of itself, and every list and every trace exactly. Each deliberate change to a number is logged with its reason.

    In the source: packages/core/src/golden/reports.test.ts, packages/core/golden/GOLDENS.md

  • The firmware's rules are tested one by one

    A one-shot layer is consumed by exactly one press, and one wasted on a modifier is counted. Toggles lock. Conditional layers settle. A combo fires only on its layers, and can open one. A macro can open a layer. The first matching branch of an adaptive key wins. Caps word ends where ZMK ends it.

    In the source: packages/core/src/sim/machine.test.ts, packages/core/src/sim/resolver.test.ts

  • It shows its work

    Every analysis says which text and rules it used, and whether space and case were counted. How is this typed? shows the presses behind any word. The Library says how much of the text each layout can't type, and the Corpus view where each text comes from.

  • Private by construction

    No account of ours, and no analytics. The app is static files; the only server code is a small worker that signs you in with GitHub and keeps nothing. The app's content security policy lets it talk only to itself, to api.github.com and to that worker; a token is never put in a link, an export or an error. This page loads nothing from anywhere else and runs no JavaScript.

    In the source: apps/web/vite.config.ts, apps/web/src/server/github-auth.test.ts, apps/web/src/storage/github-api.ts, apps/web/src/storage/github.test.ts

  • Checked on every change

    Formatting and lint, a strict type check, the unit tests and a production build run on every pull request and every push to main, and only an app build that passes them is published.

    In the source: .github/workflows/ci.yml

How it compares

Checked on 7 October 2026 against each tool's documentation and code. Not found means we didn't find the feature in what we checked; Claimed means the tool's own description says so and we couldn't confirm it. No is only said of LayerBench, and of a tool whose sources show it plainly.

Keyboard layout analyzers, feature by feature
Feature LayerBench cyanophage playground Oxeylyzer Dario Götz's optimizer Mana2 cmini
Runs in the browser, nothing to install Yes Yes Partial desktop app; Oxeylyzer 2 is an early web version3 Yes5 No terminal app7 Partial a Discord bot8
Letters on more than one layer Yes Not found Partial shift only4 Yes layers reached by modifiers6 Claimed7 Not found
One-shots and the cost of reaching a layer Yes one-shots simulated, layer presses counted and charged Not found Partial shift only4 Yes hold, one-shot and long-press costs6 Claimed layer-aware analyses7 Not found
Adaptive (magic) keys Yes any number, chained Partial one, on its magic page1 Not found Not found Claimed7 Not found
Repeat key Yes and alternate repeat Partial on its magic page1 Partial through corpus rules4 Not found Partial through magic rules7 Not found
Combos Yes per layer, any kind of key Partial up to 13, applied to all text, on its magic page1 Not found Not found Claimed7 Not found
Macros that type several letters Yes Partial a magic output can be several letters1 Not found Not found Not found Not found
Reads your firmware keymap Yes through keymap-drawer YAML Not found Not found Not found Not found Not found
Shows the presses behind a word Yes Not found Not found Not found Not found Not found
Metrics you can change or define Yes a composer, in the browser Partial weights in its optimiser2 Partial weights, in the app or a config file3 Partial parameters; new metrics need Rust6 Claimed user-definable stats7 Not found
Your own text Yes Yes lowercased, some accents folded2 Yes Yes Yes7 No a fixed list8
Languages 6, accents kept 14, mixable2 5 ready; rules for about 30 with your own text3 German, English; Ukrainian outside the web app6 Not found a fixed list of corpora8
A link to the analysis Yes for every layout, bundled texts and presets Partial the magic page's settings aren't in it1 Not found Partial publish to its database5 Not found Partial within Discord
Generates layouts No Partial an optimiser page, not linked from the site2 Yes3 Yes5 Claimed7 Partial constrained random8
Layouts to browse the bundled ones, and your own a stats page of 20 and more2 about 800 bundled, 146 for English3 a database of results5 about 130 bundled7 about 4,1008
Licence MIT none declared2 Apache-2.03 GPL-3.05 MIT7 GPL-3.08
  1. cyanophage's magic page takes one magic key keyed on the letter before it, one repeat key and up to 13 combos that apply everywhere; its settings are not written to the link. magic.html, keyboard_svg_magic.js
  2. The playground lowercases a pasted text, drops digits and folds some accents; it offers 14 languages that can be mixed, a stats page, and an optimiser page that the site does not link to. The repository has no licence file. playground, optimiser, repository
  3. Oxeylyzer is a command-line REPL and a desktop app with several search methods and weights set in the app or its configuration. The data it downloads has about 800 layouts to browse and ready text for 5 languages, with rules for about 30 more that need the text supplied. Oxeylyzer 2 runs in the browser and is in early development. oxeylyzer, oxeylyzer-2
  4. Oxeylyzer's corpus rules can simulate shift and a repeat key before scoring. english_repeat.toml
  5. Dario Götz's optimizer evaluates and optimizes in the browser, and results can be published to a shared database. web app, database, repository
  6. Layers are reached by hold, one-shot and long-press modifiers, each with its own cost; configuration sets parameters, while a new metric means writing Rust. The web app offers German and English texts; the repository also has Ukrainian n-grams. README, ngrams
  7. Mana2 is a terminal app. Its description claims combo-, layer- and magic-aware analyses, user-definable stats and layout generation with magic; it loads a corpus from a file, its layouts carry hold keys, and one-shots aren't mentioned. About 130 layouts come with it, one of them with a repeat key written as magic rules. Version 0.1.0 is MIT licensed. pkg.go.dev, core API, repository
  8. cmini is a bot on the alt-layouts Discord with about 4,100 layouts, a fixed list of corpora and a constrained random generator. The community's layout data now lives in AKLDB, which imported cmini's layouts; cmini's repository last synced on 23 August 2026. cmini, AKLDB

When another tool is the better choice

  • You want a layout generated for you. LayerBench analyzes; it doesn't optimize. Oxeylyzer, Dario Götz's optimizer, Jalo and keycraft do, and Mana2 says it does.
  • Your layout is one layer of 30 keys. cyanophage's playground is instant, and its numbers are the ones the community quotes.
  • You want to browse thousands of layouts. cmini and AKLDB, akl.gg and Emulayout have them.
  • You want scores from your own typing speed. Trialyzer uses trigram speeds you measure yourself; LayerBench has no timing model.
  • You need a language we don't ship. cyanophage has 14, and Oxeylyzer has rules for about 30 if you bring the text.

Also worth knowing

  • Keysolve, which the Keyboard Layouts Doc points to for scissor stats; inactive since 2023.
  • Genkey, an analyzer and generator that now points its users to Oxeylyzer.
  • KLA and KLAnext, the classic web analyzer and its continuation.
  • Jalo, an analyzer and optimizer whose metrics follow the Keyboard Layouts Doc.
  • keycraft, an analyzer, ranker and optimizer.
  • Kawalyser, a spreadsheet that handles a magic key, a repeat key and a dead key.
  • Emulayout, to filter and try community layouts, magic ones included.
  • keymap-drawer, which draws ZMK and QMK keymaps; LayerBench reads and writes its YAML.
  • The Keyboard Layouts Doc, the community's reference for what the metrics mean, and layouts.wiki.

Start in four steps

  1. Pick a layout

    The Library first opens ranked by Effort. Choose one, or bring your own from a keymap-drawer file.

  2. Read two numbers

    Effort is how hard the keys are to reach, and SFB how often one finger presses two keys in a row. Lower is better for both.

  3. Change a key

    In Analyze, select a key and choose what it does. Every change is kept as you make it, every number follows it, and Undo takes it back.

  4. Compare

    Two layouts side by side, number by number.

Open the Library Read the guide