Convert Figma logo to code with AI

qmk logoqmk_firmware

Open-source keyboard firmware for Atmel AVR and Arm USB families

17,970
38,634
17,970
654

Top Related Projects

2,615

ZMK Firmware Repository

Clackety Keyboards Powered by Python

Quick Overview

QMK Firmware is an open-source keyboard firmware based on the tmk_keyboard firmware with some useful features for Atmel AVR and ARM controllers. It powers many custom and DIY keyboards, offering extensive customization options and a vibrant community of contributors.

Pros

  • Highly customizable, allowing users to create complex layouts and macros
  • Supports a wide range of keyboards and microcontrollers
  • Active community with frequent updates and contributions
  • Extensive documentation and resources for users and developers

Cons

  • Steep learning curve for beginners, especially those new to programming
  • Requires command-line knowledge and comfort with text editors
  • Can be overwhelming due to the vast number of features and options
  • Firmware flashing process can be risky if not done correctly

Code Examples

  1. Defining a simple keymap:
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    [0] = LAYOUT(
        KC_ESC,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T,
        KC_TAB,  KC_A,    KC_S,    KC_D,    KC_F,    KC_G,
        KC_LSFT, KC_Z,    KC_X,    KC_C,    KC_V,    KC_B
    )
};
  1. Creating a custom macro:
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
    switch (keycode) {
        case CUSTOM_MACRO:
            if (record->event.pressed) {
                SEND_STRING("Hello, QMK!");
            }
            return false;
    }
    return true;
}
  1. Implementing a layer toggle:
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    [0] = LAYOUT(
        KC_A,    KC_B,    KC_C,
        KC_D,    KC_E,    MO(1)
    ),
    [1] = LAYOUT(
        KC_1,    KC_2,    KC_3,
        KC_4,    KC_5,    KC_TRNS
    )
};

Getting Started

  1. Clone the QMK repository:

    git clone https://github.com/qmk/qmk_firmware.git
    
  2. Set up your environment:

    cd qmk_firmware
    ./util/qmk_install.sh
    
  3. Create a new keyboard firmware:

    qmk new-keyboard
    
  4. Customize your keymap in the generated keymap.c file.

  5. Compile and flash your firmware:

    qmk compile -kb your_keyboard -km your_keymap
    qmk flash -kb your_keyboard -km your_keymap
    

Competitor Comparisons

2,615

ZMK Firmware Repository

Pros of ZMK

  • Built for wireless keyboards, with better power management
  • Uses modern Zephyr RTOS, offering improved portability
  • Supports split keyboards natively without additional configuration

Cons of ZMK

  • Smaller community and ecosystem compared to QMK
  • Limited compatibility with existing QMK keymaps and features
  • Fewer supported boards and microcontrollers

Code Comparison

ZMK keymap example:

/ {
    keymap {
        compatible = "zmk,keymap";
        default_layer {
            bindings = <
                &kp Q &kp W &kp E &kp R &kp T
            >;
        };
    };
};

QMK keymap example:

const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    [0] = LAYOUT(
        KC_Q,    KC_W,    KC_E,    KC_R,    KC_T
    )
};

ZMK uses a device tree syntax for keymap configuration, while QMK uses C arrays. ZMK's approach is more declarative and potentially easier to read, but may require learning a new syntax for users familiar with QMK.

Clackety Keyboards Powered by Python

Pros of kmk_firmware

  • Written in Python, making it more accessible for beginners and easier to customize
  • Supports CircuitPython boards, allowing for a wider range of hardware options
  • Smaller codebase, potentially easier to understand and maintain

Cons of kmk_firmware

  • Less mature project with fewer features compared to QMK
  • Smaller community and ecosystem, resulting in fewer resources and third-party tools
  • Limited support for advanced features like RGB lighting and OLED displays

Code Comparison

QMK Firmware (C):

const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
    [0] = LAYOUT(
        KC_ESC,  KC_Q,    KC_W,    KC_E,    KC_R,    KC_T
    ),
};

KMK Firmware (Python):

from kmk.keys import KC
from kmk.kmk_keyboard import KMKKeyboard

keyboard = KMKKeyboard()
keyboard.keymap = [
    [KC.ESC,  KC.Q,    KC.W,    KC.E,    KC.R,    KC.T]
]

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Quantum Mechanical Keyboard Firmware

Current Version Discord Docs Status GitHub contributors GitHub forks

This is a keyboard firmware based on the tmk_keyboard firmware with some useful features for Atmel AVR and ARM controllers, and more specifically, the OLKB product line, the ErgoDox EZ keyboard, and the Clueboard product line.

Documentation

The docs are powered by VitePress. They are also viewable offline; see Previewing the Documentation for more details.

You can request changes by making a fork and opening a pull request.

Supported Keyboards

The project also includes community support for lots of other keyboards.

Maintainers

QMK is developed and maintained by Jack Humbert of OLKB with contributions from the community, and of course, Hasu. The OLKB product firmwares are maintained by Jack Humbert, the Ergodox EZ by ZSA Technology Labs, the Clueboard by Zach White, and the Atreus by Phil Hagelberg.

Official Website

qmk.fm is the official website of QMK, where you can find links to this page, the documentation, and the keyboards supported by QMK.