Pixel graphics in terminal(github.com)

231 pointsby potatoPhDvor 12 Jahren68 comments

https://github.com/asciimoo/drawille/

21 comments

etfbvor 12 Jahren

I learned Turbo Pascal in an MS-DOS emulator running on old green-screen Burroughs smart terminals, circa 1987. I knew the terminals had some sort of graphics capacity because their font changed when they left VMS mode and started emulating MS-DOS, so I wrote a program to rummage around in memory until I found where the font designs were stored. Then I wrote a font editor that changed the standard font whenever I logged in, to a design based on my own handwriting. After that, I took a leaf out of the Microbee computer's books and emulated hi-res graphics: I wrote a program that printed all the ASCII characters from 33 to 255 in a rectangle, set their font definitions to all zeroes, and then selectively set individual pixels back on according to a pattern that assumed the exact layout of characters. Implemented line, circle, flood fill and a few other graphics primitives. Fun!

elliottcarlsonvor 12 Jahren

One of my first "public" programs that I made was written in Turbo Pascal and was a read me style app for a demo group (I wasn't anywhere near capable of doing what the rest of the group could do - but at least I found a way to contribute) - I used a custom made font, had a scrolling buffer etc - always nice to take a stroll down memory lane.

btbuildemvor 12 Jahren

> take a scroll down memory lane

thomvor 12 Jahren

Ah, cool. You used to be able to define your own characters on Amstrads, and that's how I wrote most of my first games.

tripzilchvor 12 Jahren

> You used to be able to define your own characters on Amstrads

ah so THAT is how you could make graphics on those machines? wish I had known that back when I was 10 :-P

ah well, good times :)

etfbvor 12 Jahren

Pretty sure it was the way hi-res graphics worked on the VIC-20 too -- 22 characters by 8 pixels per character = 176 pixels wide, multi-colour mode where each block of 8x8 pixels had a background and a foreground colour. Deeply freaky.

bchvor 12 Jahren

The Vic also had a mode whereby you could make "double height" characters (halving the number of addressable rows), so when you typed "a", it would emit (iirc):

  a
  b

and when you typed "b", it would emit:

  c
  d

When I was about 8, I fooled with this peeking and poking pixels so that "a" and "b" bitmaps where the top and bottom halves of a double-height "a", through to the end of the alphabet. I imagined that this would make it easy for my grandparents to use computers. Never mind that they couldn't type, had no interest, and would never remember commands like "load $,8,1".

edit: formatting

zellynvor 12 Jahren

On the ZX81 and ZX Spectrum, they called them "User-Defined Graphics" or UDGs. I think I wrote a pixel-flipping grid font editor for characters on every computer I had access to! The ZX81, the ZX Spectrum, the Apple II (once I noticed that one of the games I had (Taipan?) hooked the text output routines into a hires character generator), and eventually various x86 programming environments, although there you were editing bitmaps, not changing the character generator source. :-)

mzsvor 12 Jahren

I used semigraphics on a CoCoII, not my video, but gives an idea of what that means ;)

https://www.youtube.com/watch?v=F2rscrAGCaM

Fr0styMattvor 12 Jahren

Alright this is the most awesome post I've read all day :) I really need to get to work putting together the kit Microbee that's currently sitting on my other desk....

etfbvor 12 Jahren

Are you old enough to remember daisy wheel printers? Basically, the computerised equivalent of a typewriter, with the individual letters on a daisy-like wheel that spun around under computer control to produce slow but "letter quality" printing. When I showed people my handwriting font, they were very impressed and asked if my printouts would be in my handwriting too. Given that the only printers we had were daisy wheels, I suggested that perhaps this would not be happening.

Someonevor 12 Jahren

Some daisywheel printers could be coerced to print high-resolution graphics, by repeatable printing a few zillion periods and using the variable line spacing and tab settings.

'Fast' was not a word one would use to describe them, though, even compared to the matrix printers that took minutes for each page of high-resolution output.

etfbvor 12 Jahren

Coming back to the original post, I wrote a proof-of-concept Braille output program for a daisy wheel printer. Basic idea was: take a line of text input, eg "hello". Convert to Braille ("⠓⠑⠇⠇⠕"), but reverse the dot patterns to make "⠪⠸⠸⠊⠚"). Sandwich a sheet of paper towel between two sheets of paper, feed it into the printer and print the reversed dots using "." and space, micro-positioned.

Theoretical result: raised dots punched into the paper by the daisy wheel, able to be read by a blind person.

Actual result: the proportions were wrong for reading, and most of the time the paper jammed on the roller because of the padding.

Nice idea though.

jevinskievor 12 Jahren

I think [0] is an example of what Terry (TempleOS [dead]) is talking about. Graphics certainly give the terminal a fun feel! =)

(sound warning, there are some very raw tones)

[0]: https://www.youtube.com/watch?feature=player_detailpage&v=EV...

P.S. The REPL command line in TempleOS is very cool. You can even disassemble your shell functions.

dlsymvor 12 Jahren

He and his OS seem pretty much alive http://www.templeos.org/Wb/Doc/ChangeLog.html

jevinskievor 12 Jahren

Oh, I was referring to the [dead] comment, not Terry nor his OS.

zx2c4vor 12 Jahren

That video is incredible. What an OS!

chuckupvor 12 Jahren

So why don't we have full blown graphics/widgets in the terminal?

I'm thinking a hybrid console meets explorer: When I type "ls *.png", why don't I get a sortable table? Or, if I mouseover a filename, get a preview?

I remember "type BBSAD.ANS" in the DOS days - you'd see an animated ANSI right in the terminal - but I can't type "view lolcat.png" in 2014 (without shifting focus to the GUI).

Maybe this is overkill and not worth it, but I've always felt there's room to make the CLI a little more GUI-like

eschatonvor 12 Jahren

You mean like the command line on Lisp machines, such as this example from Symbolics Genera? https://www.youtube.com/watch?v=o4-YnLpLgtk

The command line is contextually intelligent and presents interactive graphics and text. Not a simulation of a teletype on a simulation of a character terminal.

mietekvor 12 Jahren

Thank you for sharing this video.

There's an Alpha workstation in my closet, waiting to have OpenGenera installed...

jackybvor 12 Jahren

Terminology is what you might be looking for: http://www.enlightenment.org/p.php?p=about/terminology

granttimmermanvor 12 Jahren

You might want to look at https://github.com/visionmedia/term-canvas

drdaemanvor 12 Jahren

w3m/w3m-img had this for quite long time for some X11 terminals, with a ugly but interesting hack: http://w3m.cvs.sourceforge.net/viewvc/w3m/w3m/w3mimg/x11/x11...

unfamiliarvor 12 Jahren

Why should we have graphics in the termal? Use the GUI whenever you need to do these things.

> Or, if I mouseover a filename, get a preview? ...I can't type "view lolcat.png"

Most GUIs don't even do this. However, on OS X with iTerm you already can cmd-click the filename to open the file. Or use the Finder's QuickLook utility from the command line: qlmanage -p "$@" >& /dev/null &

Basically I see no need to merge the two. They operate perfectly well together and compliment each other. To extend the functionality you could simply write shell scripts which generate custom HTML and send it to a browser (or quicklook in the case of OS X).

Furthermore, a lot of these suggestions are already implemented in ipython notebooks, which is a REPL with graphical capabilities.

lstamourvor 12 Jahren

qlmanage -p is cool. I tend to just use "open" personally, as in open . to see the current folder or open lolcat.png to view a file in the default editor. On Windows you can use explorer.exe to do similar things. I do, however, wish terminal had better GUI for history, scrollback bookmarks, note taking, etc. Especially if I've a 4K display with so many pixels, it's criminal to not use a few of them more effectively.

jorrizzavor 12 Jahren

Some time ago I did write this crude UTF-8 terminal hack which does show an image in full 256 color glory. https://gist.github.com/jorrizza/e9deadd9fd1318ee09fb

riquitovor 12 Jahren

Termkit ( http://acko.net/blog/on-termkit/ ) is similar to what you described, but it's discontinued if I remember correctly.

rogualvor 12 Jahren

That's sad. I remember when the author first announced Termkit on Reddit and got massively shat on for trying to introduce graphics (the very thought!) to something as serious as The Command Line.

I hope he hasn't totally abandonded the idea but I wouldn't be surprised if he did.

boie0025vor 12 Jahren

I just had a BBS days flashback to RIP: http://en.m.wikipedia.org/wiki/Remote_imaging_protocol

mseebachvor 12 Jahren

It's not exactly a terminal, but I like the IPython Notebook for pretty much those reasons. I think you could quite easily build something like a sortable ls output as a reusable component.

http://ipython.org/notebook.html

Raphaelvor 12 Jahren

https://github.com/unconed/TermKit

thrownaway2424vor 12 Jahren

We do in fact have full-blown graphics modes in the terminal and have had for decades. You can switch xterm to Tex4014 mode at your leisure, although this might not have been the graphics you had in mind. I believe you can _still_ pay money to HP for the pleasure of using decterm, which emulates the VT340 and other REGIS-protocol terminals.

One of the craziest hacks on graphics terminals was NCSA Telnet. It supported multiple detached Tek terminals as well as a raster graphics protocol called "ICR". It had its own TCP stack built in, and could offer these features even on DOS. One of the weirdest rigs I ever saw was a guy at college who browsed the web, with graphics, using NCSA Telnet on a PC/AT running PC-DOS, at a time when that computer was at least 10 years old.

cnvogelvor 12 Jahren

Regarding Tek("Tektronix")-Graphics, here's an animated gif showing Tek4014 graphics...

http://phk.freebsd.dk/AducLoran/animation2.gif

...part of a Loran-C receiver made by Poul-Henning Kamp which aparently outputs these plots over its serial port.

http://phk.freebsd.dk/AducLoran/

To play with it, for example gnuplot can output on an xterm running in tektronix-mode. Open an Xterm, then...

    * mkfifo /tmp/tek
    * cat /tmp/tek
    * Ctrl-Middle-Mouse menu:
        - show tek window
        - switch to tek window
        - (in Tek window:) hide vt window

Open a second terminal (Xterm or any other)

    * start gnuplot, on the gnuplot-prompt
    * set term tek40xx
    * set output "/tmp/tek"
    * plot tan(x)    {or whatever you want to plot}

Using two separate terminal emulators, and the fifo, makes it easier to coordinate the two different modes, because frankly gnuplot doesn't switch sensibly between the two display modes and will clobber one or the other either with Tek control codes on the VT, or write the prompt over the graphics.

ChuckMcMvor 12 Jahren

I've got a couple VT340's in storage, they have ReGIS graphics on them which is quite fun. It would be great if someone decided to implement ReGIS in one of the Linux or Mac terminal emulators because all those cool DEC BASIC games would suddenly work great.

[1] http://terminals.classiccmp.org/wiki/index.php/DEC_VT340

LukeShuvor 12 Jahren

Plain old xterm has a VT340 mode (`-ti vt340`) that supports ReGIS. I'm not sure whether it is complete enough for games to work.

thristianvor 12 Jahren

I don't know how much ReGIS it supports, but it very definitely supports sixel graphics quite nicely:

https://mediacru.sh/plKQQj7ymWNT

The only limitation I've found is that the standard ppmtosixel conversion tool spits out 8-bit control-characters, but xterm seems to only recognise their 7-bit equivalents (hence the sed command in that screenshot).

LukeShuvor 12 Jahren

UTF-8 mode is interfering with the 8-bit control-characters. Give `+u8` to disable UTF-8 mode.

LukeShuvor 12 Jahren

It won't let me edit the comment, but I should throw in: xterm must be compiled with `--enable-regis-graphics` (or `--enable-sixel-graphics` for sixel graphics) for it to work. Your distro's xterm might not have been compiled with those flags.

ChuckMcMvor 12 Jahren

This was the case for me, but rebuilt from source and it worked fine. Given the code exists I wonder why it isn't more common in terminal emulators. Its really handy when you want to pop up a simple picture or a line drawing.

mzsvor 12 Jahren

mlterm does sixels at least too.

akavelvor 12 Jahren

Hm, I remembered something seemed to be linked here on HN some time ago, so after quick googling:

https://news.ycombinator.com/item?id=7539648

http://41j.com/hterm/

Surprised that you missed it, so I'm still not quite sure if maybe I misunderstood something in your question, or you were just having some healthy holidays around that particular time :)

[EDIT] Oh! For more added fun, I've stumbled upon ReGIS's sibling for bitmaps, SIXEL; some pretty screenshots e.g. at:

http://web.archive.org/web/20140521194225/https://pypi.pytho... (submitted to the Wayback Machine, as it loads faster from there for me...)

ChuckMcMvor 12 Jahren

Nice, you're correct I completely missed this posting! Added it to my evernote database, thanks!

minikomivor 12 Jahren

I think this is related too.. for 256 color terminals, a little off-the-cuff go lib I wrote that converts pictures to blended colored ascii https://github.com/minikomi/ansipix

b6vor 12 Jahren

This is cool. Another earlier use of braille to draw in terms is aempirei's Chat-Art[0] project. I've used it to make cool stuff like [1].

[0]: https://github.com/aempirei/Chat-Art [1]: http://i.imgur.com/iN24OEG.png

chinpokomonvor 12 Jahren

But what does it say?

kilovoltairevor 12 Jahren

if you like this you'll also like spark, for sparklines in the terminal ▁▂▃▅▇

https://github.com/holman/spark

zx2c4vor 12 Jahren

C implementation:

http://git.zx2c4.com/spark/about/

dspillettvor 12 Jahren

A semi-related play-thing project (which seems to have stagnated completely now: last update 2001 which makes me feel old) is AALib: http://en.wikipedia.org/wiki/AAlib

If you want to give yourself a migraine, try playing through Quake2 using that as the output device...

VLMvor 12 Jahren

mplayer, the video file player, also supports aalib as an output mode.

billpgvor 12 Jahren

Back in university, we had lots of Falco t310 terminals. (VT100-esque terminals connected to a serial port.)

Occasionally, I'd accidentally cat an executable file to the terminal and it would sometimes switch to a graphical mode and draw lines on the screen like an 80s BASIC program. Clearly there must be some control codes lurking in that executable that coincidentally work as graphical instructions.

I tried experimenting with cutting the file up and into pieces to narrow down the magic control codes, but the number of bytes with a value of 7 in that file started annoying the people around me.

They replaced those terminals with Windows PCs the next year.

3JPLWvor 12 Jahren

Why use braille when you can have a real image? A really awesome feature of iTerm 2's new beta is the ability to display PNGs right inline with the browser[1]. It's easy to use and can create some really cool effects[2].

[1]. Documentation: http://www.iterm2.com/images.html#/section/home

[2]. Example usage: http://i.imgur.com/oOibjuT.png

gfixlervor 12 Jahren

Nah, that's cheating. I like my restrictions. They keep me sharp.

outworldervor 12 Jahren

OMG!

Are there any implementations for terminals running in other operating systems?

viraptorvor 12 Jahren

That reminds me of an old idea from lcamtuf (1st on http://lcamtuf.coredump.cx/soft/obsolete/STUPID_IDEAS.txt) - replace fonts while text is being displayed directly on VGA/EGA. I wonder is anyone attempted to implement it in the end. This project comes really close though.

banevor 12 Jahren

I believe the old music software Impulse Tracker did something like this. It was in text mode, yet had smooth mouse cursors, audio visualizations and other "graphical" things.

http://roartindon.blogspot.com/2014/02/20-years-of-impulse-t... (more detail from the author in the comments)

ashmudvor 12 Jahren

A number of text mode programs had smooth mouse cursors. They modified extended ascii characters to produce the effect. Some intros did some limited animations (e.g., scrolling starry backgrounds) using the same approach. This and cycling color palettes made for some pretty snazzy effects.

banevor 12 Jahren

You're right about that. For some reason I have it in my head that IT did something more dynamic with the characterset to produce the graphics, but I can't find the source for that other than the recent blog posts by Jeff Lim.

toleavethemanvor 12 Jahren

This inspired me to make a Julia version: https://github.com/sunetos/DotPlot.jl

It doesn't do arbitrary raster yet, but it has a cleaner syntax and prettier graph than the python/javascript ones.

callesggvor 12 Jahren

Nice the last pice needed for a webkit browser in the terminal..

pasbesoinvor 12 Jahren

It didn't have braille characters, but my old Kaypro 2x had a blocky, character oriented form of pixel graphics. (The rather fat pixels needed to be rolled together into a "character" that was outputted, as best as I recall.

It was enough to be able to display some chunky looking but workable fractal images. Somewhat similar to the time I generated the like on a Dec something or other and printed them on the available dot matrix printer.

Fun, if much simpler, times.

bitwizevor 12 Jahren

Reminds me of the TRS-80 Model I, which could do "graphics" using special characters in the space above ASCII 127. Each such character was a 2x3 pixel grid with certain pixels turned "on" or "off". With 64 such characters, it was possible to plot arbitrary monochrome graphics (albeit with really chunky pixels) on the screen. Which is how Dancing Demon and other TRS-80 programs got their famous chunky appearance.

ilakshvor 12 Jahren

I wonder if you could implement Mystery House in the terminal now.

Also maybe you could do color lines with ANSI.. although overlapping lines wouldn't work.

couchandvor 12 Jahren

Thanks for that! Things I learned from the WP page [0]:

- Sierra was originally called On-Line Systems. A throwback to the Mother of all Demos, perhaps?

- There was a Japanese game company back in the 80s called StarCraft.

[0]: https://en.wikipedia.org/wiki/Mystery_House

dalkevor 12 Jahren

If you want to get into the background of Mystery House - not how to play it but more the background of how it was made and fits into the larger context of interactive fiction - then you should read Jimmy Maher's description at http://www.filfre.net/2011/10/mystery-house-part-1/ along with part 2. Those are part of a very long and enjoyable description of the evolution of interactive fiction, the developers, and the computer systems.

However, the only description of the choice in using "On-Line" is a conjecture in http://www.filfre.net/2011/10/ken-and-roberta/ :

> Specifically, he wanted to bring FORTRAN, as it happens the implementation language of the original Adventure (not that Ken likely knew this or cared), to the little Apple II. With that purpose in mind, he registered a company of his own, choosing to call it On-Line Systems, a name fairly typical of the vaguely futuristic, vaguely compound, but essentially meaningless names (Microsoft, anyone?) that were so common in the era.

gfixlervor 12 Jahren

I did this once, but not in such a general way.

http://www.reddit.com/r/somethingimade/comments/ctk8c/i_made...

chjvor 12 Jahren

I am wondering if we could use same technique for displaying graph charts in program comments. Let's hope the code points aren't overlapping.

snarfyvor 12 Jahren

Reminds me of textro:

https://www.youtube.com/watch?v=twBgcuaZVOA

shmerlvor 12 Jahren

Great idea, looks better than libcaca approximation.

TempleOSV207vor 12 Jahren