Stories with Tag Text User Interface

• TUI editor and Vim/Neovim alternative

  permalink

  Posted: 2025-03-24 16:14:22

  Verbose tl;dr

  Lilly is a TUI text editor built with Rust that aims to offer a modern, performant, and customizable alternative to Vim and Neovim. It prioritizes extensibility through plugins written in Lua, offering a familiar experience for Neovim users. Featuring built-in Language Server Protocol (LSP) support, tree-sitter for syntax highlighting, and asynchronous execution for responsiveness, Lilly seeks to combine the speed and efficiency of a terminal interface with the advanced features of modern GUI editors. The project is actively under development and welcomes contributions.

  The GitHub repository for Lilly presents it as a modern, cross-platform, and highly customizable TUI (Terminal User Interface) editor built with Rust. It aims to provide a powerful and efficient editing experience comparable to, or even exceeding, established text editors like Vim and Neovim, while incorporating a more approachable and intuitive user interface. Lilly is designed with extensibility in mind, utilizing a plugin system based on Lua, allowing users to tailor the editor to their specific needs and workflows. This plugin architecture facilitates integration with various tools and languages, potentially enabling features like syntax highlighting, code completion, and linting. The project emphasizes performance, leveraging Rust's inherent speed and memory safety. The repository contains instructions for building Lilly from source and contributions are welcomed. While still under active development, the roadmap indicates aspirations for features such as multiple cursors and selections, advanced search and replace functionality, and integration with language servers. Lilly positions itself as a viable alternative for users seeking a modern TUI editor with the power and flexibility of Vim/Neovim but potentially with a gentler learning curve. It leverages the advantages of Rust for performance and reliability, and its Lua-based plugin system promises a high degree of customization and extensibility.

  • tui
  • Text User Interface
  • Editor
  • vim
  • Neovim
  • Alternative
  • terminal
  • Command Line
  • Lua
  • GTK
  • lilly
  • tauraamui

  Summary of Comments ( 14 )
  https://news.ycombinator.com/item?id=43462676

  Verbose tl;dr

  Hacker News users discuss Lilly, a TUI editor and potential Vim/Neovim alternative, focusing on its Lua extensibility and clean slate design. Some express excitement about a modern, scriptable TUI editor, praising its apparent performance and the potential of Lua for customization. Others question its long-term viability given the established competition, and some debate the merits of modal vs. non-modal editing. Several commenters highlight the difficulty of attracting users away from entrenched editors, while others suggest Lilly could find a niche among those seeking a simpler, more easily customized TUI experience. A few express interest in specific features like the integrated file explorer and fuzzy finder. Overall, the comments show cautious optimism tempered by an awareness of the challenges faced by new text editors.

  The Hacker News post discussing the TUI editor Lilly and its potential as a Vim/Neovim alternative generated several comments exploring various aspects of the project.

  One commenter expressed excitement about the prospect of a modern TUI editor with good defaults and cross-platform compatibility. They specifically mentioned their frustration with configuring Neovim and the inconsistency of its plugins across different operating systems. This commenter saw Lilly as a potential solution to these issues.

  Another commenter highlighted the project's use of the Slint UI toolkit, questioning its suitability for a text editor due to potential performance overhead. They raised concerns about input latency and redraw performance compared to more established TUI libraries. A further comment acknowledged the visual appeal of Slint but reiterated the performance concerns, suggesting that a terminal application might be better served by a more lightweight approach.

  A different commenter focused on the lack of extensibility in Lilly. They argued that a key strength of Vim and Neovim lies in their powerful plugin ecosystems, allowing users to customize the editor to their exact needs. They expressed skepticism about Lilly's ability to compete in this area, particularly given its early stage of development.

  Someone else chimed in with praise for the project's ambition and clean codebase. They emphasized the value of having a modern, well-designed TUI editor alternative to Vim and Neovim. They also pointed out that while performance might be a concern at this stage, it's likely to improve as the project matures.

  The developer of Lilly also participated in the discussion, addressing some of the concerns raised by commenters. They acknowledged the performance challenges associated with using Slint and explained their rationale for choosing it, citing its cross-platform capabilities and ease of use. They also expressed openness to exploring alternative UI toolkits in the future if performance issues persist. Additionally, they addressed the question of extensibility, outlining plans to introduce a plugin system down the line. The developer indicated that initial focus is on establishing a solid core editing experience before tackling more advanced features like extensibility.

  Finally, a comment highlighted the challenges of building a successful text editor, mentioning the competitive landscape and the high expectations of users. They wished the developer luck and expressed hope that the project would succeed.

• Show HN: Shelgon: A Framework for Building Interactive REPL Shells in Rust

  permalink

  Posted: 2025-03-06 19:32:12

  Verbose tl;dr

  Shelgon is a Rust framework designed for creating interactive REPL (Read-Eval-Print Loop) shells. It offers a structured approach to building REPLs by providing features like command parsing, history management, autocompletion, and help text generation. Developers can define commands with associated functions, arguments, and descriptions, allowing for easy extensibility and a user-friendly experience. Shelgon aims to simplify the process of building robust and interactive command-line interfaces within Rust applications.

  Nishant Joshi has introduced Shelgon, a Rust framework designed to simplify the creation of interactive Read-Eval-Print Loops (REPLs). REPLs provide a dynamic environment where users can input commands, have them executed, and see the results immediately, making them powerful tools for experimentation, debugging, and interactive development. Shelgon aims to streamline the process of building these interactive shells by offering a structured and efficient approach within the Rust programming language.

  The framework leverages Rust's ownership and borrowing system to ensure memory safety and prevent common concurrency issues often encountered in REPL development. It provides developers with a set of pre-built components and abstractions, handling the complexities of command parsing, execution, and output formatting. This allows developers to focus on the core logic of their REPL, defining the specific commands and their behavior, rather than grappling with the underlying infrastructure.

  Shelgon employs a modular architecture, enabling developers to customize and extend the functionality of their REPLs with ease. It supports the integration of custom command parsers, allowing for flexibility in handling different input formats. Furthermore, Shelgon facilitates the creation of interactive help systems and auto-completion features, enhancing the user experience within the REPL environment.

  The project emphasizes simplicity and ease of use, aiming to provide a clear and intuitive API for developers. The stated goal is to empower Rust developers to quickly and efficiently build robust and feature-rich REPLs for a wide range of applications, from scripting and prototyping to embedded systems and command-line utilities. By abstracting away the low-level details of REPL management, Shelgon allows developers to concentrate on the unique aspects of their specific use case, ultimately fostering a more productive and enjoyable development experience.

  • Rust
  • REPL
  • shell
  • Framework
  • interactive
  • cli
  • Command-Line Interface
  • developer tools
  • terminal
  • tui
  • Text User Interface
  • Open Source
  • GitHub

  Summary of Comments ( 7 )
  https://news.ycombinator.com/item?id=43284227

  Verbose tl;dr

  HN users generally praised Shelgon for its clean design and the potential usefulness of a framework for building REPLs in Rust. Several commenters expressed interest in using it for their own projects, highlighting the need for such a tool. One user specifically appreciated the use of async/await for asynchronous operations. Some discussion revolved around alternative approaches and existing REPL libraries in Rust, such as rustyline and repl_rs, with comparisons to Python's prompt_toolkit. The project's relative simplicity and focus were seen as positive attributes. A few users suggested minor improvements, like adding command history and tab completion, features the author confirmed were planned or already partially implemented. Overall, the reception was positive, with commenters recognizing the value Shelgon brings to the Rust ecosystem.

  The Hacker News post titled "Show HN: Shelgon: A Framework for Building Interactive REPL Shells in Rust" generated a modest discussion with a few interesting comments. No one expressed outright negativity toward the project.

  One commenter pointed out that the project appears similar to rustyline, a popular Rust library for creating command-line interfaces, and asked the author about the advantages of Shelgon over this established solution. This comment highlighted a common concern when introducing a new tool in a space with existing options: demonstrating a clear and compelling reason for its existence. The author responded by explaining that Shelgon is designed to be more flexible and extensible than rustyline, particularly for building complex REPLs with features beyond basic line editing. They specifically mentioned the ability to easily create custom keybindings and widgets, suggesting Shelgon might be better suited for highly interactive interfaces.

  Another commenter expressed their interest in the project, mentioning their own struggles with creating a REPL in Rust and hoping that Shelgon would simplify the process. This comment underscores the potential value of such a framework for the Rust community.

  Other comments were shorter and more general, offering words of encouragement or simply acknowledging the project's existence. One commenter suggested publishing the project to crates.io, the central package registry for the Rust ecosystem, to increase its visibility and accessibility. This is a standard recommendation for new Rust projects seeking wider adoption.

  Overall, the comments reflect a generally positive reception to Shelgon. The most compelling points revolve around its potential advantages over existing solutions like rustyline, its ability to address a specific need within the Rust community for easier REPL creation, and the practical advice regarding publishing on crates.io. There wasn't a large volume of discussion, but the existing comments provide valuable feedback and context for the project.