FVision

Define responsive text UIs once in portable .fvui files, then run them across modern terminals, native consoles, and custom embedded displays.

Comment

Inspiration

Terminal applications remain essential for developer tools, system administration, and embedded systems, but their interfaces are often tied to fixed coordinates, a particular terminal emulator, or one implementation language.

FVision applies modern declarative and responsive UI ideas to text-mode applications. It is inspired by the immediacy of classic text interfaces and by modern toolkits such as Slint, while being designed as a new, independent library.

What it does

FVision is a portable declarative text UI toolkit. Developers describe an interface in a standalone .fvui file using responsive Rows, Columns, Grids, fixed gaps, weighted spacers, percentage sizing, viewport margins, and minimum/maximum constraints.

The same .fvui source can be:

  • Loaded and interpreted at runtime.
  • Compiled into Rust during build.rs.
  • Exposed through generated, strongly typed Rust properties, actions, callbacks, and observable models.
  • Reused by future independent Python, MISRA C++, and Ada implementations.

The retained runtime includes dialogs, windows, menus, status bars, editors, lists, trees, tabs, validation, utility dialogs, keyboard and mouse handling, and runtime-switchable Classic, Monochrome, and Dark themes.

FVision supports modern ANSI/VT terminals, Linux virtual consoles with optional GPM, FreeBSD consoles, Windows Virtual Terminal and native Console APIs. Applications can also replace the entire input/output layer, allowing the UI model to target embedded character displays or other custom hardware.

The demonstration

The submitted application is an interactive .fvui Inspector whose own interface is defined in portable .fvui and compiled into Rust.

It lets evaluators:

  • Edit .fvui source in a responsive, syntax-highlighted editor.
  • Load valid and deliberately broken examples.
  • Run FVision's real parser and semantic analyzer.
  • View structured diagnostics and normalized-document results.
  • Exercise generated typed callbacks, properties, and observable models.
  • Toggle declarative local state without entering Rust.
  • Switch themes while the application is running.
  • Resize the terminal and watch the layout respond.

This makes the showcase a real developer workflow rather than a static widget gallery.

How it was built

The declarative pipeline parses .fvui, resolves imports and components, type-checks properties and actions, and produces a normalized document. That representation can either be mounted at runtime or translated into Rust through fvision-build.

Generated bindings provide a typed API while using the same retained widget runtime as runtime-loaded interfaces.

The renderer draws styled, grapheme-aware cells into an intermediate surface. Host drivers normalize keyboard and mouse events and efficiently emit changed cells. Platform-specific terminal and console behavior remains isolated beneath the widget and declarative layers.

How Codex helped

FVision had a working pre-event foundation. During Build Week, Codex implemented and refined the scoped declarative compiler work, typed integration, responsive layout behavior, platform investigations, tests, quality improvements, evaluator packaging, and the final showcase.

GPT-5.6 was used for the final productization pass: turning the underlying capabilities into a coherent demonstration, preparing evaluator packages and evidence, verifying the supported platforms, and helping produce the submission video.

The human owner directed the architecture and made the key language, portability, layout, palette, licensing, and visual acceptance decisions. Git history and OpenSpec records document the collaboration and distinguish the Build Week work from the pre-existing foundation.

Challenges

The hardest problems were found at the boundaries:

  • Preserving responsive layout on a cell-based display.
  • Keeping runtime-loaded and build-compiled .fvui behavior equivalent.
  • Generating useful typed APIs without coupling the source format to Rust.
  • Supporting terminals and native consoles with very different input, color, Unicode, and mouse capabilities.
  • Making Classic, Dark, and true one-bit Monochrome themes work structurally rather than as simple color substitutions.
  • Avoiding flicker and visual corruption during rapid terminal resizing.

Testing on real Linux and FreeBSD consoles exposed behavior that ordinary terminal emulators did not reveal.

Accomplishments

The result combines a portable declarative language, generated typed Rust integration, responsive layout, native text controls, syntax highlighting, multiple runtime themes, and replaceable host I/O in one coherent system.

The standalone .fvui format is deliberately language-neutral. Future ports will be independent implementations rather than bindings around the Rust library.

What is next

Next steps include expanding the .fvui tooling, creating additional example applications, improving documentation, and beginning the independent Python implementation. MISRA C++ and Ada implementations are planned for industrial and safety-conscious environments.

Built With

  • ansi-terminal
  • build-scripts
  • cargo
  • code-generation
  • declarative-ui
  • embedded-systems
  • freebsd
  • freebsd-console-api
  • fvision
  • fvui
  • gpm
  • gpt-5.6
  • linux
  • linux-console-api
  • macos
  • openai-codex
  • responsive-layout
  • rust
  • syntax-highlighting
  • text-user-interface
  • unicode
  • vt100
  • windows
  • windows-console-api
Share this project:

Updates