New package: terminice - build polished, beautiful, complex Dart CLIs with 30+ simple components

Plugins & Packages New releases
,
1

Hi! I wanted to share a new package I made: terminice.

I built it because creating a beautiful, complex CLI shouldn’t mean building an entire terminal UI from scratch. It should be easy to create, easy to style, easy to manage as it grows, and most importantly easy and enjoyable for people to use.

terminice turns more than 30 common terminal interactions into small method calls, with no setup and no framework required.

https---github.com-jozzdart-terminice-raw-main-terminice-assets-terminice-visual-demo-2

Need a value from the user?


final name = terminice.text('Project name');

Need a searchable menu?


final template = terminice.searchSelector(

prompt: 'Template',

options: ['CLI', 'Server', 'Package'],

);

Need a file browser, config editor, command palette, progress bar, multi-step form, calendar, or help center? Those are method calls too.

There is no setup, widget tree, context object, or new application architecture. Import the package, call the component you need, and keep using package:args, CommandRunner, dart:io, or whatever already powers your CLI.


dart pub add terminice

Make the entire CLI look like yours

Don’t like the borders? Hide them:


final t = terminice.minimal;

Want the borders, but fewer hints and less visual noise?


final t = terminice.compact;

Want different colors? Pick a built-in theme:


final oceanUi = terminice.ocean;

final matrixUi = terminice.matrix;

final neonUi = terminice.neon;

final arcaneUi = terminice.arcane;

Or combine everything:


final t = terminice.neon.compact;

Now every component created from t follows the same style:


final name = t.text('Project name');

final token = t.password('API token');

final config = t.filePicker('Config file');

final confirmed = t.confirm(message: 'Create the project?');

(you can also create a fully custom, advanced theme, and it will automatically be used across all 30+ components!)

That is one of the main ideas behind Terminice: customize the instance once, and the colors, borders, glyphs, display mode, fallback behavior, and terminal I/O stay consistent across the entire CLI.

You can also create a custom theme in a few seconds by mixing the included colors, glyphs, and display features:


final brandTheme = PromptTheme(

colors: TerminalColors.ocean,

glyphs: TerminalGlyphs.rounded,

features: DisplayFeatures.compact,

);

final t = terminice.themed(brandTheme);

Need finer control? Every color palette, glyph set, and display configuration supports copyWith, so you can change one accent color or one behavior without rebuilding the rest of the theme. The custom theme then affects prompts, menus, pickers, progress indicators, flows, guides, and every other built-in component.

The catalogue

Terminice currently includes more than 30 ready-to-use components.

Prompts

  • text for single-line input
  • password for masked input
  • confirm for yes/no questions
  • multiline for terminal text editing
  • slider and range for numeric input
  • rating for star-based ratings
  • date for keyboard-driven date input
  • form for collecting multiple fields together

Selectors

  • searchSelector for long, filterable lists
  • choiceSelector for card-style single or multi-select choices
  • checkboxSelector for checklists
  • gridSelector for two-dimensional navigation
  • tagSelector for managing multiple tags
  • toggleGroup for editable boolean settings
  • commandPalette for a fuzzy-searchable action launcher

Pickers

  • filePicker for browsing files
  • pathPicker for choosing directories
  • colorPicker for interactive ANSI color selection
  • datePicker for a full calendar interface

Progress and status

  • Full and inline loading spinners
  • Full and inline progress bars
  • Minimal dot-based progress
  • info, success, warn, error, detail, and log messages
  • task for wrapping async work with a status indicator
  • progressTask for determinate async work
  • trackStream for collecting a stream while showing its progress

Complete CLI experiences

  • flow for multi-step workflows with context, conditions, validation, and review
  • configEditor for searchable, nested application settings
  • cheatSheet for quick-reference tables
  • helpCenter for searchable documentation inside the terminal
  • hotkeyGuide for keyboard shortcut discovery
  • themeDemo for previewing themes and colors
  • Custom components when your CLI needs something package-specific

Every catalogue item has its own detailed documentation with controls, behavior, examples, and API notes. I wanted the README to be useful as a practical reference, rather than leaving developers to discover important behavior through trial and error.

The vision

The goal is not only to make prompts look better. I want Terminice to make beautiful, complex CLIs easier to create, style, manage, test, and use.

to create: add prompts, selectors, pickers, progress, or configuration screens with small method calls—not a new architecture.

to style: choose or create one theme, and let the entire CLI follow it. No repeating colors, borders, glyphs, and display options everywhere.

to manage: keep components, behavior, fallbacks, and tests consistent as the CLI grows.

to use: give people clear hints, predictable controls, validation, cancellation, readable fallbacks, and good defaults.

Terminice sits between a prompt package and a full TUI framework. It is the human-facing layer of an existing Dart CLI: questions, choices, files, settings, progress, and feedback.

It can stay tiny when tiny is all you need:


final email = terminice.text('Email');

That same CLI can later grow into searchable menus, filesystem navigation, validation, progress tracking, configuration screens, or complete flows—without switching packages.

When rich UI is not appropriate, the built-ins can fall back to predictable plain text for limited terminals, non-TTY output, scripts, and unattended execution.

Terminal I/O is abstracted as well, so you can feed scripted input into a component and assert its captured output in tests instead of depending on real stdin/stdout.

So the short version is:

  • One import and no setup
  • 30+ components covering individual prompts through complete CLI workflows
  • 11 built-in style presets
  • Chainable themes and verbose, compact, or borderless minimal display modes
  • One shared configuration across the whole CLI
  • Custom themes and components when the built-ins are not enough
  • Cross-platform support for Linux, macOS, and Windows
  • Predictable fallbacks and test utilities for real-world use

Links:

A small personal note

I started working on what eventually became terminice over a year ago, it didn’t begin as one big, carefully planned package. While working on real projects, I kept creating terminal components that I needed- a prompt in one project, a selector in another, a progress indicator somewhere else, then themes, flows, config tools, and testing helpers.

For a while, all of that work was scattered across different projects. Gradually, I started moving the useful pieces into one place, redesigning them around a shared API, and turning them into a unified, robust tool that is genuinely fun and easy to use.

The package is not perfect. There are still many things that need refinement, and probably many things I cannot see because I built them around my own use cases. I want Terminice to become the best tool it can be, but I know I cannot do that alone.

If you build Dart CLIs, I would really appreciate it if you tried it, even in a small project, and told me what you think. If an API feels awkward, a component is missing, the documentation is unclear, or something simply does not feel right, I want to hear about it. Every bug report, idea, criticism, and any feedback is appreciated (:

2 Likes