←

PLAINTEXT

Software should be legible.

A manifesto for readable, auditable, deliberately plain tools.

[01] The Manifesto

We build in the terminal. We read in the terminal. We debug in the terminal. Yet most of our tools pretend they are anything but text.

PLAINTEXT is a developer toolkit that embraces plaintext as a first-class citizen. No hidden state. No opacity. No design debt masquerading as interface.

Every command is a sentence. Every output is a table or a diagram you can read, copy, pipe, and understand. We render in monospace because that is where software lives. We use color sparingly because contrast is legibility1. We reject fancy animations because engineers have deadlines.

This is not nostalgia. This is engineering.

[02] Core Principles

  1. Legibility over aesthetics. If you cannot read it plainly, it is not finished.
  2. Plaintext as source of truth. Every configuration, state, and log is human-readable text. No binary blobs2.
  3. Piping over clicking. Unix philosophy: small, composable tools that do one thing well.
  4. Auditable by default. Your software is your responsibility. Make it inspectable in five minutes.
  5. Monospace is orthogonal. System fonts, consistent metrics, no surprises across platforms.

[03] Release History

Version Release Date Notes
2.1.0 2026-07-15 Add plaintext log export; fix pipe buffering in daemon mode.
2.0.5 2026-06-22 Deprecate JSON output flag. Use ASCII tables only.
2.0.0 2026-05-01 Rewrite core in plain C. Remove all external dependencies.
1.8.2 2026-03-14 CLI now parses config from plaintext TOML. No JSON.
1.5.0 2026-01-20 First stable release. Core audit toolkit launched.

[04] System Architecture

┌────────────────────────────────────────────────────────┐
│                    PLAINTEXT RUNTIME                     │
├────────────────────────────────────────────────────────┤
│                                                         │
│  ┌───────────┐    ┌───────────┐    ┌──────────────┐   │
│  │   Shell   │───▶│ Lexer &   │───▶│ Audit Engine │   │
│  │ Interface │    │ Parser    │    │              │   │
│  └───────────┘    └───────────┘    └──────────────┘   │
│       ▲                                      │         │
│       │                                      ▼         │
│       │            ┌──────────────────────────────┐    │
│       │            │  Plaintext Config Store      │    │
│       └────────────│  (TOML, no serialization)    │    │
│                    └──────────────────────────────┘    │
│                              │                         │
│                              ▼                         │
│                    ┌──────────────────┐               │
│                    │ ASCII Table &    │               │
│                    │ Diagram Renderer │               │
│                    └──────────────────┘               │
│                                                         │
└────────────────────────────────────────────────────────┘

[05] CLI Specimen

Every PLAINTEXT command is readable. Here is an audit routine:

$ plaintext audit --config config.toml --output report.txt

PLAINTEXT AUDIT REPORT
Generated 2026-07-21 16:42:03 UTC

┌─────────────────────────────────────────────┐
│ SCAN: src/                                  │
├─────────────────────────────────────────────┤
│ Files analyzed: 847                         │
│ Lines of code: 58,340                       │
│ Cyclomatic complexity (avg): 3.2            │
│ Undocumented functions: 12                  │
│ Binary dependencies detected: 0             │
└─────────────────────────────────────────────┘

LEGIBILITY SCORE: 94/100

Issues:
  [WARN] Function parse_json lacks comments (line 342)
  [INFO] Consider breaking parse_table into smaller units

Output written to report.txt

[F] Footnotes

1 We use a single accent color (#d24b16, rust orange) for warnings and highlights. Everything else is black on warm paper or white on dark. Deliberate, not arbitrary.
2 Configuration is stored in human-readable TOML. Logs stream as plaintext. Audit trails are tables you can grep. No hidden metadata, no opaque formats, no surprise complexity.