jexer VS Lanterna

Very interesting! I was thinking literally yesterday about a TUI/GUI Qubes type concept, maybe also applicable for industrial type data diodes.

I did something like that once. Is your project online somewhere? I'm always curious what else is going on. :)

When I transliterated from D to Java around 2015, Java wasn't quite the "uninteresting" language it is perceived to be today. But all along I had hoped others might pick up some tricks, and put some notes on porting it here. Yet Java's been a pretty solid workhorse for me, and having the Swing GUI to test on was a godsend actually once I got into images.

If you code in Java, and like TUI (console type applications), then you might enjoy Jexer: https://gitlab.com/klamonte/jexer

I started Jexer in 2013, and off-and-on it's gotten better. I think my favorite part has been crossing paths with other terminal emulator ecosystem folks over the last few years. This release brings a few prettified effects inspired by other projects that you are all hopefully quite familiar with (notcurses, chafa, and vtm):

* Translucent windows, including images under/over each other and text.

* Animated/pulsing text

* Animated gifs

* A new XtermVideoPlayer example that uses ffmpeg/JavaCV to play movies inside a text-draggable window. (No audio though.)

* New button styles: round, diamond, left/right arrows. The button ends and shadows are drawn with images so specific font support is not required.

* A _much_ faster and _much_ higher quality sixel encoder.

* Different window border styles: single, double, none, and rounded corners.

* A femme theme option.

Some screenshots are posted here: https://twitter.com/AutumnMeowMeow/status/148922891703050240...

It's on maven and Sourceforge.

If you code in Java, and like TUI (console type applications), and enjoy transfemme in-jokes, then you might also enjoy jexer.

A path that started in the BBS era and is currently bringing DOOM to Xterm. And ironically, there is much better support for this now than there ever was for RIPscript.

Story time: when I first posted Jexer to Reddit, people were all "twin does that". No, it does not. twin does not pass vttest. twin has almost no widgets. twin does not support images at all, it does not multiplex images, it does not multihead images, and it does not play videos (a bit too slowly but still) in a text draggable/resizable window that could be part of a larger system. mpv/mplayer doesn't do those things either. In fact, the only two projects I know of that can do these kinds of tricks are Jexer and notcurses. (And notcurses is hella faster and great, and I would have used it in 2013 when I started Jexer, but it didn't exist then.)

One way to do translucent windows. - Inspired by notcurses

foot is great, dnkl is great. It's so far the fastest sixel-supporting terminal I've got to test XtermDOOM on. (I run iTerm2-based images against wezterm.)

It parses them, but then reduces to the 8/16 ANSI colors. Which makes translucent TUI windows not work. :(

I wrote a TUI before for work, entirely of my own volition and for my own near-exclusive consumption (it was theoretically for anyone, but I'm the only person who would've had a reason to look at it - we were a fairly silo'd dev shop).

This is what made me pick TUI over a web UI:

* no web stack, period. no client/server. no js or html. this simplified the problem dramatically. also, no additional services to babysit.

* no browser - no certificates, security, auth, etc. It's just unix permissions and ssh.

* there's something comforting about the constraints of just ASCII/ANSI and curses. No bikeshedding over border widths or radii when it's just you picking among a few characters for the shape. just having less decisions to make speeds things up and helps you focus on what you actually want the UI to be able to do.

Obviously if your app is just calling APIs anyway, that might be negate some of these bullets about no additional services to babysit etc. In this case, it was running an internal infra app that directly connected to a pg db.

And what made me pick it over just having a CLI:

* discoverability - it was a complicated app and while it was all technically exposed via cli flags, having a GUI made it a lot easier to figure out what the right incantation is.

* richer communication medium that's back-and-forth instead of unidirectional. The TUI is able to fetch a list of e.g. valid IDs and let you pick them with a check-list, instead of you having to go query the db yourself and type them in.

I consider it one of my greatest victories that my boss was able to use the TUI to recover from an incident without needing to page me while I was on holiday, and he said he barely had to read the docs and felt confident he was getting it right the first time. "I did it while sipping my coffee."

I used https://github.com/mabe02/lanterna - would recommend. They even have a Swing-based emulation mode for easy development iteration running it from intelliJ.

This looks really cool.

In the past I used lanterna (https://github.com/mabe02/lanterna/tree/master) to develop a text UI for a critical process at the trading firm I worked at. It was essentially a process that would take updated market data and handle things that changed between the last trading session and today - like symbol renames (PCLN to BKNG), changes to market cap that make it change what "category" it fell into (they were based on market cap and volatility measures etc). Things of that nature, that the realtime system didn't handle but happened too often or were too hairy for us to just handle manually.

The system had a desktop UI component that was oriented towards use by our trading staff. We didn't really have notion of a "server UI" and the server was headless.

Nobody at our firm was a frontend developer, just backend, systems and data programmers who occasionally dabbled in frontend. So web UIs were very simplistic or highly specific to their use-case, we had no shared tooling.

In 2023 with things like create-react-app and whatever next.js does, I probably would've opted for one of those. I could've made another desktop app but I wanted to be able to easily get to this from a shitty ssh connection over tethered 4g when I was on-call. So X11 forwarding and RDP were out. So i looked around for a TUI-builder in the project's language, Java.

What i really liked about Lanterna was that it had a Swing-based implementation which meant I could easily run it from IntelliJ, and that would let me iterate rapidly, and then in production I could run it in a terminal via SSH directly on the machine the server was on (which had certain advantages).

I'll keep an eye on this to see if I can think of anything neat to build on it. I still generally don't like web apps because they feel like they take a lot of effort to get something compared to a functionally-equivalent product built in something non-browser-based like a TUI or desktop GUI.

Just to differ what others already mentioned: Lanterna. Pretty retro GUIs just for fun.

Lanterna https://github.com/mabe02/lanterna Has examples for most of the things you're looking for (see links in https://github.com/mabe02/lanterna/blob/master/docs/contents.md)

You can use a library such as https://github.com/mabe02/lanterna to do fancy console printing. You could even do full console UIs, but just printing lines and moving the cursor and so on is also possible I think.

There is lanterna for that.

You can use https://github.com/mabe02/lanterna

Is this just a personal excercise? Because https://github.com/mabe02/lanterna is pretty much what you're talking about and pretty good.