I wish to ask a question if I may (and as such pardon my ignorance on jupyter kernel, I don't know much about it and I hope you can tell me more about it :-D)
but my question is, is there a way to swap the jupyter kernel within euphorie to something else more minimalist?
And when you run a project with ssh, there are ways to give access to other users with user:password if I may ask?
I didn't know that there were ways to run jupyter kernels in terminal, I don't know when I might need it but I am prepared with this information now, this feels so nice to me, thanks for making it!!
This is like a checklist of a thing I didn't know that I needed/existed but the second I know that it has existed, it feels like my mind has checked it off and just a satisfaction from knowing projects like these existing.
(I think in some sense this is a bit of same reaction to me on Ratty too), Its just so good seeing projects in these spaces :-D
Edit: just remembered the one time I think I was using some websites which gave me jupyter and then I tried to use browsh to run jupyter to run jupyter in terminal so that it can be controlled by terminal but it had some issues and I wasn't able to run it.
I also wish to ask if there is a way to sign in to jupyter instance like that itself perhaps? (IIRC it was a jupyterhub instance)
i want something like jupyter but for unix shells, not for programming languages. and, i don't want it in the terminal, i want it to be the terminal, that is, i want to get rid of terminal escape codes that you currently need to make this work.
think about it like this: in jupyter you have pieces of code and their output. you change the code, it changes the output.
a unix shell version of this would be a commandline, and its output which would be text or an image or whatever the commandline produced. every output box would be itself a terminal if the output is text. but that's only necessary to support programs that produce terminal output. new programs could produce structured data that this jupyter for shells could interpret and display directly.
You mention using this over ssh. Is there any way to get this working in tmux or anything similar by any chance? Or is the idea that euporie itself is acting like a multiplexer?
https://www.youtube.com/watch?v=o48KzPa42_o
Joking apart, the whole thing was both an exercise in madness and genius. Sometimes I wonder what he would have done if he had not gone crazy. We will never know...
[1]: github.com/eza-community/eza
Terminals on other operating systems that grew up with a framebuffer don't have this limitation.
This might overtake “a haiku+macOS mashup” as my idealised computing future.
What's overlooked here are the insane political and economic forces that were required to get anywhere close to the (sort of!) consistent implementation of plain text we have today. These projects try to piggyback off that success yet only contribute back harm. We have standards for a reason.
I'm not saying people can't have fun, but don't try to start a cyberpunk-inspired revolution and then blame the side effects of groupthink and software rot on everyone else when it goes sideways.
Super slow, but I guess thats what web devs want.
https://github.com/vadimdemedes/ink
Which is what Claude Code CLI uses (or was using?) and it caused many issues such as flickering, thrashing, and latency.
Rendered as instanced quads in 3d space. Tens of millions at >60fps, and an entire class of "grid based text rendering" evaporates.
Inline graphics from 1981,
For those who haven't watched it: https://www.youtube.com/watch?v=yJDv-zdhzMY
Here is another video, this time with S-PACKAGE used to develop Nintendo 64.
https://www.youtube.com/watch?v=gV5obrYaogU
Which given the REPL capabilities, you can easily embedd them on it, just like the other video.
The 3D can be wiggle 3D, or perspective from webcam head/eye tracking, or stereo from shutter glasses, or XR HMDs. Wiggle is easiest - just move the object orientation back and forth. Cute but distracting. Well, cross/parallel-eye gaze is easier, but limited - ok for little UI test swatches. Perspective is more subtle, less intrusive. Can be simple with a head tracker driving a single orientation, or go all in with eye pose (for distance) and window locations, to do an accurate 3D render. App stereo pairs can be "I give you two windows Left/Right-eye", or "alternating L/R view, labeled/synced/polled". Other possibilities. Many of these need window system/manager/desktop support. I found a lot of leverage in using a stack of electron and X.
It's fun to displace text in 3D. Like colorization, but more so. And if you don't mind a cluttered appearance, you can add secondary information layers segregated by depth. And... etc. Emacs with characters-have-a-depth finally gets you something LispMs didn't have. Fun aside, to explore possibilities with code text, with anything not inherently 3D, far easier to prototype UX with fg/bg colors, fonts, unicode, and animation. Or in browser, overlaid divs and transparent 2D/3D canvases.
It's this. Every character is a 3d placed quad, instanced rendered, so you get tens of millions and then some. They are individually addressable and mutable like any polygon. I use it to render entire GitHub repos in one go. I have two versions, native Apple and web. Web has the basics of an ide setup. Would love insight or thoughts.
I don’t know what this is supposed to do, let alone how to use it. But I looked at it for you!
Nifty.
Some scattered thoughts...
First-time visitors easily bounce away if there's friction. My experience was: After reloading the page to reread the "load a repo" message, it took a search to find it. Two-fingers unexpectedly panned not zoomed. I consulted the keyboard shortcuts found earlier. My scroll panned. Keys zoomed, but speed was limited by key autorepeat. No response when clicking on shortcuts, suggesting they can't be changed. I eventually noticed shift-two-finger zoomed.
So perhaps add an initial popup, as with browser games, giving basic orientation/keys? And perhaps have some default repo already loaded?
Is antialiasing turned off? The text is less readable than I'd expect, and there's flicker during zoom.
I didn't find the usual github-icon link to the repo. Add it?
Perhaps try google/bing maps-like zooming towards cursor location, rather than always towards center?
Perhaps clamp zoom-out and scroll so one can't reach no-text-visible blank black screen? Perhaps clamp zoom-in earlier, so "slam inward" stops short of the current one-line-high screen?
Clicking README.md brings up a 3 column render, which is too small to read on my screen without further zooming. I'm unclear on what I'd like instead.
A big picture observation. Early phone apps did skeuomorphic UIs - a calendar app might render a wire binder spine, and animate paper page turning, with sound effects. It helped onboard a user population unfamiliar with phones. We don't do that anymore. It'd be silly. Most VR UIs seem to me skeuomorphic transients. Why hobble ourselves by unnecessarily importing the severe constraints of a Euclidean physical world?
So for example, file presentation might combine content-aware and location based scaling. A README might show up with the header lines enlarged, as in some md editors, and perhaps with fisheye-like distortion (when at the top, the top is rendered normally, but with increasing shrink below). Or mix in outliner-like expand/collapse. And so on. Whatever dynamic geometries are task helpful for the human. Once text colorization is working, it might be fun to work little exercises (make videos?) - with files X and task Y, how might they be most helpfully presented? When skimming agentic markdown as it scrolls by, I keep wishing for a couple of cloud-fast small models that watch it with me, and adjust the text size/color/annotation/etc to guide my attention to notable bits.
In the vein of making functionality easy to explore, perhaps give diff a default pr?
It's neat to see a repo slurped into something like this. Thanks for sharing.
I agree, a REPL isn't Unixy in the streams of text kind of way... or is it?
It's a bit more abstract and useful than "character-selectable" when viewed at the byte-level abstraction.
The ability to chain together utilities with no complicated data structures is extremely flexible. One of my favorite current use-cases is using FFmpeg to process RTSP streams that send output (e.g. high quality stream for recording, low quality low FPS for processing, max quality low FPS for stills, etc) to separate file descriptors. FFmpeg doesn't care whats on the other end (e.g. redirect to file, read via Python, etc) due to these lovely abstractions.
Reliability translates directly to scriptability. Yes, you can create monsters, but through the use of sub-shells and pipes I think it's the fastest, cheapest, most concise way to pull off some really cool multiprocessing tricks.
Because nobody is willing to put in the work to create a GUI toolkit that doesn't suck ass.
It's not that people want the "terminal abstraction". What people want is "Put <thing> on screen without me needing a PhD in graphics programming." That's why the dominant desktop interface paradigms have become TUIs and a Browser-In-A-Trenchcoat.
Compiz 3d effects were ultimately a useless gimmick and I predict this is too.
It's the ability to convey more information in less space.
Top-of-my-head notion: The cursor spins (or changes in another way) to reflect CPU use, or bandwidth use, instead of taking up space elsewhere on the screen.
Then spend their tokens on abominations like this
Make it make sense
It's not hypocrisy when different people do different things.
[1] https://rapha.land/introducing-glyph-protocol-for-terminals/
Also, if you want advanced GUI with icons, maybe you should just write a GUI app.
As for shipping custom icons, this is not very bright idea as well. If you switch between several applications on one terminal, then one application can redefine glyphs from another application. Also, when the application terminates, nobody cleans up its glyphs. Also, this increases attack surface because font standards are pretty complicated and one will be able to attack the system by just providing a glyph. We already have programs that can break the terminal, which should never happen.
Also, as for icons, I find emoji characters too distracting (and too large). They stand out too much and take away user's attention, breaking any visual hierarchy. The icons in terminal should be monochrome, and with thin lines, so that they do not distract you from the text and its structure.
I agree that the addition of sending custom glyphs to the terminal is potentially problematic.
A few thoughts:
1. Linux VTs kind of have this feature already: there is the normal buffer, the alternate buffer (that something like htop would draw on), and an IOctl can change them to/from graphics mode.
2. It makes sense for interactivity. Kitty's graphics protocol is quite useful for static shapes, can be abused for animations, but doesn't really cut it for interactivity (say, pan a graph around). Wayland is designed for this.
3. Wayland would be a good fit: isolate each command from another, let them request buffers, but keep control of where to display them, do not update them when off screen, etc.
4. One downside is that terminals excel for one-shot tasks. What's the purpose of the display when you are done with it? Should you kill the process driving it? Due to this, it may make more sense to delegate more features to the terminal emulator (displaying the 3D model, etc). Or maybe just allow the app to temporarily take over the window.
5. Once you have it up and running, have it talk directly to the direct rendering manager. Your "kmscon" is now your compositor / desktop environment. That's a fun thought! Add some basic terminal features like tabs and tiling, and you've inverted the usual setup.
6. One downside is accessibility. I really like that I can copy-paste any part of the interface for reference, "screenshots", etc. It's good for screen readers, too. You lose these advantages by going to Wayland.
7. Another current terminal limitation is fonts. Power line, yazi & other make use of custom fonts for drawing part of the interface, logos, etc. AFAIK there is no good way to query their availability (which is also an issue for color emoji). Custom fonts or a new protocol could be useful, but client apps could draw it themselves if given a surface (that can already do that with the kitty graphics protocol, mind you)
Obviously I am not seriously considering to make such a terminal emulator, but it would be an interesting experiment (heck, maybe something I should try this "vibe coding" with, since I wouldn't want to spend too much time on it).
- Atari ST GEM OS
- AmigaDOS
- Smalltalk
- Interlisp-D
- Genera
- Oberon
- MS-DOS (mode 13h and VESA)
- TempleOS
- Mac OS classic
It is just another graphical application window on the OS.
Questions:
- rendering capabilities of this seem like it should also be able to handle 2d well, or am I mistaken? every solution I see for getting high quality 2d images or rasterization in terminal is all pretty bad. Could this do better than other solutions or is there a fundamental limit being hit somewhere?
- What happens with ssh given that this is gpu accelerated?
That's how I read images under a remote pubnix with tut using a Mastodon account over plain SSH.
Chafa and XTerm. It works.
Then I added WebGL and WebGPU renderers [1], including support for Kitty.
Then I see this this project on a Monday morning... so now I have to implement Ratty Graphics Protocol?!?! [2].
ETA: I looked into this; Ghostty would need patched to support Ratty since Ghostty-Web now defers APC handling there. It would also require pulling in a 3D engine like three.js or otherwise implementing file parsing, lighting, etc. Finally, since local filenames are part of the protocol, a browser would need some file resolver helper, either to get the data over the APC channel or via a URL.
[1] https://github.com/NimbleMarkets/ghostty-web/tree/nm-webgpu
[2] https://github.com/orhun/ratty/blob/main/protocols/graphics....
Glyph rendering in three.js, fully instanced and addressable and positionable instances. Handles tens of millions. Sample app loads up full GitHub repositories in the web in a few seconds.
https://github.com/tikimcfee/glyph3d-js https://ivanlugo.dev/ide
So anyway, being that guy, I immediately installed it.
I kept trying to optimize my terminal layout and realized I could just run my terminals inside of the browser, and let Claude Code write JavaScript in the same browser tab to customize the experience however I want. It's kind of a terrible idea, but it's my terrible idea, and I love it.
And have you run into any other issues, maybe like performance?
I feel like web-ified terminals get nerfed pretty hard and I'm not sure if/how people overcome that.
I like the idea of customizing multiplexed terminals with on-the-fly JavaScript, tho.
edit: But your spirit lives on ( based on the project:D )
Still giving me goosebumps
Seriously, though, when are we going to see the convergence of terminals and GUI remoting protocols? People have already departed far from Unix pipeline utilities. "TUI" programs are already GUIs in disguise. Why keep pretending that the terminal (as used by TUI programs) is a different kind of thing?
You could also do really cool text highlights by working with light sources and shader effects
Another feature I'm looking for is smooth scrolling when you hit enter. I've had debates before where they claim it's not possible, that the text must jump one line. But I think it's possible, by shifting the frame buffer up.
If you render your text like a polygon, you get full 3d animations for free.
2. 3D rat: +100 points.
3. Outdated 80s UI paradigm: +100 points.
4. Uses Rust: +100 points.
That had me in stitches.
If rendering is not aligned then it's possible for the terminal emulator to read the framebuffer while the application is writing to it, causing visual artifacts.
[1] https://x.com/zack_overflow/status/2035921425341763756?s=20
This is a game engine.
I, Beldar, approve.
> When I first got introduced to [TempleOS], I was shocked and impressed by the flashy colors, graphical sprites and uncomprehensible UI. There are so many things that makes it so unique, weird and fascinating at the same time, somehow.... Basically, the command line becomes the direct interface for everything. You can write code, interact with the system and render graphics all in the same place, which is why TempleOS feels so unusual compared to conventional operating systems.
I think this could be a really cool approach. I enjoy tools like Chafa, imgcat, etc but something always feels a little clunky about the separation between text and images. Paradoxically having text and non-text all jumbled up like this feels better somehow.
I tried something similar a few months ago that acts more as a library to ratatui than a separate terminal emulator [0].
Was surprised how far one can get using some off the shelf characters like half-block when rasterizing.
The Glyph protocol mentioned in the blog post is interesting … perhaps custom glyphs could help smooth some of the (literal) rough edges from the low effective resolution of a terminals character grid.
You'll soon may be able to implement overlapping graphics windows in TUI within GUI.
This is stupid af.
My second reaction: "Oh wait is that TempleOS being cited? This is either awesome or terrible."
Brilliant. The dream lives on! This is the best form of paying respects.
It's walking a fine line between madness and genius, and who knows if it'll ever be practical, but more important is the sense of wonder and "fuck yeah" as King Terry expressed so eloquently.
