Skip to content
| Marketplace
Sign in
Visual Studio Code>Data Science>TablifyNew to Visual Studio Code? Get it now.
Tablify

Tablify

Johannes Tiefnig

|
15 installs
| (0) | Free
Open JSON, YAML, CSV and log files as interactive, filterable tables. Edit cells in place and see git changes and blame per entry.
Installation
Launch VS Code Quick Open (Ctrl+P), paste the following command, and press enter.
Copied to clipboard
More Info

Tablify

Open JSON, YAML, CSV and log files as interactive tables in VS Code. Filter thousands of entries in a keystroke, edit cells without reformatting the file, and see which entries changed since the last commit, with git blame per field.

A requirements file open in Tablify: a table with ID, type, status and text columns, filtered by "status=valid AND type=requirement", showing 8 of 24 rows

Features

  • Any list of records becomes a table. JSON and YAML lists or ID → entry maps, CSV and TSV. Entries nested inside a file ({"data": {"items": [...]}}) open with one click.
  • Filter like a query, not a regex. status=open AND priority>=2, free text, header dropdowns, autocomplete for fields and values, saved filters.
  • Edit in place, keep the file tidy. Type-aware editors (dropdowns, checkboxes, dates, rich text). Each edit changes only that value, so comments, quoting and formatting elsewhere stay as they are, and undo works as usual.
  • Git-aware. A change bar marks entries added or modified since the last commit (compared by ID, not by line), a "changes only" filter shows deleted entries too, and per-field git blame shows who changed what.
  • Log files as a table. JSON Lines, logfmt, syslog, access logs, Nginx/Apache error logs, Log4j-style and Python logs are detected automatically, with level filter, search and stack traces kept together. Handles files with millions of lines.
  • Shareable views. Column order, widths, types, colors and saved filters live in .vscode/tablify.yaml, so the whole team sees the same table.
  • Local and private. No telemetry, and Tablify makes no network requests of its own. Your data stays in the editor.

Install

Search for Tablify in the Extensions view (Ctrl/Cmd+Shift+X), or run:

code --install-extension JohannesTiefnig.tablify

Requires VS Code 1.90 or later.

Quick start

  1. Open a JSON, YAML or CSV file that holds a list of records.
  2. Click the table icon in the editor title bar (or right-click the file in the Explorer → Open as Table).
  3. Press Ctrl/Cmd+F and type a filter such as status=open, or click a column header to pick a value.
  4. Double-click a cell to edit it, Ctrl/Cmd+click to jump to it in the source.

For a log file, right-click it → Open as Log Table. Open as Text in the title bar always switches back.

Supported files

Tablify reads JSON, YAML and CSV/TSV files whose top level is either a list of entries or a hash of ID → entry:

[
  { "id": "REQ-001", "type": "requirement", "status": "valid" },
  { "id": "REQ-002", "type": "requirement", "status": "draft" }
]
{
  "REQ-001": { "type": "requirement", "status": "valid" },
  "REQ-002": { "type": "requirement", "status": "draft" }
}

The same two shapes work in YAML:

- id: REQ-001          # list
  status: valid

REQ-001:               # hash: the key becomes the `id` column
  status: valid

When the entries are nested deeper, for example in an API response such as {"data": {"items": [...]}}, the "Not a table file" page offers a Show data.items button (see Entries nested in the file). Any other shape shows the message with an Open as Text button.

CSV and TSV files (.csv, .tsv) are read as a list: the first line names the columns, every other line is an entry.

id,status,tags
REQ-001,valid,"Functional, Security"
  • Delimiter: comma, semicolon, tab or |, detected from the header line.
  • Quoting: quoted fields may contain delimiters, "" and line breaks.
  • Values: all values are text. Empty fields count as missing, like a missing field in JSON. Comma-separated values work with multienum attributes.
  • Editing: an edit rewrites only the changed field, quoted when needed. Line endings and a byte order mark are kept.

Usage

  • Right-click a file in the Explorer and choose Open as Table, or use the table icon in the editor title bar. The command palette has Tablify: Open as Table as well.

  • Open as Text in the title bar switches back to the text editor.

  • To always open a file pattern as a table, add an editor association:

    "workbench.editorAssociations": { "**/requirements/*.yaml": "tablify.tableView" }
    

The table updates live while you edit the file in a text editor next to it. Cmd/Ctrl+click a cell, or right-click a row and choose Reveal in Text Editor, to jump to its entry in the source.

Editing

Double-click a cell to edit it. Changes are written to the file as minimal text edits, so comments, formatting and quoting elsewhere stay as they are; the file becomes dirty and is saved, undone and redone like any other edit.

Type Editor
string, date, number inline input (date picker, number field)
text multi-line text box (Shift+Enter or click outside to save)
html rich-text popup with bold, italic, underline, strikethrough, heading, paragraph, lists and clear formatting (Ctrl/Cmd+Enter to save, Esc to cancel)
enum dropdown of the defined values, with search; clearing it removes the field
multienum multi-select dropdown; click outside to save
list one item per line
boolean single click toggles; the file's spelling is kept (yes/no, true/false, 1/0)

Without attribute definitions the editor is chosen from the data: numbers, booleans, lists, HTML, long text and short text. Values keep their representation where possible: a comma-separated multienum string stays a string, and in YAML, strings such as yes are quoted so YAML 1.1 tools still read them as strings. Images in HTML keep their relative paths.

Some cells are read-only: the key of a hash entry, nested objects, and rows that are not objects.

Filtering

Press Cmd/Ctrl+F in the table, or click the filter icon in the editor title bar, to open the filter box at the top right. It filters as you type and suggests field names and known values (Tab/Enter accepts). Escape closes the box but keeps the filter: the filtered columns stay highlighted, the title-bar icon switches to Clear Filter, and the status bar shows the active query and match count (click it to edit).

Clauses are joined with AND:

Syntax Meaning
status=valid or status:valid exact match (case-insensitive; matches any element of a list)
text~oauth contains
status!=valid no element matches
priority>=2, due<2026-12-31 compare (numeric for numbers, text order otherwise; works for ISO dates)
tags="API Design" quote values that contain spaces
oauth free text in any column

Clicking a column header adds a clause for that column. Columns with few distinct values open a dropdown of those values. Unfinished clauses such as status= are ignored until a value is typed.

Saved filters: the bookmark button in the filter box lists the saved filters of the file's view; click one to apply it, or × to delete it. Save Current Filter… (also Tablify: Save Filter… in the editor's … menu) asks for a name and stores the query in the view's filters in .vscode/tablify.yaml. Saving under an existing name replaces that filter. Without a matching view, you choose a new view for this file or folder, as with Save View. The bookmark is filled while the current query is a saved filter.

Display

Without attribute definitions, each field becomes a column in the order the fields first appear. Long text wraps, lists are comma-separated, and nested objects show as JSON. String values wrapped in <html>…</html> are rendered as sanitized HTML. Relative image paths resolve against the file's folder.

Workspace configuration and views

Tablify is configured per workspace folder in .vscode/tablify.yaml (.yml and .json work too). It holds a list of views; each applies to the data files matched by its files globs (relative to the workspace folder; patterns without / match the file name anywhere). The first matching view is used, so put specific views before broad ones. Without a matching view, every field is shown as plain text in data order. The table updates when the file changes. See test_data/.vscode/tablify.yaml for a full example.

views:
  - name: Requirements
    files: ["requirements/**/*.yaml"]
    path: document.data.objects # where the entries are (default: top level)
    columns: [id, type, status, text] # column order
    hiddenColumns: [internal_note] # not shown (still filterable)
    otherColumns: show # show | hide fields that are not in `columns`
    widths: { id: 90, text: 420 }
    readonlyColumns: [created] # not editable in the table
    filters: # saved filters, offered in the filter bar
      - { name: Open, query: "status=draft" }
    attributes: # how fields are displayed, edited and filtered
      id: { type: string, readonly: true }
      title: string # shorthand: just the type
      status:
        type: enum
        label: Status # column title
        description: Lifecycle state # header tooltip
        values:
          - draft # shorthand: just the value
          - { value: valid, label: Valid, color: green, description: Approved }

Entries nested in the file

By default the entries are the list or hash at the top level of the file. When they are nested deeper, path in the view says where:

# data file
document:
  title: Inventory
  data:
    objects:
      - { id: A1, name: Pump }
      - { id: A2, name: Valve }
# .vscode/tablify.yaml
views:
  - files: ["inventory/*.yaml"]
    path: document.data.objects

Keys are separated by . or / (/document/data/objects and $.document.data.objects work too). Array items are selected by index, items[0].rows or items.0.rows; keys containing ., / or brackets are quoted: sheets["2026.Q1"]. Editing, adding, deleting and moving rows, git changes and blame work as for top-level entries; the rest of the file is left as it is. If a file has no table at the top level, the error page offers a Show … button for the first nested list it finds, for example Show data.items. The choice is remembered for the file, and Save View writes it to the view as path.

Running a command on save

onSave runs a shell command after a file of the view is saved while it is open as a table (from the table or a text editor), for example a formatter:

views:
  - files: ["requirements/**/*.yaml"]
    onSave: npx prettier --write ${file}

Placeholders are replaced with shell-quoted values: ${file} (absolute path), ${relativeFile}, ${fileDirname} and ${workspaceFolder}. The command runs in the workspace folder and is stopped after 30 seconds. Its output (stdout and stderr) is shown as a notification, as an error when the command fails or times out; the full output is in the Tablify output channel. If it rewrites the file, the table reloads. On-save commands only run in trusted workspaces.

Arranging and saving a view

  • Drag a column header to move the column.
  • Right-click a header for Hide column, Show column › (lists hidden columns), Save View… and Reset View.
  • Resize columns by dragging the header edge.

Changes are kept in the editor tab until you save them. While there are unsaved changes, a Save View icon appears in the editor title bar (also in its … menu, with Reset View). Saving writes columns, hiddenColumns, otherColumns and widths to .vscode/tablify.yaml: into the view that matches the file, or into a new view for this file, this folder, or this folder and its subfolders. A new view is placed first, so it takes precedence. The config file is created if needed; comments in it are kept.

Attribute types

Type Use for Display Filter
string single-line text plain = ~, value dropdown if few distinct values
text multi-line plain text wraps, keeps line breaks ~
html structured text sanitized HTML (images resolve relative to the file) ~ on the text
enum single select from values badge with label and color = value or label, dropdown of defined values
multienum multi select from values (list or comma-separated string) badges = any element, dropdown of defined values
list free list of strings chips = any element
number numbers right-aligned = < <= > >=
boolean true/false, yes/no, 1/0 check mark =true / =false
date ISO 8601 dates plain = < <= > >=

Attribute properties: type (required), label, description, readonly (not editable in the table), and values for enum / multienum. Value properties: value (required), label, color (gray, blue, green, yellow, orange, red, purple), description.

Values that are not in an enum's values (or booleans that cannot be read as true/false) are marked with a dashed red outline. An invalid config file shows a warning, and the table falls back to the generic display. VS Code validates and autocompletes .vscode/tablify.yaml through the bundled JSON schema (YAML needs the Red Hat YAML extension).

Scroll position and the filter are kept per editor tab.

Saving

Ctrl/Cmd+S in the table view runs Save without Formatting. A format-on-save formatter (e.g. Prettier) would otherwise reformat the whole file and change entries you did not touch; the table's own edits only change what you edited. Turn this off with tablify.saveWithoutFormatting. Saving through the File menu, Save All, or the prompt when closing still runs the formatter.

Adding, deleting and moving rows

Rows are managed from the narrow baseline column at the left of the table:

  • Hover it to show a small toolbar: add row above, add row below, delete row.
  • Drag it (the grip appears on hover) to move a row; it is placed next to the row you drop it on.

New rows get a short random ID (8 characters, e.g. k7f3x9qa), unique in the file, and nothing else; in a hash the ID is the key (k7f3x9qa: {}, which becomes a regular block when you fill in the first field). As with cell edits, changes are minimal text edits: in YAML whole entries move, including comments inside them, and every action is a single undo step. Rows of flow-style YAML collections ([...], {...}) cannot be added, deleted or moved, and the last entry of a YAML file cannot be deleted from the table.

Git changes and blame

For files tracked by git, the baseline column shows what changed since the last commit, like the change markers in the editor gutter: green for entries that are new, blue for entries that were modified. Changed cells get a small corner mark. Entries are compared by ID (or hash key) and value, not by line, so reformatting the file does not show up as a change. Unsaved edits are included.

Click the baseline of any row to see its history: for each field the current value, the previous value if it changed, and git blame (author, date and commit) for the field's lines. Blame is loaded only when you open the popup, and includes unsaved changes. The data refreshes after commits, checkouts and similar git operations.

Click the header of the baseline column to show only the changes since the last commit: new and modified entries, plus entries that were deleted (red bar, struck through, shown where they used to be; read-only). It combines with the filter query and is kept per editor tab; click the header again, or Clear Filter, to show all rows.

Log files

Open as Log Table (Explorer context menu, the editor title bar of .log files, or the command palette) shows a log file as a read-only table: one row per log event, one column per field. It works for any file, including extensionless ones such as syslog or messages. The Log Table editor is also offered in Reopen Editor With… for *.log, *.log.1, *.jsonl, *.ndjson, access_log* and error_log*; to always use it, add an editor association:

"workbench.editorAssociations": { "*.log": "tablify.logView" }

Formats. The format is detected from the first lines of the file:

Format Example
JSON Lines / NDJSON {"time":"…","level":"info","msg":"…"} (pino / bunyan numeric levels as well)
logfmt ts=2026-10-14T10:37:02Z level=error msg="payment failed" order=4711
Syslog RFC 3164 (and rsyslog) Oct 14 10:37:02 web01 sshd[2341]: Accepted password for alice
Syslog RFC 5424 <34>1 2026-10-14T10:37:02.123+02:00 web01 sshd 2341 ID47 [origin ip="…"] …
Access log (Common / Combined) 10.0.0.5 - alice [14/Oct/2026:10:37:02 +0200] "GET / HTTP/1.1" 200 5123 …
Nginx error log 2026/10/14 10:37:02 [error] 1234#0: *56 open() "/x" failed …
Apache error log (2.4) [Wed Oct 14 10:37:02.123456 2026] [core:error] [pid 2341:tid 140] …
Application log 2026-10-14 10:37:02,123 ERROR [main] com.example.OrderService - Payment failed
Python logging 2026-10-14 10:37:02,123 - orders.payment - ERROR - Payment failed

Anything else opens as plain text: a leading timestamp and a level keyword are picked out when present, otherwise each line is one row. The status bar shows the format (Log: Syslog RFC 3164); click it to choose another one. The choice is remembered per file.

Entries. Lines that do not start an entry (stack traces, Caused by: chains) belong to the entry above; such entries show a +N lines badge. Lines that do not match a single-line format (JSON Lines, logfmt, access logs) are shown dimmed. Levels are normalized (WARNING → warn, SEVERE → error, syslog severities, pino levels, …) and colored; access logs get a level from the status code (5xx error, 4xx warn). Timestamps are shown as written and parsed for sorting. Syslog timestamps without a year take the year of the file's modification time.

Filtering. Like in the table view, Ctrl/Cmd+F or the filter button in the editor title opens the filter bar:

  • Search the message as you type: plain text (case-insensitive) or /regex/flags. The All fields toggle searches the whole entry.
  • Level: click the level column's header to choose the levels shown, with the count per level; Alt+click shows only that level.
  • Columns: right-click a header to show or hide columns. Columns that are always empty or -, and those in tablify.log.defaultHiddenColumns, start hidden.

Click a header to sort (ascending, descending, file order), or right-click it; timestamps sort by time. Drag a header's edge to resize it. Click a row, or use the arrow keys, to see the full entry with all fields below the table; double-click or Enter opens the text editor at that line (Reveal in Source). The table reloads when the file changes on disk.

Large files. Parsing and filtering run in the extension host, and the table only renders the visible rows, so files with millions of lines stay responsive. Above tablify.log.largeFileThresholdMB (50 MB) you choose to load the first or last 100,000 lines, or all of it.

Custom formats. Add formats in the settings: a JavaScript regex with named groups, and the role of each group (timestamp, level, message, source). Custom formats take part in detection and win ties with the built-in ones. Invalid patterns are reported and skipped.

"tablify.log.customFormats": [
  {
    "id": "my-ecu-trace",
    "label": "ECU trace",
    "pattern": "^(?<timestamp>\\d+\\.\\d+)\\s+(?<channel>\\w+)\\s+(?<level>[A-Z])\\s+(?<message>.*)$",
    "roles": { "timestamp": "timestamp", "level": "level", "channel": "source", "message": "message" },
    "multiline": false
  }
]

Optional keys: multiline (default true: non-matching lines continue the entry above) and postProcess, a list of built-in enrichers: syslog-pri (facility, severity and level from pri), split-http-request (method, path, protocol from request), status-level (level from status), nil-dash (- means empty) and sd-params (RFC 5424 structured data from sd as sd.<id>.<param> columns).

Settings

Setting Default Description
tablify.idField id Column name for the key of each entry in hash files.
tablify.git.enabled true Show the change bar and blame for files in a git repository.
tablify.saveWithoutFormatting true Ctrl/Cmd+S in the table saves without format-on-save and other save actions.
tablify.log.customFormats [] Additional log formats (see Log files).
tablify.log.detectionSampleLines 200 Non-empty lines from the start of a log file used to detect its format.
tablify.log.detectionThreshold 0.6 Share of sampled lines a format must match to be detected; otherwise plain text.
tablify.log.largeFileThresholdMB 50 Larger log files ask whether to load the first or last lines, or all of it.
tablify.log.defaultHiddenColumns ["ident", "version", "tid"] Log table columns hidden by default.

Troubleshooting

  • "Not a table file". The top level must be a list of entries or a hash of ID → entry. For nested data, click the Show … button on that page, or set path in a view. A single object (a settings file, for example) is not a table.
  • No change bar or blame. The file must be tracked by git (committed or staged), the git executable must be on your PATH (or set in git.path), and tablify.git.enabled must be on. Untracked files show no change bar.
  • The table does not open by default. Tablify never takes over .json or .yaml files on its own. Use Open as Table, Reopen Editor With…, or an editor association (see Usage).
  • Saving reformats the whole file. Ctrl/Cmd+S in the table skips format-on-save, but File → Save and Save All do not. See Saving.
  • A log file is shown as plain text. Click the format in the status bar to choose one, or add a custom format (tablify.log.customFormats).
  • The on-save command does not run. It only runs in trusted workspaces; its output is in the Tablify output channel.

Known limitations

  • Log tables are read-only.
  • Nested objects inside a cell are shown as JSON and cannot be edited in the table.
  • CSV values are always text.
  • Rows of flow-style YAML collections ([...], {...}) cannot be added, deleted or moved, and the last entry of a YAML file cannot be deleted from the table. In an empty list, add the first entry in the text editor.
  • Autocompletion in .vscode/tablify.yaml needs the Red Hat YAML extension (.json config works without it).

Feedback and contributing

Bug reports, ideas and pull requests are welcome:

  • Report a bug or request a feature
  • Changelog · Releases
  • If Tablify saves you time, a rating on the Marketplace helps others find it.

Development

npm install
npm run build      # bundle extension + webview into dist/
npm run watch      # rebuild on change
npm run check      # type-check
npm test           # parser unit tests (Node >= 22.18)
npm run package    # build a .vsix

Press F5 in VS Code to start an Extension Development Host with test_data/ open.

Layout:

  • src/ runs in the extension host: the custom editor provider, the JSON/YAML parser and the webview HTML with its CSP.
  • src/log/ is the log table: formats (data, not code), detection, the streaming parser, the record store (filtering, sorting, row windows) and its read-only editor provider.
  • webview/ runs in the webview: the Tabulator table, formatters and filter; webview/log/ is the virtualized log grid.
  • test/ holds the parser tests, which use the files in test_data/, and the log tests with one fixture per format in test/fixtures/logs/ (snapshots in __snapshots__/; run UPDATE_SNAPSHOTS=1 npm test to update them).

License

MIT

  • Contact us
  • Jobs
  • Privacy
  • Manage cookies
  • Terms of use
  • Trademarks
  • Your Privacy Choices
  • Consumer Health Privacy
© 2026 Microsoft