This is a full-stack typing practice web application (keybr.com) built as a large TypeScript monorepo. The system provides adaptive typing lessons that track every keystroke, compute per-key statistics, and automatically generate lessons targeting the user's weakest keys. It supports dozens of keyboard layouts (QWERTY, Dvorak, Colemak, regional layouts, ergonomic layouts) and languages, with phonetic model-based word generation for practice text. The application includes a multiplayer typing race mode via WebSocket, user accounts with OAuth authentication (Google, Microsoft, Facebook), premium subscriptions via Paddle, and a theme designer for custom UI themes. The architecture is a monolith with server-side rendering (Fastr framework), a React 19 frontend bundled with webpack, a MySQL/SQLite database via Knex/Objection, and a separate WebSocket game server. The codebase is highly modular with over 50 packages covering UI widgets, charts, keyboard layout definitions, binary serialization, color science, math/statistics, internationalization, and code syntax generation for code-typing practice. While primarily an application, it also contains significant data/research components: phonetic model generation from word frequency dictionaries, statistical analysis of typing performance (learning rate, speed distributions, polynomial regression), and a C++ tool for validating user data files. The repository demonstrates high craftsmanship with clean abstractions, extensive test coverage, and reusable libraries that could be extracted for other projects.
The repository implements Trime, a fully functional Android input method (IME) based on the Rime input engine. It provides a highly customizable keyboard with YAML-based themes, color schemes, key layouts, and gesture support. The core architecture is a Kotlin/JNI bridge to the native librime library, with a service-based IME lifecycle (`TrimeInputMethodService`), a daemon for Rime session management, and a rich UI layer for candidate display, clipboard, popups, and liquid keyboards. The application also includes a settings interface for schema management, user dictionaries, sync via Storage Access Framework, and clipboard history. The codebase is modular, with clear separation between Rime interaction, theme management, UI delegates, and data persistence, using modern Android patterns (Room, Paging, WorkManager, Coroutines, Kodein DI). It is actively maintained with frequent commits and extensive test coverage for core components. The YAML theme system is particularly sophisticated, featuring typed color resolution with fallback chains and a custom parser that handles anchors and aliases.
MonitorControl is a macOS menu-bar utility that controls external displays' brightness, contrast, and volume. It does not just send one kind of command; it uses multiple control paths: hardware DDC/CI over IOKit I2C on Intel Macs, DDC/CI over IOAVService on Apple Silicon, Apple's private DisplayServices API for Apple/Thunderbolt displays, gamma-ramp adjustments for software dimming, and transparent shade windows for virtual displays. User input flows from native media keys, custom keyboard shortcuts, and menu-bar sliders into a DisplayManager singleton, which coordinates native OSD overlays, smooth brightness transitions, and cross-display synchronization. The app uses Sparkle for updates, SimplyCoreAudio for audio device handling, MediaKeyTap for media-key interception, and KeyboardShortcuts for user-defined bindings. Architecturally, this is a classic Cocoa application with a storyboard-based preferences UI, a login helper app (MonitorControlHelper), and a clean separation between models (Display, AppleDisplay, OtherDisplay), support services (DisplayManager, DDC backends, OSD utilities, media-key handling), and view controllers for preferences and onboarding. Entry points are main.swift, AppDelegate, DisplayManager, and MenuHandler. Persistence is UserDefaults backed through a PrefKey enum, and the UI is localized into 19 languages. There is no data/research component; this is purely an end-user utility. The codebase is modular and well organized, with the DDC communication isolated into Intel and ARM backends and display-specific logic abstracted behind a base Display class. It is actively maintained, with recent commits and a modern dependency setup. Technical drift is medium rather than low because much of the functionality depends on private or undocumented macOS APIs (DisplayServices, CoreDisplay, OSDUIHelper) and the code contains many macOS-version-specific workarounds, but the project tracks current macOS releases and continues to update its fallbacks.
Deskflow is a free and open-source keyboard and mouse sharing utility (software KVM without video) that allows one computer's keyboard, mouse, and trackpad to control multiple computers over a network. It uses a client-server architecture with a core process handling input forwarding and network protocol, a daemon for Windows service/UAC support, and a Qt-based GUI for configuration. The system supports TLS encryption, clipboard sharing, and multiple platforms including Windows, macOS, Linux (X11 and Wayland). It implements a custom binary protocol with version negotiation (1.0-1.8) and provides platform-specific backends for input capture and injection. The codebase is well-structured with clean abstractions, extensive unit tests, and CI/CD pipelines, though it carries some legacy code from its Synergy/Barrier origins.
This repository contains the complete design files, firmware, and assembly instructions for the Redox ergonomic split mechanical keyboard. It is not a software application in the traditional sense but rather an open-source hardware project delivering PCB Gerber/KiCad files, 3D-printable case STLs, precompiled QMK firmware hex files, and detailed build guides for both wired (Rev1.0) and wireless (Rev1.0W, Rev2.0WHS) variants. The code aspect consists of firmware configuration and custom KiCad footprints for keyboard components. The repository serves as a distribution hub for makers to manufacture their own Redox keyboard, with instructions for flashing via avrdude, ST-Link/Docker, and supports multiple firmware ecosystems (QMK, ZMK, KMK). The primary value is in the hardware design and documentation, not in runtime software.
FlorisBoard is a free and open-source Android keyboard (IME) application written in Kotlin with Jetpack Compose. In production it functions as a fully-featured soft keyboard service (FlorisImeService extends InputMethodService) with clipboard history management (Room-backed), emoji input with search and history, multi-language keyboard layouts (50+ locale JSON layouts), a custom extensions system for themes/keyboards/language packs, and a custom stylesheet-based theming engine called Snygg that powers all IME UI styling. The app also includes a settings activity (FlorisAppActivity) with ~30 configuration screens, a spell-checker service, backup/restore infrastructure, incognito mode, and a native Rust/JNI library scaffold for performance-critical work. The architecture is a multi-module Gradle build (:app, :lib:android, :lib:compose, :lib:kotlin, :lib:native, :lib:snygg) with a clear separation between the Android-specific app layer and reusable common KMP libraries.
This repository contains the open-source hardware design files for the 'dumbpad', a customizable 4x4 mechanical macropad with support for rotary encoders, OLED displays, and RGB LEDs. It is a hardware design repository, not a software application. The repo includes multiple PCB variants (Eagle and KiCad formats) with different features: through-hole switches, hotswap sockets, low-profile Gateron switches, per-key RGB, and OLED displays. Also included are 3D-printable case designs (STL and SketchUp files), Gerber manufacturing files, and VIA configuration JSON. The designs are modular, with reusable KiCad footprints and a standard keyboard matrix pattern. The project is actively maintained with several community-contributed variants. No firmware source code is present; the macropad is intended to run QMK firmware, which is maintained separately.
ADBKeyBoard is an Android virtual keyboard (InputMethodService) designed to receive text input and key events via system broadcast intents sent from ADB. It overcomes the limitation of `adb shell input text` which cannot handle Unicode characters. The app listens for intents like ADB_INPUT_TEXT, ADB_INPUT_B64 (base64-encoded text), ADB_INPUT_CODE (keyevent), ADB_EDITOR_CODE (editor actions), ADB_INPUT_CHARS (Unicode codepoints), ADB_CLEAR_TEXT, and direct IME actions (SEARCH, GO, DONE, NEXT, SEND). The single Java source file (AdbIME.java) implements the entire logic: registering a BroadcastReceiver, parsing intent extras, and using InputConnection to inject text or keys into the current input field. The code is straightforward and minimal, with no external libraries beyond the Android SDK. It has been widely used for device automation and testing (nearly 2000 stars). However, the codebase is monolithic, lacks tests, and shows signs of gradual maintenance (e.g., Android 13 compatibility fixes, but still targets older API levels). It is not designed for reuse outside of Android, but the broadcast-receiver-command pattern is clean and could serve as a reference for similar automation keyboards.
This repository contains no source code. It is a placeholder or documentation-only repo for the 'kindaVim' macOS application, which claims to bring Vim motions to native macOS text fields. The only file is a README.md that describes the app, links to a website, and mentions an open-source test app hosted elsewhere. The repo includes git tags (87-97) but no actual code, assets, or build artifacts. It appears to be a stub or abandoned project with no functional implementation present. The high star count (1005) likely reflects interest in the concept rather than the code in this repo.