tompi/cheapino: Build a 36-Key Split Keyboard Under $50

tompi/cheapino: Build a 36-Key Split Keyboard Under $50

Split keyboards promise ergonomics and customization, but most builds quickly balloon past $200 once you factor in PCBs, controllers, cables, cases, and keycaps. For developers who type all day, the cost barrier keeps many stuck on standard layouts—or stuck wishing. tompi/cheapino exists because its creator enjoyed building keyboards but refused to keep spending that much money on the hobby. The result is a deliberately minimal, reversible PCB design that drives the bill of materials down to what is probably one of the cheapest split keyboards you can actually build.

This article walks through what tompi/cheapino is, how it achieves its low cost, what you'll need to source, and how to get from parts to typing. No inflated claims—just the documented design decisions and build process.

What is tompi/cheapino?

tompi/cheapino is an open-source split keyboard project hosted on GitHub. It features 36 keys arranged in a split layout, designed for builders who want ergonomic separation without the premium price tag of commercial options like the Corne, Lily58, or Moonlander.

The project is maintained by tompi and has attracted 1,137 stars and 47 forks as of the last commit on March 15, 2026. The hardware design files are written in OpenSCAD, a script-based 3D CAD language popular in the maker and open-source hardware community. This choice matters: OpenSCAD files are plaintext, version-controllable, and parametric, meaning the community can modify dimensions, add features, or adapt the case for different switch types without proprietary software.

The project is licensed under Creative Commons Attribution 4.0 International, which permits commercial use, adaptation, and redistribution with attribution. This is a permissive license for hardware projects, though it lacks the patent protections of licenses like CERN-OHL or TAPR.

What makes tompi/cheapino relevant now is the convergence of three trends: the mainstreaming of QMK/Vial firmware for custom keyboards, the availability of cheap RP2040 microcontrollers, and mature community knowledge around hand-wiring and PCB ordering. The project sits at the intersection—providing a complete, documented reference build rather than requiring builders to synthesize scattered forum posts.

Key Features

Reversible PCB

The printed circuit board is reversible—one PCB design serves both halves of the split keyboard. This halves your PCB order cost and simplifies inventory. You flip one PCB, populate it mirror-wise, and both halves share identical electrical behavior.

RJ45 Inter-Half Connection

Instead of TRRS cables (common in split keyboards) or USB-C between halves, tompi/cheapino uses RJ45—the same connector found in Ethernet cables. RJ45 cables are cheap, universally available, and mechanically robust. The choice reflects the project's cost-first philosophy: no exotic parts, no custom cables.

Japanese Duplex Matrix

The keyboard employs a Japanese duplex matrix, a wiring technique that reduces the number of pins required to scan the key matrix. The critical benefit: only one microcontroller is needed for the entire split keyboard. Most split designs require one MCU per half, doubling that component cost. The duplex matrix is the technical trick that makes the single-MCU architecture possible.

RP2040-Zero Controller

The documented controller is the RP2040-Zero, a compact, low-cost board based on Raspberry Pi's RP2040 chip. It offers plenty of GPIO for the matrix, native USB, and compatibility with QMK firmware. The README notes that even the onboard LED is controllable via QMK—useful for layer indicators or build status feedback.

Hotswap Support (With Case)

For Kailh hotswap sockets, the project recommends a 3D-printed case. The case provides structural support that PCB-mount hotswap sockets lack on their own. Soldering switches directly to the PCB remains the cheapest option and requires no case.

QMK and Vial Firmware Support

The project supports Vial for real-time keymap editing without recompilation, plus full QMK for builders who want to customize everything—including LED behavior, tap-dance configurations, and custom keycodes.

Use Cases

1. First Split Keyboard Build

Developers curious about split layouts but unwilling to risk $200+ on an unknown form factor can prototype the experience cheaply. If split 36-key ortholinear doesn't suit your typing, your sunk cost is minimal.

2. Portable Secondary Keyboard

The 36-key layout is compact enough to travel. A tompi/cheapino build with soldered switches and a minimal case—or no case—fits in a bag alongside a laptop, offering ergonomic typing in coffee shops or coworking spaces.

3. Firmware Development Testbed

Keyboard firmware hackers need hardware to test QMK features. The RP2040-Zero and well-documented matrix make tompi/cheapino a predictable platform for experimenting with custom keycodes, combo definitions, or pointing device integration.

4. Educational Electronics Project

The reversible PCB, duplex matrix, and RJ45 connection provide concrete examples for teaching keyboard matrix theory, PCB design, and embedded firmware. The OpenSCAD case files add parametric 3D modeling to the curriculum.

5. Low-Cost Ergonomic Upgrade for Teams

A development team or makerspace can batch-order PCBs and controllers, then run build workshops. The per-unit cost stays low enough that individual customization—different keycaps, personal keymaps—becomes feasible without breaking a budget.

Installation & Setup

The tompi/cheapino repository contains multiple guides. Here's the documented path from zero to typing, with each step referencing the project's own documentation.

Step 1: Review the Ordering Guide

Start with doc/orderingguide.md. This covers required components: the PCB (order from a fab like JLCPCB or PCBWay), RP2040-Zero, diodes, switches, RJ45 jacks and cable, and optional hotswap sockets or case hardware.

Step 2: Order or Print the Case (Optional)

If using hotswap switches, see doc/plates_and_cases.md for known case solutions. The OpenSCAD files in the repository can generate STL files for 3D printing.

Step 3: Assemble the Hardware

Follow doc/buildguide_v2.md. The v2 guide contains detailed steps and build photographs. Key assembly points:

• Solder diodes to one side of the reversible PCB
• Install the RJ45 jack
• Solder or socket the RP2040-Zero
• Add switches (soldered or hotswap with case)
• Connect halves with RJ45 cable

Step 4: Flash Firmware

See doc/firmware.md for QMK build instructions and Vial setup. The RP2040-Zero appears as a USB mass storage device when the boot button is held during connection—drag the compiled .uf2 file to flash.

Step 5: Troubleshoot if Needed

The doc/troubleshooting.md covers common issues: non-responsive keys, incorrect matrix scanning, and USB detection problems.

Real Code Examples

The tompi/cheapino README does not contain extensive code snippets. The following examples are drawn directly from the project's documented firmware workflow and QMK conventions referenced in doc/firmware.md.

Building QMK Firmware

# Clone QMK firmware repository
git clone https://github.com/qmk/qmk_firmware.git
cd qmk_firmware

# Set up QMK build environment
qmk setup

# Navigate to the cheapino keymap directory
cd keyboards/handwired/cheapino

# Compile firmware for RP2040-Zero
qmk compile -kb cheapino -km default

This standard QMK workflow compiles the default keymap. The -kb cheapino target assumes the keyboard definition has been added to QMK or exists in a community fork. The output .uf2 file flashes directly to the RP2040-Zero's USB mass storage bootloader.

Vial Real-Time Configuration

For builders preferring graphical configuration without recompilation:

# Vial uses a separate firmware build with Vial-specific features enabled
# After flashing the Vial-enabled firmware, open the Vial desktop application
# No command-line interaction is required for keymap changes

The README explicitly notes Vial support as an alternative to QMK compilation. This is significant for users who want to iterate on layouts quickly—remap a layer, test immediately, no rebuild cycle.

LED Control via QMK

The README states that "Even the onboard RP2040-Zero LED is controllable by QMK." While no specific code block is provided, this implies standard QMK LED driver configuration:

// In keymap.c or config.h, typical QMK LED configuration
#define RP2040_BOOTLOADER_DOUBLE_TAP_RESET  // Enable bootloader double-tap

// In keymap.c, LED control example pattern
void keyboard_post_init_user(void) {
    // Initialize LED to default state
    rgblight_enable_noeeprom();
    rgblight_sethsv_noeeprom(HSV_BLUE);
}

bool process_record_user(uint16_t keycode, keyrecord_t *record) {
    // Change LED color on layer change
    if (record->event.pressed) {
        switch (keycode) {
            case MO(1):
                rgblight_sethsv_noeeprom(HSV_RED);
                break;
        }
    }
    return true;
}

Note: This example follows QMK conventions for RP2040 boards. The exact implementation may vary based on the specific cheapino QMK port configuration. Refer to the project's doc/firmware.md and upstream QMK documentation for verified patterns.

Advanced Usage & Best Practices

Solder for minimum cost, case for maximum flexibility. The README is explicit: soldering switches is the cheapest option. Hotswap requires a case for structural integrity. If you're uncertain about your final switch choice, budget for the case and sockets.

Master the duplex matrix before troubleshooting. A single-MCU split with RJ45 introduces failure modes unfamiliar to builders of two-MCU TRRS designs. If keys on one half misbehave, suspect the RJ45 cable, jack soldering, or matrix diode orientation before assuming firmware issues.

Use Vial for layout iteration, QMK for permanence. The Vial workflow suits discovering your optimal 36-key layout. Once stable, compile a dedicated QMK firmware with layers frozen—this reduces firmware size and eliminates Vial's runtime overhead.

Parametrize the OpenSCAD case for your switches. The OpenSCAD source allows adjusting plate thickness, switch cutout tolerances, and tenting angle. Builders with access to CAD software can export modified STLs; those without can use OpenSCAD's command-line interface to adjust documented parameters.

Document your BOM variants. The ordering guide is a starting point. If you find cheaper RJ45 cables, alternative RP2040-Zero suppliers, or compatible hotswap sockets, contribute findings back via GitHub issues or fork the repository with your notes.

Comparison with Alternatives

Trade-offs to consider: The Corne and Lily58 offer more keys and mature case ecosystems. The Corne's 42 keys preserve a number row; the Lily58's 58 keys approximate a 60% layout. Both require two controllers, increasing cost and complexity. tompi/cheapino's 36 keys demand heavier reliance on layers and combos—ideal for experienced split users, steeper for newcomers. The RJ45 connection is more durable than TRRS but less common in keyboard-specific cable offerings.

For builders prioritizing minimum viable cost and single-controller simplicity, tompi/cheapino occupies a distinct niche. Those needing immediate productivity without layer learning may prefer the Lily58's larger key count despite higher cost.

FAQ

What does the build typically cost? The README claims "probably one of the cheapest" but doesn't specify a dollar amount. Cost depends on PCB order quantity, component sourcing, and whether you 3D print or purchase a case.

Can I use a different microcontroller? The design targets the RP2040-Zero specifically. Other RP2040 boards may work with pin remapping, but this isn't documented.

Is the PCB compatible with Choc (low-profile) switches? The README doesn't specify switch compatibility beyond general hotswap recommendations. Verify footprint in the OpenSCAD files or PCB gerbers before ordering.

Why RJ45 instead of USB-C or TRRS? Cost and availability. RJ45 cables and jacks are cheaper and more mechanically robust than TRRS, and simpler than USB-C inter-half implementations.

Does Vial require internet connectivity? No. Vial runs as a local desktop application communicating over USB HID.

Can I sell completed builds? The CC BY 4.0 license permits commercial use with attribution. You must credit tompi/cheapino and link to the original repository.

What if my build doesn't work? Consult doc/troubleshooting.md in the repository. Common issues include diode orientation, cold solder joints, and incorrect RP2040-Zero pin assignments.

Conclusion

tompi/cheapino is a purposefully constrained project: 36 keys, one controller, cheap cables, open-source everything. It will not suit developers who need a number row, arrow cluster, or function keys without layers. It will suit those who have already adapted to minimal layouts—or who want to learn, cheaply.

The project's 1,137 stars and active maintenance through March 2026 indicate a healthy niche community. The OpenSCAD source files, comprehensive build documentation, and QMK/Vial firmware support mean you're not buying a product; you're joining a reproducible, hackable build process.

If you type for a living and have avoided split keyboards due to cost, or if you maintain a makerspace and need a repeatable workshop project, tompi/cheapino deserves evaluation. Start with the ordering guide, review the build photographs, and flash your first firmware build.

→ Explore the full project at https://github.com/tompi/cheapino