QMK (Quantum Mechanical Keyboard) es el firmware de referencia para teclados cableados; resuelve el control total sobre el comportamiento del teclado. Está escrito en C, es de código abierto y soporta literalmente miles de teclados, el Corne incluido. Nació como una bifurcación que Jack Humbert hizo del firmware TMK (de Jun Wako) para su teclado Planck, y en 2015 la renombró QMK. Su filosofía es: defines tu keymap en código, lo compilas (traduces el código fuente a un binario que el chip ejecuta) y lo flasheas al controlador. Es más trabajo que una app gráfica, pero te da control total sobre capas, combos, macros y tap-hold (la pulsación que hace una cosa al tocar y otra al mantener, presentada en 5.5). En este artículo entiendes la estructura, escribes un keymap real y lo flasheas.

El entorno: qmk_firmware y qmk_cli

QMK se trabaja desde una copia del repositorio qmk_firmware más la herramienta de línea de comandos qmk. La instalas con:

python3 -m pip install qmk
qmk setup

qmk setup clona el repo y prepara las dependencias. A partir de ahí trabajas siempre con el comando qmk.

La estructura de archivos

Lo que define a tu teclado vive en dos sitios. La definición del hardware está en keyboards/<teclado>/ (para el Corne, keyboards/crkbd/). Tu personalización vive en un keymap dentro de ese teclado:

keyboards/crkbd/keymaps/mi_keymap/
├── keymap.c      # las capas y la lógica de teclas
├── config.h      # ajustes (tapping term, etc.)
└── rules.mk      # qué features compilas (VIA, RGB, etc.)

• keymap.c es el corazón: define las capas y qué hace cada tecla.
• config.h ajusta parámetros como TAPPING_TERM.
• rules.mk activa o desactiva funcionalidades para ahorrar memoria.

Un keymap.c real

Antes de leerlo, una pieza de vocabulario: en QMK cada tecla se nombra con un keycode, una constante que empieza por KC_ y representa la pulsación que se envía al ordenador (KC_A es la “a”, KC_SPC el espacio, KC_ENT el Enter). Un keymap es, en esencia, una tabla de keycodes por capa.

Este es un keymap mínimo de tres capas para el Corne. Fíjate en la matriz: 42 teclas, organizadas visualmente como el teclado físico (mitad izquierda y mitad derecha por fila), con las teclas de pulgar al final de cada fila inferior.

#include QMK_KEYBOARD_H

enum layers { _BASE, _LOWER, _RAISE };

const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    [_BASE] = LAYOUT_split_3x6_3(
    //,-----------------------------------------------------.                    ,-----------------------------------------------------.
        KC_TAB,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,                         KC_Y,    KC_U,    KC_I,    KC_O,    KC_P,    KC_BSPC,
    //|--------+--------+--------+--------+--------+--------|                    |--------+--------+--------+--------+--------+--------|
        KC_LCTL, KC_A,    KC_S,    KC_D,    KC_F,    KC_G,                         KC_H,    KC_J,    KC_K,    KC_L,    KC_SCLN, KC_QUOT,
    //|--------+--------+--------+--------+--------+--------|                    |--------+--------+--------+--------+--------+--------|
        KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B,                         KC_N,    KC_M,    KC_COMM, KC_DOT,  KC_SLSH, KC_ESC,
    //|--------+--------+--------+--------+--------+--------+--------|  |--------+--------+--------+--------+--------+--------+--------|
                              KC_LGUI, MO(_LOWER), KC_SPC,        KC_ENT, MO(_RAISE), KC_RALT
    ),

    [_LOWER] = LAYOUT_split_3x6_3(
        KC_TAB,  KC_1,    KC_2,    KC_3,    KC_4,    KC_5,                         KC_6,    KC_7,    KC_8,    KC_9,    KC_0,    KC_BSPC,
        KC_LCTL, KC_EXLM, KC_AT,   KC_HASH, KC_DLR,  KC_PERC,                      KC_CIRC, KC_AMPR, KC_ASTR, KC_LPRN, KC_RPRN, KC_GRV,
        KC_LSFT, KC_EQL,  KC_MINS, KC_PLUS, KC_LCBR, KC_RCBR,                      KC_LBRC, KC_RBRC, KC_COMM, KC_DOT,  KC_BSLS, KC_ESC,
                              KC_LGUI, _______, KC_SPC,          KC_ENT, MO(_RAISE), KC_RALT
    ),

    [_RAISE] = LAYOUT_split_3x6_3(
        KC_TAB,  KC_F1,   KC_F2,   KC_F3,   KC_F4,   KC_F5,                        KC_F6,   KC_F7,   KC_F8,   KC_F9,   KC_F10,  KC_BSPC,
        KC_LCTL, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,                      KC_LEFT, KC_DOWN, KC_UP,   KC_RGHT, XXXXXXX, XXXXXXX,
        KC_LSFT, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX, XXXXXXX,                      KC_HOME, KC_PGDN, KC_PGUP, KC_END,  XXXXXXX, XXXXXXX,
                              KC_LGUI, MO(_LOWER), KC_SPC,        KC_ENT, _______, KC_RALT
    )
};

Claves para leerlo:

• KC_* son los keycodes (códigos de tecla). KC_A es la “a”, KC_SPC el espacio.
• MO(_LOWER) activa la capa LOWER mientras mantienes pulsada esa tecla (momentary).
• _______ (“transparent”) deja pasar lo que haya en la capa de abajo; XXXXXXX (“no-op”) es una tecla muerta.
• LAYOUT_split_3x6_3 es la macro que mapea las 42 teclas al hardware del Corne.

Tap-hold y home row mods

Para un home row mod usas códigos mod-tap. Por ejemplo, una tecla que es “F” si la tocas y Shift izquierdo si la mantienes:

LSFT_T(KC_F)

Y ajustas el tiempo de decisión en config.h:

#define TAPPING_TERM 200

Compilar y flashear

Una vez tienes tu keymap, lo compilas:

qmk compile -kb crkbd -km mi_keymap

El resultado de compilar es el fichero de firmware listo para cargar. Si el controlador es un Pro Micro (ATmega32U4), QMK genera un .hex (el formato binario clásico de los microcontroladores AVR). Si es un RP2040 en formato Pro Micro, generas un .uf2 (un formato pensado para flashear copiando el fichero a una unidad USB, sin herramienta extra); muchas configuraciones del Corne usan un converter:

qmk compile -kb crkbd -km mi_keymap -e CONVERT_TO=rp2040_ce

Para flashear:

qmk flash -kb crkbd -km mi_keymap

QMK te pedirá que pongas el controlador en modo bootloader (el modo de arranque en el que el chip acepta firmware nuevo en lugar de ejecutar el que ya tiene). En un Pro Micro se hace puenteando RST (el pin de reset) a GND (masa) dos veces seguidas: un doble reset. En un RP2040 mantienes el botón BOOT al conectar el USB: aparece una unidad llamada RPI-RP2, y entonces basta con arrastrar el .uf2 a esa unidad (o dejar que qmk flash lo haga). El controlador se reinicia ya como teclado.

Recuerda que el Corne es partido: tienes que flashear cada mitad por separado. Conecta una mitad por USB, flashéala, desconéctala, conecta la otra y repite. Las dos llevan el mismo firmware; el firmware detecta cuál es la maestra según cuál tenga el USB conectado.

Cuándo usar QMK

QMK es la opción cuando quieres potencia y control y no te importa recompilar para cada cambio. Es perfecto para teclados cableados y para keymaps complejos. Su pega es justa esa: cada ajuste exige recompilar y reflashear. Para que el usuario final cambie teclas sin tocar C, existe Vial, que veremos a continuación y que es un QMK con configuración en tiempo real.