VTM is a based open-source text-based desktop environment that pushes Windows Terminal to the limit

YouTube Video

Summary

This YouTube video transcript is a passionate and enthusiastic introduction to VTM (Viewport Terminal Manager), a text-based application created by Dimitri Sapnikov. The speaker, clearly impressed, compares VTM to older text-based multitasking environments like Desk View, and modern terminal multiplexers like Screen and T-Mox, but positions VTM as a more innovative and powerful evolution of these concepts.

The video begins with the speaker expressing admiration for Dimitri Sapnikov and his VTM project, emphasizing its “insane beast mode” nature and the need for more recognition (stars on GitHub). He explains VTM as a text-based application, contrasting it with graphical user interfaces (GUIs) and relating it to Text User Interfaces (TUIs). He reminisces about Desk View, a DOS-era text-based multitasking environment, showcasing images to illustrate TUIs. He then mentions Midnight Commander and YEdit as examples of well-designed TUIs, highlighting their use of ASCII characters to simulate graphical elements and interactive buttons.

The speaker then dives into demonstrating VTM itself. He showcases both a graphical and a text-mode version of VTM. In the graphical version, he demonstrates features like:

• Window resizing and repositioning using mouse drag and drop.
• Z-order management for windows.
• Split window management similar to T-Mox or Screen.
• The ability to run multiple applications (terminal emulators, DOS, bash, posh, vim, Midnight Commander) within VTM as separate windows.
• Physics-based window flinging as a playful feature.

He then transitions to the text-mode version of VTM, accessed via a command-line switch (VTM /t). He highlights that even after shutting down the graphical VTM application, the processes started within it remain running, similar to detached processes in Screen or T-Mox. He re-attaches to these running processes in text mode, demonstrating VTM’s capability as a terminal multiplexer even in a pure text environment.

The speaker emphasizes the concept of an “infinite terminal manager” where you can visually manage and organize multiple terminal sessions across a large virtual space. He describes VTM as rethinking terminal management, combining features of window managers and terminal multiplexers in a novel way.

He points out the mouse support within VTM’s TUI, including different click actions (left, right, middle, control-click) for resizing and manipulating windows. He shows how to split and close windows using hotkeys reminiscent of Screen and T-Mox.

The speaker connects VTM to the broader history and potential of TUIs, referencing his old blog post “Windows is missing the text mode boat” and mentioning guey.cs (Gui.cs) as a modern framework for building sophisticated console applications with UI elements. He emphasizes that VTM’s text-mode functionality works well within Windows Terminal, praising both Dimitri’s work and the Windows Terminal team for supporting such applications.

Finally, he encourages viewers to explore VTM on GitHub (github.com/directvt/vtm), star the repository, and share their favorite text-mode applications in the comments. He ends by demonstrating the viewport dragging feature in the text-mode VTM, reiterating his positive impression.

Accuracy

The information provided in the transcript is largely accurate regarding established knowledge of text-based computing and related technologies:

• Desk View: Desk View was indeed a real text-mode multitasking environment for DOS, popular in the late 1980s and early 1990s. The description as a TUI and the screenshots shown in the video (though not in the transcript) are consistent with its actual functionality.
• Screen and T-Mox: The comparison of VTM to Screen and T-Mox is accurate in terms of core functionality. Screen and T-Mox are well-known terminal multiplexers that allow users to detach and re-attach terminal sessions, create multiple windows/panes within a single terminal, and manage detached processes. VTM seems to incorporate and expand upon these concepts in a TUI context.
• TUI (Text User Interface): The explanation of TUI and its distinction from GUI is correct. The examples of Midnight Commander and YEdit are valid and well-known examples of TUIs that use ASCII characters to create interactive and visually appealing interfaces within a text-based environment.
• Midnight Commander and YEdit: These are real and popular TUI applications. Midnight Commander is a file manager, and YEdit (or Yet Another Editor) is a text editor, both demonstrating sophisticated TUI design.
• guey.cs (Gui.cs): Gui.cs is indeed a real and actively developed cross-platform framework for building text-based user interfaces in .NET. The speaker’s mention of it in the context of modern TUI development is accurate.
• VT100: VT100 is a classic terminal standard that defines a set of control codes for text-based terminals. Referring to VTM’s text mode as a “VT100 terminal” is a reasonable analogy, as TUIs often utilize VT100 or similar terminal control sequences for display and interaction. The concept of re-attaching to detached processes in a text-mode environment is also consistent with the behavior of terminal multiplexers in text-based systems.
• VTM’s Features: Based on the description and demonstration, VTM’s features like window resizing, Z-order, detached processes, and both graphical and text modes appear to be accurately represented. The speaker’s enthusiasm seems genuine, and the described functionality aligns with what one might expect from a modern terminal management tool aiming to innovate in the TUI space.

Minor potential inaccuracies or subjective points:

• “Infinite Terminal Manager”: While the concept of a large, scrollable viewport for terminal management is interesting, the term “infinite” might be a slight exaggeration. It’s more likely a very large, but finite, canvas.
• “Rethinking” terminal management: While VTM seems innovative in its TUI approach and combination of features, the core concepts of terminal multiplexing and window management are well-established. VTM is likely building upon and extending these concepts rather than completely “rethinking” them from scratch.
• “Obscure and confusing”: The speaker mentions VTM being “obscure and confusing” and taking time to learn. This is subjective but could be true for new users unfamiliar with its specific interface and interaction paradigms.

Overall, the transcript provides an accurate and enthusiastic overview of VTM and related technologies. Any minor inaccuracies are likely due to the informal and demonstrative nature of a YouTube video rather than deliberate misinformation.

Resources

Here are the top 5 most relevant resources to learn more about the subjects presented in the transcript:

1. VTM GitHub Repository: github.com/directvt/vtm

   • Relevance: This is the primary resource to learn about VTM itself. Explore the code, documentation (if any), issues, and potentially contribute or engage with the developer. It’s the best place to get the most up-to-date information and potentially download and try VTM.
   • Type: Project Repository, Source Code, Community

2. GNU Screen Official Website and Documentation: https://www.gnu.org/software/screen/

   • Relevance: Understanding Screen is crucial for grasping the context of terminal multiplexers and appreciating VTM’s lineage. Screen is a foundational tool in this space, and learning about its features and usage will provide valuable background.
   • Type: Official Website, Documentation, Software

3. tmux Official Website and Documentation: https://github.com/tmux/tmux/wiki (Official Wiki on GitHub)

   • Relevance: tmux is a modern and widely used terminal multiplexer, often considered a successor to Screen. Learning tmux provides a contemporary perspective on terminal multiplexing and allows for comparison with VTM. The official wiki is a great starting point.
   • Type: Official Website (Wiki), Documentation, Software

4. Gui.cs (guey.cs) GitHub Repository: https://github.com/gui-cs/Gui.cs

   • Relevance: For those interested in the development of modern TUIs, Gui.cs is an excellent example. It demonstrates how to build sophisticated console applications with rich UI elements. Exploring its examples and documentation can provide insights into TUI development.
   • Type: Project Repository, Source Code, Documentation, Framework

5. Wikipedia page on Text-based user interface: https://en.wikipedia.org/wiki/Text-based_user_interface

   • Relevance: Provides a broader conceptual understanding of TUIs, their history, and their significance. It offers definitions, examples, and context for the technologies discussed in the video, including Desk View and other TUI applications.
   • Type: Encyclopedia Article, Educational Resource, Background Information

These resources offer a combination of practical tools (VTM, Screen, tmux), development frameworks (Gui.cs), and foundational knowledge (Wikipedia on TUIs) to comprehensively explore the world of text-based interfaces and terminal management as presented in the video transcript.