Monodraw

Every codebase older than a year has one: a comment block where someone tried to draw the request flow with hyphens and pipes, gave up halfway, and left a lopsided box pointing at nothing. ASCII diagrams are among the most useful documentation a developer can write and among the most miserable to maintain. Move one box three columns to the right and you’re redrawing every line that touched it, one character at a time.

Monodraw, from the small developer Helftone, exists to end that ritual. It’s a dedicated editor for diagrams, flowcharts, layouts and banners built entirely from plain-text characters. You draw with real objects (rectangles, connectors, text blocks) on an infinite canvas, and Monodraw renders them into a character grid. You can copy that grid into a source file, a Markdown README, an email, a commit message or a terminal. The output is just text. That’s the entire pitch, and it’s sharper than it first sounds.

The obvious question today is why anyone needs this when GitHub and most documentation platforms render Mermaid diagrams natively. The answer is reach. Mermaid needs a renderer. A header comment in a C file, a --help screen, a man page, a plain-text email, a code review in a terminal: none of those render anything. ASCII displays everywhere without help. Monodraw targets the places diagrams-as-code can’t follow.

Its market position is deliberately narrow. Free browser tools like ASCIIFlow cover casual sketching, and general-purpose diagram apps like OmniGraffle and draw.io cover everything else. Monodraw sits between them. Simon Willison’s description of it as “basically OmniGraffle for ASCII art” is the most accurate one-line summary in circulation. It costs a one-time $9.99, offers a free trial, and requires a reasonably current version of macOS. It runs only on the Mac, a constraint that shapes almost everything else in this review.

• Attachment-aware lines: Lines snap to attachment points on shapes, so when you drag a box, its arrows follow. Connectors can run orthogonally or in staircase steps, with custom dash patterns. This one feature is what separates an ASCII drawing from an ASCII diagram.
• Real shape objects on an infinite canvas: Rectangles support borders, backgrounds and shadows. A CoreText-based text engine controls alignment and line direction. Pencil, eraser, bucket fill and picker tools handle freehand work.
• Crow’s Foot notation: Three variants of the standard cardinality notation make Monodraw a credible tool for sketching database schemas directly in a migration file or design doc.
• Built-in FIGlet engine: It ships with a large library of banner fonts and accepts custom ones, which covers CLI splash screens, log headers and section dividers.
• Organization tools: You get groups, alignment guides, a focus mode that locks or hides shapes, and image overlays for tracing a whiteboard photo or mockup.
• Keyboard-first control: Every function has a keyboard shortcut.
• Export and automation: It exports plain text, PNG and SVG. The version sold on Helftone’s website adds a command-line tool with JSON output, which the Mac App Store version lacks.

The Core Loop: Draw Objects, Ship Characters

Monodraw is built on a split between what you manipulate and what you ship. On screen you work with objects. A rectangle knows it’s a rectangle, an arrow knows which two shapes it connects, and a text block knows its alignment. On export, all of that collapses into a grid of characters. That separation is what makes the app worth paying for. A hand-typed diagram is dead the moment it’s committed. A Monodraw diagram stays editable for as long as you keep the source document.

The payoff shows up the second time you touch a diagram. Consider a basic architecture sketch:

+--------+       +---------+       +----------+
| Client | ----> | Gateway | ----> | Postgres |
+--------+       +---------+       +----------+

Inserting a cache layer between the gateway and the database by hand means counting hyphens, re-padding boxes, and inevitably misaligning a corner. In Monodraw you drag the database box right, drop in a new rectangle, and the connectors reroute themselves. This is the feature the app is built around, and for good reason. It turns maintenance from a rewrite into an edit, and an edit is cheap enough that people will actually make it.

Precision Versus Expression

The toolset divides cleanly into structured and freehand tools. Rectangles, lines and text are the structured side, and that’s where the app is strongest. The staircase line option deserves particular credit. Orthogonal connectors are tidy but produce long detours in dense layouts, while stepped diagonals give a more compact route without leaving the grid. Custom dash patterns let you encode meaning, such as dotted for async calls and solid for sync, without a legend that eats half the canvas.

The freehand tools (pencil, eraser, bucket fill, picker) make Monodraw a passable ASCII art program for the occasional logo or illustration. They’re competent, but they aren’t the reason to buy. Nobody buys this app for its pencil.

The FIGlet engine is the pleasant outlier. With a large set of built-in banner fonts plus custom font support, producing the big block-letter headers that CLI tools print on launch takes seconds. It isn’t essential, but developers who build command-line tools will likely use it constantly.

Crow’s Foot support is the most quietly ambitious feature. ER diagrams usually live in heavyweight modeling tools. Three variants of the notation in a text-diagram editor mean a schema can be documented right beside the SQL that defines it. Schema documentation is notorious for drifting out of date, and keeping it in the same file gives it a fighting chance.

Workflow and Interface Flow

Onboarding friction is minimal. The tool palette is small, the canvas is the obvious place to start, and the mental model (draw boxes, connect them, copy the result) is clear from the start. The Johnny.Decimal blog called it “a lovely little Mac app,” and “little” is doing honest work there. This is a focused utility, not a platform with ambitions.

It scales up through its organization tools. Groups and alignment guides keep larger diagrams coherent. Focus mode, which locks or hides shapes, solves a real problem in dense drawings, where clicking a label tends to grab the box underneath it instead. Image overlays let you trace a whiteboard photo or a design mockup, a clever bridge from meeting-room sketch to committed documentation. Because every function has a keyboard shortcut, practiced users can build diagrams almost as fast as they think. That matters, because the whole point is to make diagrams cheap enough that people bother to draw them.

The Edition Split and the CLI

Buyers need to understand one decision before paying. The command-line tool with JSON output ships only with the version sold on Helftone’s website, not the Mac App Store edition. A casual user won’t care. Anyone who wants to script diagram workflows or pipe structured output into other tooling loses the most extensible part of the product by buying through the App Store. Buy direct. The App Store’s convenience isn’t worth that trade.

The Team Problem

Monodraw’s output is universal, but its editing is not. A Windows or Linux colleague can open your README and read the diagram perfectly. They can even edit it, by hand, one character at a time. That is exactly the misery Monodraw was built to eliminate, and it disconnects the text from the structured source where the arrows still know what they’re attached to. In mixed-OS teams, diagrams tend to become the property of whoever owns a Mac. That isn’t a bug in the software. It’s a hard ceiling on its reach.

Monodraw looks the way a well-made native Mac utility should, with restrained chrome, a large canvas, and tools that stay out of the way until needed. The restraint suits the subject. When your output is monospace characters, decorative UI would just be noise.

The CoreText-based text engine handles character alignment and line direction precisely. That’s unglamorous, but everything else depends on it. An ASCII editor that misplaces a single column produces broken diagrams, and the grid discipline here is what should let output survive being pasted into other editors intact.

Zoom is the weak spot. It’s limited, and on an infinite canvas that hurts. Small diagrams are fine. Large system maps, exactly the diagrams that benefit most from structured editing, become hard to see as a whole, forcing panning instead of stepping back. An app built around a boundless canvas shouldn’t make the whole canvas so hard to view.

On performance, a character grid is a light workload for any Mac that meets the minimum system requirements, so this is not the kind of app that should strain hardware. PNG and SVG export help for slides or wikis that won’t preserve monospace formatting, though they undercut the plain-text premise. Treat them as an escape hatch, not a workflow.

Monodraw has no iOS or iPadOS version. It is a macOS app, with no Windows, Linux or web edition either.

For iPhone and iPad users, the relationship runs one way. Monodraw’s diagrams read fine on a phone wherever monospace is preserved, such as GitHub’s code view, a terminal app or a plain-text email. Width is the catch. Narrow screens punish any diagram that wraps instead of scrolling horizontally, so a diagram that looks crisp in a desktop README can break into fragments in a mobile mail client. Authors who expect mobile readers should keep their diagrams narrow.

Authoring on iPad isn’t possible. That’s a missed opportunity, since an Apple Pencil plus a hardware keyboard seems like a natural fit for box-and-arrow work. It’s also understandable. Monodraw’s dense shortcuts and precise grid manipulation are built for a Mac with a trackpad or mouse. A touch version would require rethinking the interaction model, not just recompiling it.

Monodraw is a niche product that knows exactly how big its niche is and serves it thoroughly. Its low profile and thin store-rating data reflect how specialized it is, not necessarily how good it is.

The attachment-aware connector system alone justifies the price. It turns ASCII diagrams from fragile one-off artifacts into documents that can be revised in seconds, and that changes whether developers draw them at all. The ER notation, FIGlet engine and focus mode show a developer who understands real documentation work rather than padding a feature list. The weaknesses are real: cramped zoom, a CLI withheld from App Store buyers, and a Mac-only editor whose diagrams travel everywhere it can’t. None of them undermine the core proposition, but they keep this a recommendation for a specific audience rather than a broad one. If you’re on a Mac and have ever redrawn an ASCII diagram by hand, the free trial should make the case quickly. Buy it from Helftone’s website, not the App Store.