Como criar textos `.txt` no estilo clássico de documentação Unix

Um guia prático para transformar Markdown, documentos técnicos, histórias, manuais e textos longos em arquivos .txt bonitos, legíveis e com cara de documentação clássica de terminal.

1. O que é esse estilo de texto?

Você provavelmente já viu arquivos assim pela internet:

INTRODUCTION
============

This is a long technical document formatted as plain text. The lines are
manually wrapped so they fit nicely inside an old terminal window, usually
around 72 to 80 columns wide.

1.1 Basic idea

  - plain text
  - fixed-width font
  - manual line wrapping
  - simple headings
  - readable in terminals, browsers and old editors

Esse tipo de documento parece simples, mas não é bagunçado. Ele segue uma tradição muito forte de documentação Unix, RFCs, manuais de software, HOWTOs, arquivos README antigos, zines digitais, ficção hacker, BBS, Gopher, Gemini e textos distribuídos em .txt.

A lógica é:

• usar texto puro;
• limitar as linhas a 72, 76, 78 ou 80 colunas;
• usar fonte monoespaçada;
• criar títulos com sublinhados simples;
• preservar compatibilidade máxima;
• evitar dependência de HTML, CSS, PDF ou editores específicos.

É feio para quem espera design moderno. É bonito para quem entende durabilidade digital.

2. Por que 72 a 80 colunas?

A largura de 80 colunas vem da tradição de terminais antigos. Muitos terminais exibiam 80 caracteres por linha. Por isso, documentação técnica era escrita para caber bem nesse espaço.

Mas usar exatamente 80 nem sempre é o melhor. Na prática:

Minha recomendação: use 76 colunas.

É largo o bastante para não quebrar demais e estreito o bastante para ficar elegante em terminal, navegador e editor de texto.

3. Ferramentas principais

Você não precisa de uma ferramenta obscura para fazer isso. O caminho mais prático hoje é:

Markdown -> Pandoc -> TXT formatado

Além disso, existem ferramentas auxiliares:

4. Instalando as ferramentas

Debian, Ubuntu e derivados

sudo apt update
sudo apt install pandoc coreutils par

O pacote coreutils geralmente já vem instalado e inclui ferramentas como fmt e fold. Mesmo assim, deixar no comando não machuca.

Fedora

sudo dnf install pandoc coreutils par

Arch Linux

sudo pacman -S pandoc coreutils par

macOS com Homebrew

brew install pandoc par

Windows

No Windows, o caminho mais limpo é usar uma destas opções:

1. instalar o Pandoc pelo instalador oficial;
2. usar WSL com Ubuntu/Debian;
3. usar Git Bash ou MSYS2 para ferramentas Unix.

Com WSL:

sudo apt update
sudo apt install pandoc coreutils par

5. Criando um documento em Markdown

Crie um arquivo chamado manual.md:

# Runv.Club Manual

Runv.Club is a small pubnix for shell accounts, static pages, weird
experiments, personal tools and quiet internet infrastructure.

## Services

The instance provides a few basic services for members:

- shell account
- static web hosting
- email
- IRC community
- small terminal toys
- personal garden

## Philosophy

The goal is not to become a giant platform. The goal is to preserve a small,
readable and human-scale corner of the internet.

Esse Markdown é normal. Nada especial.

A mágica vem na conversão.

6. Convertendo Markdown para .txt com Pandoc

Para gerar um arquivo .txt com 76 colunas:

pandoc manual.md -t plain --columns=76 -o manual.txt

Para 80 colunas:

pandoc manual.md -t plain --columns=80 -o manual.txt

Para 72 colunas:

pandoc manual.md -t plain --columns=72 -o manual.txt

A opção mais importante é esta:

--columns=76

Ela define a largura usada pelo Pandoc ao gerar texto puro.

7. Visualizando o resultado

Use:

less manual.txt

Ou:

cat manual.txt

O less é melhor para documentos longos.

Dentro do less:

q       sair
/seta   navegar
/termo  buscar por um termo

8. Verificando linhas longas

Para encontrar linhas com mais de 76 caracteres:

awk 'length($0)>76 { print NR ": " length($0) " chars: " $0 }' manual.txt

Para verificar limite de 80 caracteres:

awk 'length($0)>80 { print NR ": " length($0) " chars: " $0 }' manual.txt

Se o comando não retornar nada, ótimo: nenhuma linha passou do limite.

Mas atenção: linhas com URLs, caminhos de arquivo e blocos de código podem passar do limite. Isso nem sempre é erro. Às vezes é melhor preservar a URL inteira do que quebrá-la de forma horrível.

9. Reformatando um .txt já existente com fmt

Se você já tem um texto simples em .txt, pode usar fmt.

Exemplo:

fmt -w 76 entrada.txt > saida.txt

Ou:

fmt -w 80 entrada.txt > saida.txt

O fmt tenta respeitar parágrafos. Ele é bom para texto corrido.

Exemplo de entrada:

Este é um parágrafo muito longo que foi escrito em uma única linha e precisa ser quebrado de forma decente para caber em uma largura fixa de terminal.

Depois de:

fmt -w 76 entrada.txt > saida.txt

A saída fica parecida com:

Este é um parágrafo muito longo que foi escrito em uma única linha e precisa
ser quebrado de forma decente para caber em uma largura fixa de terminal.

10. Quando usar fold

O fold é mais bruto que o fmt.

fold -s -w 76 entrada.txt > saida.txt

A opção -w 76 define a largura.

A opção -s tenta quebrar em espaços, não no meio das palavras.

Use fold quando você quer apenas forçar a quebra de linhas. Para texto literário ou documentação, prefira fmt ou Pandoc.

Diferença direta:

fmt  = entende melhor parágrafos
fold = quebra linhas de forma mais mecânica

11. Usando par

O par é uma ferramenta clássica para formatar parágrafos em terminal.

Instalação:

sudo apt install par

Uso básico:

par 76 < entrada.txt > saida.txt

Ele é útil para textos com indentação, citações e blocos de e-mail.

Exemplo:

par 72 < notas.txt > notas-formatadas.txt

O par é poderoso, mas não precisa ser sua primeira escolha. Para a maioria dos casos, pandoc e fmt resolvem.

12. Criando títulos no estilo clássico

Em Markdown, você escreve:

# Introduction

## Installation

### Basic usage

Na saída em texto puro, o Pandoc pode transformar em algo parecido com:

Introduction
============

Installation
------------

Basic usage

Esse estilo é antigo, simples e muito legível.

Você também pode escrever manualmente em .txt:

INTRODUCTION
============

Installation
------------

Use com moderação. Se tudo está em caixa alta, nada se destaca.

13. Estrutura recomendada para documentação técnica

Um bom documento .txt clássico pode seguir esta estrutura:

TITLE
=====

1. Introduction

2. Requirements

3. Installation

4. Configuration

5. Usage

6. Troubleshooting

7. References

Em Markdown:

# Title

## 1. Introduction

## 2. Requirements

## 3. Installation

## 4. Configuration

## 5. Usage

## 6. Troubleshooting

## 7. References

Depois converta:

pandoc document.md -t plain --columns=76 -o document.txt

14. Estrutura recomendada para histórias e ensaios

Para textos literários, histórias ou ensaios, não exagere na estrutura técnica.

Exemplo:

# The Last Terminal

There was still one machine running in the basement.

Nobody remembered who installed it. Nobody remembered why it mattered. But
once a week, someone would log in, read the system mail, clean the old logs and
leave a short note in `/var/local/diary`.

## I. The Login

The prompt appeared after three seconds.

That was the first strange thing. Old machines were supposed to be slow. This
one felt patient instead.

Converter:

pandoc historia.md -t plain --columns=76 -o historia.txt

Resultado: texto com cara de arquivo encontrado em algum canto empoeirado da internet. Exatamente o charme.

15. Criando um script simples de conversão

Para não digitar o comando sempre, crie um script chamado md2txt-classic:

mkdir -p ~/bin
nano ~/bin/md2txt-classic

Cole:

#!/usr/bin/env bash
set -euo pipefail

if [ "$#" -lt 1 ]; then
  echo "Uso: md2txt-classic arquivo.md [largura]"
  echo "Exemplo: md2txt-classic manual.md 76"
  exit 1
fi

INPUT="$1"
WIDTH="${2:-76}"
OUTPUT="${INPUT%.*}.txt"

pandoc "$INPUT" -t plain --columns="$WIDTH" -o "$OUTPUT"

echo "Gerado: $OUTPUT"
echo "Verificando linhas maiores que $WIDTH caracteres..."
awk -v w="$WIDTH" 'length($0)>w { print NR ": " length($0) " chars" }' "$OUTPUT" || true

Dê permissão de execução:

chmod +x ~/bin/md2txt-classic

Se ~/bin ainda não estiver no seu PATH, adicione ao ~/.bashrc ou ~/.zshrc:

export PATH="$HOME/bin:$PATH"

Recarregue o shell:

source ~/.bashrc

Agora use:

md2txt-classic manual.md

Ou com largura específica:

md2txt-classic manual.md 80

16. Criando um Makefile

Para projetos maiores, use um Makefile.

Crie um arquivo chamado Makefile:

TXT_WIDTH = 76
SRC = manual.md
OUT = manual.txt

all: txt

txt:
	pandoc $(SRC) -t plain --columns=$(TXT_WIDTH) -o $(OUT)

check:
	awk 'length($$0)>$(TXT_WIDTH) { print NR ": " length($$0) " chars: " $$0 }' $(OUT)

view:
	less $(OUT)

clean:
	rm -f $(OUT)

Uso:

make
make check
make view
make clean

Isso é especialmente bom se você quer manter um repositório com arquivos .md e gerar .txt sempre que precisar.

17. Fluxo de trabalho recomendado

O fluxo mais limpo é este:

1. Escreva em Markdown.
2. Converta com Pandoc usando --columns=76.
3. Verifique linhas longas com awk.
4. Leia com less.
5. Publique o .txt.

Na prática:

pandoc texto.md -t plain --columns=76 -o texto.txt
awk 'length($0)>76 { print NR ": " length($0) " chars: " $0 }' texto.txt
less texto.txt

18. O que evitar

Evite estas besteiras:

1. Quebrar tudo com fold sem revisar

fold pode destruir blocos de código, URLs e tabelas.

2. Usar fonte proporcional para revisar

Revise em fonte monoespaçada. Caso contrário, você não vai perceber alinhamento errado.

3. Fazer tabelas complexas demais

Tabela em .txt é possível, mas tabelão complexo vira sofrimento.

Prefira:

Name        Role
----        ----
runv        pubnix
nyx         server
skull       vps

Evite tabelas gigantes com 12 colunas.

4. Quebrar URLs manualmente

URLs quebradas são irritantes. Melhor deixar uma URL passar de 76 colunas do que torná-la inútil.

5. Confundir .txt bonito com falta de estrutura

Texto puro não significa texto relaxado. Na verdade, como você não tem CSS, sua estrutura precisa ser melhor.

19. Exemplo completo

Crie example.md:

# Plain Text Publishing

Plain text is not primitive. It is durable.

A well-formatted text file can be opened in a terminal, sent by email, mirrored
in a repository, indexed by search engines, printed, archived and read decades
later without requiring a specific application.

## Recommended width

For most documents, 76 columns is a good default. It preserves the old terminal
feeling without making the text too cramped.

## Tools

Use Pandoc for conversion, fmt for simple paragraph rewrapping and awk for line
length checks.

Converta:

pandoc example.md -t plain --columns=76 -o example.txt

Veja:

cat example.txt

Saída aproximada:

Plain Text Publishing
=====================

Plain text is not primitive. It is durable.

A well-formatted text file can be opened in a terminal, sent by email,
mirrored in a repository, indexed by search engines, printed, archived and
read decades later without requiring a specific application.

Recommended width
-----------------

For most documents, 76 columns is a good default. It preserves the old
terminal feeling without making the text too cramped.

Tools
-----

Use Pandoc for conversion, fmt for simple paragraph rewrapping and awk for
line length checks.

20. Publicando na web

Um .txt pode ser publicado diretamente em um servidor web.

Exemplo com Nginx:

/var/www/html/manual.txt

Acesse:

https://example.com/manual.txt

Se quiser servir com tipo correto:

location ~ \.txt$ {
    default_type text/plain;
    charset utf-8;
}

Mas na maioria dos casos, o servidor já entrega .txt como text/plain.

21. Criando uma pequena coleção de textos

Estrutura simples:

texts/
├── source/
│   ├── manual.md
│   ├── manifesto.md
│   └── story.md
├── dist/
│   ├── manual.txt
│   ├── manifesto.txt
│   └── story.txt
└── Makefile

Makefile:

TXT_WIDTH = 76
SRC_DIR = source
OUT_DIR = dist
SOURCES = $(wildcard $(SRC_DIR)/*.md)
OUTPUTS = $(patsubst $(SRC_DIR)/%.md,$(OUT_DIR)/%.txt,$(SOURCES))

all: $(OUTPUTS)

$(OUT_DIR)/%.txt: $(SRC_DIR)/%.md
	mkdir -p $(OUT_DIR)
	pandoc $< -t plain --columns=$(TXT_WIDTH) -o $@

check:
	@for f in $(OUTPUTS); do \
		echo "Checking $$f"; \
		awk 'length($$0)>$(TXT_WIDTH) { print FILENAME ":" NR ": " length($$0) " chars" }' $$f; \
	done

clean:
	rm -f $(OUT_DIR)/*.txt

Gerar tudo:

make

Verificar tudo:

make check

22. Receita curta

Se você só quer o comando e acabou:

pandoc entrada.md -t plain --columns=76 -o saida.txt

Para revisar:

awk 'length($0)>76 { print NR ": " length($0) " chars: " $0 }' saida.txt
less saida.txt

Para reformatar .txt simples:

fmt -w 76 entrada.txt > saida.txt

23. Conclusão

O jeito mais inteligente de criar textos .txt clássicos hoje é não escrever tudo manualmente em .txt desde o começo.

Escreva em Markdown, que é confortável e estruturado. Depois gere a versão final em texto puro com Pandoc.

A combinação ideal é:

Markdown para autoria
Pandoc para conversão
76 colunas para estética clássica
awk para auditoria
less para leitura final

Esse formato é simples, portátil e resistente. Não depende de plataforma, editor, navegador moderno ou layout quebradiço. Um bom .txt é quase infraestrutura cultural: pequeno, legível e difícil de matar.