# vim-quickui, a Turbo C++ style widget set for Vim > vim-quickui is a terminal user interface widget library for Vim and NeoVim written entirely in VimScript with no external dependencies, offering a dropdown menubar, a context menu, a data-driven dialog system and a set of popups. The visual reference is the Borland and Turbo C++ IDE of the 1990s, and the author's own screenshot of that editor is in the README. **skywind3000/vim-quickui** — The missing UI extensions for Vim 9 (and NeoVim) !! :sunglasses: - Repository: https://github.com/skywind3000/vim-quickui - Website: https://www.vim.org/scripts/script.php?script_id=5845 - Stars: 1,181 · Forks: 42 - Language: Vim Script - License: MIT - Published: 2026-10-19 · Updated: 2026-10-19 · Language: en - Canonical page: https://hysenlabs.com/projects/skywind3000-vim-quickui ## Why a Turbo C++ IDE inside Vim vim-quickui is described as a Borland and Turbo C++ inspired TUI widget library for Vim and NeoVim, offering menus, dialogs, context menus and more, all in pure VimScript with no dependencies. The repository description puts it more bluntly, the missing UI extensions for Vim 9 and NeoVim. The reference point is deliberate and the author is explicit about it, since the README carries a screenshot of a Turbo C++ style editor the author wrote for Watcom C++ back in the day, and the project is described as an attempt to bring that classic TUI experience into modern Vim. The author is Lin Wei, an open source advocate and long-time Vim user. The audience is a Vim user who wants interactive surfaces inside the editor, and the no dependency rule is a real constraint on the design rather than a slogan, since the feature list explicitly rules out a plus python requirement and claims zero overhead. ## A menubar in a dozen lines of VimScript The quick start is a menubar, and the amount of code needed to get one is the demonstration of the library. You clear the existing menus, install a menu with a list of items, and map a key to open it. ```vim " clear all the menus call quickui#menu#reset() " install a 'File' menu call quickui#menu#install('&File', [ \ [ "&Open\t(:w)", 'call feedkeys(":tabe ")'], \ [ "&Save\t(:w)", 'write'], \ [ "--", ], \ [ "E&xit", 'qa' ], \ ]) noremap :call quickui#menu#open() ``` The structure of an item is a label and a command, with the ampersand marking a hotkey and a tab separating the label from a right-aligned annotation, and a lone dash acting as a separator. The menus display as a row of dropdowns at the top of the screen, and the README says to navigate with hjkl or the mouse and pick an item with Enter. A complete configuration example is in test/menu_example.vim. The point for an evaluator is that a menu system with hotkeys, annotations and separators is about twenty lines of configuration, which is what makes the widget set usable in a real configuration rather than a demo. ## A context menu that appears where the cursor is The context menu is the right-click style widget, and its use case is commands that are relevant to what is under the cursor. The content is the same list of label and command pairs as the menubar, with a dash as a separator, and the widget is opened with a call that takes the content and an options dictionary. ```vim let content = [ \ ['&Help Keyword', 'echo 123' ], \ ['&Signature', 'echo 456' ], \ ['-'], \ ['&Peek Definition', 'echo 789'], \ ] call quickui#context#open(content, {}) ``` The README describes it as ideal for presenting commands relevant to the current context, which is the part that distinguishes it from a fixed menu. A configuration that puts a peek definition or a documentation lookup in a context menu is a small amount of VimScript that a user can bind to the right mouse button and immediately have something that feels like an IDE. The API reference for it is in MANUAL.md under the context menu section, alongside the menu reference, so the two widgets share one document. ## The dialog is data, and the result is a dictionary The dialog is the most capable widget, and the README calls it the most powerful one. You declare a list of controls, each a dictionary with a type, and the widget returns all the values as a dictionary. The supported control types are label, input, radio, check, button, separator and dropdown, and navigation is with Tab and Shift-Tab or with hotkeys. ```vim let items = [ \ {'type': 'label', 'text': 'Settings:'}, \ {'type': 'input', 'name': 'name', 'prompt': 'Name:', 'value': 'test'}, \ {'type': 'radio', 'name': 'choice', 'prompt': 'Pick:', 'items': ['A', 'B', 'C']}, \ {'type': 'check', 'name': 'flag', 'text': 'Enable Feature'}, \ {'type': 'button', 'name': 'confirm', 'items': [' &OK ', ' &Cancel ']}, \ ] let result = quickui#dialog#open(items, {'title': 'Settings'}) echo result ``` The declaration is data, which means a settings screen is a list of dictionaries rather than a pile of input() calls, and the result is a dictionary keyed by the names you gave, so the caller never has to parse prompt output. The dialog has its own guide in DIALOG.md, a tutorial on dev.to about building real dialogs in Vim with no Python and no dependencies, and a set of examples in test/test_dialog.vim. ## Six more popups, and a manual for each The rest of the widget set is catalogued in a table in the README, and the entries are more than a list of names. The Listbox is a scrollable list with search, using the slash or the question mark, and mouse wheel support, which the README points at buffer switching and function navigation. The Textbox displays arbitrary text in a popup, useful for reading help or messages without splitting the window. The Preview is a popup window near the cursor for glimpsing definitions or quickfix results. The Inputbox is a single line text input popup, the Terminal runs terminal programs in a popup window, and Confirm is a simple choice dialog. Each has its own section in MANUAL.md, which the README describes as the complete API reference for all widgets, while DIALOG.md is the in-depth guide to the dialog system. Colour schemes and border styles are configurable, with Borland, gruvbox and solarized named as the schemes, and the manual is the place to find the rest. ## Installing it and the shape of the repository There are two installation routes, one for plugin managers and one for Vim's own package system. ```vim Plug 'skywind3000/vim-quickui' ``` ```bash mkdir -p ~/.vim/pack/vendor/start cd ~/.vim/pack/vendor/start git clone https://github.com/skywind3000/vim-quickui ``` The script is also published on vim.org, and the README asks readers to vote for it there as well as starring the repository. The repository layout is conventional for a Vim plugin, with autoload/ holding the functions, plugin/ the entry points, colors/ the colour schemes, lua/ for the Lua parts, test/ for the test scripts, and docs/ for the images and site material, next to MANUAL.md, DIALOG.md, an AGENTS.md and a CLAUDE.md. A related project by the same author, vim-navigator, is powered by QuickUI, which is the clearest signal of what the widget set is for, since it is a command and function navigation interface built on the listbox and the preview window. ## Version rhythm and what is not documented The release history is quick and the numbers are small, with 1.5.1 on 2026-04-30, 1.5.4 on 2026-05-02 and 1.5.6 on 2026-05-03, so several patch releases in a few days. The repository is not archived and the last push was on 2026-06-30, so the work continues, and the version range the README claims is wide, Vim 8.2 or later and NeoVim 0.4 or later, which is reassuring for anyone on an older distribution build. The licence is MIT, in the LICENSE file, which is the permissive grant expected for a Vim plugin and imposes nothing on the configuration that uses it. What the README does not cover is the failure modes, since there is no section on what happens when a widget overlaps a popup, on terminals with unusual capabilities, or on how the library behaves in a headless or remote session, and the repository holds no issue template or troubleshooting guide. For a project whose appeal is entirely visual, those are the gaps a new user will meet first, and the manual pages are where you will look for the answers. ## Conclusion vim-quickui fits a Vim user who wants interactive surfaces in the editor, a menu system, a prompt for structured input, or a popup for a definition, without pulling in a plugin manager stack, an embedded Python or a compiled extension. It does not fit a user who wants a modern mouse-driven IDE interface, since the whole design is a terminal widget set in the Borland idiom, and it does not fit a team that needs a maintained plugin for the long term without checking who is going to carry it. Verify three things first: that your Vim or NeoVim version is inside the supported range, since the library asks for Vim 8.2 or later and NeoVim 0.4 or later, how the dialog widget behaves in your terminal with your colours, since the borders and colour schemes are part of the appeal, and whether the widgets you want are the ones the manual documents, because the widget set is broad but each one has its own page. ## FAQ ### What is vim-quickui? It is a terminal user interface widget library for Vim and NeoVim, inspired by the Borland and Turbo C++ IDE, providing menus, dialogs, context menus and popups in pure VimScript with no external dependencies. It supports Vim 8.2 or later and NeoVim 0.4 or later. ### How do I install vim-quickui? With vim-plug, add Plug 'skywind3000/vim-quickui' to your plugin list. With Vim's built-in package manager, create the directory ~/.vim/pack/vendor/start and clone the repository into it. The script is also published on vim.org. ### What widget types does the vim-quickui dialog support? label, input, radio, check, button, separator and dropdown. The controls are declared as a list of dictionaries and quickui#dialog#open returns the values as a dictionary, and you navigate with Tab and Shift-Tab or with hotkeys. ### Where is the vim-quickui documentation? MANUAL.md is the user manual and complete API reference for all the widgets, and DIALOG.md is the in-depth guide to the dialog system. Example configurations live in the test directory, with menu_example.vim and test_dialog.vim, and there is a dev.to tutorial on building dialogs in Vim without Python. ## Sources - [License: MIT](https://github.com/skywind3000/vim-quickui/blob/master/LICENSE) - [Project website](https://www.vim.org/scripts/script.php?script_id=5845) - [README](https://github.com/skywind3000/vim-quickui/blob/master/README.md) - [Releases](https://github.com/skywind3000/vim-quickui/releases) - [skywind3000/vim-quickui on GitHub](https://github.com/skywind3000/vim-quickui) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/skywind3000-vim-quickui