dusko + ascii   163

command line - What protocol/standard is used by terminals? - Unix & Linux Stack Exchange
Properly-written Unix programs don't emit these escape sequences directly. Instead, they use one of the libraries mentioned above, telling it to "move the cursor to position (1,1)" or whatever, and the **library** emits the necessary terminal control codes based on your TERM environment variable setting. This allows the program to work properly no matter what terminal type you run it on.
xterm  terminal  commandline  cli  shell  console  x11  xorg  unix  utf8  unicode  ansi  ascii 
9 days ago by dusko
ANSI Codes and Colorized Terminals
In terms of digital representation ANSI and ASCII are different sets of characters, ASCII using only 7 bits for representing a character and ANSI using 8 bits.
ansi  ascii  reference  xterm  terminal  shell  console  cli  unix 
9 days ago by dusko
Unprintable ACSCII characters and TTYs
What happens when typing special "control sequences" like <ctrl-h>, <ctrl-d> etc.?

For convenience, "^X" means "<Ctrl-X>" in the following (ignoring the fact that you usually might use the lower case x).

About a possible origin of the "^"-notation, see also an article in a.f.c, <62097@bbn.BBN.COM> (local copy).
ascii  ansi  xterm  terminal  cli  x11  xorg  unix 
11 days ago by dusko
Text File formats – ASCII Delimited Text – Not CSV or TAB delimited text
See http://en.wikipedia.org/wiki/Unit_separator and

In summary ASCII Delimited Text is using the last 4 control characters (28-31) for their purpose as field and record delimiters and not using CSV (Comma Separated Values)
csv  tsv  ascii  data  programming  plaintext  text  terminal  cli  reference 
11 days ago by dusko
Things Every Hacker Once Knew | Lobsters
feoh (Jan 27, 2017)

Now this article I can get behind! While I often find Mr. Raymond’s opinion pieces objectionable and occasionally out and out wrong, but in my view his work really shines when he strives to educate, and this article is a great example.

I wish there were a bit more depth on UUCP, but overall - great article. Thanks for posting it.

. . .

Dutch feoh (Jan 27, 2017)

My sentiments exactly. I stopped visiting his sites a few years ago; the signal to bombast ratio was just too low for me. If it weren’t for postings on aggregators, I’d miss great articles like this.

. . .

Screwtape (Jan 27, 2017)

A TTY-related fact that wasn’t mentioned in the article:

To control text-formatting on an ANSI-compatible terminal (or emulator), you can send it terminal control sequences like \e[1m to enable bold or whatever. Paper-based terminals didn’t have control-sequences like that, but people still figured out ways to do formatting. For example, if you printed a letter, then sent backspace (Ctrl-H, octet 0x08) and printed the same letter again, it would be printed with twice as much ink, making it look “bold”. If you printed a letter, then sent backspace and an underscore, it would look underlined.

The original Unix typesetting software took full advantage of this trick. If you told it to output a document (say, a manpage) to your terminal (as opposed to the expensive typesetting machine in the corner), it would use the BS trick to approximate the intended formatting.

This worked great, up until the invention of video display terminals, where the backspace trick just replaced the original text, instead of adding to it. So people wrote software to translate the backspace-trick into ANSI control codes... software like less(1).
unix  terminal  shell  console  commandline  cli  ascii  ansi  it  computing  history  reference  rs232serialport 
11 days ago by dusko
Things Every Hacker Once Knew | Hacker News
bogomipz on Jan 27, 2017 [-]
>"It becomes immediately obvious why, eg, ^[ becomes escape. Or that the alphabet is just 40h + the ordinal position of the letter (or 60h for lower-case). Or that we shift between upper & lower-case with a single bit."

I am not following, can you explain why ^[ becomes escape. Or that the alphabet is just 40h + the ordinal position? Can you elaborate? I feel like I am missing the elegance you are pointing out.

soneil on Jan 27, 2017 [-]
If you look at each byte as being 2 bits of 'group' and 5 bits of 'character';

00 11011 is Escape
10 11011 is [

So when we do ctrl+[ for escape (eg, in old ansi 'escape sequences', or in more recent discussions about the vim escape key on the 'touchbar' macbooks) - you're asking for the character 11011 ([) out of the control (00) set.

Any time you see \n represented as ^M, it's the same thing - 01101 (M) in the control (00) set is Carriage Return.

Likewise, when you realise that the relationship between upper-case and lower-case is just the same character from sets 10 & 11, it becomes obvious that you can, eg, translate upper case to lower case by just doing a bitwise or against 64 (0100000).

And 40h & 60h .. having a nice round number for the offset mostly just means you can 'read' ascii from binary by only paying attention to the last 5 bits. A is 1 (00001), Z is 26 (11010), leaving us something we can more comfortably manipulate in our heads.

I won't claim any of this is useful. But in the context of understanding why the ascii table looks the way it does, I do find four sets of 32 makes it much simpler in my head. I find it much easier to remember that A=65 (41h) and a=97 (61h) when I'm simply visualizing that A is the 1st character of the uppercase(40h) or lowercase(60h) set.
unix  terminal  shell  console  commandline  cli  ascii  ansi  it  computing  history 
11 days ago by dusko
What we still use ASCII CR for today (on Unix)
This description may sound like CR is no longer used on Unix, except as part of being carefully compatible with old protocols like SMTP and newer ones like HTTP. This is misleading, because CR is still in active use on Unix today.

Posted on January 28, 2017.
smtp  mailserver  sendmail  unix  ascii  http  reference 
11 days ago by dusko
less - What does [?1049h and [?1h ANSI escape sequences do? - Unix & Linux Stack Exchange
The question mark shows that it is "private use" (a category set aside for implementation-specific features in the standard). About a third of the private-use modes listed in XTerm Control Sequences correspond to one of DEC's (those have a mnemonic such as DECCKM in their descriptions). The others are either original to xterm, or adapted from other terminals, as noted.
xterm  terminal  x11  xorg  ansi  ascii  unix 
19 days ago by dusko
True Colour (16 million colours) support in various terminal applications and terminals · GitHub
Terminal Colors

There exists common confusion about terminal colors. This is what we have right now:

ANSI escape codes: 16 color codes with bold/italic and background
256 color palette: 216 colors + 16 ANSI + 24 gray (colors are 24-bit)
24-bit true color: "888" colors (aka 16 milion)


Terminals that parse ANSI color sequences, but approximate them to 256 palette

xterm (but doing it wrong: "it uses nearest color in RGB color space, with a usual false assumption about orthogonal axes")
terminal  xterm  shell  cli  colour  reference  ansi  ascii 
20 days ago by dusko
ANSI Escape Codes
ANSI Escape Sequences

Standard escape codes are prefixed with Escape:

Ctrl-Key: ^[
Octal: \033
Unicode: \u001b
Hexadecimal: \x1b
Decimal: 27

Followed by the command, usually delimited by opening square bracket ([) and optionally followed by arguments and the command itself.

Arguments are delimeted by semi colon (;).
ansi  ascii  commandline  cli  shell  terminal  xterm  x11  xorg  reference 
20 days ago by dusko
What's the correct way to use ANSI escape sequences to edit terminal content "in place"? - Unix & Linux Stack Exchange
The behavior on \e[2J differs across terminals. Some, e.g. Xterm clear the screen as you expect.
xterm  terminal  cli  ansi  ascii  x11  xorg  tips 
21 days ago by dusko
Escape sequences with "echo -e" in different shells - Unix & Linux Stack Exchange
There's no such thing as a "Linux shell".

There's for instance the echo builtin of the /bin/sh shell as provided by the dash package on Debian (an operating system that can have Linux or FreeBSD as its kernel).


Note that at any time and in almost any shell, you can figure out which "echo" will be called by typing type echo or which echo. It's usually a shell builtin. So it depends on which "echo" is installed and on which shell you're using.


which echo should not be used, it likely won't tell you if you are using a builtin because which is usually an external binary. type is good, though.


Well spotted, though on my main shell (zsh), it's a builtin (as revealed by type which or which which). ;)
shell  sh  script  terminal  ascii  unix  reference  linux  bsd 
25 days ago by dusko
Terminal codes (ANSI/VT100) - introduction [Bash Hackers Wiki]
These features require that certain capabilities exist in your termcap/terminfo. While xterm and most of its clones (rxvt, urxvt, etc) will support the instructions, your operating system may not include references to them in its default xterm profile. (FreeBSD, in particular, falls into this category.) If `tput smcup` appears to do nothing for you, and you don't want to modify your system termcap/terminfo data, and you KNOW that you are using a compatible xterm application, the following may work for you:

echo -e '\033[?47h' # save screen
echo -e '\033[?47l' # restore screen
shell  script  cli  terminal  ansi  unix  reference  vt100  freebsd  ascii 
29 days ago by dusko
How can I change the colors of my xterm using Ansi escape sequences? - Super User
Note that modern Xterms support 32-bit color!

Simple example. To set a nice dark purple background (hey, each to his own) of value #53186f, you do:

echo -ne "\033]11;#53186f\007"

Note that this instantly changes the color of the whole window, not just of the subsequent text. This is especially nice for making a window obviously different after ssh'ing to a server (for example). Put the above 'echo' into your .bashrc and your terminal automatically changes colors when you log into that server (but won't change back when you Ctrl-D out)

You can spend HOURS on the net looking for this - most docs only talk about the original 16 ANSI colors.
xterm  terminal  ansi  ascii  keyboard  unix  reference 
5 weeks ago by dusko
shell - What are the special characters to print from a script to move the cursor? - Unix & Linux Stack Exchange
If your terminal emulator supports ANSI escape sequences, you can move the cursor up by running this:

echo -n -e '\033[2A'


ruby -e 'print "\033[2A"'

This will move the cursor up 2 lines. It works in gnome-terminal and xterm and many others.


Those special characters are from the 7-bit ASCII set, which contains the 128 characters in this table (http://www.asciitable.com/); shell escape notation is not shown there, but \r is the 14th character (decimal value 13), CR (carriage return). The bell is the 8th character (decimal value 7). \n, known in *nix and derived realms as the newline, is the 11th character (decimal value 10), LF (line feed).

Most of the ASCII set are normal alphanumeric characters. Most of the "special characters" at the beginning of the table actually don't serve any purpose today (the newline, etc., being exceptions). ANSI compliant terminals (including most modern *nix based virtual ones) use ESC (decimal 27, octal 33) to start special control sequences (\033...) -- some of which, as Mark Plotnick points out in his answer (https://unix.stackexchange.com/questions/107417/what-are-the-special-characters-to-print-from-a-script-to-move-the-cursor/107441#107441), allow for vertical movement.
xterm  terminal  ansi  ascii  shell 
5 weeks ago by dusko
ANSI Escape sequences (ANSI Escape codes) - VT100 / VT52
This document describes how to control a VT100 terminal (http://ascii-table.com/documents/vt100/).

ANSI escape sequence is a sequence of ASCII characters, the first two of which are the ASCII "Escape" character 27 (1Bh) and the left-bracket character " [ " (5Bh). The character or characters following the escape and left-bracket characters specify an alphanumeric code that controls a keyboard or display function.

Information is also available int the VT100 User Guide (http://ascii-table.com/documents/vt100/chapter3.php#S3.3.3).
ansi  ascii  terminal  vt100  reference 
5 weeks ago by dusko
Control character - Wikipedia
In computing and telecommunication, a control character or non-printing character (NPC) is a code point (a number) in a character set, that does not represent a written symbol. They are used as in-band signaling to cause effects other than the addition of a symbol to the text. All other characters are mainly printing, printable, or graphic characters, except perhaps for the "space" character (see ASCII printable characters).

All entries in the ASCII table below code 32 (technically the C0 control code set) are of this kind, including CR and LF used to separate lines of text. The code 127 (DEL) is also a control character[citation needed]. Extended ASCII sets defined by ISO 8859 added the codes 128 through 159 as control characters, this was primarily done so that if the high bit was stripped it would not change a printing character to a C0 control code, but there have been some assignments here, in particular NEL. This second set is called the C1 set.
ascii  ansi  utf8  unicode  reference 
5 weeks ago by dusko
Unicode Characters Table
Since its conception, ASCII codes knew many evolutions and, in the 1990's, evolved to a new code called Unicode™ that handles alphabets of many nations and symbols.

The Unicode code space is divided into 17 planes (http://ascii-table.com/unicode-planes.php). Each plane contains 65,536 code points (16-bit) and consists of several charts.

If the Unicode standard can handle up to 1,114,112 characters (http://ascii-table.com/unicode-characters.php), it currently assigns characters to more than 96,000 of those code points.

The first 256 characters table is identical to the ISO 8859-1 character set (the ANSI table (http://ascii-table.com/ansi-table.php) is identical to the ISO 8859-1 table, except in the range 80h-9Fh where we can find C1 control characters). The first 128 characters table is hence identical to the standard ASCII table (http://ascii-table.com/ascii.php).
unicode  utf8  ascii  ansi  reference 
5 weeks ago by dusko
toilet - a free replacement for the ​FIGlet utility
The TOIlet project attempts to create a free replacement for the ​FIGlet utility (http://www.figlet.org/). TOIlet stands for “The Other Implementation’s letters”, coined after FIGlet’s “Frank, Ian and Glen’s letters”.
ascii  cli  tool  plaintext  terminal  shell  documentation  writing 
november 2019 by dusko
Hasciicam - ASCII for the masses
Hasciicam makes it possible to have live ascii video on the web.
ascii  software  web 
november 2019 by dusko
What Every Programmer Absolutely, Positively Needs to Know About Encodings and Character Sets to Work With Text
This article is about encodings and character sets. An article by Joel Spolsky entitled The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (No Excuses!) (http://www.joelonsoftware.com/articles/Unicode.html) is a nice introduction to the topic and I greatly enjoy reading it every once in a while. I hesitate to refer people to it who have trouble understanding encoding problems though since, while entertaining, it is pretty light on actual technical details. I hope this article can shed some more light on what exactly an encoding is and just why all your text screws up when you least need it. This article is aimed at developers (with a focus on PHP), but any computer user should be able to benefit from it.
unicode  utf8  ascii  programming  reference 
october 2019 by dusko
opendetex - Improved version of Detex
Tool for extracting plain text from TeX and LaTeX sources.
tex  latex  ascii  plaintext 
october 2019 by dusko
opendetex - Fork of opendetex with custom changes
OpenDetex is a program to remove TeX constructs from a text file. It recognizes
the \input command.

This program assumes it is dealing with LaTeX input if it sees the string
"\begin{document}" in the text. It recognizes the \include and \includeonly
tex  latex  ascii  plaintext 
october 2019 by dusko
ASCII Art Farts
Large collection of ASCII art dating as long as 1999.
ascii  plaintext 
october 2019 by dusko
The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (No Excuses!)
In this article I’ll fill you in on exactly what every working programmer should know. All that stuff about “plain text = ascii = characters are 8 bits” is not only wrong, it’s hopelessly wrong, and if you’re still programming that way, you’re not much better than a medical doctor who doesn’t believe in germs. Please do not write another line of code until you finish reading this article.

And I should warn you that character handling is only a tiny portion of what it takes to create software that works internationally, but I can only write about one thing at a time so today it’s character sets.

Some people are under the misconception that Unicode is simply a 16-bit code where each character takes 16 bits and therefore there are 65,536 possible characters. **This is not, actually, correct.** It is the single most common myth about Unicode, so if you thought that, don’t feel bad.

Until now, we’ve assumed that a letter maps to some bits which you can store on disk or in memory:

A -> 0100 0001

In Unicode, a letter maps to something called a **code point**, which is still just a theoretical concept. How that code point is represented in memory or on disk is a whole nuther story.

Every platonic letter in every alphabet is assigned a magic number by the Unicode consortium which is written like this: U+0639. This magic number is called a code point. The U+ means “Unicode” and the numbers are hexadecimal. U+0639 is the Arabic letter Ain. The English letter A would be U+0041. You can find them all by visiting the Unicode web site (http://www.unicode.org/).

There is no real limit on the number of letters that Unicode can define and in fact they have gone beyond 65,536 so not every unicode letter can really be squeezed into two bytes, but that was a myth anyway.

OK, so say we have a string:


which, in Unicode, corresponds to these five code points:

U+0048 U+0065 U+006C U+006C U+006F.

Just a bunch of code points. Numbers, really. We haven’t yet said anything about how to store this in memory or represent it in an email message.


That’s where encodings come in.

The earliest idea for Unicode encoding, which led to the myth about the two bytes, was, hey, let’s just store those numbers in two bytes each. So Hello becomes

00 48 00 65 00 6C 00 6C 00 6F

Right? Not so fast! Couldn’t it also be:

48 00 65 00 6C 00 6C 00 6F 00 ?

Well, technically, yes, I do believe it could, and, in fact, early implementors wanted to be able to store their Unicode code points in high-endian or low-endian mode, whichever their particular CPU was fastest at, and lo, it was evening and it was morning and there were already two ways to store Unicode. So the people were forced to come up with the bizarre convention of storing a FE FF at the beginning of every Unicode string; this is called a Unicode Byte Order Mark and if you are swapping your high and low bytes it will look like a FF FE and the person reading your string will know that they have to swap every other byte. Phew. Not every Unicode string in the wild has a byte order mark at the beginning.

For a while it seemed like that might be good enough, but programmers were complaining. “Look at all those zeros!” they said, since they were Americans and they were looking at English text which rarely used code points above U+00FF.

Thus was invented the brilliant concept of UTF-8. UTF-8 was another system for storing your string of Unicode code points, those magic U+ numbers, in memory using 8 bit bytes. In UTF-8, every code point from 0-127 is stored in a single byte. Only code points 128 and above are stored using 2, 3, in fact, up to 6 bytes.

How UTF-8 works

This has the neat side effect that English text looks exactly the same in UTF-8 as it did in ASCII, so Americans don’t even notice anything wrong. Only the rest of the world has to jump through hoops. Specifically, Hello, which was U+0048 U+0065 U+006C U+006C U+006F, will be stored as 48 65 6C 6C 6F, which, behold! is the same as it was stored in ASCII, and ANSI, and every OEM character set on the planet. Now, if you are so bold as to use accented letters or Greek letters or Klingon letters, you’ll have to use several bytes to store a single code point, but the Americans will never notice. (UTF-8 also has the nice property that ignorant old string-processing code that wants to use a single 0 byte as the null-terminator will not truncate strings).

So far I’ve told you three ways of encoding Unicode. The traditional store-it-in-two-byte methods are called UCS-2 (because it has two bytes) or UTF-16 (because it has 16 bits), and you still have to figure out if it’s high-endian UCS-2 or low-endian UCS-2. And there’s the popular new UTF-8 standard which has the nice property of also working respectably if you have the happy coincidence of English text and braindead programs that are completely unaware that there is anything other than ASCII.

UTF 7, 8, 16, and 32 all have the nice property of being able to store any code point correctly.

The Single Most Important Fact About Encodings

If you completely forget everything I just explained, please remember one extremely important fact. It does not make sense to have a string without knowing what encoding it uses. You can no longer stick your head in the sand and pretend that “plain” text is ASCII.

There Ain’t No Such Thing As Plain Text.

How do we preserve this information about what encoding a string uses? Well, there are standard ways to do this. For an email message, you are expected to have a string in the header of the form

Content-Type: text/plain; charset="UTF-8"

For a web page, the original idea was that the web server would return a similar Content-Type http header along with the web page itself — not in the HTML itself, but as one of the response headers that are sent before the HTML page.
unicode  utf8  ascii  ansi  programming  cli  terminal  email  reference  html  web  sysadmin 
september 2019 by dusko
Scribble - Buttersquid.ink
I'm a fan of ASCII art in source code but have always been bothered by the inconvenience of modifying the diagram. I recently decided to learn Javascript, so I wrote a tool which lets you draw line diagrams. The tool converts the diagram into ASCII, and appends a string representing the serialized, compressed version of the diagram. This lets you get recreate and modify the original line diagram–round-trip editing.

Software is a collection of complicated ideas embodied as machine code. Pictures are an excellent way of conveying complicated ideas. Obviously we should be documenting software source code with pictures...right? Yet despite decades' worth of attempts at developing visual programming languages, typing plain old text into plain old text files continues to be the most effective way of implementing and documenting software.

As a compromise, you can embed ASCII art into source code comments or README files. This isn't a bad solution, and there are several desktop and web-based tools (e.g. Emacs artist-mode) which let you draw simple vector objects--boxes and lines--then render the drawing as ASCII. But when you try to update the ASCII art, you quickly run into the limitations of these tools. Rendering vector objects into ASCII effaces the information associated with the vector objects: you can no longer move or reshape the vector objects because it's just a collection of ASCII characters.

Scribble is an ASCII art editor which lets you draw vector diagrams and render them into ASCII art. The original vector objects are converted into a short (well, short-ish) URL and string, appended to the bottom of the diagram. Paste both the ASCII art and URL into your source code or README file. If you need to modify the ASCII art later, you can regenerate the original vector shapes in Scribble by using the URL.
diagram  ascii  documentation  writing  tool  javascript  cli  shell  terminal  plaintext 
june 2019 by dusko
Explaining Code using ASCII Art
People tend to be visual: we use pictures to understand problems. Mainstream programming languages, on the other hand, operate in an almost completely different kind of abstract space, leaving a big gap between programs and pictures. This piece is about pictures drawn using a text character set and then embedded in source code. I love these! The other day I asked around on Twitter for more examples and the responses (https://twitter.com/johnregehr/status/1095018518737637376) far exceeded expectations (thanks everyone!). There are a ton of great examples in the thread; here I’ve categorized a few of them. Click on images go to the repositories.
diagram  ascii  documentation  writing  plaintext 
june 2019 by dusko
binpretty - A tool to view mixed binary/textual data
It turns out a lot of binary formats are a mix of plaintext and binary; the binary means regular text editors aren't great at viewing them, but reading the plaintext in the small ascii representation on the right hand side of hex viewers isn't very nice either.
plaintext  ascii  programming 
may 2019 by dusko
Formattinf for listings in an external style file.
A lot of options for colouring and line numbers and similar.
tex  latex  writing  technicalwriting  documentation  pdf  cli  unix  postscript  ascii  plaintext 
april 2019 by dusko
Groff and mom - An overview
Groff and mom: an overview
Contains a useful summary of basic groff concepts and workflow
tex  latex  writing  technicalwriting  documentation  pdf  cli  unix  postscript  ascii  plaintext 
april 2019 by dusko
GNU troff (Groff) - a GNU project
Groff (GNU troff) is a typesetting system that reads plain text mixed with formatting commands and produces formatted output. Output may be PostScript or PDF, html, or ASCII/UTF8 for display at the terminal. Formatting commands may be either low-level typesetting requests (“primitives”) or macros from a supplied set. Users may also write their own macros. All three may be combined.

Present on most Unix systems owing to its long association with Unix manuals (manpages), groff is capable of producing typographically sophisticated documents while consuming only minimal system resources.
tex  latex  writing  technicalwriting  documentation  pdf  cli  unix  postscript  ascii  plaintext 
april 2019 by dusko
Halibut - yet another free document preparation system
Halibut is a documentation production system, with elements similar to TeX, debiandoc-sgml, TeXinfo, and others. It is primarily targeted at people producing software manuals.
What does it do?

Halibut reads documentation source in a single input format, and produces multiple output formats containing the same text. The supported output formats are:

Plain ASCII text
Unix man pages
Unix info, generated directly as .info files rather than .texi sources
Windows HTML Help (.CHM files), generated directly without needing a separate help compiler.
Windows WinHelp (old-style .HLP files), also generated directly.
tex  latex  documentation  writing  plaintext  ascii  pdf  unix 
february 2019 by dusko
Dita - DIagrams Through Ascii Art
... I almost always have some sort of data that I can munge into nodes and edges. (Program call graphs, DB schema, etc) or I make up nodes and edges in a text file. Then I use GraphViz to automagically do the layout and drawing. Works great for me.
diagram  ascii  plaintext  documentation  writing  visualization 
january 2019 by dusko
Real-time ASCII Art Rendering Using Decision Tree - PixLab
Real-Time ASCII Art Rendering
Transform an input image/frame (human faces included) into printable ASCII characters using a single decision tree.
ascii  design  web 
january 2019 by dusko
Charaster - Character raster based editor, useful for ASCII art and diagrams
A browser based drawing program that rasters characters instead of single pixels, to support the creation of text based diagrams and artwork (e.g. ANSI and ASCII art).
ascii  diagram 
january 2019 by dusko
Diagrammer - ASCII diagrams to pictures converter

Often diagrams are parts of a source code or some documentation that must be easily comprehended in its original text representation. For this reason, ASCII diagrams must not be polluted by special commands for tools, they are processed by.
ascii  diagram 
january 2019 by dusko
ditaa addons - Ditaa EPS
Another addon is ditaa eps, which is a simple command-line utility that converts ascii art to scalable EPS graphics (instead of PNG bitmaps)
ascii  cli  diagram  tex  latex  plaintext  documentation  writing 
january 2019 by dusko
Interactively create and edit tables and export them to plain text.
ascii  plaintext  documentation  writing 
january 2019 by dusko
List - ASCII Sandbox
This list is a collection of ASCII tools, apps, applets, etc. It includes ASCII editors (much more capability than notepad), flow chart and diagram generators (spruce up your comment blocks), font generators, and animation tools to help you create ASCIImations.
ascii  documentation  writing 
january 2019 by dusko
« earlier      
per page:    204080120160

Copy this bookmark: