
The Plain Text Project - mmillin
https://plaintextproject.online/
======
mntmoss
Recently I decided that I was going to solve the problem of: I easily write
inline TODO comments while I work on code, but then have difficulty keeping
track of them and getting my head back into the state of things later. While
there is IDE support for such things, it's usually not _exactly_ the right
interface I want.

So I made a tiny CLI app that scans the source for TODO and FIXME lines and
presents a menu of files, containing the number of items to work on in each.
Then I type in which file I want to work on and it instantly reports all
relevant lines, plus successive comment lines. All I have to do is punch in
the line number and start working.

I felt a kind of stress relief almost instantly after doing this. It's better
than Trello for me.

If I need to add additional kinds of data sources, many syntaxes, etc. it
might become a bit more complex, but still managable as long as there's an API
to get some plaintext lines out. It's basically following up on the hypothesis
of a lot of information tools today: it isn't the data generation that's the
issue, but the filtering.

~~~
chch
Just be careful about Microsoft's Patent US6748582B1; it doesn't expire for
another few months. ;)

From the patent (edited down a bit):

> According to various example implementations of the invention, a task list
> facilitates code development by assisting developers in keeping track of and
> managing a variety of tasks, such as errors to be corrected, opportunities
> for optimization, and other user-defined tasks. As the developer edits
> source code, warnings and coding errors are detected and inserted as tasks
> in a task list. The developer can also embed keywords known as comment
> tokens in the code. These comment tokens are detected and used to define
> tasks.

> [...]

> Tasks can also be identified using tokens or keywords. These tokens or
> keywords typically preface comment lines in the code and may include
> predefined labels such as, for example, “UNDONE,” “TODO,” or “HACK,” as well
> as labels that are defined by the individual developer. If the source code
> has no syntax errors, the parser [...] determines whether any of the
> keywords are present in the source code[.] If so, [it] extracts the comment
> from the source code and uses the tag to determine the priority of the task.
> The task is then inserted in the task list[.] For example, if the source
> code contains the comment, “/ _TODO: Need to add copyright text_ /”, the
> parser [...] adds the task “TODO: Need to add copyright text” to the task
> list with a priority rating assigned to the “TODO” tag. [1]

[1]
[http://patents.google.com/patent/US6748582B1/en](http://patents.google.com/patent/US6748582B1/en)

~~~
arminiusreturns
How is it you are aware of this? Affiliation with MS or a project that ran
into it?

Wouldn't the key part:

" _and_ in response to completion of a task, modifying the task list during
the interactive code development session to indicate that the task has been
completed."

mean it doesn't apply?

Worst case, just put a US exclusionary clause in the release so US copyright
law doesn't apply. At least Europe is ahead of the US in this and doesn't
allow such trivial patents and considers them invalid by definition.

~~~
chch
Someone discovered it years ago online, and it's done a couple rounds in the
media[1] as an example of an "overreaching software patent", similar to the
"pop-under" patent, which patents a pop-up ad that opens after a window is
closed[3].

So no personal experience, but I definitely think it's pretty frivolous; I
don't imagine its ever been tested in court. :)

[1]
[https://www.theinquirer.net/inquirer/news/1040068/microsoft-...](https://www.theinquirer.net/inquirer/news/1040068/microsoft-
patents-to-do-lists) from 2004 [2] [https://www.geek.com/news/microsoft-
granted-patent-covering-...](https://www.geek.com/news/microsoft-granted-
patent-covering-to-do-lists-1288600/) from 2010 [3]
[https://en.wikipedia.org/wiki/Pop-
up_ad#Patent_controversy](https://en.wikipedia.org/wiki/Pop-
up_ad#Patent_controversy)

------
loh
I think more and more people are realizing that simpler is almost always
better, and not only when it comes to software. I've found that this approach
works best for nearly all aspects of life.

The hard part is simplifying complex things. We have so many odd pieces
(usually due to legacy reasons or conflicting designs) which don't quite fit
into an otherwise simple solution.

Plain text could probably work for most forms of communication and data
formats. It's when you need to separate, categorize, and interact with the
information that you need more than plain text.

This website briefly addresses plain text's shortcomings, so to add to that,
in terms of software UX, I would say plain text should be used as a starting
point while adding interactive elements (e.g., buttons) and layouts only as
necessary. By layouts I mean visual separation of categorized information via
whitespace and/or color variations. I've found that this results in extremely
intuitive interfaces that are both easy for users to digest and developers to
maintain.

We seem to be following a trend where "winning" software has little to no
learning curves, as they are becoming the simplest possible tools for daily
use. I'm not sure if it's a result of the fact that most people are tech
savvy, or if we're just getting better at building software and designing
interfaces. It's probably some combination of both.

~~~
asdff
I don't think the UX needn't be complicated. If you really wanted that you can
use .rtf, but whitespace and at least grayscale separation are already
possible in plaintext of course. Want a cute header? How about:

##########

Header

##########

Smaller plain text files + folders are great for separating, categorizing, and
interacting with information. Got another file type relevant to that note?
throw it in a folder with a matching filename.txt describing it all. Have
aliases or shortcuts to make these appear in any configuration you want all
over your OS.

MacOS also lets you put tags on any file leading to further customization.
Throw in Calendar into the mix for reminders (not proprietary Reminders) mail
for communication and sending yourself notes when you don't have your laptop,
and MacOS has all the features baked into the OS that most notetaking apps
drip feed through a poorly optimized app on a subscription and with
proprietary formats.

This system works on any computer built in the last 40 years and will probably
work on all computers built in the next 40. Lets see a company like evernote
last for that long.

~~~
lstamour
It’s worth noting that unless your header text file is in a format that can be
converted to HTML, there’s no easy way for third-party accessibility tools to
understand your plain text the way you do. Accessibility is one of the reasons
WYSIWYG is so common. It’s hard to translate plain text to a semantic verbal
description (though with AI and pattern matching this might be getting
easier), and even harder if it’s not actually text. ¯\\_(ツ)_/¯

------
nlh
While we’re on the subject, I just moved my whole financial life over to
hledger ([https://hledger.org/](https://hledger.org/)) and oh my goodness I’m
so much happier (I dumped both QuickBooks and Quicken, which I’d been using
previously).

It won’t be for everyone, but if you know a bit about what you’re doing with
double-entry accounting, it’s so so so much better. I only wish I’d discovered
this was of doing things years ago (before dumping hundreds of hours into
clicking and trying to wrestle with Intuit’s tools.)

~~~
kazinator
I do my self-employment accounting using an accounting system I wrote myself
in my own Lisp dialect (TXR Lisp), making heavy use of its object system. It
works very well.

The entry is done in a file called "data.tl", using simple function calls and
object construction. That is then checked into Git after every new
transaction.

It does everything: deducting income tax, expenses, GST, capital cost
allowance for writing off depreciation on equipment, ... And it has decent
columnar format reporting for querying the accounts.

Invoices to clients are generated in HTML + CSS + SVG logo, which can render
to a very polished PDF.

I based the system on something I call "zero sum accounting". Every
transaction contains 2 or more deltas (N-entry, not just double entry), which
represent entries going into various accounts. These deltas must add up to
zero: like voltages around a circuit. So for instance a single transaction
representing a paid invoice gets split up into an income tax withholding
account, gst, account, equity account, cash account, and others, in a single
transaction. Negative-running accounts represent outside interests in the
business: e.g. the equity account (owner's interest in the business) runs
negative, and so would an account representing a bank loan (lender's interest
in the business). Positive accounts are what the business has, like cash or
value of assets. The confusing "debit" and "credit" terminology is completely
avoided.

~~~
jchook
Any plans to open-source your tool? Sounds fantastic.

Also I think "double-entry accounting" literally means "N-entry zero sum
accounting" as you describe it, and hledger supports it.

~~~
kazinator
When designing this system I wasn't able to find any online resource about
accounting describing anything other than double-entry accounting in which
every transaction consists of one debit and one credit in equal amounts
(usually positive), not adding to zero.

The Wikipedia page has nothing about an N-entry, zero sum method:

[https://en.wikipedia.org/wiki/Double-
entry_bookkeeping_syste...](https://en.wikipedia.org/wiki/Double-
entry_bookkeeping_system)

Not going to open-source; I never open source anything without decent
documentation, and this has none.

~~~
sjy
It’s implied in the first paragraph – “In double-entry bookkeeping, a
transaction always affects _at least two accounts_ , always includes at least
one debit and one credit, and always has _total debits and total credits_ that
are equal.”

------
geraldbauer
Great collection of tools and articles. Plain text is also a great (and the
best) choice for datasets. Do NOT use JSON, YAML and friends, for example, as
your input format but use plain text with a custom parser to import into any
SQL database and than you can easily export to JSON, YAML and friends. See the
football.db and the Premier League or World Cup match schedule as living
examples [1]. [1]:
[https://github.com/openfootball](https://github.com/openfootball)

~~~
xg15
If your dataset is mostly a list of strings, sure. If it's anything more
structured, why exactly?

I'd argue that using "plaintext" for structured data (a.k.a, inventing your
own data representation) will set up both you and the users of your dataset
for unnecessary pain dealing with unescaping and parsing.

~~~
enriquto
if the dataset is "more structured" you can try to simplify this structure for
great gains. As a byproduct, you get to use text files for the data.

~~~
xg15
Could you give an example?

~~~
geraldbauer
See above the world cup match schedule [1], for another other examples with
geo tree (e.g. country/province/city/district/etc.), see the Belgian Football
clubs, for example [2] or for yet another example the Football leagues [3]
with tiers (1,2,3, etc.) and cups and supercups, playoffs, etc. The .txt
version are pretty compact with "tight" / strict error checking and JSON, YAML
and friends I'd say it would be 2x, 3x or even more effort / typing. [1]:
[https://github.com/openfootball/world-
cup/blob/master/2018--...](https://github.com/openfootball/world-
cup/blob/master/2018--russia/cup_finals.txt) [2]:
[https://github.com/openfootball/clubs/blob/master/europe/bel...](https://github.com/openfootball/clubs/blob/master/europe/belgium/be.clubs.txt)
[3]:
[https://github.com/openfootball/leagues/blob/master/europe/l...](https://github.com/openfootball/leagues/blob/master/europe/leagues.txt)

~~~
xg15
I see what you mean. I agree, for a human editor with domain knowledge, those
files are easier to read and maintain than JSON. However, it's definitely
nontrivial to parse as a machine-readable format. If other projects are
supposed to consume the .txt files directly (i.e. not going through the
command-line utility), you should at least provide an EBNF grammar.

Example: I assume, the scorer lists are actually lists-of-lists, where
equivalent JSON could look like this:

    
    
      [
        {"player":"Gazinsky", "goals":[{"minute":12}]},
        {"player":"Cheryshev",

"goals":[{"minute":43}, {"minute":90, "overtime":1}]}, ... ]

... which is absolutely more verbose.

However, if someone just went by the data, they could get parsing wrong: It
looks like the outer list (of players) is delimited by spaces - however, there
are also spaces inside the player names. A better approach could be to split
the list by ' signs as each player has at least one time - however, players
can have more than one time and could probably also have apostrophes inside
their names (e.g. Irish players). So I guess, the best delimiter would be a
letter after an apostrophe after a number. Except, we might also have
parantheses, etc etc.

------
brokenkebab
I find it weird that Emacs is not present in "Tools" section, even while org-
mode mentioned several times in descriptions (as a compatibility) of other
tools.

------
tubbs
I recently just upped my StandardNotes subscription (the Black Friday ad is
still active), and I'm now locked in for ~5.5 years. It's a very plain-text
webapp/mobile app that aims to be simple and long-lasting, yet feature-full by
means of optional extensions. It's not perfect, but I've been using it for a
few months now without any data loss/major bugs encountered, and was excited
to use it to ditch Google Keep/Google Authenticator.

It's amazing what you can do with simple text, especially with a Markdown-
supporting editor.

~~~
philips
I tried to love standard notes but I had several times where note contents
were overwritten or missing between machines. I looked at the API for syncing
and it did not give me confidence.

Using pass + git now. Works great.

~~~
mobitar
Do you recall when this was? This kind of feedback is highly unusual for us.
Most users love SN precisely for its reliable sync. Our syncing engine
underwent large-scale changes in June/July of this year to solve an edge case
with opening out-of-date clients. If you experienced any issues after this
date with updated clients, I'd be very surprised, but would love to hear more
if you can spare a moment.

The only other issue we have heard of precisely one other time has to do with
Firefox pinned tabs + some assortment of Firefox browser extensions. To be
clear, any reproducible issues with syncing are 100% fixed as quickly as
possible.

Lastly, regarding our API for syncing, while our encryption specification is
described in plain text detail, you'd have to inspect our source to see how
syncing works.

~~~
jaydouken
Is it possible to use VIM as a text editor in the terminal with SN? Or are
users required to use a text editors supported by SN? This seems like an
application I'm looking for but I can't ditch my vimrc and plugins

~~~
ghewgill
Yes, you can use [https://github.com/tannercollin/standardnotes-
fs](https://github.com/tannercollin/standardnotes-fs) to edit your notes with
vim.

~~~
jaydouken
Wow, this might actually be what I need! Thanks!

------
kirubakaran
I use this plain text planner / calendar every day and I love it, if I can say
so myself, since I made it too. I've been using it for a few years now and I
can say that it has definitely made me more productive.

[https://crushentropy.com/](https://crushentropy.com/)

You can plan and log your day in plain text and it visualizes your schedule.

Markdown for planning, if you will.

~~~
Cub3
This is awesome, have been looking for something like this for a while,
wondering if there's a way to export it to and from my ical

~~~
kirubakaran
Thanks, I'd be happy to implement that. Can you please email me? My email is
in my profile.

------
jahbrewski
I really feel like this site should be in plain text.

~~~
hinkley
All I see is text and a few links. Are you claiming that typesetting doesn’t
count as plain text?

If so then what do you call books?

~~~
saagarjha
Books don't have links.

~~~
hinkley
Sometimes I forget that even HN has people who will happily argue about
absolutely anything.

 _Plain_ text is printed in a physical surface by mechanical or manual means,
but you don’t seem to have a problem with pixels.

Footnotes, figures, and bibliographies all refer to material out of time and
space. Frequently you had to bust ass to make use of them but they were there.
And they were replaced with something demonstrably better.

So you want a website about plain text with no hypertext at all where you have
to copy and paste URLs in order to get past the landing page, in order to have
a plain text experience. Maybe bullet journals should only be described in
bullet journals and embroidery instructions be embroidered onto fabric.

> some of you are thinking, “but John, you just said there’s no difference
> between geeks and nerds,” and to you I say, “shut up nerds.” - John Hodgeman

~~~
anamexis
The point is that this site is literally about plain text files, i.e. not
using a markup format or other adornments.

~~~
hinkley
We use other media to learn and talk about _every_ medium. So what?

You do at least recognize that you guys are bagging on OP, right?

Just let it go man. Vannevar Bush was essentially talking about hypertext (and
the semantic web) in the late forties. MIME types didn’t exist until decades
later. It’s a jargon term _and_ a concept, and the jargon term is often
rendered as a single word.

------
hprotagonist
not to be That Guy, but: all those things listed under each bullet are very
nearly just org-mode documentation chapter titles.

Org is very clearly Just Plain Text, but there is a nontrivial caveat, which
is "... backed by LISP, so text is also data is also code is also text". Most
of the real goodies (babel, refile, capture) will not (ever, probably) work
outside of emacs.

I agree that plain text is rad, though!

~~~
merlincorey
Furthermore, the templates provided are basically proto-org-mode syntax
probably re-invented by someone who has never seen org-mode in the first
place.

To me, that speaks to how natural much of (but certainly not all of) org-mode
syntax is.

------
yegle
Related: [https://plaintextaccounting.org/](https://plaintextaccounting.org/)

In particular, the beancount community is pretty strong, judging by the
frequency of posts in the mailing list and the Telegram group I'm in.

~~~
gen220
I’m going to smuggle in some hyperbole, but Ledger fundamentally changed the
way I view software. Other than programming languages and excel, there’s not
much other software I’ve used where the actual solution is consistently such a
short gap from my desire for a solution to exist. Good software should make
you feel more powerful every time you use it.

Ledger compelled me to see progressively structured but minimally verbose
“plain text”, as an input, as a large advantage with regards to barrier to
entry, provided you have excellent documentation, intelligent design that’s
close to the domain at hand, and copious examples for that structure.

Power users can dive deep into the syntax at will, and evolve a simple file
into a complex one at their own pace over time. Feature discovery is like
discovering a language, which makes sense, because you’re discovering how the
plain text you’re typing matches a parser, and how that parsed representation
maps to higher level concepts.

Meanwhile, my nontechnical friends are totally capable of keeping a ledger,
and reading the results with minimal assistance.

Learning software that’s been built this way is like learning a language; it’s
a challenge that’s tackled in stages and allows you to progress at your own
speed.

------
hsitz
I didn't see any mention of in a quick look through the linked website, but
the book "The Pragmatic Programmer" is one of the best resources you'll find
for making the most out of text-based tools. PP goes a little beyond that,
too, it's not the book's sole focus, but it's a major one, and the book is a
classic: [https://www.amazon.com/Pragmatic-Programmer-journey-
mastery-...](https://www.amazon.com/Pragmatic-Programmer-journey-mastery-
Anniversary/dp/0135957052)

~~~
oneepic
I agree, but I found some of the relevant practices really hard to adopt. For
example, how do you setup your tooling to put documentation in one place so it
can be used for a wide variety of purposes, like code comments and relevant
customer docs? Is that realistic from both the dev and user-facing
perspectives?

------
Emendo
Plain text is great when I am on my laptop, but not as well as soon as I want
to, for example, check or update my todo list on OneDrive/Google Drive on my
phone or on my work computer.

I have found myself moving back into proprietary formats like docx and xlsx
because of the above.

All I want is a folder full of markdown files (and other files that need to
stay in their original format), but I not could find a way to make it work on
mobile.

~~~
nixpulvis
Seems like there _should_ be an app that serves as an editor for you well
enough. The syncing problem is only a problem because Apple (I'm assuming your
on iOS, and I don't know as much about android) doesn't give you a fucking
filesystem.

I'd be pretty happy with something like ViMobile, and `git push` personally.

~~~
goerz
This situation has improved a lot within the last year. I'd highly recommend
trying out a combination of a-Shell (includes vim!), and WorkingCopy for git.
Both of these can access any folder in Files or any external file provider
(even outside of their sandbox). SecureShellFish is also great if you want to
interface with a server.

------
kickscondor
I keep a similar list of sites where you can host plain text or hypertext or
Web projects.

[https://href.cool/Web/Participate/](https://href.cool/Web/Participate/)

------
ggm
Except it's html. They didn't serve text/plain. I do get that thinking as
words helps but isn't org mode or markdown plaintext?

~~~
oneeyedpigeon
That would be text/markdown :) Although serving markdown as text/plain should
be totally fine if the client is a web browser. It would be incredibly useful
if web browsers rendered text/markdown natively, though - mine renders PDFs,
so I think the precedant's there.

~~~
ggm
I too would welcome this and text/org-mode

------
ImprovedSilence
I have a plain text file that’s basically my notes, bookmarks, how to write
ups and anything. I mark each section with hashtag labels, and set alias
vinfo=vim /path/info.txt. Anytime I need to reference back how to setup some
configuration, or the typical arguments for a command, or likes to YouTube
vids on my watch list, I just vinfo in, and /#<topic>. It’s the best system
I’ve used, and out lived all the Evernote’s, todo lists, stickies, whatever.
Dropbox or chron rsync it to where u want.

------
WalterBright
I used to store bookmarks in the browser. But they wouldn't survive changing
the browser, upgrading the browser, reinstalling the operating system, or
moving to another device. Besides, I didn't really want to share my bookmarks
with the browser vendor, every browser app vendor, and random web sites.

Now I just store them in a .txt file. My text editor recognizes URLs and I can
just click on them. Matching { } is also supported, which is all one needs for
a tree-style database.

~~~
bellweather49
> Matching { } is also supported, which is all one needs for a tree-style
> database.

Could you elaborate on this; maybe give an example?

------
ses4j
I never thought of plaintext as a way of life, but I think I agree with it in
principle (as many others on here probably do.) I didn't know I was part of a
movement, but I did write my own simple (and open source) hours
tracking/invoicing tool on plaintext principles:
[https://github.com/ses4j/ts](https://github.com/ses4j/ts)

------
preek
With organice[1], you have access Org mode without using Emacs. It is an
implementation of Org mode without the dependency of Emacs. It is built for
mobile and desktop browsers and syncs with Dropbox, Google Drive and WebDAV.

1\. [https://github.com/200ok-ch/organice/](https://github.com/200ok-
ch/organice/)

------
Nerada
Plaintext email is great too, cuts out a lot of superfluous junk.

[https://useplaintext.email/](https://useplaintext.email/)

~~~
zzo38computer
They do not list Heirloom-mailx, which is what I use. Heirloom-mailx uses a
command-line interface, uses plain text email, and does not use top posting.
It also supports entering pipe commands.

------
zzo38computer
I think many things can and should use plain text and yet they don't. Even,
with gopher you can easily have plain text files, and simple menus which could
be implemented by many different kind of user interface, you don't need to do
what they do HTML try to have desktop/mobile and then it doesn't work on
anything other than they expected it to be.

Many documents I will write plain text file, compatible with everything more
than HTML and Microsoft Word is. I also don't like WYSIWYG when I do want text
formatting.

I don't use favicon on my own server, and have it disabled on the browser. I
also think "Plain Text Project" uses too much CSS too. Just you can use plain
text. I don't want to use your large font sizes and narrow columns.

I use file with plain text for editing. Articles on Usenet and Unusenet too,
are written plain text sometimes also with headers, but the headers are also a
plain text just are more structured. Some programs have a different user
interface for adjusting the headers, but I just use them same as with the rest
of the text.

In addition to Usenet articles, there is many other thing that you can use a
plain text file for many other things. Depending what kind of data it is, you
might use just one string per line, or CSV or TSV, or JSON or YAML, or RDF
(RDF/XML isn't so good, but I think the RDF Turtle format is good), etc.

In many cases I wrote my own programs because I do not like the existing ones.

------
bloak
Assume "plain text" means something like traditional printed text. This has
three features which don't seem to be implemented on computers in a sensible
standardised way:

* Spaces. In traditional printed text there is space between words but there are no leading spaces, double spaces or trailing spaces, so the ASCII space character is not an adequate representation.

* Paragraphs. In traditional printed text you can start a new paragraph but you can't have an empty paragraph so '\n' is not an adequate representation. Then there's the problem that some systems use '\r' or "\r\n" instead of '\n'. Then there's the problem that Emacs's "long lines" mode and Git's --word-diff don't work properly. (Almost certainly patch tools and "git rebase" don't work either.)

* Emphasis. In traditional printed text words and phrases can be printed in italics for emphasis. There are several ways this can be indicated in a computer file, but do editors and diff tools handle them nicely? I think not. Also, it's not completely clear how this should work. For example, I don't think <em></em> should be allowed, but are <em>a</em><em>b</em> and <em>ab</em> the same thing, or different things? You wouldn't be able to tell them apart in traditional printed text, but in traditional printed text you can't tell whether a space, a full stop or a dash is printed in italics, or not, either, so it's clear, I think, that we need to somewhat extend the concept of emphasis from what's available in print, but how far do you extend it? (What about nested emphasis?)

~~~
marcthe12
That I believe in stuff like markdown. You usually need like 3 or 4 options

------
pletnes
Great find! But why on earth is there no mention of git, or the other VCSes?
IMHO they’re a huge reason for using plaintext for more purposes.

------
tabtab
I've been kicking around the idea of a plain-text GUI to demonstrate what a
"GUI Markup Standard" may work like. Making a graphics-enabled version is a
lot work for a demo.

VB-classic also had a text-based mouse-able GUI option for a short while, but
it never took off. It was based on ANSI escape sequences for DOS consoles,
which is sort of in-between "pure text" and graphics. A pure-text GUI is also
doable, but console approach is probably more compact because it can use
colors as cues instead of symbols.

An alternative or supplement to a markup standard is a text-based screen
designer. Both a pure-ASCII and console text UI can be defined using plain
text for semi-WYSIWYG designing. Rough example:

    
    
         $ Employee Edit Form
         * _thisLine.title
         $
         $ Last: [#last    ] First: [#firstname] MI: [#MI]
         * #last:fullname=last_name, required=true; #MI:fullanem=mid_initl
         $ 
         $    {#Save}    {#Cancel}   {#Other}
         * #Save:click=_thisForm.submit; #Cancel:click= _thisForm.close
         * #Other:click=specialProcedureX(), display="Other Options"
    

Symbols and conventions:

    
    
         $ = start of template line
         * = start of definition or command line
         [...] = input widget template
         {...} = button template
         # = start of reference name. 
         "fullName=" = use if actual database name is diff from reference name
         ; = definition or command separator
         "type=" = to define widget type, such as SELECT (not shown)
         "display=" use if actual label is different from reference label

Notes: "type=label" can be used to make bold or italics. The definition
line(s) don't have to follow the template lines in most cases. One can thus
optionally put most definition lines at the bottom. It may make interpreting
the template easier for some people.

~~~
hinkley
Interactive shell libraries exist. They are quite common for Unix oriented
tools. Might be possible to reimplement the same API for a GUI

~~~
tabtab
An example product? Note that I was talking about two different things: a GUI
markup standard (probably XML based), and an ASCII WYSIWYG GUI designer. I'll
make the distinction clearer in an edit.

------
rhardih
I can recommend [https://jrnl.sh](https://jrnl.sh) for a minimal plaintext
journal.

------
marcg
Plain text is best text. Word format is the worst when it comes to rendering
from, say, legal docs to web copy, or any other hidden characters.

I came here to voice my support for PlainTasks plugin for Sublime, and found
myself disappointed that the author skips over the gold standard in modern
text editors... Sublime Text.

------
anderspitman
I love plain text, and generally agree with the principles here.

That said, I think it's important to remember that plain text is still a
binary format under the hood. Its power comes from its simplicity and many
independent implementations. There's a lesson there for designing software in
general, especially APIs and protocols.

I also think it's somewhat unfortunate that breaking changes were made to the
plain text "API" along the way, in the form of Unicode. Unicode is great, but
I wish it wasn't conflated so much with the original plain text. Plus it adds
significant complexity. Sure, you can view a plain text file from 1991 in
today's editors, but you can't view a Unicode file in an editor from 1991. And
it's not apparent to the user why that is.

~~~
jedimastert
Wasn't Unicode made to be kind of backwards-compatible with ASCII? If you
stick to the ascii subset of unicode characters then it should be exactly the
same, and if you don't then there's no good way to convert it back to ascii
anyways.

------
reggieband
When I'm not using a custom tool I tend to fallback on two (or three)
alternatives:

* Markdown-ish in a text editor

* Google Doc

* Google Sheets

The first is for any quick notes I need to take or anything that might turn
into a code checkin, confluence page, etc. The second is for anything I think
I'll have to share and may want collaborators. The third is for almost
everything else.

I feel I disagree with a lot of people in the rest of the comments. I think
plain text in general is a major pain to deal with. I recall several years ago
having to deal with CSV parsing and I was aghast at how complicated that is to
get "correct". Give me highly structured data formats please. I'll take yaml,
toml, JSON or even XML over CSV, TSV or plain text at pretty much every
opportunity.

~~~
gnud
CSV is fairly OK if you just ignore Excel. Unfortunately, if you're working
with others, they won't let you ignore Excel.

------
gojomo
And yet, the site uses a favicon of a typewriter
([https://plaintextproject.online/favicon.png](https://plaintextproject.online/favicon.png)).
It's so hard to be pure in this world!

~~~
msla
It's something I don't like about what programmers tend to mean when they say
plain text: Plain text isn't the same as ASCII. It isn't the same as Latin-1
or some other eight-bit encoding. UTF-8 is plain text. UTF-16 is plain text,
too, but UTF-8 is better to use on the Internet.

My point is that you can go well beyond the Latin alphabet and still be in the
world of plain text. You can have correct quotes, as opposed to the
apostrophe-quotes typewriters saddled us with, and still be producing plain
text. There's nothing inherently "fancy" about using the writing systems most
of the people on Earth are fluent in, and, thanks to Unicode, there's many
fewer compatibility problems.

~~~
peterbhnews
You say this but I bet most of the people who style themselves plain text
purist _really do mean ASCII_.

------
lwhsiao
Does anyone know of a system for managing contacts in plain text? I would love
some CLI I could use to fuzzy search contacts, making it easy to grab info to
my clipboard for using email clients like mutt or aerc.

~~~
test_user_123
I don't know of an existing system, but you could look into constructing
something using FZF and a plain text file of contacts names and email
addresses formatted in a specific way.

[https://github.com/junegunn/fzf](https://github.com/junegunn/fzf)

------
hollerith
That’s nice I guess, but doesn’t address my main wish around text: that I will
continue to be able to read textual email from my friends without using a full
browser engine.

------
ngcc_hk
I switch to bear as it is text based with tag. I think similar text based and
Cli would be useful and may be better than using a too specific And structured
format.

------
MontagFTB
I use TaskPaper synced via Dropbox to achieve a level of organization across
my tasks, notes, and deadlines:
[https://www.taskpaper.com/](https://www.taskpaper.com/)

The beauty of it is that I have a GUI when I want it, but at the end of the
day it's all stored as plain text, so I'm not bound to the GUI and can fall
back to any text editor effortlessly.

------
thanatropism
I use Wordpress.com for blogging and its wizzy-wig editor because it gives me
a rough visual estimate of how long my text really is. It’s a perfectly stupid
reason and totally inadequate for the level of tech-savvy I’m supposed to
have. Or maybe it’s just that the heavy crufty web editor was developed for a
purpose and is good at it.

------
gtzi
I'm a fan of Writeroom for Mac
([http://www.hogbaysoftware.com/products/writeroom](http://www.hogbaysoftware.com/products/writeroom)).

------
whatever_dude
Nice to see Joplin in the list. It's a note-taking app, sorta like an open-
source Evernote, and one of the _main_ reasons why I use it is indeed because
it's plain text (markdown) only.

------
tannhaeuser
You should definitely add SGML to your list of tools. SGML can turn plain-text
files into markup (HTML) documents using your own custom rules (via short
references).

------
agsilvio
Plain text is the cornerstone of my b brainstorming app at jumproot.com. there
are other tools too but it all starts with plain text.

~~~
Madeindjs
A saas product is the oposite of a plaintext file..

------
miguelmota
Related: [http://motherfuckingwebsite.com](http://motherfuckingwebsite.com)

~~~
nathcd
Alright now everybody, please, resist the urge to post the shitty copycat
sites that are always posted after motherfuckingwebsite.com. You can do it!

------
sktrdie
This is the most hipster project I've ever seen.

