Turbo Vision, ported to modern terminals: a C++ TUI framework with Unicode support

What Turbo Vision solves for C++ terminal applications

Writing a terminal interface by hand means handling escape sequences, terminal capabilities and platform differences before you write a single line of application logic. Turbo Vision is a widget framework that takes that over. The README lists what it provides: resizable overlapping windows, pull-down menus, dialog boxes, buttons, scroll bars, input boxes, check boxes and radio buttons, plus event dispatching and display of fullwidth Unicode characters. It is aimed at C++ programmers who want a desktop-style interface inside a terminal, and who are willing to work with a codebase that dates back to Borland's early 1990s design.

The README is direct about where the library is weak. It states that many GUI tools today separate appearance specification from behaviour specification, use safer or dynamic languages, and support parallel or asynchronous programming, and that Turbo Vision does not excel at any of those. That is an unusual admission in a project README, and it tells you the intended audience: developers who value source-level compatibility with old Turbo Vision code and predictable cross-platform behaviour over modern C++ idioms.

How the port works: char arrays, UTF-8 and per-platform colour handling

The compatibility goal shapes the architecture. The README says the project keeps using `char` arrays instead of `wchar_t` or `TCHAR`, which are described there as implementation-defined and platform-dependent. Unicode is carried as UTF-8 in ordinary strings, and the README points to UTF-8 support in `setlocale` in recent versions of Microsoft's RTL as the piece that makes filenames such as `コンピュータ.txt` work on Windows without conditional compilation.

Platform quirks are absorbed by the library rather than the application. The README gives one concrete example: to get a bright background colour on the Linux console, the blink attribute has to be set, and Turbo Vision does this for you. That is the pattern throughout: the application describes what it wants to look like, and the library maps it onto whichever terminal or console it is running on. The README also notes that some Borland C++ RTL functions were implemented to keep old applications source-compatible, which is a deliberate cost: it keeps legacy code building, at the price of carrying behaviour that modern standard libraries already provide.

Building Turbo Vision on Unix/Linux and running a first example

The README gives an exact build recipe for Unix/Linux: Turbo Vision builds as a static library with CMake and GCC or Clang. The command below configures a Release build in a `build` directory and then compiles it. The README notes that CMake versions older than 3.13 may not support the `-B` option.

cmake . -B ./build -DCMAKE_BUILD_TYPE=Release && # Could also be 'Debug', 'MinSizeRel' or 'RelWithDebInfo'.
cmake --build ./build # or `cd ./build; make`

The README states that this produces `libtvision.a`. If your CMake is older than 3.13, the README offers an alternative that creates the directory first:

mkdir -p build; cd build
cmake .. -DCMAKE_BUILD_TYPE=Release &&
cmake --build .

For a first real use, the README points at three sample applications: `hello`, `tvdemo` and `tvedit`. On Unix systems it says you have to build Turbo Vision yourself to try them. On Windows and DOS, the README says up-to-date binaries of the examples are attached to successful GitHub Actions workflows, in an Artifacts section: `examples-x86.zip` and `examples-x64.zip` (MSVC builds, Windows Vista or later), and `examples-dos.zip` and `examples-dpmi32.zip` (Borland C++ builds, described as having no Unicode support). The README also notes that Turbo Vision can be consumed as a CMake dependency and is available through Vcpkg, with sections for MSVC, MinGW and Borland C++ builds.

No stable releases, and what upgrading from master means

The most consequential limitation is packaging. The README states plainly: "This project has no stable releases for the time being. If you are a developer, try to stick to the latest commit and report any issues you find while upgrading." The release list on the repository is thin and old, with the most recent entries dated 2020. The last push to the repository was on 2026-09-18, so the code is moving even though tagged releases are not.

For a team, that changes the upgrade model. There is no version number to pin to and no changelog between releases to read before upgrading. You track a commit, and the README asks you to report what breaks. If your project needs a fixed dependency version with a documented compatibility promise, this library does not offer one today.

There is also a hard platform boundary. The DOS and DPMI32 example builds are described in the README as having no Unicode support. If your target is 16-bit DOS, the Unicode work that landed in 2020 does not reach you.

Turbo Vision compared with ncurses for terminal interfaces

The repository lists ncurses among its topics, and the comparison is the right one to make. ncurses is a terminal capability and screen-drawing library: it abstracts terminfo, cursor movement and colour, and leaves window management, menus and dialogs to you or to a layer such as CDK or a toolkit built on top. Turbo Vision is a level above that. It ships the widget classes, the event loop and the palette system, and the README recommends the `palette` example for how palettes are used.

The trade-off follows from the level of abstraction. With ncurses you keep control of the drawing model and can target a wider range of terminal behaviour directly. With Turbo Vision you inherit a specific visual and interaction model, the one Borland shipped in the early 1990s, including its palette-based colour scheme and its view hierarchy. If you want that model, you get a large amount of interface code for free. If you want a different model, you are working against the framework rather than with it.

A second difference is language. Turbo Vision is a C++ library with a legacy-compatible API; its documentation trail runs through Borland's own guides. The README points new users at the Turbo Vision For C++ User's Guide and the Turbo Vision 2.0 Programming Guide on archive.org, noting that the latter uses Pascal but is, in the author's opinion, more intuitive.

Licence status and what to check before shipping

The repository's licence is reported as NOASSERTION, which means the automated classifier could not map the `COPYRIGHT` file at the top level to a known licence identifier. That is a signal to read the file yourself rather than a statement about what it contains. The project descends from Borland's Turbo Vision, so the terms are unlikely to be a plain permissive boilerplate licence, and the `COPYRIGHT` file is the place to look.

This is not a reason to avoid the library, but it is a reason to resolve the question before the dependency is baked into a distributed product. If you are linking `libtvision.a` into a binary you ship, the licence terms and any attribution requirements belong in the same review as the rest of your third-party dependencies.

Editorial conclusion

Adopt it if you are writing a C++ terminal application that needs overlapping windows, menus and dialogs, and you accept building from the latest commit rather than a tagged release. Do not adopt it if you need a stable release line, a widget set that separates appearance from behaviour, or Unicode on 16-bit DOS, where the README states there is no Unicode support. Before committing, build the library with the CMake commands above, run the tvdemo example, and confirm the compiler and C++ standard your toolchain uses.

Frequently asked questions

Official sources

1. Issues
2. magiblot/tvision on GitHub
3. README
4. Releases