Open-source alternatives to Inquirer.js

Ratatui is a terminal rendering engine and library for the Rust language used to build interactive text-based user interfaces. It provides a framework for creating command-line dashboards and visual applications by rendering widgets and layouts directly to a terminal screen. The project utilizes a backend-agnostic interface to decouple UI logic from terminal drivers and employs a constraint-based layout engine to divide screen space into nested rectangular areas. It manages rendering through an immediate-mode drawing loop and a buffer-based system to minimize screen flicker. The library supp

Clack is a Node.js CLI framework and prompt library designed for building stylized, interactive command-line user interfaces. It provides a toolkit for creating terminal applications that collect structured user input and display formatted information. The library includes a set of interactive terminal UI components, such as validated input fields for text and passwords, searchable selection menus with autocomplete, and grouped options for user choice. It also provides mechanisms for process visualization, including loading spinners, progress bars, and sequential task lists to communicate bac

go-prompt is a library for building interactive command-line interfaces in Go. It serves as a cross-platform console UI framework and terminal input manager, providing the tools necessary to capture user input and execute commands through a persistent interactive loop. The library features a dedicated auto-completion engine that provides real-time command suggestions. It also supports dynamic prompt prefixes updated via callback functions and a system for managing and recalling command history. The framework covers a broad range of terminal capabilities, including keyboard shortcut mapping,

This project is a Node.js CLI input library and toolkit for building interactive command-line user interfaces. It functions as a questionnaire framework and prompt orchestrator designed to capture structured user data through a variety of visual input controls. The system differentiates itself through a logic-driven engine that supports dynamic prompt chains, allowing the sequence and properties of questions to adapt at runtime based on previous user answers. The toolkit provides a wide range of specialized input types, including date pickers, searchable lists, masked passwords, and numeric

This project is a terminal user interface library for Node.js, designed to facilitate the construction of interactive command-line applications. It provides a comprehensive toolkit of high-level widgets that abstract complex terminal escape codes and rendering logic, allowing developers to build functional interfaces using reusable components. The framework distinguishes itself by implementing a box-model-based layout engine and a virtual DOM-style reconciliation system. These mechanisms enable responsive design patterns—such as percentage-based sizing and relative positioning—to function wit

tview is a library for building interactive text-based user interfaces in Go. It functions as a toolkit for managing event loops, user input, and screen rendering, providing a framework of pre-built widgets and an integrated layout engine for creating command-line applications. The project distinguishes itself through a comprehensive layout system that uses grid and flexbox models to create responsive designs. It also supports UI layer stacking to manage multiple screens and modal overlays. The framework includes a diverse suite of interactive components for data display, such as tables and

blessed-contrib is a terminal user interface framework and a Node.js console widget library designed for building data-driven command line interfaces. It serves as an ASCII data visualization toolkit and a dashboard framework for organizing grid-based layouts and interactive elements within a console. The project provides a collection of reusable terminal components, including a command line image renderer and tools for text-based graphic rendering. It specifically enables the creation of terminal dashboards through a system for positioning multiple widgets across rows and columns and a mecha

termbox-go is a Go terminal user interface library and cross-platform terminal emulator abstraction. It provides a system for creating text-based graphical interfaces by managing a terminal cell buffer and handling raw input events. The library functions as a terminal cell buffer manager and input handler. It maintains an internal grid of characters and colors, using a back buffer to synchronize updates to the physical screen and translate keyboard and mouse events into structured data. Its capability surface covers text user interface rendering and terminal display management, including cur

Asciimatics is a cross-platform terminal user interface framework and console wrapper. It functions as a curses-compatible library providing a toolkit for building interactive text-based applications, an ASCII art generator, and a terminal animation engine. The project distinguishes itself through a visual effects engine capable of rendering sprites, particle systems, and anti-aliased lines. It includes specialized systems for creating moving text-based graphics and tools for converting image files into character-based representations. The framework covers core terminal management including

This project is a Python terminal user interface library and toolkit designed for building interactive command-line applications. It provides a terminal input manager and a widget toolkit for rendering dashboards, menus, and editors within a terminal emulator. The library enables the creation of full-screen terminal interfaces and interactive shells. It distinguishes itself with advanced input handling, including lexer-based syntax highlighting for visual feedback on code structure and support for industry-standard keyboard navigation modes such as Emacs and Vi. The capability surface covers

Termui is a Go terminal user interface library used for building interactive dashboards and visual layouts within a command-line environment. It functions as a TUI layout engine, an interactive CLI framework, and a terminal data visualization toolkit. The library provides a set of specialized widgets for rendering charts, plots, gauges, and tables using character-based graphics. It includes a grid-based system for arranging interface elements using relative coordinates and proportional sizing to create structured displays. The toolkit covers a broad range of capabilities including data visua

gocui is a console user interface library for the Go programming language. It provides a toolkit for building interactive terminal applications using a layout engine that organizes overlapping rectangular views and coordinates. The library features a terminal input handler to capture and map keyboard shortcuts and mouse events to specific application actions. It includes an ANSI escape sequence parser to manage text attributes, colors, and cursor positioning. The framework covers interface view management and overlapping window layering, allowing for a structured arrangement of content. Rend

This project is a framework for building interactive, graphical-style terminal applications. It provides a declarative component model that organizes user interfaces into a tree of nested widgets, each managing its own lifecycle, state, and rendering. By subclassing the base application class, developers can construct complex, keyboard-navigable interfaces that run directly within terminal emulators. The framework distinguishes itself through a reactive architecture and a CSS-based layout engine. It uses a reactive attribute system to automatically track state changes and trigger targeted int

Ark is a headless UI component library that delivers accessible, cross-framework primitives with behavior governed by finite state machines. It provides unstyled components that encapsulate logic and accessibility — including full keyboard navigation, focus management, and WAI-ARIA support — while leaving visual styling entirely to the consumer. Components expose scoped data attributes for CSS targeting and use state machines to produce predictable, testable interactive behavior across every state transition. The library distinguishes itself through a state propagation model that distributes

Ora is a terminal spinner library and Node.js CLI component used to integrate animated loading indicators and task-outcome symbols into JavaScript-based terminal applications. It functions as a progress visualizer that signals the status of command-line operations through animated sequences of characters. The library provides promise-based spinner wrapping, allowing animations to start and resolve automatically based on the outcome of asynchronous tasks. It replaces active animations with specific success, failure, warning, or info symbols to communicate the final result of a process. The to

Chalk is a Node.js console formatter and terminal styling library used to add colors and text modifiers to command line output. It functions as a tool for formatting strings with foreground colors, background tints, and text styles using ANSI escape sequences. The library includes a terminal color support detector that automatically determines the color depth and capabilities of the current environment. It features an ANSI color downsampler that converts RGB, Hex, or 256-color values to the nearest compatible format based on the detected terminal capabilities. The project provides capabiliti

Commander.js is a framework for building command-line interfaces and terminal applications. It functions as an argument parsing library and command lifecycle manager, transforming raw terminal input strings into structured, validated objects for use in executable scripts. The system utilizes a recursive command tree pattern, allowing developers to organize complex execution flows through nested subcommands. It features a declarative interface for defining command-line flags and arguments, which maps user input directly to internal state properties. To assist with usability, the framework auto

oclif is a Node.js framework for building command-line interfaces. It provides a structured system for developing terminal applications with consistent command patterns, argument parsing, and automated help generation. The project features a modular plugin architecture that allows for external functionality to be injected via a manifest-based loading mechanism. It includes a dedicated distribution pipeline and packager to bundle applications into OS-native installers and tarballs for Windows, macOS, and Linux. The framework covers a broad range of development capabilities, including project

yargs is a command-line interface framework and argument parser for Node.js. It translates raw command-line strings into structured JavaScript objects, providing a toolkit for building terminal applications with nested sub-commands, dedicated handlers, and a structured user interface. The framework distinguishes itself through automated help text generation, which constructs formatted usage menus and instructions based on registered metadata. It also provides shell completion generation for Bash and Zsh and uses string-distance algorithms to offer typo correction suggestions when invalid inpu

Filament is a full-stack framework for building administrative panels and management interfaces within the Laravel ecosystem. It provides a declarative, component-based architecture that allows developers to construct complex, data-driven applications using server-side configuration objects rather than manual HTML. By inspecting database model structures and relationships, the framework automates the generation of CRUD interfaces, forms, and data tables, significantly reducing boilerplate code. The project distinguishes itself through a highly modular and extensible design that supports custo

This project is a command-line utility and development framework designed to modify, extend, and customize the Spotify desktop client. It functions as a binary patching engine that injects custom scripts, stylesheets, and interface components directly into the host application, enabling users to alter visual themes and add new functionality. The tool distinguishes itself by providing a comprehensive development environment for building modular extensions and custom applications. It includes a hot-reloading pipeline for rapid iteration, a declarative library for constructing interactive UI pan

gui.cs is a .NET terminal user interface toolkit and framework used to build interactive, cross-platform text-based applications. It provides a structured system for composing terminal views using a view hierarchy and a dedicated layout engine. The library distinguishes itself through a component-based widget system and a constraint-based layout engine that allows interfaces to remain responsive across different terminal window dimensions. It employs a virtual-screen buffer to minimize flickering during redraws and uses state-driven theme configurations to maintain persistent visual styles.

tcell is a Go terminal user interface library and framework for building cell-based applications. It functions as a terminal emulator backend and input processor, utilizing a change-based diffing engine to manage screen state and efficiently render updates. The project is distinguished by its pluggable backend abstraction, which allows terminal interfaces to be rendered across physical terminals or compiled into WebAssembly for web browser display. It provides a virtual screen simulation to enable programmatic event injection and output inspection for automated application testing. Its capab

Opentui is a terminal user interface framework for building interactive command line applications. It provides a component-based system featuring a flexbox layout engine, a virtual node component tree, and a low-level 2D cell array renderer. The project is distinguished by a sophisticated keyboard binding engine that maps complex multi-stroke sequences and chords to named commands using prioritized, reactive layers. It also implements a plugin architecture that allows external modules to inject custom UI components into designated layout slots and extend input logic at runtime. Its capabilit

xterm.js is a high-performance terminal emulator library designed for web applications. It provides a core rendering engine and a modular interface that allows developers to embed fully functional, interactive command-line interfaces directly into browser environments. By processing standard terminal data streams and managing internal buffer states, the library enables the creation of rich, text-based user interfaces that support standard terminal protocols. The project distinguishes itself through a highly extensible architecture that allows for deep customization of terminal behavior. Devel

Trippy is a network diagnostic tool and terminal user interface that combines ping and traceroute functionality to analyze network paths and performance. It provides a network packet parser and path analyzer to detect packet loss, jitter, and multipath routing through continuous network probing. The project is distinguished by its support for specialized tracing strategies, including Paris and Dublin, to ensure consistent path discovery. It identifies network address translation devices and utilizes heuristic analysis to distinguish genuine packet loss from rate-limiting. Broad capability ar

This project provides a comprehensive guide and set of architectural patterns for developing professional command-line interfaces using Node.js. It focuses on establishing industry standards for terminal-based applications, ensuring that tools are predictable, maintainable, and user-friendly. The guide emphasizes creating high-quality user experiences through interactive terminal elements, actionable error reporting, and graceful handling of system signals. It distinguishes itself by detailing how to integrate command-line tools into automated pipelines, specifically through the use of struct