I Built a Game Console Into My Split Keyboard

Technical Architecture

The Hardware Platform

The Lily58 is a split ergonomic keyboard with 58 keys. Each half runs on an ATmega32U4 microcontroller (Pro Micro compatible) with a 128x32 OLED display. The halves communicate via TRRS cable using I2C protocol. This existing infrastructure becomes the foundation for distributed gaming.

Distributed Game State

The game field spans 256 pixels across both displays. The left OLED renders pixels 0-127, the right OLED renders 128-255 (mapped to 0-127 locally). Ball position, velocity, and paddle states synchronize between controllers through a custom message protocol.

typedef struct {
    bool pong_mode_active;
    uint16_t ball_x;        // 0-255 across both displays
    uint8_t ball_y;         // 0-31 (OLED height)
    int8_t ball_vx;         // Ball velocity X
    int8_t ball_vy;         // Ball velocity Y
    uint8_t left_paddle_y;  // Left paddle position
    uint8_t right_paddle_y; // Right paddle position
    uint8_t left_score;
    uint8_t right_score;
} pong_state_t;

Distributed Pong Implementation

Cross-Display Ball Physics

The ball physics run at 20 FPS with collision detection for walls and paddles. When the ball crosses the center line (x=128), it seamlessly transfers from one display to the other. The visual effect is a ball that appears to fly off one screen and appear on the other.

// Ball transfer message when crossing displays
typedef struct {
    int16_t ball_y;
    int16_t velocity_x;
    int16_t velocity_y;
    uint8_t trail_length;
    uint8_t special_effects;
} ball_transfer_payload_t;

Paddle Control System

Each keyboard half controls its respective paddle. The left half uses WASD keys, the right half uses arrow keys. Rotary encoders provide analog control for smoother paddle movement. Paddle hits add spin based on where the ball contacts the paddle surface.

I2C Communication Protocol

Message Architecture

The communication protocol handles game state synchronization, ball transfers, paddle updates, and score changes. Messages include checksums for error detection and sequence numbers for reliability.

Protocol Reliability

Each message includes a magic byte for validation, protocol version, message type, payload length, timestamp, sequence number, and checksum. This ensures reliable communication even with the limited bandwidth of I2C on split keyboards.

typedef struct {
    uint8_t magic;          // Protocol validation
    uint8_t version;        // Protocol version
    message_type_t type;    // Message type
    uint8_t length;         // Payload length
    uint32_t timestamp;     // Message timestamp
    uint8_t sequence;       // Sequence number
    uint8_t checksum;       // Error detection
    uint8_t payload[24];    // Actual message data
} comm_message_t;

Development Metrics Dashboard

uroboro Integration

Beyond gaming, the OLED displays serve as a development command center. The keyboard receives metrics from the host machine via serial communication, showing real-time development statistics during coding sessions.

Display Modes

The keyboard supports multiple display modes switchable via key combinations:

• Game Mode: Distributed Pong across both displays
• Metrics Mode: Development dashboard with live stats
• Logo Mode: QRY Labs branding for presentations
• Hybrid Mode: Game with minimal metrics overlay
• Screensaver Mode: Animated logo after idle timeout

QRY Logo Animation System

Branding Integration

The keyboard displays QRY Labs branding during idle periods and layer transitions. The logo uses an 8x8 pixel matrix design that scales cleanly on the OLED displays, with both normal and inverted variants for visual variety.

Professional Presentation

The animated logo system serves practical purposes: professional branding visible during video calls, conversation starter in technical discussions, and visual feedback for keyboard state. The left and right displays show complementary animations - normal logo on left, inverted on right.

QMK Firmware Integration

Layer Architecture

The firmware maintains full keyboard functionality while adding gaming capabilities. Four layers provide complete workflow support:

Memory Optimization

The ATmega32U4 has limited resources. The firmware uses fixed-point math instead of floating point, efficient data structures, and optimized rendering with dirty rectangle updates. Current firmware uses 73% of available flash (21KB), leaving room for additional features.

Technical Challenges and Solutions

Why This Matters

Beyond the Gimmick

This project demonstrates several transferable skills: distributed systems design (two controllers maintaining synchronized state), real-time embedded programming (physics updates without blocking keyboard function), and protocol design (reliable messaging over constrained I2C).

Daily Driver Enhancement

The development metrics dashboard provides actual utility: seeing commit counts, build status, and uroboro capture streaks while typing. The keyboard becomes a development command center rather than just an input device.

Project Status and Future Development

Potential Extensions

• Additional Games: Snake, Tetris, or Breakout across displays
• Advanced Physics: Multiple balls, power-ups, particle effects
• Sound Integration: Buzzer feedback for game events
• RGB Underglow: Visual effects synced to game state
• Tournament Mode: Score tracking across sessions