Build Markdown tables in a visual grid editor with per-column alignment, then copy neatly padded pipe-table syntax for READMEs, docs, and wikis.
Content last reviewed
Open markdown editor
Monaco loads only after you open the editor.
| Header 1 | Header 2 | Header 3 | | :----------- | :----------- | :----------- | | Row 1, Col 1 | Row 1, Col 2 | Row 1, Col 3 | | Row 2, Col 1 | Row 2, Col 2 | Row 2, Col 3 |
Add or remove rows and columns until the grid matches your data; the top row is the header.
Type into the cells and click each column's alignment icon to cycle left, center, right.
The padded pipe-table syntax updates live below — copy it into your README, doc, or wiki.
Name left-aligned, Qty centered, Price right-aligned — note the colon positions in the separator row.
Input
Grid: header Name / Qty / Price, one data row Apple / 4 / 1.20, alignments left / center / rightOutput
| Name | Qty | Price |
| :---- | :-: | ----: |
| Apple | 4 | 1.20 |Hand-writing a Markdown table means counting pipes, aligning dashes, and re-padding every column each time a cell changes — the least enjoyable part of writing documentation. This tool replaces that with a small spreadsheet-style grid: you type into cells, and the correctly formatted pipe-table syntax is generated underneath, padded so the raw Markdown is as readable as the rendered result.
The grid works the way you would expect. Buttons add rows and columns; hover controls remove them. The first row is always the header. Each column has an alignment control that cycles through left, center, and right, which the generator translates into the :---, :---:, and ---: separator syntax that GitHub, GitLab, and most Markdown renderers understand. Cells even preview the alignment as you type.
The generated code appears in a read-only editor below the grid with a copy button, and every edit — a renamed header, a new row, a changed alignment — updates it instantly. Everything runs in your browser, so table contents are never uploaded.
Start with the 3 × 3 starter grid. Click Add Row or Add Column to grow it, or use the trash icons (visible on hover for rows, in each column header for columns) to shrink it.
Type your content into the cells. The bold top row is the header row.
Click the alignment icon above any column to cycle its alignment: left → center → right. The cell text previews the alignment immediately.
Review the Generated Markdown panel below — it re-renders with every change, with columns padded to equal width.
Click the copy button and paste the table into your README, wiki page, or documentation file.
Type into cells instead of hand-aligning pipes — the syntax is generated for you.
Cycle each column through left, center, and right; the generator emits the matching colon syntax in the separator row.
Columns are padded to the width of their longest cell, so the raw Markdown stays legible in any code editor.
Add or remove rows and columns at any time; the table regenerates instantly.
The generated syntax appears in a read-only code editor with syntax highlighting and a one-click copy button.
Build feature comparisons, option references, and compatibility matrices without wrestling with pipe syntax.
Create parameter tables and configuration references for docs sites that render Markdown.
Produce tables for GitLab wikis, Obsidian, Notion, and other Markdown-aware editors.
Draft comparison tables for static-site generators like Hugo, Jekyll, or Astro.
Paste a quick results or test-matrix table into a PR description or issue comment.
The generator walks your grid and emits standard pipe-table syntax. First it measures every column to find its widest cell, then pads each value with spaces to that width so all the pipes line up vertically in the raw text.
The first grid row becomes the header line. The second output line is the separator that Markdown renderers use to recognize a table — a run of dashes per column, decorated with colons according to your alignment choice: :--- for left, :---: for center, ---: for right. Remaining grid rows become the table body. The whole document is regenerated from scratch on every keystroke, so the output always reflects the current grid exactly.
The GitHub-flavored table syntax with alignment colons, rendered by GitHub, GitLab, Obsidian, Notion, and most documentation generators.
Grows the grid; new cells start empty.
Trash icons delete a row (shown on hover) or a column (in its header). At least one row and one column always remain.
One button per column cycles left → center → right, previewed in the cells and encoded in the output.
The | character is the column separator in Markdown, so a raw pipe inside a cell splits it in two when rendered. Escape it as \| in the cell text.
Some minimal renderers (strict CommonMark without extensions) do not support tables. GitHub, GitLab, and most modern editors do — check what your target platform renders.
Markdown table cells are single-line. Use <br> inside a cell if your renderer allows inline HTML, or restructure the content.
\|.The output is the standard single-line-per-cell pipe table: no merged cells, no multi-row cells, and no nested tables — Markdown itself does not support them. Pipes typed inside cells are not escaped automatically, so escape them as \| yourself. There is no import from CSV or spreadsheets; cells are filled in by typing (pasting works one cell at a time). Plain CommonMark without the tables extension will not render the output, though virtually all modern platforms include it. Very wide tables remain valid but can overflow on narrow screens once rendered.
The grid and the generated Markdown live entirely in your browser — nothing you type is uploaded, logged, or saved by the tool. Refreshing the page resets the grid to its starter state.
Keep headers short — column width follows the longest cell, so long headers widen the raw text for every row.
Right-align number columns and left-align text for a cleaner rendered table.
Escape any pipe character inside a cell as \| before copying.
Preview the pasted table on the destination platform; Markdown flavors differ slightly.
For wide datasets, consider splitting into two smaller tables — very wide tables overflow on mobile.
Design the table before filling it: fewer, well-named columns beat many cramped ones, both for readers and for whoever edits the file next. Since Markdown lacks merged cells, restructure data that seems to need them — usually by adding a row or splitting the table.
Use alignment deliberately. Numbers read best right-aligned, text left-aligned, and centering works for short status-style values. Consistent alignment across the tables in one document looks considerably more polished than the default everything-left.
After pasting, view the rendered result once before committing. Ten seconds of preview catches the stray pipe or missing separator dash that would otherwise ship broken.
The table is generated client-side from the grid state on every change. Column widths are computed as the maximum cell length per column (minimum three characters), values are space-padded to that width, and the separator row encodes alignment with leading and trailing colons on the dash run. The output panel is a read-only Monaco code editor with Markdown highlighting, loaded on demand. Cell text is inserted verbatim — no characters are escaped or transformed.
Developers and open-source maintainers writing READMEs and PR descriptions, technical writers producing docs-as-code, and note-takers in Markdown apps like Obsidian who want tables without memorizing separator syntax. If you write Markdown occasionally, it saves looking up the colon rules; if you write it daily, it saves the re-padding chore every time a cell changes.
The separator row under the header controls each column: :--- left-aligns, :---: centers, and ---: right-aligns. The alignment buttons place these colons for you, so you never edit the separator by hand.
GitHub, GitLab, Bitbucket, Obsidian, Notion, and most documentation generators support pipe tables. Bare CommonMark without the tables extension does not, so a rare minimal renderer may show the raw syntax.
Yes, but escape it as \| — an unescaped pipe is read as a column boundary and splits the cell when rendered. The tool inserts cell text verbatim, so add the backslash yourself.
Not in one go — the grid cells are individual inputs, so pasting fills one cell at a time. For converting existing CSV data into other formats, the CSV ↔ JSON converter in the developer tools may help; for tables, add columns and rows here and fill the cells.
No hard limit — add as many as you need. Keep in mind that very wide tables become hard to read raw and can overflow on narrow screens once rendered.
No. The grid, the generated Markdown, and the copy action all run locally on the page; nothing is uploaded or stored.