Show HN: TRUST – Coding Rust Like It's 1989

Remember the satisfying clack of keys, the stark blue of a DOS prompt, and the sheer directness of it all? TRUST, a new TUI (Text User Interface) IDE for Rust, resurrects that very feeling, aiming to let you code Rust like it’s 1989. It’s a deeply nostalgic, yet surprisingly functional, experiment that asks a fundamental question: can the raw, focused experience of retro development coexist with a modern, powerful language like Rust?

The Blue Screen Beckons: TRUST’s Purposeful Simplicity

TRUST isn’t just a visual skin; it’s a curated experience. It’s an experimental nostalgia project designed to mimic the iconic blue-screen DOS development environments. Forget bloated, feature-heavy IDEs that demand your every CPU cycle. TRUST strips it back. Its core functionality is elegantly focused: it edits .rs, .toml, and .lock files, navigates your Rust project structure, and seamlessly integrates with Cargo. Compiler output, blessedly concise, lands in a dedicated bottom pane.

What truly sells the illusion are the subtle, yet powerful, interaction models. Mouse support is there, but it feels intentional. Cursor movement, text selection, file and directory navigation, pane focus, and even resizing are all handled with a tactile precision that feels a million miles away from today’s often nebulous touch-and-drag interactions. The key bindings are a love letter to the past: F1 for help, F2/Ctrl+S for save, F3/Ctrl+O for open, F5/Ctrl+R for cargo run, F7 for cargo check, and the like. It even offers basic menu options for “File > New” and “Project > New project” (for Cargo projects). It’s the kind of focused environment that makes you feel like you’re wrestling directly with the code, not an abstract representation of it.

The Rust Conundrum: Where Speed Meets Legacy

This brings us to the crux of the matter. TRUST’s core appeal lies in its “fast-feeling” retro UI. The immediate responsiveness of the terminal interface is a stark contrast to the often sluggish performance of modern IDEs wrestling with complex language features. However, Rust itself presents a unique challenge. Its notorious compile times, while improving, are still a significant pain point for many developers. The irony isn’t lost: you’re navigating a lightning-fast retro interface while waiting for the Rust compiler to do its work.

The technical hurdles of building robust tooling for Rust are well-documented. The rustc compiler, while powerful, isn’t designed as a library for IDEs. This has led to projects like rust-analyzer essentially reimplementing compiler logic, resulting in occasional slowdowns in autocomplete, definition lookup, and significant memory usage on larger projects. TRUST, by its very nature as a simplified TUI, sidesteps many of these complex analysis challenges, leaning instead on Cargo for execution. This makes it incredibly performant for what it does, but it’s crucial to understand its scope.

The Experimental Edge: When TRUST Shines and When to Bail

Let’s be clear: TRUST is an “experimental nostalgia project.” It is not, and likely never will be, a production-ready IDE for professional Rust development. Its most significant omission? The debugger. This is a critical limitation for serious development, meaning that while you can happily type and run your code, pinpointing runtime errors will require external tools or a return to more conventional IDEs.

So, when should you embrace this 1989 throwback for your Rust endeavors? For small, self-contained projects where the focus is on pure coding and rapid iteration on well-understood code. As a learning tool to understand Rust’s fundamentals without the distraction of advanced IDE features. Or simply as a curiosity, a deeply enjoyable way to reconnect with the feel of programming. Projects like TermIDE are pushing the boundaries of what’s possible in Rust TUI development with more advanced features, but TRUST’s charm lies in its deliberate limitations.

Ultimately, TRUST is a triumph of intent. It’s a beautifully executed homage that offers a unique, focused coding experience. It’s a reminder that sometimes, stripping away the complexity can reveal the pure joy of crafting code. Just don’t expect it to replace your rust-analyzer-powered behemoth for your next complex microservice refactor. But for a dose of retro charm and a refreshing coding perspective? TRUST is undeniably compelling.