What I would really like to see is more integration between terminal emulator and the shell (and commands you run in it). Currently in Fedora/GNOME the shell prompt is set up to make the terminal notify you (with a native GUI notification) about long running commands completing. That's cool, but we could go so much further.
For one, the shell could let the terminal know the current directory, hostname, username, git branch, current command, last command status, etc. etc.
The terminal then would display that info in its GUI, and perhaps even let you interact with it (imagine a GtkPopover for changing git branches and a Nautilus-like pathbar for the cwd!) We could then shrink back the prompt back to a simple dollar sign.
That would already be infinitely cool, but it gets better.
What if the shell could send its completions to the terminal and the terminal would display them in a native autocomplete widget (like in Builder)?
What if the terminal could track where the output of each command is and allow you to collapse/expand it with a GtkExpander? What if it could visually present each command and its output as this expandable card, along with the time it was issued and the time it took to run (like `time` outputs) and its exist code? And if it failed, paint that card red? And if it segfaulted, add a button to duck duck go the error, run ABRT or even run dnf debuginfo-install and coredumpctl gdb?
What if pagers like `less` could make use of the native scrolling instead of faking it by moving lines? What if `man` rendered the content to HTML (or GTK's native markup format) and presented it as an actual page, sort of like what you get by running `yelp man:foo` but right there in the terminal?
What if `ls` could make use of the native list/table widget and render file icons, just like Nautilus? What if you could expand the folders it outputs right there using mouse and get a tree view?
Don't tell me that fish or vim already display completions in a pop-up using some magical pseudographics. I'm not talking about abusing the old grid-of-characters model of terminals. I'm talking about making the shell and the terminal communicate better so we can use *native* (e.g. GTK+) widgets for what is traditionally done using text-based interfaces.
Mind, just like currently `ls` knows to columnize and colorize its output and `grep` knows to highlight the matches in red *when outputting to a terminal*, but fall back to plain text when piped to something, what I'm describing here would simply fall back to plain text when piped or run in a less magical terminal. So this is about enhancing the existing tools, not about breaking compatibility in any way.
And at the same time that would really get the terminal/shell experience from "emulating ancient hardware to be able to do stuff we haven't yet made a GUI for" to "a way to do advanced stuff with your computer using a command-based interface".
That would truly be a command-based interface for the 21th century. That would be something I'd be proud, not ashamed, to show off to Windows users as the advanced way to tune your system.
I've made a mock-up to illustrate my ideas about the next-gen terminal experience!
Featuring:
• the pathbar
• username, hostname and git branch displayed in the UI, shrinking the shell prompt back to just a $
• commands as cards
• syntax highlighting, including graying out the output a bit to differentiate it from commands themselves
• autocompletion (displayed in a native widget)
• built-in error handling options
• the time each command took (on the right)
@bugaevc this seems overcomplicated, I'd much rather have something like Acme or Plan 9's rio shells and build these things on top of that
@grainloom @bugaevc And, going back even further, Symbolics Genera and other Lisp Machine implementations.
TBH all these fancy shell prompts and such are getting pretty ridiculous. If you are using a graphical UI it should take advantage of that. So far all we have are some weird terminal emulators with a baud rate setting.
That has to change
I think you are undervaluing the efficiency of text.
Compare the logographic below to its (possible) translation:
"If a man utters this spell while pure, it assures going forth by day after his death" (see https://www.quora.com/How-does-Egyptian-hieroglyphics-translation-work for further info and translations).
We have a spacial problem (pixel to meaning ratio), a problem of composability and a problem of interpretation.
IMHO, text centric UI (like #Plan9's one) are simply too ahead of times.
@ckeen @bugaevc idk, I like a lot of the ideas in theory but if it's not as portable and modular as what we currently have, I don't see myself using it anytime soon
i'm not against making UIs better but I'm not sure how I feel about these ideas
how does it compare to what came before? how does it compare to Emacs?
None of this is portable in any way. That's why we are still stuck with what we have. Every wanted to know how the graphical shells change their title? There are some escape sequences for that. Icky stuff...
@ckeen @grainloom well, the idea *is* to make it portable. The shell and the terminal emulator would negotiate over some standard escape sequence-based protocol, and that protocol would not be bash- or GTK- specific, it'd work for any toolkit and shell combination. A bit like DWDs if you remember those.
@ckeen @grainloom (if you don't, this is what I'm talking about: https://kver.wordpress.com/2014/10/25/presenting-dwd-a-candidate-for-kde-window-decorations/)
I boosted because I had the exact same reaction of @grainloom : this interface is cool but cannot be done with a shell.
Some aspects of what @bugaevc propose are part of what I'd like to try in the #Jehanne UI (admitely a low priority task), but in a way that do not increase the complexity of the shell too much:
- the pathbar
- username
- folder specific tools (eg git/hg branch displayed in the UI)
- autocompletion
but I'd like to retain:
- editable output
- plumber integration
Note that all of this could be built in Jehanne without modifying the shell, but we need a new screen multiplexer (aka rio) that somewhat integrate a text editor (eg sam) and a modified graphical terminal (aka win) to do the integration/framing.
This could hurt network transparency over 9P, though (I'm trying to design my file protocol so that it can preserve such transparency, but it's a loooong process, don't hold your breath).
@grainloom @ckeen I am, in fact, a fan of Plan 9 and have used acme as my editor in the past! (On freaking 
10 https://vk.com/wall268678817_641)
And this ideas are partly inspired by how Plan 9/acme/rio are all integrated, whereas in today's systems we have a sleek GUI and a powerful CLI that live in very different, disconnected worlds.
It would not be feasible to adopt acme's model directly, because modern interfaces are not all text, so instead, I opted to enhance the CLI UX with modern GUI advancements
@grainloom @ckeen I don't know much about Emacs — are you talking about displaying images inline (with X11-specific hacks?..) or integrating actual GUI widgets into the CLI experience?
@grainloom @ckeen perhaps you can point me at a demo of how it works in Emacs then? I thought it was TUI-only, possibly in a basic GUI frame.
@grainloom @ckeen yes! Jupyter is *amazing*, even though it's web-based.
OTOH, I'm focusing on the Unix shell and native widgets here. Python/Jupyter is mostly about visualizing data — it does nothing to display or let you control the state of your Python session in its GUI.
$www-browser --dump $file
where www-browser is something like lynx or w3m.
@bugaevc @grainloom @ckeen @lanodan
I appreciate the objection, but printing text extracted by HTML is not rendering HTML for any useful definition of rendering. :-)
#Lynx dump IS rendering but without any interactivity.
Until it ignores #CSS, #JavaScript and any other external resource, it's not a road to #hell.
But integrate the rendering into a terminal emulator and you'll soon face the joy of #JS hijacking your shell.
If a program is hijacking your shell you have a serious Operating System hell.
Anyway elinks has CSS and probable JS support and does work in a terminal.
@lanodan @Shamar @ckeen @grainloom @bugaevc In fact it already has been done multiple times before :
Sometime there is a working PoC sometimes just specs.
On a more serious note: the disability to just render images on screen is the serial line interface heritage.
Plan 9's graphical windows are just graphical windows, you can blit anything on them. Even the shell could, no special support required (apart from generating the right pixels).
@grainloom @ckeen @bugaevc @lord @lanodan
Yet on rio, window + rc cannot intersperse text and graphics: when you need to see an image, you either open a new window or replace the contents of the current one.
AFAIK, you would need a different `window` program and a different shell to do that, exposing to rc a new folder (say /dev/images/) where you can copy an raster image to see it rendered as the output (under the command, before the next prompt).
I wonder if it's worth the effort though.
@grainloom @ckeen @bugaevc @lord @lanodan
I mean: once you are freed from the scrolling nature of a teletype, why you need a top-down sequence for image?
For text it make sense anyway, but for images?
@Shamar @ckeen @bugaevc @lord @lanodan
could it not work like a nested rio session where each (top-level ?) command in rc gets its own /dev/draw while it's running which is drawn under its invocation and after it finished running the multiplexing stuff is dropped and the image is stored with its position
slight problem: how do you echo -n > /dev/text for clearing images as well?
@bugaevc it has a coolness factor to it but I would sleep better if I knew that whoever implemented this took a look at acme and rio first