Build your menu now with web designer
tcMenu is a modular, cross‑platform UI framework for embedded devices. It provides a structured menu system, flexible input handling, portable rendering, and optional IoT/remote control integration. More than an Arduino menu library, tcMenu helps you build complete embedded applications with consistent UI behaviour across Arduino, mbed, STM32, ESP32, PicoSDK and more.
https://github.com/user-attachments/assets/cdd26e29-db7b-444f-b681-079de567a04e
Get started building your menu right away without any installation using our hosted web designer. However, if you’re sensitive to version changes or public hosting you can install the docker images yourself and quickly get it running. We are presently hosting these versions:
The designer works much like a form designer in desktop development — you define the structure, behaviour, and appearance, and the tool handles the boilerplate. It’s also fully non‑destructive: your application code remains yours, and you can round‑trip safely throughout development.
TcMenu is an open‑source project used by thousands of developers across Arduino, STM32, ESP32, PicoSDK and more. Hosting the designer, maintaining the infrastructure, and developing new features all take real time and cost. If you find TcMenu valuable, please consider helping keep the project cost‑neutral by sponsoring its development.
Sponsor me on GitHub (this repository).
In any fork, please ensure all text up to here is left unaltered.
Documentation
_____ __ __
/ / / |_ ___| \/ | ___ _ __ _ _
/ / /| __/ __| |\/| |/ _ \ '_ \| | | |
/ / / | || (__| | | | __/ | | | |_| |
/_/_/ \__\___|_| |_|\___|_| |_|\__,_|
documentation
Questions, community forum and support
Community questions can be asked in the discussions section of this repo, or using the Arduino forum (but please tag me). We generally answer most community questions but the responses may not be timely. Before posting into the community make sure you’ve recreated the problem in a simple sketch, and please consider making at least a one time donation (see links further up):
- Discussions section of this git repo (available from top menu of github page).
- Arduino discussion forum where questions can be asked, please tag me using
@davetcc.
The easiest and fastest way to build your first menu is using our web-based designer. It can generate nearly all existing menu, handle all existing plugins, and supports a new fluent mode where the output is much cleaner.
Note for All-In-One or Fluent API mode you need to use TcMenu Library as 4.5.x.
Quick Start for the impatient
Open Web based TcMenu Designer and either drag an example EMF file into it, or start a new project. Once you got an open project, you’ll see the menu tree structure on the left, and the details for each menu when selected on the right. Below the menu tree are buttons that manage items in the menu tree.
Once you’ve arranged your menu using the UI how you’d like it, go to the “Generate” tab at the top, choose appropriate hardware arrangements and hit generate. This will provide a zip with your new project.
TcMenu supports different boards and build tools. It is possible to use it directly with both platformIO and Arduino IDE. It should also work with most mbed tooling as the libraries compile on mbed.
The easiest way to get started is to install tcMenu library using library manager, all the dependencies are automatically installed. However, if you like to manually manage libraries, below are the links to their repos:
Embedded Libraries for Arduino and mbed
Additional libraries you may need depending on display
Licenses and usage
All components of tcMenu are licensed under Apache License 2.0. However, the TcMenu name, project branding, logos, icons and artwork are not covered by this licence and remain the intellectual property of the project maintainers. Any use of the TcMenu branding that implies endorsement, affiliation or official project status requires prior permission.
The goal is straightforward: keep tcMenu open and accessible while protecting the identity and reputation of the project and supporting its long-term sustainability. Apache 2.0 permits both personal and commercial use of the software, while the TcMenu branding remains reserved to help distinguish official releases, services and project communications.
In initializer mode multi-lanaguage menus are still workable using the same resource bundle arrangements discussed in tis link: https://www.thecoderscorner.com/products/arduino-libraries/tc-menu/multi-language-locale-menu/
The python script is here tcmenu-i18n.py
Loading and saving menu items
tcMenu can also save menu item state to EEPROM storage. On AVR that will generally be internal EEPROM, on 32 bit boards generally an AT24 i2c EEPROM.
Here are a few examples of how the menu can look with version 2.0 of our menu library on Arduino, PicoSDK, STM32Cube and mbed:
Ice White theme
Running on STM32Cube LTDC framebuffer with touch screen. The LTDC driver is accelerated proving excellent performance.
Cool blue theme and dark modern theme
On ESP32 SPI ILI9341 and touch screen. With the SPI speed set at 10-20Mhz the performance is good. TcMenu has plugins for TFT-eSPI and Adafruit display drivers, we have an extension to the Adafruit driver that improves drawing speed. We also support color OLEDs and ST77xx displays.
Monochrome and eInk
We offer a few different OLED and Monochrome themes and have drivers for most OLEDs. For eInk we have a special theme that allows for the eInk devices with 3 or 7 colors.
LCD/LiquidCrystal
The oldest of all plugins, the first we supported all the way back in 2018! We fully support 16x2 and 20x4 LCDs.
We fully support rotary encoder based input with no need for any additional components in many cases. You can even connect your rotary encoder on a PCF8574, AW9523 or MCP23017. Further, we even support more than one encoder.
You can configure 3 or more buttons to work like a digital joystick using button based rotary encoder emulation (Up, Down and OK buttons with optional left and right) on either board pins, i2c expander, shift register. DfRobot analog input style buttons. Either DfRobot, or other analog ladder (configurable in code).
We also support the ESP32 touch pad interface, allowing up to 9 touch buttons to be used for menu input, they currently configure as per digital joystick.
Support for matrix keyboards
Matrix Keyboards of configurable size and key combination. Pre-canned options for 4x3 and 4x4 layouts. Most of the core functions work with a matrix keyboard.
Support for touch screens
From 2.0 onwards we’ll support touch screen interfaces. We have built the support so that we can add many devices later, but to start with we will support resistive touch screens using 4 inputs, and the STM32 BSP provided touch screen interface.
Drawing to LiquidCrystal (i2c or direct)
We have a fork LiquidCrystal for 20x4 or 16x2 displays - can be either directly connected, over an i2c sheild (PCF8574, MCP23017, AW9523) or on a shift register. Our version of the library integrates better with task manager, yielding frequently.
Adafruit_GFX integration for many displays
Most libraries that are compatible with Adafruit_GFX will work with tcMenu, we’ve tested with the following TFT’s ILI9341, ST7735 and also Nokia 5110 display. We even have a quick start option that helps you get started with this option.
U8G2 integration for mono display
We can render onto most buffered displays using this library. Tested with OLED devices such as SSD1306 and SH1106. We can even provide a custom I2C byte function that yields to task manager frequently, making it work better with task manager, and correctly yield on ESP boards too.
TFT_eSPI and STM32 LTDC framebuffer integration
From 2.0 onwards we’ll support TFT_eSPI and STM32 LTDC framebuffer based BSP functions to provide very high performance display rendering, we’ve tested with these two options on both ESP32 and STM32F429, the results were highly impressive.
Should your app not need any local display or input technologies, you can set up tcMenu so that it does not have local input or display, or you could have a single switch or LED on the device and manage it manually. In this case you’d use the below IoT support to manage the device remotely.
Remote IoT support on Ethernet, WiFi, Serial and Bluetooth/BLE
This menu library provides complete IoT remote control, presently over serial and ethernet. We’ve tested the serial support with both USB serial and Bluetooth, both work acceptably well. The full menu structure is sent over the wire and the Java API provides it as a tree that can be manipulated. There is also a defined protocol for other languages. In addition to this the menu can be programatically manipulated very easily on the device.
- RS232 endpoint that supports full control of the menu items using a Java API - example app included.
- Ethernet endpoint that supports either Ethernet2 library or UipEthernet.
- Ethernet endpoint for mbed that supports the mbed socket implementation.
- ESP8266 and ESP32 based WiFi both supported.
Ready built APIs and remote control UIs for tcMenu - embedCONTROL
TcMenu was built from day one for remote control and there are a few different offerings, we’ll go through each one in turn, along with their intended use case:
Java embedCONTROL UI
This desktop UI can be easily built from the source here using the instructions provided, it is also packaged for desktop those who want to use it as it exists out of the box. This offering builds on top of JavaFX, it has an automated UI that builds automatically for any menu app with form support for more advanced cases.
Java / JVM API
There is a java API for accessing the menu remotely, source includes JavaDoc to help getting started. There is an example JavaFX UI built with it within the above Repo. Include the following into your maven build file:
<dependency>
<groupId>com.thecoderscorner.tcmenu</groupId>
<artifactId>tcMenuJavaAPI</artifactId>
</dependency>
C# API
The C# API is relatively complete and can do most of what the Java API can do, it is well tested and stable.
Repo: https://github.com/TcMenu/tcmenu-dotnet-sdk
Python API
There is now a Python API thanks to @vzahradnik - https://github.com/TcMenu/tcmenu-python-sdk
JavaScript and TypeScript
There is also an early version of a TypeScript API that can be used from any JavaScript environment. https://github.com/TcMenu/embedcontrolJS. In the future, we may better package this API to a package manager.
There is also a Webserver/HTML based app that you can deploy, but it only really works from a Raspberry PI with the embedded Java support. It is somewhat limited in what it offers. After careful evaluation we decided NOT to support ESP32 and STM32 for this app at the moment as it is too large for them.
Desktop Designer (Optional / Offline Use)
Note that web designer is now strongly recommended, and we’ve archived the desktop app. It is still packaged for installation on Windows, Linux, and MacOS for those who can’t or prefer not to move over to the web designer.
Historic 4.4.x releases are directly available from the releases page, where there is a signed Windows version, notarized macOS version, and a package for Linux. There are also nightly builds in the repository – see the badges at the top.
The most recent builds of TcMenu Designer include a CLI that has support for creating projects, adding and removing items, verifying and generating menus. Building and Generating menus from the CLI
Developer setup
See the developer guide
![dependabot[bot]](https://avatars.githubusercontent.com/in/29110?v=4)
评论