CSV, TSV, or pasted spreadsheet in — a clean, padded GFM table out
:--- left, :---: center, ---: right). Pipes inside your data are escaped automatically. The engine is markdown-table 3.0.4 — the same one the remark ecosystem uses — at 2.2 KB, running in this tab. A 3-column × 4-row uptime grid comes out as 249 bytes of perfectly aligned markdown.
| Delimiter cell | Effect | 4-char column “Left” | 6-char column “Center” |
|---|---|---|---|
--- | Left (the default) | | ---- | | | ------ | |
:--- | Left, explicit | | :--- | | | :----- | |
:---: | Center | | :--: | | | :----: | |
---: | Right | | ---: | | | -----: | |
The rule the engine follows: the delimiter row is padded to the same width as the column, and the colons count toward that width — a 6-character centered column gets :----: (colon, four dashes, colon). Data cells get one space of padding on each side of the widest value, which is why the output looks hand-aligned.
Three stages, all local. Your input is tokenized first: tabs are detected before commas (that's what a spreadsheet range copy produces), commas come next (real CSV, with quoted fields containing commas handled), then semicolons and pipes. Rows become arrays, short rows are padded, and cell text with a literal pipe is escaped to \| — the GFM escape — because a bare pipe would split the cell.
The arrays then go through markdown-table 3.0.4 (MIT), the table serializer from the remark ecosystem — the same code path that GFM tooling has leaned on for years. It measures every cell, widens each column to its longest value plus padding, builds the delimiter row from your alignment choices, and emits the pipes. It's 2.2 KB minified, vendored on this site, and runs on every keystroke.
Take a monitoring-tools grid — 3 columns, 4 rows (one header), the longest cell being "ToolAspect embeds" at 17 characters:
| What | Result |
|---|---|
| Output size | 249 bytes, 5 lines (header, delimiter, 3 data rows) |
| Column 1 width | 19 chars — 17 (longest cell) + 2 padding |
| Delimiter row | | ----------------- | ------------ | ---------- | — dashes match each column's width |
| Aligned version | Numeric columns set to ---: right-align costs and uptime; nothing else moves |
Why pad at all? Markdown doesn't care — |a|b| renders the same as the padded version. Humans and diffs care: a padded table scans vertically, and a one-cell edit produces a one-line diff instead of a reflowed block. That's also why the "pad columns" toggle exists — some wikis and Slack paste better unpadded.
"Smith, John" stays one cell; embedded newlines are joined (table cells can't span lines).\| so the cell doesn't split.Table serialization by markdown-table 3.0.4 (MIT, part of the remark ecosystem), bundled to 2.2 KB under /vendor/ with its license. Everything runs in your browser tab.
One header row, one delimiter row, then data rows — pipes between cells: | Tool | Cost | on line one, | --- | --- | on line two, then | Pingdom | $15 | for each data row. The delimiter row is what makes it a table. Alignment comes from colons in the delimiter: :--- left, :---: center, ---: right. This generator produces all of it from pasted CSV or spreadsheet data, with every column padded to the same width so the source stays readable.
Paste the CSV into the generator — quoted fields with commas inside them are handled — and the markdown table appears instantly with balanced column widths. Tabs work too, which is what you get copying a range straight out of Excel or Google Sheets. Set per-column alignment with the dropdowns, then copy the output into your README or wiki.
Colons in the delimiter row set column alignment: :--- (or just ---) is left, :---: is center, ---: is right. The colons count toward the column's width, so a centered 6-character column gets :----: (colon, four dashes, colon). Alignment is a display hint — GitHub, GitLab, and most renderers honor it, but plain-text readers just see a monospaced grid either way.
Because someone padded the cells. Markdown doesn't require aligned pipes — | a | b | renders identically however many spaces you use — but padded tables are dramatically easier to scan and diff. The markdown-table engine this tool uses pads every cell to the widest value in its column plus one space on each side, which is why the output looks typed by hand.
A literal pipe inside a cell would break the table, so the generator escapes it as \| — the escape that GitHub-Flavored Markdown defines for exactly this case. Cells like "yes|no" come out as yes\|no and render as a single cell reading yes|no. Newlines inside quoted CSV fields are joined into a single line, since markdown table cells can't span lines.
Yes — the output is standard GitHub-Flavored Markdown (GFM), which all three parse. The same goes for most wikis, static site generators with tables enabled, and Slack's markdown-ish renderer. Notion and GitHub both honor the colon alignment controls. If a platform strips tables, the HTML route is the fallback: convert markdown to HTML and paste that instead.