tcell alternatives and similar packages
Based on the "Advanced Console UIs" category.
Alternatively, view tcell alternatives based on common mentions on social networks and blogs.
bubbletea9.8 7.8 tcell VS bubbleteaA powerful little TUI framework 🏗
termui9.7 0.0 tcell VS termuiGolang terminal dashboard
Rich Interactive Widgets for Terminal UIsTerminal UI library with rich, interactive widgets — written in Golang
gocui9.5 0.0 tcell VS gocuiMinimalist Go package aimed at creating Console User Interfaces.
color9.3 3.7 tcell VS colorColor package for Go (golang)
go-prompt9.1 0.0 tcell VS go-promptBuilding powerful interactive prompts in Go, inspired by python-prompt-toolkit.
lipgloss9.1 2.8 tcell VS lipglossStyle definitions for nice terminal layouts 👄
termbox-go9.1 0.0 tcell VS termbox-goPure Go termbox implementation
pterm8.7 8.8 tcell VS pterm✨ #PTerm is a modern Go module to easily beautify console output. Featuring charts, progressbars, tables, trees, text input, select menus and much more 🚀 It's completely configurable and 100% cross-platform compatible.
progressbar8.6 5.7 tcell VS progressbarA really basic thread-safe progress bar for Golang applications
tui-go8.5 0.0 tcell VS tui-goGo UI library for building rich terminal applications.
termdash8.3 5.8 tcell VS termdashTerminal based dashboard.
asciigraph8.2 4.2 tcell VS asciigraphGo package to make lightweight ASCII line graph ╭┈╯ in command line apps with no other dependencies.
uiprogress8.2 0.0 tcell VS uiprogressA go library to render progress bars in terminal applications
mpb8.1 6.1 tcell VS mpbmulti progress bar for Go cli applications
uilive7.8 0.0 tcell VS uiliveuilive is a go library for updating terminal output in realtime
termenv7.6 0.0 tcell VS termenvAdvanced ANSI style & color support for your terminal applications
aurora7.6 0.0 tcell VS auroraGolang ultimate ANSI-colors that supports Printf/Sprintf methods
go-isatty7.1 4.5 tcell VS go-isattyisatty for golang.
go-colorable7.1 2.8 tcell VS go-colorableColorable writer for windows.
clui7.0 1.7 tcell VS cluiCommand Line User Interface (Console UI inspired by TurboVision)
uitable6.9 2.8 tcell VS uitableA go library to improve readability in terminal apps using tabular data
termtables6.3 0.0 tcell VS termtablesA Go port of the Ruby library terminal-tables for simple ASCII table generation as well as providing markdown and HTML output
chalk6.2 0.0 tcell VS chalkIntuitive package for prettifying terminal/console output. http://godoc.org/github.com/ttacon/chalk
simpletable6.2 0.0 tcell VS simpletableSimple tables in terminal with Go
yacspin6.0 1.5 tcell VS yacspinYet Another CLi Spinner; providing over 80 easy to use and customizable terminal spinners for multiple OSes
GCli6.0 7.8 tcell VS GCli🖥 Go CLI application, tool library, running CLI commands, support console color, user interaction, progress display, data formatting display, generate bash/zsh completion add more features. Go的命令行应用，工具库，运行CLI命令，支持命令行色彩，用户交互，进度显示，数据格式化显示，生成bash/zsh命令补全脚本
tabular5.9 0.0 tcell VS tabularTabular simplifies printing ASCII tables from command line utilities
tabby5.7 0.0 tcell VS tabbyA tiny library for super simple Golang tables
go-colortext5.4 0.0 tcell VS go-colortextChange the color of console text.
cfmt4.0 0.0 tcell VS cfmt:art: Contextual fmt inspired by bootstrap color classes
marker2.9 0.0 tcell VS marker🖍️ Marker is the easiest way to match and mark strings for colorful terminal outputs!
ctc2.6 0.0 tcell VS ctcConsole Text Colors - The non-invasive cross-platform terminal color library does not need to modify the Print method
table2.6 3.1 tcell VS tablepretty colorfull tables in go with less effort
colourize2.4 0.0 tcell VS colourizeAn ANSI colour terminal package for Go
go-ataman1.7 0.0 tcell VS go-atamanAnother Text Attribute Manupulator
go-palette0.8 10.0 tcell VS go-paletteDecorate your terminals using Palette 🎨
crab-config-files-templatingDynamic configuration file templating tool for kubernetes manifest or general configuration files
gommon/color0.2 - tcell VS gommon/colorStyle terminal text.
Access the most powerful time series database as a service
Do you think we are missing an alternative of tcell or a related project?
Tcell is a Go package that provides a cell based view for text terminals, like XTerm. It was inspired by termbox, but includes many additional improvements.
Please see [here](UKRAINE.md) for an important message for the people of Russia.
NOTE: This is version 2 of Tcell. There are breaking changes relative to version 1.
Version 1.x remains available using the import
A brief, and still somewhat rough, [tutorial](TUTORIAL.md) is available.
- proxima5 - space shooter (video)
- govisor - service management UI (screenshot)
- mouse demo - included mouse test (screenshot)
- gomatrix - converted from Termbox
- micro - lightweight text editor with syntax-highlighting and themes
- godu - utility to discover large files/folders
- tview - rich interactive widgets
- cview - user interface toolkit (fork of tview)
- awsome gocui - Go Console User Interface
- gomandelbrot - Mandelbrot!
- WTF - personal information dashboard
- browsh - modern web browser (video)
- go-life - Conway's Game of Life
- gowid - compositional widgets for terminal UIs, inspired by urwid
- termshark - interface for tshark, inspired by Wireshark, built on gowid
- go-tetris - Go Tetris with AI option
- fzf - command-line fuzzy finder
- ascii-fluid - fluid simulation controlled by webcam
- cbind - key event encoding, decoding and handling
- tpong - old-school Pong
- aerc - email client
- tblogs - development blogs reader
- spinc - irssi inspired chat application for Cisco Spark/WebEx
- gorss - RSS/Atom feed reader
- memoryalike - memorization game
- lf - file manager
- goful - CUI file manager
- gokeybr - deliberately practice your typing
- gonano - editor, mimics nano
- uchess - UCI chess client
- min - Gemini browser
- ov - file pager
- tmux-wormhole - tmux plugin to transfer files
- gruid-tcell - driver for the grid based UI and game framework
- aretext - minimalist text editor with vim key bindings
- sync - GitHub repo synchronization tool
- statusbar - statusbar motivation tool for tracking periodic tasks/goals
- todo - simple todo app
- gosnakego - a snake game
Pure Go Terminfo Database
Tcell includes a full parser and expander for terminfo capability strings, so that it can avoid hard coding escape strings for formatting. It also favors portability, and includes support for all POSIX systems.
The database is also flexible & extensible, and can be modified by either running a program to build the entire database, or an entry for just a single terminal.
Tcell is portable to a wide variety of systems, and is pure Go, without any need for CGO. Tcell is believed to work with mainstream systems officially supported by golang.
No Async IO
Tcell is able to operate without requiring
SIGIO signals (unlike termbox),
or asynchronous I/O, and can instead use standard Go file objects and Go routines.
This means it should be safe, especially for
use with programs that use exec, or otherwise need to manipulate the tty streams.
This model is also much closer to idiomatic Go, leading to fewer surprises.
Rich Unicode & non-Unicode support
Tcell includes enhanced support for Unicode, including wide characters and combining characters, provided your terminal can support them. Note that Windows terminals generally don't support the full Unicode repertoire.
It will also convert to and from Unicode locales, so that the program can work with UTF-8 internally, and get reasonable output in other locales. Tcell tries hard to convert to native characters on both input and output. On output Tcell even makes use of the alternate character set to facilitate drawing certain characters.
More Function Keys
Tcell also has richer support for a larger number of special keys that some terminals can send.
Better Color Handling
Tcell will respect your terminal's color space as specified within your terminfo entries. For example attempts to emit color sequences on VT100 terminals won't result in unintended consequences.
In legacy Windows mode, Tcell supports 16 colors, bold, dim, and reverse, instead of just termbox's 8 colors with reverse. (Note that there is some conflation with bold/dim and colors.) Modern Windows 10 can benefit from much richer colors however.
Tcell maps 16 colors down to 8, for terminals that need it. (The upper 8 colors are just brighter versions of the lower 8.)
Better Mouse Support
Tcell supports enhanced mouse tracking mode, so your application can receive regular mouse motion events, and wheel events, if your terminal supports it.
(Note: The Windows 10 Terminal application suffers from a flaw in this regard, and does not support mouse interaction. The stock Windows 10 console host fired up with cmd.exe or PowerShell works fine however.)
A compatibility layer for termbox is provided in the
To use it, try importing
Most termbox-go programs will probably work without further modification.
Working With Unicode
Internally Tcell uses UTF-8, just like Go.
However, Tcell understands how to
convert to and from other character sets, using the capabilities of
Your application must supply
them, as the full set of the most common ones bloats the program by about 2 MB.
If you're lazy, and want them all anyway, see the
Wide & Combining Characters
SetContent() API takes a primary rune, and an optional list of combining runes.
If any of the runes is a wide (East Asian) rune occupying two cells,
then the library will skip output from the following cell. Care must be
taken in the application to avoid explicitly attempting to set content in the
next cell, otherwise the results are undefined. (Normally the wide character
is displayed, and the other character is not; do not depend on that behavior.)
Older terminal applications (especially on systems like Windows 8) lack support for advanced Unicode, and thus may not fare well.
Tcell assumes the ANSI/XTerm color model, including the 256 color map that
XTerm uses when it supports 256 colors. The terminfo guidance will be
honored, with respect to the number of colors supported. Also, only
terminals which expose ANSI style
setab will support color;
if you have a color terminal that only has
setb, please submit
Tcell supports 24-bit color! (That is, if your terminal can support it.)
NOTE: Technically the approach of using 24-bit RGB values for color is more accurately described as "direct color", but most people use the term "true color". We follow the (inaccurate) common convention.
There are a few ways you can enable (or disable) true color.
For many terminals, we can detect it automatically if your terminal includes the
Tccapabilities (or rather it did when the database was updated.)
You can force this one by setting the
COLORTERMenvironment variable to
24bit. This is the same method used by most other terminal applications that support 24-bit color.
If you set your
TERMenvironment variable to a value with the suffix
-truecolorthen 24-bit color compatible with XTerm and ECMA-48 will be assumed. (This feature is deprecated. It is recommended to use one of other methods listed above.)
You can disable 24-bit color by setting
TCELL_TRUECOLOR=disablein your environment.
When using TrueColor, programs will display the colors that the programmer
intended, overriding any "
themes" you may have set in your terminal
emulator. (For some cases, accurate color fidelity is more important
than respecting themes. For other cases, such as typical text apps that
only use a few colors, its more desirable to respect the themes that
the user has established.)
Reasonable attempts have been made to minimize sending data to terminals, avoiding repeated sequences or drawing the same cell on refresh updates.
(Not relevant for Windows users.)
The Terminfo implementation operates with a built-in database.
This should satisfy most users. However, it can also (on systems
with ncurses installed), dynamically parse the output from
for terminals it does not already know about.
terminfo/ directory for more information about generating
new entries for the built-in database.
Tcell requires that the terminal support the
cup mode of cursor addressing.
Ancient terminals without the ability to position the cursor directly
are not supported.
This is unlikely to be a problem; such terminals have not been mass-produced
since the early 1970s.
Mouse support is detected via the
kmous terminfo variable, however,
enablement/disablement and decoding mouse events is done using hard coded
sequences based on the XTerm X11 model. All popular
terminals with mouse tracking support this model. (Full terminfo support
is not possible as terminfo sequences are not defined.)
On Windows, the mouse works normally.
Mouse wheel buttons on various terminals are known to work, but the support in terminal emulators, as well as support for various buttons and live mouse tracking, varies widely. Modern xterm, macOS Terminal, and iTerm all work well.
Terminals that appear to support the XTerm mouse model also can support
bracketed paste, for applications that opt-in. See
EnablePaste() for details.
There is a
SimulationScreen, that can be used to simulate a real screen
for automated testing. The supplied tests do this. The simulation contains
event delivery, screen resizing support, and capabilities to inject events
and examine "
physical" screen contents.
POSIX (Linux, FreeBSD, macOS, Solaris, etc.)
Everything works using pure Go on mainstream platforms. Some more esoteric platforms (e.g., AIX) may need to be added. Pull requests are welcome!
Windows console mode applications are supported.
Modern console applications like ConEmu and the Windows 10 terminal, support all the good features (resize, mouse tracking, etc.)
Plan9, WASM, and others
These platforms won't work, but compilation stubs are supplied
for folks that want to include parts of this in software for those
platforms. The Simulation screen works, but as Tcell doesn't know how to
allocate a real screen object on those platforms,
NewScreen() will fail.
If anyone has wisdom about how to improve support for these, please let me know. PRs are especially welcome.
Tcell is absolutely free, but if you want to obtain commercial, professional support, there are options.
- TideLift subscriptions include support for Tcell, as well as many other open source packages.
- Staysail Systems Inc. offers direct support, and custom development around Tcell on an hourly basis.
*Note that all licence references and agreements mentioned in the tcell README section above are relevant to that project's source code only.