Tactile: Open-Source Physical Task Management

Tactile is an ambitious plan to reinvent personal task management by bridging the physical and digital worlds. The core idea is a wooden board (30x40 cm) embedded with a grid of RFID sensors that can detect the position and identity of small, 3D-printed tokens. Each token represents a task, a project, a context, or a priority. By placing tokens on the board, you instantly capture and organize your work. The system scans the board at 5 Hz and transmits the state to a local server over USB. The server runs a rule engine that maps token configurations to actions in your task manager (e.g., Todoist, Trello, or a built-in kanban). The entire design — circuit schematics, firmware, 3D models, and software — is open-source under CC-BY-SA, so anyone can build, customize, and extend it. The vision is to reduce screen time and make task management as intuitive as moving pieces on a board. No cloud dependency, no subscriptions, just a delightful physical interaction that syncs with your digital workflow.

Digital task managers are powerful but suffer from interface overload: you have to open an app, navigate menus, type, tap, and scroll. This friction leads to abandonment. Physical methods (whiteboards, paper planners) are immediate but lack syncing, search, and notifications. Tactile solves this by offering a tactile, glanceable interface that directly feeds into your digital system. It scratches the itch for a tangible, always-on, and low-effort way to capture and move tasks, combining the best of analog and digital.

• Design and publish an open-source hardware reference board (PCB + enclosure) with a 10x15 active grid of RFID sensors.
• Develop robust firmware that can read up to 50 tokens simultaneously with position accuracy within 1 cm.
• Create a local server application (Python) that translates token configurations into task operations (create, update, delete, complete).
• Build a plugin system to sync with popular task managers (Todoist, Trello, TiddlyWiki) via REST API.
• Release a library of 12 token designs (e.g., red hexagon for urgent, blue square for project, green circle for low priority) as 3D-printable STL files.
• Write comprehensive build instructions, including a parts list, soldering guide, and firmware flashing tutorial.
• Host a community forum for sharing custom token mappings and board modifications.

• Not a commercial product; no intention to manufacture or sell.
• No mobile app: interaction is solely through the physical board and a web dashboard for configuration.
• No cloud-hosted service; everything runs on user's local network.
• Not a replacement for detailed project management; focused on personal task capture and daily triage.
• No support for time tracking or reporting (only task states).

• Hardware: ESP32-PICO-D4 microcontroller, 48x multiplexed RFID coils (using PN532 ICs and analog multiplexers), custom PCB (4-layer), USB-C power/data, plywood laser-cut enclosure, 3D-printed PLA tokens with embedded NTAG213 tags.
• Firmware: PlatformIO, C++17, Arduino framework, FreeRTOS for concurrent scanning tasks, custom coil driver libraries.
• Software: Python 3.11 backend (Flask + asyncio), SQLite for state persistence, WebSocket for live board state updates, React-based web dashboard for token mapping and logs.
• Integration: REST API for external sync; OAuth2 for Todoist/Trello connectors; JSON export.
• Open-source licenses: Hardware: CC-BY-SA 4.0; Firmware & Software: GPLv3.

The Tactile system has three layers: Board (hardware), Agent (local server), and Sync (integration). The Board consists of a grid of 150 coils arranged in 10 rows x 15 columns, each coil driven by an ESP32 via analog multiplexers. The ESP32 scans rows sequentially, activating one row at a time and reading the voltage change on the receiving coil. When a token with an RFID tag is placed, it detunes the coil, changing the sensed voltage. The firmware identifies which coils are loaded (token present) and reads the token's UID via a short-range NFC reader integrated into each coil driver. This data is sent over USB-C serial at 115200 baud. The Agent (a Python Flask server on the user's computer or Raspberry Pi) receives the data, parses it into a list of token positions and UIDs, and updates an internal state graph (a directed acyclic graph of tasks). A rule engine maps token configurations: e.g., placing a red hexagon (high priority) in the 'Inbox' column creates a new task with priority = high; moving a token from 'Doing' to 'Done' completes a task. The state is persisted to a JSON file and broadcast via WebSocket to the web dashboard. The Sync layer listens for state changes and pushes them to connected task managers via their APIs. The entire system is event-driven and designed to work offline, with Sync being optional.

• RFID interference: Dense token placement may cause mutual induction and false reads. Mitigated by multiplexing and careful coil design (overlapping fields).
• Token durability: 3D-printed tokens may wear out; solution: provide resin-printed optional files and encourage injection molding for serious users.
• Cost: BOM ~$80 per board, not including assembly time. High barrier for casual tinkerers.
• User confusion: Mapping tokens to tasks requires configuration. Risk of abandonment if it's too complex. Mitigated by pre-built token sets and wizards.
• Integration maintenance: External APIs change often, requiring updates. Community-maintained plugins may lag.

• Should tokens be hot-swappable (reassignable UIDs) or fixed? Fixed is simpler but less flexible.
• How to handle token removal from the board (delete task vs. postpone)? Need a gesture (e.g., flip token upside down).
• Should the board support multiple users? Multi-token UIDs could be associated with users, but scanning multiple users at once is technically challenging.
• What about token theft or loss? Perhaps a backup code printed on each token.

The project lost momentum after initial prototype because reliable token detection across the full grid required advanced RF engineering that the team didn't have time to perfect. Around the same time, simpler digital-first solutions (like Notion's quick capture) reduced the perceived need. The idea lives on as a design artifact and a reminder that physical computing still has untapped potential for productivity.

This plan was originally sketched in 2022 as a weekend project and evolved into a six-month research effort. The prototype proved the concept on a 4x4 grid, but scaling to 150 cells introduced noise issues that were never fully resolved. The open-source community showed interest, but no one stepped up to finish the hardware. The software side (the Agent) was completed and used to simulate the board with a virtual grid, but the physical version remains a dream.