PlanFacile(1)
π PlanFacile(1) β the Linux user manual, but make it a vibe π
okay bestie, so this is planfacile from the Linux user manual, and I'm gonna walk you through it like we're texting at 2am. no cap, it's actually kind of a slay once it clicks. π¦
β¨ NAME β¨
planfacile β literally just: a document compiler. that's the whole name. icon behavior. π
β¨ SYNOPSIS β¨
planfacile [options] [files]
that's it. options, then files, in that order. periodt. π
β¨ DESCRIPTION β¨
so PlanFacile is a document compiler, and its whole main character thing is computing a table of contents. like, that's the assignment. π
more precisely β and this is the part that lowkey rewires your brain β PlanFacile treats a document as a bunch of concepts that are linked together by dependencies. then it generates the document using those ideas, sorted so you can read it start to finish with the fewest possible cross references to later parts of the document. it's giving "put things in the right order so nobody has to flip ahead." obsessed. πβ¨
and heads up: PlanFacile only generates non-formated documents β stuff like HTML or LaTeX sources. it hands you the source, not the pretty rendered thing. that's someone else's job, bestie. π
β¨ BASIC GRAMAR β¨
(for real, if you just wanna use PlanFacile normally you do not need to learn the whole language. this section is the bare minimum to write a document. we're keeping it cute and keeping it short. π§)
π Document
Ideas
so, like we said: a document is a set of ideas the author wants to communicate to the reader. and one idea = one part of the document that can be represented by a title. so if you, the writer, notice that one title doesn't accurately represent the text of the same idea, you just gotta make sure you don't cram two concepts into one #idea command. simple. π
the syntax of an idea is genuinely so simple:
#idea{reference}title#text
text
#end
also, some ideas depend on each other inside one document, so they get linked by dependencies (go read the Dependencies paragraph, bestie, it's right there).
Automatic ideas
sometimes PlanFacile adds an idea to the document all by itself. when that happens, the writer can swap out the default text for an idea that actually suits the document. to do that there are two commands, and they work just like #idea:
#missing{index}{reference}title#text
text
#end
the index parameter is given by PlanFacile, in the default message... (iykyk, you'll see it)
and in the same way:
#generic{parent reference}{reference}title#text
text
#end
Dependencies
in a document with ideas about the same subject, it's super natural that some ideas need other ideas to be understood by the reader. that relation is what we call a dependency between ideas. π¦
so if the writer puts a dependency in the text of idea A pointing to idea B, that means the reader needs to understand idea B before reading idea A in order to understand idea A. it's giving prerequisites. no cap.
the syntax of a dependency, in its simplest form, is:
#dep{reference}{#depref}{}
but sometimes the writer needs to add a positive number to specify the weighting of the dependency β like if the organisation of the document isn't the right one even though the writer already put in the correct dependencies:
#dep{pertinence}{reference}{#depref}{}
the reference has to be one of the words used in the #idea command. that's the rule, don't fight it. π
π Complete source code
ideas alone are not enough to produce a document, bestie. to complete a source code, the writer needs to learn a lil bit more about the PlanFacile language. let's go. β¨
Standard
the first command of the source can be #standard, which tells PlanFacile to load standard definitions so it can produce a document in LaTeX or in HTML (more formats will be present in the future β they said it, not me π).
Options and macros
when the writer uses the #standard command, the compiler will be able to generate all formats. so the writer has to say which one they want, using some commands.
a choice, like the output format, gets set with an option:
#option{optionname}
and a text parameter gets set with a macro, for a very specific use:
#define{parametername}{value}
β¨ OPTIONS β¨
okay so PlanFacile uses 36 options to modify its behavior. listing all 36 here is honestly not interesting, because the -h option gives you help about all of them. go ask -h, it knows everything. π
some options are often useful though:
-ooutput file β specify the output file, to write the document ; βοΈ-Ooption β define a compiler option, exactly like the#optioncommand. so the user gets the possibility to set some parameters at the time of compilation ; π₯-dβ ignore invalid dependencies. useful when the writer wants to compile a part of a document to check if this part is error free ; π§-Aβ ignore undefined automatic ideas. sometimes PlanFacile adds some ideas to complete the document, and this option avoids an error when an automatic idea appears. π«Ά
β¨ SEE ALSO β¨
see also latex(1), xpdf(1), firefox(1), lynx(1). go read those too, bestie, they're the supporting cast. π
β¨ CONTACTS β¨
if you have a problem you can't solve by reading the documentation, or if you find a bug, you can send an email to planfacile@gmail.com and they will send a reply as quickly as possible. π«Ά they're nice like that.
reminder bestie: keep every command, reference, index and number exactly as written up there. copy-paste energy only, no improvising the syntax. the language is not the vibe, the document is. π
and that's the whole page, angel π β this was Version 2.0, dated 27/05/06, straight from the PlanFacile(1) page of the Linux user manual. mwah. πππΈ
π¦ where this page comes from
- ubuntu jammy: planfacile 2.0.070523-0ubuntu5
- π girlified by deepseek-ai/DeepSeek-V4.1-Flash on : a language model's rewrite of the original, under its terms