Every programmer who has spent a decade at a keyboard eventually asks the same question: why does this key do that, and can I change it? The answer used to mean soldering irons and AVR datasheets. In 2026 it means picking a firmware. QMK, VIA, and ZMK are the three names that dominate every Reddit thread, Discord server, and keyboard-shop FAQ page on the subject, and each one solves the remapping problem in a different way. QMK gives you full control through code. VIA gives you live remapping through a graphical app. ZMK gives you a wireless-first platform built for split and Bluetooth keyboards. Picking wrong does not brick a board, but it does waste hours re-flashing firmware you did not need in the first place.
This comparison breaks down the specs, the benchmarked latency numbers, the actual dollar cost of getting into each ecosystem, and which one fits a given workflow, whether that is a stationary desk with a wired 75%, a standing desk with a Bluetooth split, or a laptop bag with a board that has to talk to three different operating systems in one day. We pulled GitHub star counts, official documentation changelogs, and third-party latency tests published between January and September 2026 to keep the numbers current rather than recycled from older buying guides.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What Keyboard Firmware Actually Does for a Programmer
Stock keyboard firmware, the code baked into a board by its manufacturer, handles one job: turning a key press into a USB HID signal. It rarely lets you remap a key, build a layer, or add a macro without buying a separate vendor app that only runs on Windows. Open firmware replaces that stock code with something a programmer can inspect, modify, and rebuild. That unlocks layers (a second or third function for every key), macros (one keypress that sends a whole string or shortcut), tap-dance (different actions for a tap versus a hold), and in ZMK’s case, full control over Bluetooth pairing and sleep behavior.
For a developer, the practical upside shows up in small but constant ways: a dedicated layer for terminal shortcuts, a key that types a whole Git commit template, a Vim-style arrow cluster hidden under the home row, or a board that swaps Ctrl and Caps Lock at the firmware level so it works identically across macOS, Linux, and a client’s Windows laptop. None of that requires touching the operating system’s own remapping tools, which means the shortcuts follow the keyboard, not the machine plugged into it.
The three firmware projects differ mainly in how much friction sits between “I want to change this key” and “the change is live.” QMK asks you to edit code and recompile. VIA asks you to click and drag in a desktop app. ZMK asks you to commit a config file and let a build server compile it. Each tradeoff below explains why.
QMK Explained: The Open-Source Standard Most Boards Build On
QMK, short for Quantum Mechanical Keyboard, is the oldest and largest of the three. It is a C-based, open-source firmware licensed mostly under GPLv2, maintained on GitHub at qmk/qmk_firmware, and it now sits at roughly 20,678 stars with over 44,000 forks according to a Tech Insider firmware table dated early September 2026. That is roughly six times the star count of ZMK and fifteen times that of the Vial fork of QMK, which makes it the default choice most keyboard makers reach for first.
Scale matters here in a very concrete way. A July 2026 report from PrismNews put QMK’s officially supported keyboard count above 3,000 individual boards, everything from a $55 Keychron V1 to a custom split macropad someone etched in a garage. That library means most wired mechanical keyboards marketed as “custom” or “hot-swap” already have a QMK keymap sitting in the repository, so a buyer is rarely starting from a blank slate.
The tradeoff is the workflow. Changing a key in QMK means editing a keymap.c file (or using the browser-based QMK Configurator), recompiling the firmware, putting the board into bootloader mode, and flashing it with a single terminal command. QMK ships a formal breaking-change release cycle for this exact reason: version 0.34.0 shipped August 30, 2026, following 0.33.0 in May and 0.32.0 in February, each with a public testing window before merge, according to QMK’s own breaking-changes documentation. That cadence keeps the project stable, but it also means a programmer who wants a five-minute key swap has to sit through a compile step every single time, unless the board also exposes VIA support.
qmk flash -kb keychron/q1v2/ansi_encoder -km my_customThat single line is the entire flashing step once the CLI and toolchain are installed and the keymap has already been written. The one-time environment setup is the real time cost. After that, most keymap edits compile and flash in well under a minute on modern hardware.
VIA Explained: Remap Without Ever Touching a Compiler
VIA solves QMK’s biggest annoyance: the need to recompile for every keymap change. It is a cross-platform configurator, available as both a desktop app and a browser-based tool at usevia.app, that talks to a board over USB and rewrites its keymap in EEPROM instantly, with no flashing cycle at all. The download page at caniusevia.com was last updated September 6, 2026, which signals the project is still actively maintained rather than coasting on an old release.
Under the hood, VIA is not a separate firmware in the way QMK and ZMK are. It is a protocol layer that a QMK build (or the community fork called vial-qmk) exposes so that a desktop app can talk to it live. That is why “VIA” and “QMK” show up together so often in product listings: a board marketed as “QMK/VIA” ships with QMK firmware that has VIA support compiled in from the factory, so the buyer never has to touch a terminal unless they want to go beyond what VIA’s GUI exposes.
The workflow is genuinely simple: install VIA, plug in a VIA-enabled board, and the app auto-detects the layout. From there, remapping a key, building a macro, or adding a layer happens by clicking, with the change live the moment you release the mouse button. For anyone who does not want to learn C or manage a GitHub repository just to swap Caps Lock and Escape, that is the entire appeal. The cost of that simplicity is a ceiling: VIA exposes what the underlying firmware author chose to expose, so genuinely custom behavior, like a key that behaves differently based on how long you have been typing, still requires dropping back into QMK’s source.
ZMK Explained: Wireless-First Firmware Built for Split Keyboards
ZMK takes a different starting point than QMK. Instead of adding wireless support onto a wired-first codebase, it was built from day one on Zephyr, a real-time operating system originally designed for embedded and IoT hardware, and it targets Bluetooth Low Energy and split ergonomic keyboards as first-class citizens rather than an afterthought. The zmkfirmware/zmk repository carries roughly 4,250 GitHub stars, smaller than QMK’s but still the clear leader among wireless-focused keyboard firmware projects, and it ships under the more permissive MIT license rather than QMK’s GPLv2.
ZMK’s biggest commercial win to date is Keychron’s decision to move its Q Ultra and V Ultra series to it. Announced at CES in January 2026, the Q Ultra line pairs ZMK with up to 660 hours of battery life and an 8,000Hz polling rate in 2.4GHz dongle mode, according to AppleInsider’s CES coverage, a combination that would have been difficult to hit on QMK’s older Bluetooth stack. On the ergonomic side, MoErgo’s Glove80, priced at $399 to $409 depending on switch choice, remains the highest-profile standalone ZMK board and the one most programmers researching split keyboards run into first.
The setup workflow is the most involved of the three. ZMK’s documented path runs through the ZMK CLI: create a GitHub repository for your personal configuration, clone it locally, edit a build.yaml file to select your board and shield, commit your keymap and config files, and push. GitHub Actions then compiles the firmware in the cloud, and you download the finished .uf2 file once the build finishes.
west init -l app
west update
west zephyr-export
west build -s app -p -b nice_nano_v2 -- -DSHIELD="corne_left"That is the local build path for anyone who skips GitHub Actions and compiles with Zephyr’s own west tool directly. Either route asks more of a first-time user than a single qmk flash command or a VIA GUI, but ZMK Studio, a newer live-configuration layer for ZMK boards pulling around 590 monthly searches, is starting to close that gap by giving ZMK the same drag-and-drop remapping experience VIA gives QMK.
Release Cadence and Long-Term Maintenance
A firmware project’s release schedule tells you how much it will change under your feet, and how much you can trust it a year from now. QMK runs the most formal process of the three. Its breaking-changes page lists a public calendar with named milestones: the develop branch closes to new pull requests, a call for testers goes out, merges freeze, and only bugfixes land before the release ships. Version 0.34.0 shipped on August 30, 2026, following 0.33.0 on May 31 and 0.32.0 on February 22, a roughly quarterly cadence that has held steady for several release cycles according to QMK’s own changelog history.
VIA and its underlying vial-qmk fork move on a lighter, more continuous schedule. The firmware download database at caniusevia.com shows updates as recently as September 6, 2026, reflecting new keyboard support being added on an ongoing basis rather than in scheduled batches. That suits VIA’s role: it is a compatibility layer, so its releases track new hardware entering the market more than they track internal feature work.
ZMK sits somewhere between the two. Its core repository ships less frequently by version number than QMK, but day-to-day development happens continuously on GitHub, visible through frequent commits to hardware shield definitions and the Zephyr dependency itself. Because ZMK inherits Zephyr’s own release and security process, it benefits from an upstream project with corporate backing (the Linux Foundation hosts Zephyr) in a way that neither QMK nor VIA can claim. For a programmer picking hardware meant to last five or more years, that upstream backing is a reasonable point in ZMK’s favor, even though its own star count and contributor base remain smaller than QMK’s.
QMK vs VIA vs ZMK: Full Specs Comparison Table
The table below lines up the three projects across the specs that actually change a buying decision: license, ecosystem size, wireless support, and how much friction sits between plugging in a board and having a working custom layout.
| Attribute | QMK | VIA | ZMK |
|---|---|---|---|
| License | Mostly GPLv2 | Inherits QMK/vial-qmk licensing (GPL-compatible) | MIT |
| GitHub stars (main repo) | ~20,678 | ~1,378 (vial-qmk fork) | ~4,250 |
| Base language / platform | C, AVR and ARM MCUs | Configurator layer on top of QMK/vial-qmk | C, built on Zephyr RTOS |
| Config method | Edit source, compile, flash | Desktop or web app, live remap | Edit config, push to GitHub, cloud build |
| Reflash needed per keymap change | Yes | No | Yes (unless using ZMK Studio) |
| Wireless / Bluetooth support | Limited, board-dependent | Depends on underlying QMK build | Native, BLE-first design |
| Officially supported boards | 3,000+ | Hundreds via caniusevia.com database | Dozens of boards/shields officially listed |
| Split keyboard support | Supported, not the primary focus | Inherits QMK split support | Core design focus |
| Typical setup for beginners | Moderate (CLI + toolchain) | Easy (install app, plug in) | Advanced (Git + GitHub Actions or west) |
| Live GUI configurator | QMK Configurator (web, less flexible) | VIA desktop/web app | ZMK Studio (newer, growing feature set) |
| OS compatibility | macOS, Linux, Windows (CLI works on all three) | macOS, Linux, Windows, plus browser-based option | macOS, Linux, Windows (build tooling works on all three) |
| Best known flagship hardware | Keychron Q/V series, GMMK Pro | Any QMK/vial-qmk board with VIA enabled | Keychron Q Ultra series, MoErgo Glove80 |
Two rows deserve extra attention. The “reflash needed” row is the practical dividing line for most buyers: if you remap keys once a year, it barely matters, but if you are iterating on a layout weekly, VIA’s live editing (and ZMK Studio’s growing equivalent) saves real time. The “wireless support” row explains why ZMK has grown fastest among ergonomic split-keyboard builders specifically, since QMK’s Bluetooth story has historically lagged behind its wired one.
Benchmark Data: Input Latency and Polling Rate Compared
Latency claims in keyboard marketing get thrown around loosely, so it helps to separate measured numbers from theoretical ones. Independent testing gives QMK’s wired path some of the lowest documented latency of any consumer firmware. Software engineer Michael Stapelberg’s controller latency study found QMK running on a tuned Kinesis controller (the kint41 variant) reporting caps-to-report times of roughly 930 microseconds, under 1 millisecond, at 1000Hz polling. Less optimized QMK controllers in the same study landed between 2 and 13 milliseconds depending on the microcontroller.
Real-world consumer boards land in between those extremes. A wired keyboard latency test using a Teensy-based probe measured a Keychron Q1 Pro, a QMK/VIA board, at an average of 5.2 milliseconds with a 7.1 millisecond peak, and a Planck EZ at 5.6 milliseconds average with a 7.9 millisecond peak, both at 1000Hz polling. KeebsForAll’s own QMK latency breakdown puts an untuned default QMK build around 8 to 12 milliseconds of total input lag, with tuning able to bring that under 5 milliseconds.
ZMK’s Bluetooth path carries an inherent protocol cost that wired QMK does not. ZMK’s own documentation states that BLE communication adds roughly 3.75 milliseconds of average theoretical latency, and that split keyboards communicating between halves over BLE add another 3.75 milliseconds on average, with a worst case of 7.5 milliseconds. Layered on top of typical Bluetooth 5.3 connection intervals of 7.5 to 11-plus milliseconds, a realistic end-to-end latency for a ZMK split keyboard lands in the 10 to 20 millisecond range, noticeably higher than a tuned wired QMK board, though still fast enough that most typists and programmers will never consciously notice the difference during normal use.
| Firmware / Mode | Measured or Documented Latency | Polling Rate | Source |
|---|---|---|---|
| QMK, tuned (Kinesis kint41) | ~0.93 ms caps-to-report | 1000Hz | Michael Stapelberg latency study |
| QMK, Keychron Q1 Pro (wired) | Avg 5.2 ms / peak 7.1 ms | 1000Hz | Independent wired keyboard latency test |
| QMK, Planck EZ (wired) | Avg 5.6 ms / peak 7.9 ms | 1000Hz | Independent wired keyboard latency test |
| QMK, default/untuned build | 8-12 ms total input lag | Varies | KeebsForAll QMK latency guide |
| VIA-configured board | Same as underlying QMK build (5-12 ms typical) | Inherits host firmware | VIA is a config layer, not a separate latency path |
| ZMK, BLE protocol overhead | +3.75 ms average theoretical | BLE connection interval-dependent | ZMK official FAQ/docs |
| ZMK, split-half communication | +3.75 ms avg / +7.5 ms worst case | N/A | ZMK split keyboard documentation |
| Keychron Q Ultra, 2.4GHz dongle mode | Sub-1 ms transport (dongle mode) | Up to 8,000Hz | Keychron CES 2026 announcement |
The practical read: if you are chasing the lowest possible latency for competitive gaming or rapid keyboard-driven workflows, a wired QMK board still wins on paper. If you value freedom from cables across multiple desks, ZMK’s BLE overhead is small enough in absolute terms, single-digit milliseconds, that almost no programmer will feel it during normal typing or coding.
Configurator Tools Compared: Web, Desktop, and CLI
Beyond the three firmware projects themselves, the tool you actually sit in front of matters just as much day to day. QMK Configurator is a browser-based drag-and-drop editor that compiles a keymap on QMK’s own servers and hands back a firmware file to flash locally, useful for a first build but limited when you need conditional logic or custom keycodes that the web form does not expose. QMK CLI is the full local toolchain: it requires installing Python, a compiler, and cloning the qmk_firmware repository, but it exposes every feature the C source supports, including custom key behaviors that never make it into the web configurator.
Vial, the community fork behind vial-qmk, splits the difference. It behaves like VIA, live remapping with no recompile, but adds features VIA does not expose out of the box, like combos and tap-dance configured entirely through the GUI. That flexibility is why Vial’s GitHub star count, 1,378 as of early September 2026, keeps climbing even though it remains a fraction of QMK’s own repository size. ZMK Studio is the newest entrant in this category, aiming to give ZMK boards the same live-editing experience, though as of September 2026 it supports fewer boards than VIA’s mature caniusevia.com database covers for QMK.
The practical guidance: start with whichever GUI tool your board already supports out of the box, either VIA or Vial for QMK-based hardware. Only reach for the QMK CLI or ZMK’s GitHub Actions workflow once you have hit a wall the GUI cannot get past, since both add real setup time for a feature you might not end up needing.
Pricing: What Each Firmware Ecosystem Actually Costs
QMK, VIA, and ZMK are all free, open-source software with no license fee attached, so the real cost comparison is about which hardware ecosystem you buy into. QMK/VIA boards dominate the mainstream custom-keyboard market, which means more competition and more price tiers. ZMK’s commercial hardware options are fewer but concentrated at the premium end, since split ergonomic boards and Keychron’s flagship wireless line are the segments pushing it hardest.
| Category | Example Product | Firmware | Price (USD) |
|---|---|---|---|
| Mainstream pre-built mechanical | Generic branded mechanical keyboard | Proprietary (stock) | $60-$120 average |
| Wireless custom, 75% layout | Keychron Q1 Pro | QMK/VIA | $149.99 |
| Wireless custom, TKL layout | Keychron Q3 Pro | QMK/VIA | $143.99 |
| Wireless custom, higher-end Max line | Keychron Q6 Max | QMK/VIA | $199.99 |
| Barebones gasket-mount kit | Glorious GMMK Pro | QMK/VIA | $169.99 MSRP (sale prices as low as $59.99) |
| Budget DIY build, all-in | Keychron V1-based build | QMK/VIA | $120-$160 |
| Mid-tier DIY build, all-in | Q1 Pro or GMMK Pro-based build | QMK/VIA | $250-$350 |
| Premium DIY build, all-in | High-end parts, custom plate/case | QMK/VIA or ZMK | $450-$700+ |
| Flagship wireless ergonomic split | MoErgo Glove80 | ZMK | $399-$409 |
| Flagship wireless full-size/TKL | Keychron Q Ultra series | ZMK | Premium tier, priced above standard Q Max line |
The gap that matters most for a budget-conscious programmer: getting into the QMK/VIA ecosystem with a factory-built board starts under $150, while the cheapest well-supported ZMK hardware, the Glove80, starts around $399. Community DIY split kits running ZMK, boards like the Corne or Lily58 built from bare PCBs, can undercut that price significantly, but they demand soldering and a GitHub-based build workflow that QMK/VIA buyers can skip entirely.
Real-World Examples: Keyboards Running Each Firmware
QMK and VIA in the wild
- Keychron Q and Q Pro series: marketed directly as “QMK/VIA Wireless Custom Mechanical Keyboard,” spanning 60% to full-size layouts from roughly $130 to $220.
- Glorious GMMK Pro: a barebones gasket-mount kit widely documented in QMK forks and VIA configs, with an MSRP of $169.99.
- Royal Kludge R75: a wired budget board with community-maintained QMK and VIA firmware images, plus RGB software integration.
- ZSA Moonlander and ErgoDox EZ: QMK-based split keyboards configured through ZSA’s own Oryx web tool, which compiles a QMK keymap without requiring a local toolchain.
ZMK in the wild
- MoErgo Glove80: a fully split, contoured ergonomic keyboard running ZMK from the factory, priced at $399-$409.
- Keychron Q Ultra and V Ultra series: Keychron’s decision to move its flagship wireless line to ZMK, announced at CES 2026, paired with up to 660 hours of battery life.
- Corne, Lily58, and Charybdis: community-designed split keyboards commonly built around nice!nano controllers, with ZMK configs maintained through projects like Miryoku’s out-of-tree keyboard directory.
Notice the pattern: QMK and VIA dominate wired and semi-wireless factory-built boards sold through mainstream retailers, while ZMK’s strongest footprint is in split, Bluetooth-first hardware, whether that is a $399 factory product or a soldered DIY kit assembled from a schematic shared on GitHub.
Best Use Cases: Which Firmware Fits Which Programmer
No single firmware wins every scenario, so the right pick depends heavily on how and where you actually work. The patterns below cover most developers shopping in 2026.
- Single desk, wired, deep customization wanted: QMK. The 3,000-plus supported board library and lowest measured latency numbers make it the natural fit for a stationary setup where you are willing to recompile occasionally for genuinely custom behavior like tap-dance or combo keys.
- Frequent OS switching (macOS at home, Windows at a client, Linux in a VM): VIA. Live remapping through a GUI means the same board behaves identically everywhere without needing a build toolchain installed on every machine you touch.
- Standing desk, multiple monitors, cable management matters: ZMK. Bluetooth-first design and long battery life on boards like the Keychron Q Ultra series remove the cable clutter entirely, at the cost of a few extra milliseconds of latency most people will not notice.
- Wrist or shoulder pain, ergonomic split layout needed: ZMK, specifically through a board like the MoErgo Glove80, since split ergonomic hardware is where ZMK’s engineering focus has concentrated.
- Budget-limited first custom keyboard: QMK/VIA hardware, since factory-built options start under $150 and require zero soldering or firmware compilation to get a working, remappable board.
- Open-source purist who wants to audit every line running on their hardware: QMK, given its maturity, GPLv2 licensing, and the sheer volume of community-reviewed keymaps to learn from.
- DIY hobbyist building from a bare PCB and controller: Either QMK or ZMK depending on whether the target board is wired or wireless, since most modern DIY kits document support for both.
Migration Guide: Moving Between Firmware Ecosystems
Switching firmware is rarely a full rebuild from zero, since most boards already run some form of QMK underneath. The steps below cover the three most common migration paths programmers actually take.
From stock/proprietary firmware to QMK
- Confirm your board’s controller and layout are listed in QMK’s supported keyboard database (browse.qmk.fm or the qmk list-keyboards command).
- Install the QMK CLI and clone the qmk_firmware repository, or use the QMK Configurator web tool if you want to skip local setup entirely.
- Build or copy a keymap.c matching your desired layout, then compile with qmk compile.
- Put the board into bootloader mode (usually a physical reset button or key combo) and flash with qmk flash -kb (keyboard) -km (keymap).
- Test every key and layer before closing the bootloader tool, since a bad flash can require a full re-flash to recover.
From QMK to VIA (no firmware change required on many boards)
- Check whether your existing QMK build already has VIA support compiled in. Many Keychron, GMMK, and Royal Kludge boards ship this way by default.
- If not, add VIA support to your keymap.c and rebuild once using the standard QMK flash process above.
- Download and install the VIA app, or open the browser version at usevia.app.
- Plug in the board. VIA should auto-detect the layout without further configuration.
- Remap keys, build macros, or add layers directly in the GUI. Changes apply instantly with no further flashing needed.
From QMK to ZMK (typically a hardware swap, not just a firmware swap)
- Because ZMK targets different controller hardware (commonly nice!nano or similar Zephyr-compatible boards), this is usually a decision made when buying new hardware rather than a same-board conversion.
- Install the ZMK CLI and create a personal configuration repository on GitHub following ZMK’s official setup guide.
- Select your target board and shield in build.yaml, then write your keymap and .conf files.
- Commit and push to GitHub. GitHub Actions compiles the firmware automatically.
- Download the finished .uf2 file once the Actions workflow completes and drag it onto the board’s bootloader drive to flash.
- For live remapping afterward without repeating this whole cycle, install ZMK Studio if your board supports it.
Pros and Cons of QMK, VIA, and ZMK
Weighing tradeoffs side by side makes the decision clearer than reading feature lists in isolation.
QMK
- Pro: largest supported hardware library, over 3,000 boards, so almost any custom keyboard already has a starting keymap.
- Pro: lowest documented wired latency of the three, down to sub-millisecond on tuned controllers.
- Pro: mature, GPLv2-licensed, over a decade of community review and documentation.
- Con: every keymap change requires a recompile and reflash unless VIA support is also built in.
- Con: Bluetooth/wireless support is inconsistent across boards compared to ZMK’s native BLE design.
VIA
- Pro: instant, GUI-based remapping with zero recompiling, the fastest iteration loop of the three.
- Pro: cross-platform desktop and browser app, actively updated (last firmware database refresh September 6, 2026).
- Pro: works on any board with VIA support already compiled into its QMK or vial-qmk firmware.
- Con: not a standalone firmware, so you are limited to whatever the underlying QMK build exposes.
- Con: genuinely custom logic (conditional layers, complex combos) still requires dropping into QMK source.
ZMK
- Pro: purpose-built for Bluetooth and split keyboards, with battery life up to 660 hours on Keychron’s Q Ultra line.
- Pro: permissive MIT license and a modern codebase built on the actively developed Zephyr RTOS.
- Pro: growing GUI story through ZMK Studio, closing the live-remap gap with VIA.
- Con: BLE protocol overhead adds measurable latency, roughly 3.75 to 7.5 milliseconds, versus a tuned wired QMK board.
- Con: setup requires comfort with Git, GitHub Actions, or the Zephyr west build tool, a steeper curve than plugging in a VIA-ready board.
Common Pitfalls When Switching Keyboard Firmware
A handful of mistakes account for most of the frustration programmers report when moving between these ecosystems. The first is assuming VIA is a firmware in its own right and trying to “flash VIA” onto a board, when in fact you need a QMK or vial-qmk build with VIA support compiled in before the app can talk to the keyboard at all. The second is skipping the QMK breaking-change calendar. Flashing a keymap built against an old QMK release onto a newer toolchain can silently drop features or fail to compile, so checking the current release notes at docs.qmk.fm before a rebuild avoids wasted debugging time.
On the ZMK side, the most common trip-up is underestimating the one-time setup cost. Programmers used to QMK’s single flash command are often surprised that a first ZMK build means creating a GitHub repository, installing the ZMK CLI, and waiting on a cloud build through GitHub Actions before ever seeing a working keymap. Budgeting an evening for that first setup, rather than expecting a five-minute swap, avoids most of the frustration reported in ZMK’s own community channels. Buyers also sometimes assume any wireless keyboard makes latency irrelevant. The BLE overhead numbers in the benchmark table above are small in absolute terms, but they are not zero, and competitive typists or rhythm-game players may still notice the difference a tuned wired QMK board provides.
The Verdict: Which Firmware Should Programmers Choose in 2026
There is no single winner here, and the data backs that up rather than pointing to one project. QMK remains the right default for anyone who wants the deepest hardware compatibility (3,000-plus boards) and the lowest measured wired latency, currently as low as roughly 1 millisecond on tuned controllers and 5 to 6 milliseconds on common retail boards like the Keychron Q1 Pro. VIA is the right layer to add on top of that same QMK foundation for anyone who wants to iterate on layouts without ever opening a terminal, and its September 2026 firmware database update shows the project is still being actively maintained rather than abandoned.
ZMK earns its growing following for a narrower but real reason: it is the only one of the three built from the ground up for Bluetooth and split ergonomic keyboards, and Keychron betting its flagship Q Ultra line on it, with 8,000Hz polling and 660-hour battery life, is a strong signal that the wireless story is catching up to QMK’s wired maturity. For a programmer buying one board today, a QMK/VIA board like a Keychron Q series or GMMK Pro fits a stationary desk under $200, while a ZMK board like the Glove80 or Q Ultra earns its higher price specifically when going wireless or ergonomic matters more than shaving off the last few milliseconds of latency.
For readers still comparing actual hardware rather than firmware, the best mechanical keyboards for programmers roundup and the step-by-step QMK/VIA flashing guide both build directly on the numbers referenced here, and the custom keyboard build guide walks through assembling a board from a bare kit if you are starting from parts rather than a finished product. Readers comparing wireless split options may also want the Keychron Q11 Ultra 8K vs Moonlander vs Kinesis breakdown, and anyone deciding between switch types before picking a firmware ecosystem can check the Hall-Effect vs Optical vs Mechanical comparison.
Frequently Asked Questions
Is VIA a replacement for QMK?
No. VIA is a configuration layer that runs on top of a QMK or vial-qmk build. A board needs VIA support compiled into its firmware before the VIA app can detect and remap it. Without that underlying QMK build, there is nothing for VIA to talk to.
Can I run ZMK on any QMK keyboard?
Generally no. ZMK targets specific Zephyr-compatible controllers, commonly nice!nano and similar boards, which differ from the AVR and ARM controllers most QMK boards use. Switching a board from QMK to ZMK usually means buying different hardware rather than reflashing the existing controller.
Which firmware has the lowest input latency?
QMK on wired boards currently holds the lowest documented numbers, with tuned controllers measured under 1 millisecond and common retail boards like the Keychron Q1 Pro averaging around 5.2 milliseconds. ZMK’s Bluetooth path adds roughly 3.75 to 7.5 milliseconds of protocol overhead on top of typical BLE connection intervals.
Do I need to know how to code to use any of these?
VIA requires no coding at all. It is a point-and-click GUI. QMK requires basic comfort editing a C-based keymap file and running terminal commands, though the browser-based QMK Configurator lowers that bar. ZMK requires comfort with Git and GitHub, plus editing configuration files, making it the most technical of the three to set up from scratch.
Are QMK, VIA, and ZMK free to use?
Yes. All three are open-source projects with no license fee for end users. QMK is licensed mostly under GPLv2, VIA and vial-qmk inherit GPL-compatible licensing from QMK, and ZMK uses the more permissive MIT license. Any cost comes from the keyboard hardware itself, not the firmware.
Which one should I pick for a split ergonomic keyboard?
ZMK is the stronger choice for most split ergonomic builds, since it was designed around wireless split communication from the start and powers flagship boards like the MoErgo Glove80. QMK does support split keyboards too, and remains common in wired split boards like the ZSA Moonlander, but its wireless split story is less mature than ZMK’s.
What is ZMK Studio and does it fix ZMK’s setup complexity?
ZMK Studio is a newer live-configuration tool designed to give ZMK boards the same instant, no-reflash remapping experience VIA gives QMK boards. It reduces day-to-day friction for supported boards, but the initial firmware build still generally requires the GitHub Actions or west-based setup described in ZMK’s official documentation.
Can a single keyboard support both QMK and VIA at the same time?
Yes, and this is the most common setup on the market. Boards like the Keychron Q and Q Pro series ship with QMK firmware that has VIA support built in, so the same board can be configured through the VIA app for quick changes or through the full QMK source for deeper customization when needed.
Related Coverage
- PS5 BootROM Leak Leaves 95M Consoles Unpatched [2026]
- Apple Locks In NAND Memory Deal: 3-5 Years, No Cap [2026]
- Raspberry Pi 5 RetroPie Build: 12 Steps, $180 [2026]
- AMD Ryzen 5 7500 Non-F Price Revolt Hits 130% Markup [2026]
- AMD Ryzen 5 7500 Non-F Leak: Same Specs, 2x the Price [2026]
