About Designly
Markdown in.
Design out.
Designly turns structured Markdown into publish-ready carousels, quote cards, code images and thumbnails — in one paste, entirely in your browser.
It does not write your content. You bring that from whichever model you already use. Designly does the part that comes after.
The bottleneck moved, and the tools didn’t.
For most of the last decade, the hard part of publishing was the writing. That changed almost overnight. An LLM will now draft a decent post in the time it takes to describe one, and the supply of competent text has gone effectively infinite.
What did not change is what happens next. Good text is not something worth posting. Between the two sits a job that is entirely visual — hierarchy, restraint, type that holds together at thumbnail size, nine slides that don’t look like the same slide nine times. That job used to be hidden behind the writing. Now it is the whole bottleneck, and it is the part nobody automated.
Everyone can write now. The gap between good text and something worth posting is still design.
The tools that exist sit at two extremes. Figma will do anything, which means it asks you to make every decision — a fine trade if design is your job, a terrible one if you just want to ship a post before lunch. Template galleries ask you to make none, which is why their output is recognisable at a glance: the same frame, the same rhythm, someone else’s taste worn as a costume.
Designly takes the third position. You keep the decisions that are actually yours — what you’re saying, and what your brand looks like. It takes the ones that are mechanical: how this particular content wants to sit on the slide, where the type has to step down so nothing clips, how much air a nearly-empty card needs before it stops looking stranded. That is a narrow enough problem to solve properly, and wide enough to be worth solving.
Six stages, one direction, no surprises.
What happens between your paste and your export is a pipeline — six pure steps, each one a function of the step before it, none of them reaching backwards. That structure is not incidental. It is why the same Markdown always produces the same deck.
Only one of the six has an opinion. The rest are plumbing.
Nothing here rolls dice. The composition is derived from what is on the slide, because a regenerate button that behaves like a slot machine is a button you stop trusting on the third press. Identical content composes identically — not by seeding a generator, but because there is no generator to seed.
parse
pureMarkdown → mdast
Your text is read as a document tree. Standard, boring, well-understood — this part is a solved problem and we treat it like one.
normalize
puremdast → Block[]
The document tree is flattened into our own vocabulary of blocks: headings, quotes, lists, code. This is also where things get inferred — a bold number beside a short label stops being a paragraph and becomes a stat; a quote that opens with “Note:” becomes a callout. Markdown has no syntax for either. That inference is why plain LLM output arrives already looking designed.
segment
pureBlock[] → Section[]
Blocks are grouped into slide-sized chunks. A slide is a thought, not a character count.
deck
pureSection[] → DeckCard[]
The closing card is appended, the deck is capped to whatever the format holds, and each card is matched to a template — the deck’s, unless you picked one for that card specifically.
compose
the taste lives hereDeckCard → composition
The opinionated step, and there is only one renderer behind it. The card measures what is actually on the slide — how many blocks, of what kinds, how long — and composes accordingly. A title with nothing under it becomes a poster. A two-column table sitting alone becomes a comparison. The same table among four paragraphs stays a table, because there it is evidence rather than the point. Nothing upstream decided any of that; the card looked.
render
purecomposition → PNG · SVG · PDF
Fixed-dimension React, captured at 3× against an unscaled clone. Anything that won’t fit is caught before it renders — the type steps down rather than clipping. What you export is what you designed, not a screenshot of a preview.
Private by construction, not by policy.
Most products handle this with a promise. They collect your work, store it somewhere, and publish a document explaining the circumstances under which they won’t look at it. The promise may well be sincere. It is still a promise, and promises are only as durable as the company holding them, its next funding round, and its next breach.
Designly makes a structurally different claim. Your content never leaves your device — not because we chose not to look, but because there is nowhere for it to go. The parser, the card, the renderer and the exporter are all JavaScript running in your tab. Close it and nothing remains anywhere but your own machine.
- Servers your content touches
- 0
- There is no backend to send it to.
- Accounts required
- 0
- Nothing to sign up for, nothing to delete.
- Analytics and tracking scripts
- 0
- We don’t know what you made, or that you made it.
- Network requests on paste
- 0
- Parsing, layout and export all run on your machine.
The honest caveat, since this section is about honesty: your draft, your images, and your settings are saved to IndexedDB — and your theme to localStorage, which has to be read before the first paint so the page doesn’t flash the wrong colour at you. Both are your browser’s storage on your own disk: we can’t read either, and clearing your site data ends them permanently.
The safest place for your unpublished work is the machine it’s already on.
Built by one person.
Designly is designed and built by Deepak Kumar. It started as a tool for a problem I had — good drafts, no patience for the design step, and no interest in the output looking like a template. It turned out other people had the same problem, so it became this.
One person building it is why it has opinions. There is no committee to average them out.