Skip to content

Version history

This site offers only the current release for download, from the standalone viewer and VS Code extension pages.

What changed in each release since 6.3.0, newest first:

6.38.1

  • Fixed: the source pane's vertical scrollbar could shrink to nothing on a very large document, leaving nothing to grab. It now stays a usable size no matter how long the document is.

6.38.0

  • A comparison of two files can now be saved as one HTML file — both files, their interpreters and the view — that reopens as the same diff, and either file can be saved on its own from it again. Use Save as HTML… in the toolbar while comparing; its ▾ saves the left or right file.

  • The Messages panel (☰) now starts with a Sources list: where each file and its interpreter came from — a web address or a file name — with when it was read. A copy saved with Save as HTML… keeps that list, its messages and when it was saved and opened, so a copy passed along still says where its files came from.

6.37.0

  • In the source panes' title bars, Jump to start, Go to line and Jump to end are now one group of three buttons, with Go to line in the middle.
  • Fixed: pasting a table back from Excel with a new column inserted between two existing ones put that column at the end of the table (and the saved file); it now stays where you inserted it.
  • Opening a large document with the source panel open is much faster — for a 1 MB file about three times faster, and the panel now adds less to the opening time than the graph does. A minified file (all on one line) opens about ten times faster with the panel open.

  • A link that opens the viewer with an interpreter from another website (?interpreter= in the address) now asks before running it, since an interpreter is code that runs inside the page. An interpreter from the same website as the viewer still loads straight away.

  • A link with ?url= now opens any file the viewer can read — YAML, INI, TOML, XML, CSV, binary data — not only JSON, and pairs it with the interpreter named in the same link (?interpreter=). An address without a file extension can say its format with ?format=yaml, for example. The From URL… button works the same way.

  • A link can now open a diff: ?left= and ?right= name the two files to compare, and ?interpreter= (repeatable) the interpreters that read them, so one link answers "what changed in this config?". ?view=split opens it side by side. See "Opening files from a link" in the README.

  • Fixed: dropping two files in different formats together with both of their interpreters was refused; it now opens the diff.

  • In a very long document, the source panel's scrollbar keeps a size you can grab instead of shrinking to an invisible sliver.

6.36.0

  • Fixed: in a diff's Compact and Ultracompact views, clicking in the source on something the view leaves out could select a different entry; it now selects the box that holds it.
  • Fixed: in a diff, clicking a header of a table whose first row holds the column names now highlights that header in the source text, in every view (Ultracompact used to highlight a different column's name).
  • Fixed: in a diff's Split view, clicking a struck-through entry (one only the other file has) left the previous selection highlighted instead of selecting the clicked entry.
  • In a diff, pointing at a choice in the layout (Split / Unified) or scope (Full / Compact / Ultracompact) menu shows it right away; moving off or pressing Escape goes back, clicking keeps it.
  • Fixed: after you had looked at a diff in Split, clicking in a source pane (or searching) in Unified, or in a document opened after leaving the diff, selected nothing visible in the graph.
  • In a diff, each source pane's title bar has a ± button that turns the difference marks in the panes off and on, the same switch as Settings → Diff.
  • Table headers of a table made of rows of values (whose first row holds the column names) can now be renamed by double-clicking, like any other table's.
  • Double-clicking a header of a table shown inside a cell renames that column, instead of saying the cell holds a whole list.
  • Editing a value in the last visible line of the view no longer opens the editor below the window, where it often closed before you could type.

6.35.0

  • Settings → Diff has a switch for the marks in the source panes, on by default; off, the panes show their plain text again.
  • The diff header is shorter: instead of five buttons for Split / Unified and Full / Compact / Ultracompact, two buttons show the current choice and open a menu to change it.

6.34.0

  • Each source pane has new buttons in its title bar: jump to the start or the end of the text (also Ctrl+Home / Ctrl+End), and make the text smaller or larger (A− / A+). The size applies to every source pane and is remembered.
  • The jump and Go to line buttons have clearer icons. In a narrow pane the buttons now take a second row instead of being cut off at the edge.
  • At the bottom of a text that ends with a line break, the editable source panes showed the text one line off from where a click landed. Fixed.
  • After Paste…, closing the source pane's find bar or switching the theme no longer stops you typing before what you pasted has been shown.
  • Any opened window — a detached table or dict, a table expanded in place, a link's pinned window — can be dragged by its header bar to wherever you want it on the page. It stays there until you close it, and a file saved as HTML remembers where it was.
  • A detached table or dict gets more room: the page may scroll sideways by up to about 80 characters before the panel gets its own horizontal scrollbar, so a table only a few columns too wide shows them all at once.
  • In a diff, the source panes now show the differences too: each pane marks its own side's text with the graph's colours — removed entries red on the left, added ones green on the right, changed values amber in both, moved rows and items ringed. Hover a mark to see the other side's value. Nothing is compared line by line, so the marks always agree with the graph.

6.33.0

  • The samples download (and the documentation site) now has a ready-to-open demo of the XML interpreter's amount hint: the tool that shows amounts in millions, or converted to another currency, next to the values. The study material's comparison notebook also gained a realistic example: a portfolio against a recalculation of it, where the flexible-diff rules leave only the real changes.

6.32.1

  • Opening a file in the VS Code extension no longer flashes a "Loaded host config (no recognized settings found…)" message, or marks the message log as unread. The same goes for notebook widgets and saved pages opened with settings from Python.

6.32.0

  • Pasting something like {1: 'a'} or {'a': None} — a Python dictionary rather than JSON — used to be reported as unparsed. It now opens as a Python document, the same as when you open it from a file; this also works over a document that is already open, and in the panes of a comparison.
  • Hovering a "+k" column or row marker and then resting the mouse on a cell that holds a table or an object (or a link) no longer makes the preview flicker on and off. The preview of that cell now opens on top of the column preview, and both stay until you move the mouse away; the same goes for a preview opened from inside another preview.
  • A menu or popup that you opened and closed again very quickly could, in rare cases, make the next menu you opened swallow your click: nothing happened when you picked an entry such as an export. That no longer happens.
  • A table cell holding an object or array can now show it right inside the cell instead of as a "{n}" or "[r×c]" symbol: hover the symbol and click its button, use the new button in a table's toolbar to do it for every cell of that table, or use the new Embed button at the top right to do it for every table, three levels deep by default. Only the view changes; the data stays the same, and saved views remember it.
  • Expand links now goes three levels deep by default instead of ten.
  • Search no longer jumps around while you type: the count starts at 0, and Enter (or ›) goes to the first match, Shift+Enter (or ‹) to the last. Matches hidden inside a collapsed or partly shown box now half-highlight that box's name (or the "k of n hidden" notice, for boxes it hides), so you can see where they are. A new setting, "Search opens every dict and table holding a match", opens them all instead.
  • Clicking in the source pane, following a link, or stepping through search results now scrolls the graph so the selected box stays a comfortable distance from the top or bottom edge instead of touching it.
  • Tables no longer have a doubled line or a gap at the bottom, which was most noticeable under the "N more rows" row — in any browser and at any zoom.
  • Hovering a table's "+N" columns or "N more rows" area now tints that whole column or row — and hovering a dict's "+N more" values cell tints that cell — so you can see you're on the spot that opens the preview.
  • In a diff, and while editing, the dict or table that holds a change now shows a small red dot at the upper-right corner of its name. If it's tucked away inside a collapsed box, the dot appears on the nearest box you can see, so changes are never hidden from view.
  • Including a single link in place (from the link's own icon) no longer rearranges the whole graph: the boxes around it stay where they were. Use the Expand links button when you want the layout re-optimized.
  • The comparison demo on the documentation site (and in the samples download) now shows what flexible diff is for: it compares a portfolio with a recalculation of it that differs in many small ways — amounts not rounded to the cent, a date written differently, upper and lower case — and opens with rules that accept exactly those, so only the real changes are highlighted and the rest is counted as "within tolerance", one click away.

6.31.0

  • The graph is arranged the same whether or not the source pane is open: opening or resizing the pane still never moves boxes, and reloading or resizing the window with the pane open no longer re-arranges the graph for the narrower space (a big graph scrolls sideways instead).
  • Edits still never move the boxes around them while you work; saving now settles the graph into the arrangement the saved file opens with (in VS Code too, not only when leaving an Edit review).
  • Saving TOML, INI and YAML files keeps more of their comments: a key renamed and moved in the same save, or renamed to a name another rename freed, keeps its comments (and a TOML table stays a table); a TOML [[array]] entry whose keys were reordered or that moved keeps its comments; a file's opening comment stays at the top when the first table, section or key is removed or something is added before it; and in YAML a save that reorders and changes keys at once, or removes the first key of a list item, no longer rewrites the whole file or item.

  • The Split diff view responds right away when you collapse or expand, open or detach a table, step through search results or follow a link — on big documents these took up to several seconds.

  • In the Split diff view, following a link or stepping through search results now scrolls all the way to the target instead of stopping after a few pixels.
  • Following a link to the same box twice flashes it both times.
  • Expanding a table inside a search result that the "N hidden" limit would otherwise hide no longer makes the result disappear.

  • New in the diff view: ≈ Flexible diff sets what counts as the same — a tolerance for numbers (such as abs <= 0.01 or rel <= 1%), whitespace, case, accents and line endings in text, dates within a time window, empty values versus missing ones, list order, and a regular expression for paths to ignore — for the whole document or for chosen paths only. Differences the rules accept are never hidden silently: the header counts them ("≈ 37 within tolerance"), and clicking the count shows them, muted.

  • Hovering a changed number in a diff shows how much it changed, for example Δ +0.003 (0.02%).
  • structile.diff(..., rules=...) opens a diff with those rules already set, and refuses a mistyped rule with a message naming it.
  • The Jupyter widget now has the [?] button, showing the version, the bundled interpreters and the ones registered in Python.
  • A saved view now reopens with its boxes arranged exactly as they were, however you got there (for example, collapsing a box before or after clicking "show all").
  • Turning on Expand links no longer hides boxes that were already on screen behind the "hidden" banner; the linked boxes are added after them, and a link you include on its own always shows up.
  • Opening a saved view now reports every part of it that no longer fits the document, and keeps what you collapsed inside link windows — including inside a link you had shown in place and then put back.
  • Pasting rows into a table (or any other edit that rewrites a whole JSON file) keeps the file's layout: a one-line file stays on one line, and a 4-space or tab-indented file keeps its indentation and final newline.
  • When structile is embedded (VS Code, Jupyter), the "unsaved changes" indicator now agrees with the Save button while you're reviewing an edit, including for whitespace-only changes and text you haven't applied yet.
  • Saving a TOML or INI file whose keys or sections were put in another order now writes them in that order by moving their lines, keeping comments and blank lines; a few TOML saves that add keys and tables at once no longer rewrite the whole file.

  • With the Source pane open, collapsing, expanding, searching and scrolling stay fast on long texts: on a 10,000-line text a click went from about half a second to a few hundredths.

  • The side-by-side (Split) diff view is faster on big documents: each side draws only what's near its window, and more as you scroll.
  • Collapsing and expanding stay quick on very large documents, even with the nested-container limit turned off.
  • Stepping through search matches and following links is faster, and the rest of the view stays put while a match or a link target is opened. In VS Code, moving the cursor in the editor no longer redraws the whole view.

  • In the diff guide, the "current" label that gets crossed out while you preview another view is now crossed out cleanly, through the middle of the label.

  • The messages (☰) button now lights up while the message list is open, and the list has a × button to close it.

  • Big documents stay fast to click around in: a view now draws only what's near the window and draws more as you scroll, and collapsing, expanding, minimizing or opening a table redraws just what changed. Following a link, a search match or a source-pane click to something far away still takes you straight there. To draw everything at once, as before, tick "Draw every box" in Settings → Nested containers; printing does that on its own.

  • Clicking a link whose target is already on screen now jumps to it instantly, and every click on a document with many links redraws a bit faster.
  • Large files now say "Loading…" while they load, and when a file would take more than about 10 seconds the viewer asks before loading it — Cancel keeps what's open. Both limits are in Settings → Large files. Big files also load several times faster, and a source text over 1 MB is drawn in the Source pane only when you click Show source.
  • A custom build with bundled interpreters now says why it couldn't open a file — for example, that it's too large or too deeply nested — instead of only asking for an interpreter.
  • After saving an edit made in Edit mode, clicking a value in the graph highlights it in the source again, and clicking the source highlights the graph. This stopped working after saving in XML (every bundled XML format), TOML and YAML files until the file was reopened.
  • Saving from Edit mode keeps a Windows file's line endings and its UTF-8 byte-order mark, instead of rewriting every line ending.
  • Saving or exporting through the bundled generic and tagged XML interpreters no longer turns a plain list like ["a", "b"] into a list of one-item lists. Such lists are written with a new list element, which older versions of these interpreters can't read; files saved before read and save exactly as they did.
  • A key or attribute literally named __proto__ is no longer dropped when a file is read through the bundled XML and HTML interpreters.
  • A TOML or YAML file whose keys were all deleted, or that holds only comments, now opens as an empty document you can add keys to, instead of failing to load. Saving into it keeps its comments.
  • Saving through the example XML formats (flat attributes, references, implicit XML) no longer writes a file that reopens as different data. Data the format can't hold, such as a nested value in a flat row, is refused — and an edit that would need it now tells you why, instead of quietly not happening.
  • Saved views and copies saved as HTML now reopen more faithfully: an expanded list of plain values stays open after editing, a table that is both minimized and detached keeps both, and windows opened from a table cell or a link come back even when that cell or link isn't on screen. A table that opened only to show where you clicked in the source is no longer saved as opened.
  • A detached window no longer disappears when expanding links or lowering the nested-container limit would have hidden its box.
  • Editing a table as CSV text keeps the key order of each row instead of reordering rows you didn't change.
  • Editing an INI value to something INI can't store exactly (for example the text "8080", which INI can only write as a number) no longer rewrites the whole file and drops its comments; only that line changes.
  • Saving YAML or TOML keeps keys in the order the edit shows: a key added at the start of a list item, or table columns reordered by a paste, are no longer saved in the file's old order.
  • A negative zero (-0.0) in your data is now saved as -0.0 in JSON, Python and CSV files instead of 0, and the graph shows it as -0.
  • Editing a table as CSV text no longer adds an empty (null) value to a row that lacked that column when you insert or remove rows above it.
  • In the Edit review, Save is greyed out while there's nothing to save, for example after undoing your only edit.
  • Comparing a table with and without its header row now shows one added or removed row, instead of reporting renamed columns.
  • A key named $prims no longer hides the plain values beside it from clicks in the source view.
  • Showing a link's target in place of the link, or "show more" on a box that hides some of its children, now re-arranges the boxes around it for the new size right away. Before, the graph kept the layout it had for the small link, leaving a tall, mostly empty column until you resized the window.
  • Editing a TOML, YAML or INI file now saves only what you changed. Comments, blank lines, quoting, indentation and the way numbers are written stay exactly as they were; before, any edit rewrote the whole file in a normalized layout. Converting such a file to its own format with structile.convert also keeps it as written.
  • When you edit a number, the editor shows it the way your file writes it (for example 1.0) and saves it the way you type it: typing 2.0 keeps a decimal number decimal, and retyping 1.0 as 1 now changes the file. Changing a number and changing it back restores its original spelling.
  • In VS Code, undoing or redoing an edit puts back the file's exact text, comments and number formats included.
  • "Expand links" now counts levels correctly under a key named "↗".
  • Editing and comparing show a file's keys in the file's own order instead of sorting them alphabetically, so the view matches the file and a line-based diff of it.
  • Keys that are whole numbers (years, IDs, HTTP codes) stay in the order your file has them. Before, a CSV with the columns Name,2024,2023 showed them as 2023, 2024, Name, and editing a single cell saved the whole file with the columns moved.
  • CSV files keep values like zip code 02134, 1.50, +5 and 1e3 exactly as written. Before, the first save of any edit rewrote them as 2134, 1.5, 5 and 1000, even though you never touched them.
  • Saving keeps a file's Windows line endings and its UTF-8 byte-order mark. Before, every line of a Windows file changed on save, even with no edit, and a CSV saved for Excel lost the mark Excel needs to show accented letters correctly. This applies in the browser, the notebook widget and VS Code, which also no longer shows an empty view for a JSON file that starts with that mark.
  • Renaming in an edit review is safer: renaming a nested box or a table column onto a name that's already taken is refused instead of silently overwriting the other one, and renaming the same column or box twice now works.
  • The table "edit as text" box (✎) shows and changes the real table while you're reviewing edits or comparing files. Before, it could write text like "1 → 99" into your data, or copy rows from the other file.
  • Saving no longer writes the wrong content in two situations: after you dropped a file that was still waiting for its interpreter, and, in the notebook widget or VS Code, after a file was dropped onto the embedded view.
  • Security: a web page that opened the viewer in a new tab (as the bookmarklet does) can no longer read or replace data you later open in that tab.
  • Comparing files keeps your unsaved edits when you swap the sides or replace one side, and comparisons started from the page can now be edited in the side-by-side view. The header's difference count updates as you edit, and the compact views no longer claim two files are identical when they differ at the top level.
  • Finishing an edit review (Save or Cancel) keeps the boxes you had collapsed, minimized or opened beside the document.
  • In a Python data file, editing a value shows and accepts Python's own spelling (None, True, 'text').
  • Search is better with non-English text and regular expressions: "Σ" finds words ending in "ς", "ß" finds "ẞ", and a regular expression keeps its leading and trailing spaces. Actions you take during a search (following a link, loading a saved view) are no longer undone when the search ends.
  • Links now reach a key that is shown folded into a combined box title (such as wrap/<p1>).
  • Settings files and saved views are checked before they're used. A bad "Special values" entry can no longer leave every page blank, and opening someone else's page or saved HTML copy no longer replaces your own saved display preferences. A file that's only named like a settings or view file (such as local.settings.json) opens as data.
  • Exports warn when the target format can't hold your data exactly, and a one-column table with commas exports as tab-separated text that opens again correctly.
  • Files are read with the right text encoding even when the accented characters only appear far into the file, and data fetched from a URL honors the server's declared encoding.
  • A broken interpreter script now gives a clear message instead of leaving the page half-switched, and a page opened with a ?url= that fails to load is still usable.
  • Small tables show their size ([7×1]) and "1 more row" in full, and the source panel stays fast on large files, keeps collapsed sections aligned with the text, and keeps its find results in step with your edits.
  • The bundled TOML, YAML, INI and XML interpreters no longer change values you didn't edit when you save: very large integers, decimals like 6.02e23, text that looks like a date or a zip code, and line breaks in XML attributes all come back as written. YAML lists written at the same indentation as their key (common in CI configuration files) now open.
  • Python: saving from the notebook widget writes a .py, text or CSV file back in its own format (instead of JSON) and leaves files it can't write, like XML, untouched; opening a Markdown-like text file no longer crashes; the command line reports a missing file instead of succeeding; and Python files exported by the viewer can be opened again from Python.
  • The bundled TOML and YAML interpreters keep numbers written the way they were (1.0, 1e3, 0xFF, 1_000) when you save an edit to something else.
  • Python data files keep keys that aren't text (1, True, (5, 6)) as they were when an edit makes the whole file rewrite, such as renaming a table column.
  • Collapsed and opened boxes stay with their box when you rename it during an edit review, and when you finish the review with Save or Cancel.
  • A data file dropped together with its saved view or settings file opens with both.
  • VS Code: a new setting for showing nested values in table cells as badges, and "Set as default" now remembers the "show only the first nested items" option.
  • An interpreter for a binary file format can now make its references clickable links, as text and XML interpreters already could. Before, the link settings it declared were ignored for binary files, so a reference such as {{A}} stayed plain text.
  • Interpreters can now add hints to a value's tooltip, and a new puzzle-piece button in the header shows the interpreter's details and its settings (checkboxes, sliders, dropdowns, text fields). It appears whenever an interpreter read the file, in Jupyter and VS Code too. Hints also work when comparing two files, each side using its own interpreter.
  • Hints can also be written inside the cells, after each value, in their own color: tick "Show hints in cells" in the puzzle-piece panel. They're for reading only — double-clicking one edits nothing, and they never appear in the source, in searches, in copied text or in saved files.
  • The bundled generic XML interpreter can show amounts converted by a factor, for example 100 as ¥15800 with a factor of 158. It's off by default; switch it on in the puzzle-piece panel. The tooltip, a value and a table cell each have their own format, where \1 stands for the symbol and \2 for the amount: the tooltip shows hint: ¥15800 by default, the cells just ¥15800.
  • An expanded box of values now widens when a value gets longer, for example after changing how empty values are shown, instead of cutting it off.
  • The copy that opens in a new tab after Save As now keeps its interpreter's name, version, documentation links and clickable references.
  • In Python and Jupyter, structile.about shows what the viewer's [?] button shows — version, release date, documentation links — and which viewer is in use, with the interpreters that come with it: each one's version, documentation, what it can do and its settings. python -m structile --about prints the same in a terminal.
  • A viewer saved with "Save viewer with interpreter…" can now be used from Python with structile.set_viewer_html, and as the base of structile.build_custom_html. Before, every display through it failed.
  • The source pane can show line numbers: turn them on with the # button in its title bar. Ctrl+G goes to a line (or line:column), opening a folded section if the line is inside one.
  • Selecting several lines of source (dragging, triple-clicking, Shift+clicking, or clicking line numbers) highlights everything they cover in the graph. A collapsed box is highlighted as it is, still collapsed.
  • Clicking the empty space on a source line (its indentation, or around a : or ,) now selects that line's entry instead of the whole dict around it. When a click selects a whole dict or table, the source marks just its first line, clearly, instead of shading all of it. Shift+click in the source now extends the selection from where you last clicked.
  • The source pane has a Go to line button (↧, next to 🔍), the same as Ctrl+G. The [?] box now lists every keyboard shortcut, and each button that has one shows its key when you hover over it.
  • In Python and Jupyter, structile.open(..., interpreterOptions={...}) (and diff) opens a document with an interpreter's options already set — for example the bundled XML interpreter's scaled amounts switched on, with the factor and symbol you want, and "Show hints in cells" on — so a notebook shows the hints without a click in the puzzle-piece panel. The values apply to that document only; the viewer's own remembered options are left alone.
  • The study material has a new notebook on interpreter hints: how an interpreter adds a hint to a value, the controls it can declare for the puzzle-piece panel, hints in cells and in a diff, and what structile.about reports. The diff notebook now also shows the flexible diff from Python (rules=), and the tour has a short section on each.

6.30.1

  • Opening a JSON file from disk, by drag and drop, or from a URL no longer rounds very large whole numbers (past about 9 quadrillion). Before, an ID like 12345678901234567890 changed as soon as the file opened, and saving wrote the changed number back.
  • Python (.py) files keep special characters intact. A string Python writes with an escape, such as '\xa0' for a non-breaking space, used to open as the literal letters and save that way.
  • Very large decimal numbers such as 1e16 now stay decimal numbers when you save, instead of turning into slightly different whole numbers.
  • Comparing two files is more reliable with tables. A list that contains a table and was reordered no longer breaks the comparison view. Swapping the two sides no longer changes the number of differences. Tables that differ only by a missing value, a short row, or a repeated column name are no longer reported as identical.
  • Editing a table as text (the ✎ button) no longer changes things you didn't touch. Pasting back an unchanged copy now really changes nothing, adding or moving rows no longer turns values like "001" into numbers, and a column of names copied from Excel that contain commas pastes correctly.
  • CSV files keep rows whose only value is empty, and values containing a tab, when you save and reopen them.
  • Opening a Python dict whose keys would merge into one in the viewer (such as 1 and "1") now shows a warning, instead of one entry silently disappearing.
  • Opening a Python data file (.py) from Python or the command line now shows its contents as data, instead of the whole file as one long text value.
  • When a file format can't store a value exactly as you typed it (for example the text "001" in a CSV file, which reads back as the number 1), the edit now shows the value the saved file will really contain, with a short note. Numbers too large to store at all are refused.
  • While editing or comparing, double-clicking a column heading of a table made of plain lists no longer opens a rename box that silently does nothing.
  • The bundled YAML interpreter now opens values containing an apostrophe or quote (such as note: it's fine), and files it saves always open again — including lists of lists, text with line breaks, and an emptied document.
  • The bundled INI interpreter no longer changes values you didn't edit when saving, such as a zip code 02134 becoming 2134. Values INI can't store (like text with a line break) now give an error instead of a broken file.
  • Exporting to another format through an interpreter now warns when that format can't hold your data exactly, and names what changes.
  • Editing a value whose key is empty ("") at the top of a document no longer replaces the whole document with that value when you save.
  • Settings loaded from a file or passed from Python now get the same limits as the Settings panel, so a value like 0 rows can no longer leave boxes empty or overlapping.
  • A key literally named __proto__ is no longer lost when you edit, compare, or open Python or CSV data that contains one.

6.30.0

  • "Save as HTML…" while editing now saves a copy that opens normally, with your edits in it. Before, the copy opened stuck in the Edit bar with buttons that did nothing; a copy saved from the Jupyter widget, or with Settings open, also came back with parts of the toolbar hidden or the panel stuck open. It now also keeps which boxes were collapsed or opened on the same items even when your edit renamed keys or removed rows.
  • The export options (JSON, Python, CSV, Excel, HTML) now always save what's in the edit pane, even if you export a moment after typing. Before, they could still save the version from before your last keystrokes. "Save as HTML…" is now greyed out while your edit has an error, since the copy it made would open empty.
  • Clicking Paste… or From URL… while editing no longer throws your edit away. Paste… now pastes into the edit you're reviewing, and From URL… only replaces the document once something has actually loaded. Paste… also works again from a comparison of two documents. Leaving an edit while a search was running no longer brings the old edit-review values back when you clear the search.

  • Large documents redraw faster: parts of the view that are off screen are no longer drawn until you scroll to them, which roughly halved the time a load, a collapse or a link jump took on a document with 1,600 dicts.

  • When a view gets big enough that every click redraws tens of thousands of page elements, a warning in the top-right corner now says so and offers a fix: limiting each dict to its first 20 nested dicts/tables, or opening the setting that controls the warning. Settings → Nested containers → warnElements sets the threshold (20,000 by default, 0 turns it off).
  • A dict with many nested dicts or tables now shows only the first 20 of them, behind a clearly marked "k of n nested dicts/tables hidden" banner right under its header; the banner's buttons show 100 more at a time or all of them. Following a link, a search match or a click in the source pane to something hidden reveals just that one. Both numbers are settings (Settings → Nested containers), and a checkbox there turns the whole thing off if you'd rather always see everything. Saved views remember what you revealed.
  • The widget's "Set as default" button works again — it had silently stopped applying anything once the "clickable badges" checkbox setting existed.
  • Hovering a link (a value that names another object in the document) now shows a preview of that object right there, with two buttons: pin it in place beside the link, on top of everything else, or detach it into a side panel connected to the link by dashed lines. Both windows have a close button, and clicking the link itself still jumps to the object as before. A link that points at one row of a table previews just that row. Open link windows are kept when you save and reload a view.
  • A link can now show the object it points to right where the link is, as if the object were written there: click the chain button in the link's preview, and click it again on the box to get the link back. When a document has links, an "Expand" button at the top does this for every link at once, and for the links inside those, 10 levels deep (the number next to it changes that, or removes the limit); loops of links stop just before repeating. Editing a value inside such a box edits the original object, and every other place that shows it updates too. Your file still contains the link, not a copy.
  • Dates, times, decimals, UUIDs, enum values and your own classes in the data you open are now shown as Python writes them, for example datetime.date(2020, 1, 1), instead of stopping open() with an error. You can edit them in place, and after saving, .value holds real Python objects again. If an edit can't be turned back into an object, the viewer tells you and .value keeps its previous value.
  • A table's Copy menu (⎘) can now save the table as a JSON, Markdown or native-format file (for example .xml when your viewer has an XML interpreter built in). Before, only CSV and Excel could be downloaded, and the other formats could only be copied to the clipboard.
  • In a diff or while editing, the i guide to the six diff views now lets you pick one. Hover over a view to preview it behind the guide, and click to switch to it. Moving away without clicking brings back the view you had, including any collapsed or minimized tables, scroll position and search.
  • The [?] popover and structile --version now say when a build carries changes newer than its version number, as "6.29.3 + unreleased changes" (a build taken straight from the repository between releases). The popover's date row is now labelled "Released": it is the date of the version shown.

  • After choosing "Show as hex" for a binary file, you can still drop its interpreter onto the page and it reads that file. If the interpreter can't read it, the viewer says so and keeps showing the hex view.

6.29.3

  • Fixed: clicking a link in an expanded table used to scroll that table back to its first row. It now still jumps to the linked item, and the table stays where you had scrolled it. The same fix applies when you click inside a hover preview to pin it open.

6.29.2

  • Fixed: a file opened from Python with structile.open("data.xml") (or any other file path) was labelled as having no file on disk, just like pasted data. Its name now shows the folded corner, and hovering it gives the file's real name. Data passed in directly, not from a file, is still labelled as having no file.

6.29.1

  • Fixed: after you edited a value in the graph of an XML file (or any other interpreter-read format), clicking a value no longer highlighted it in the source, and moving the cursor in the source no longer selected it in the graph. This worked for JSON but broke for XML after the first edit. It now keeps working after every edit, in the viewer, in Edit review, in Split-view diff and in the VS Code editor.

6.29.0

  • A custom build can now bundle an interpreter for a binary file format: mark the manifest entry "binary": true (or give it "format": "bin"), and dropping a file of that extension opens it straight away — no companion .js, no hex-view prompt. The interpreter always receives the file's exact bytes, even when they happen to look like text. This also covers the file picker, a data file dropped together with its interpreter, and comparing two such files in diff view.
  • "Save viewer with interpreter…" from a binary file now produces a viewer that recognises that file's own extension (for example .abf) instead of a generic .bin that never matched anything.
  • "Save as HTML…" now works for binary data, both when read through an interpreter and in the hex view: the saved page carries the bytes and reopens showing the same data (still read-only, as in the live session). When a saved copy can't be made at all, the menu row is greyed out with the reason instead of failing after the click.
  • The [?] popover's list of bundled interpreters marks the ones that read binary files.
  • A binary file no longer has to carry the bundled interpreter's extension to be recognised: whatever the file is called, every bundled binary interpreter is tried on its bytes before the viewer asks you for one — including files whose bytes happen to look like text. The same goes for an interpreter you drop yourself: if it rejects the file read as text, it gets the raw bytes as a second try.
  • VS Code extension: an interpreter can now declare "format": "bin" to read a binary file format, and structile.extensionFormats accepts "bin" for a sibling or configured interpreter. Such files open read-only; "Structile: Show Interpreter Resolution" reports which candidate read them, as for any other format.

6.28.1

  • Filenames in the new name tag are no longer clipped along the bottom: letters like g, j, p, q and y, and the underscore, showed up with their tails cut off. The tag itself is unchanged in size and position.

6.28.0

  • The filename in the top-left corner is now a small tag shaped like a document, with the file's type shown beside the name instead of tacked onto the end of it. Diff mode's two filenames look the same way, so a file is labelled identically wherever you see it — a tab-separated file used to be called "csv" in one place and "tsv" in the other.
  • The viewer no longer makes up filenames. Opening config.yml used to show it as config.yaml — a file that doesn't exist. Hovering the name now shows what the file is really called, how the data was read, and what extension saving would use.
  • Data that came from a paste, a URL or a notebook shows a square tag rather than a folded one, so it's clear at a glance when there's no file on disk behind what you're looking at.

6.27.0

  • CSV files now open on their own. Drop a .csv, .tsv or .tab file (or open one from Python or VS Code) and it renders as a table straight away — no interpreter script to download, pair or write. Comma- and tab-separated files both work, and which one you have is detected from the file's own content, so a spreadsheet exported "as text" opens correctly too. Saving writes back the same dialect it read.
  • Every table has a new ✎ button next to its ⎘ Copy button: paste a CSV or Excel table into the box, press Process, and the changes arrive as edits you can review row by row, undo, or cancel before saving. The box opens pre-filled with the current table, so you can also just edit it in place. Copying a table out and pasting it straight back changes nothing.
  • "Export CSV…" and "Export Excel (tab-separated)…" are now always available in the Save menu, for data loaded from any format — they used to appear only if you happened to have opened a CSV file earlier in the same session. When the document isn't a table, the row explains why and points at the table's own ⎘ menu, which can now also download one table as a CSV or Excel file.
  • The bundled CSV interpreter (generic_csv.js) is gone, because nothing needs it any more. If you are on an older version and click "Use Structile's generic CSV interpreter" for a dropped .csv, that download no longer exists — upgrading is the fix, and afterwards the file just opens.
  • The VS Code extension now opens .csv/.tsv/.tab files with the viewer too.
  • The downloadable starter templates for shipping your own format — the Python plugin, the VS Code companion extension, and the custom/branded distribution — have been refreshed. The plugin and companion-extension downloads had fallen behind and contained an older example interpreter missing selection sync, plus a link that only worked inside a private repository. Re-download them if you started from a copy earlier.
  • The guide to building your own branded viewer now shows how to bake several interpreters into one build, which was always supported but only ever demonstrated with a single one.

6.26.3

  • Clicking a file name in the diff header no longer pops open a file dialog. It now simply opens the "Assembling a diff" panel for that side, where the new file can be dropped in or chosen with a button — so an accidental click is easy to ignore, and dragging a file in is possible again.

6.26.2

  • Diffs now weave right-only rows, columns, and list items into their logical positions while keeping the left order stable, preserving both source orders whenever possible. Tables with repeated key values also match exact and uniquely closest rows instead of discarding the chosen key; genuinely tied cases remain visibly added/removed rather than being guessed.

6.26.1

  • Table Copy is now the leftmost table control. JSON tables no longer repeat JSON as a separate Native option, and copied Markdown tables have neatly padded columns and matching separator widths for immediate readability.

6.26.0

  • Every table now has a Copy menu in its top-right corner. Copy the complete table—not only the rows currently visible—as CSV, Excel-friendly tab-separated text, JSON, a formatted Markdown table, or the current file type's native representation.

6.25.0

  • Assembling a comparison is no longer picky about order or aim. While Structile is waiting for the rest of a diff, anything you drop anywhere on the page joins it — the interpreter no longer has to land exactly on the panel's drop zone. Dropping the interpreter first and the two data files afterwards works too, and an interpreter you already used this session (or that came with your build) is tried automatically, so two files of a familiar format often compare with nothing else to drop.
  • While a comparison waits for its interpreter, the panel now shows the raw text of each file you dropped, so you can see what you handed over instead of staring at a request for a file.

6.24.0

  • You can now drop any file on Structile, not just the handful of data extensions it used to accept. Text files open as before — a file holding JSON or Python data just loads, and anything else shows its content and asks for an interpreter, whatever the extension is.
  • Files that aren't text (images, archives, documents, anything binary) are no longer garbled into the page. Structile says what the file appears to be and offers a built-in hex view of its bytes, or you can hand it an interpreter that reads them.
  • When you drop a file in a format Structile publishes an interpreter for (CSV, INI, TOML, YAML, XML, HTML), it now offers that interpreter directly: use it straight from the web with one click, download it to keep next to your data, or paste the address of your own.
  • TOML and YAML config files can be read out of the box now — both come with a new interpreter covering the shapes a normal configuration file uses. Each says so plainly when a file uses something it doesn't cover (multi-line strings, YAML anchors and the like) instead of quietly misreading it.

6.23.1

  • In a diff, the file names now sit on the same line as "Left:"/"Right:" and the file type, instead of slightly below them, when the new reload buttons are showing.

6.23.0

  • If you edit a file after opening it, Structile now notices and offers a ⟳ button next to the filename to reload it in place — no need to find the file in the picker again. In a diff there is one button per side, each tracking its own file. The button is always there once a document can be reloaded, and lights up only when its file has actually changed.
  • This needs a Chromium-based browser (Chrome, Edge) and works with files opened straight from disk. In Firefox and Safari everything works exactly as before, just without the reload button.

6.22.1

  • The dark theme is lighter and easier on the eyes now, using the same colors as VS Code's own default dark theme instead of the previous near-black background.

6.22.0

  • The CSV interpreter now keeps graph selections and source fields in sync in both directions, including after an edit. CSV cells can also be set to null, saved, and reopened as real null values.
  • The CSV sample, interpreter, and ready-to-open HTML demo are now included in the downloadable examples and study material.

6.21.0

  • The Save menu can now convert your data into other formats you have interpreters for, not just the one it was loaded from. Alongside the existing "Export JSON…" there's now "Export Python…", plus one "Export \…" entry for every other data format you've loaded an interpreter for this session (or that's built into your copy of the viewer) — for example, once you've loaded both a CSV and an XML interpreter, you can convert CSV data to XML and back again.

6.20.0

  • Removed the separate "Save view"/"Load view" buttons. Instead, "Save as HTML…" now remembers which panels you had open or closed and restores them when you reopen the saved file.

6.19.0

  • Interpreter scripts (the small .js files that teach the viewer a new data format) can now advertise their own documentation links, which show up in the "?" info popup right next to that interpreter's name — useful for an in-house format whose real docs live on an internal wiki.
  • Added a bundled CSV interpreter and a small sample CSV file with a ready-to-open demo, showing that new feature in action.

6.18.3

  • Fixed a crash when editing a value inside certain Python-style set data (rare, but reachable by opening a .json file that isn't strictly valid JSON). Clicking Edit used to freeze up and every later double-click said "Nothing to edit here" — editing now works normally, and the changed entry is now correctly colored red (old) and green (new) instead of showing two identical-looking, uncolored copies.

6.18.2

  • The FpML links have moved from the viewer's "?" popup to the repository page, which now links the FpML project and latest JavaScript interpreter. A new FpML sample and ready-to-open HTML demo show them working together.

6.18.1

  • Added: the "?" info popup now has an Interpreters line linking the interpreter guide and a site hosting an FpML interpreter you can load straight into the viewer by URL.

6.18.0

  • Added: an interpreter can now flag problems with a file without refusing to open it. If a file is mostly valid but has something wrong — a missing recommended field, a value out of range — the interpreter can point it out, still show you the data, and drop a note (with the rule and line) in the message log added last release. A genuinely wrong file type is still rejected as before.

6.17.0

  • Added: a message log. The little status messages and warnings that pop up and fade away are now kept in a list behind a new button next to the "?" in the top-right corner (it shows a count of ones you haven't looked at yet). Open it to re-read anything you missed, with timestamps; there's a Clear button, and the list resets when you reload the page.

6.16.0

  • Fixed: cross-reference links now work when the thing being pointed at sits in a list that's shown as a table (which is how most real FpML documents lay out their parties, streams, and so on). Previously those references showed as plain text; now they're clickable and jump straight to the matching row. Interpreters that declare an id field get this for free.

6.15.0

  • Added: a "Save viewer with interpreter…" option in the Save menu. After you open a file through an interpreter, this saves a fresh copy of the viewer with that interpreter built in and no data. Send that single HTML file to someone and they can just drag matching files straight onto it — no separate interpreter .js, no internet needed. Dropping a file the built-in interpreter doesn't recognise still works the same as before (it asks you to pick one).

6.14.0

  • Added: you can point the viewer at a companion interpreter hosted on the web with a ?interpreter=<url> in the page address, instead of having a copy of the .js file to drop in. The viewer fetches it on load and pairs it with whatever XML (or other structured file) you open next. The hosting site has to allow cross-origin requests; if the fetch fails you get a clear warning rather than nothing happening.

6.13.0

  • Added: an interpreter can now set up cross-reference links for you. If it declares its reference delimiters and id field, then dropping an id/href-style document with that interpreter makes the references clickable straight away — each jumps to the item with the matching id — without opening Settings and typing a link prefix/suffix yourself. A new bundled ref_xml.js interpreter and sample_ref_xml.xml show it working. Your own saved link prefix/suffix are not overwritten on disk.

6.12.0

  • Added: a new bundled interpreter for the ISDA CDS Standard Model / Markit "Interest Rate Curve XML" format. Pair it with an <interestRateCurve> document (drop or paste both together) to view and edit the deposit and swap curve points as an ordinary structured tree, and save changes back to the same XML. A sample curve file is included.

6.11.0

  • Changed: you can now drop a file anywhere on the standalone viewer to load it, not just onto the top bar. Dropping onto a blank area of the page used to do nothing (or, worse, make the browser navigate away and lose unsaved edits).
  • Added: while you drag a file over the window, a full-screen hint appears saying what dropping will do — one file loads; dropping two or more data files at once compares them (the same as the "Diff…" button, whether or not something is already open). When a document is loaded, the "Diff…" button lights up during the drag, and dropping the file onto it compares it against whatever is already open. Before anything is loaded the hint doesn't mention "Diff…", since the button isn't available yet.

6.10.0

  • Fixed: in a Jupyter widget showing data that wasn't loaded from a file (e.g. a plain Python object passed straight in), "Save As…" used to silently do nothing when clicked — there was no file location to save a copy to. It's now shown grayed out in that case, so it's clear upfront that it isn't available, instead of appearing to work.

6.9.0

  • Added: while reviewing an edit (the Edit button's before/after view), Save As…, Export JSON…, and Save as HTML… now work right away instead of being grayed out until you'd made a change and waited a moment — and once you have changed something, they save your in-progress edit, not the original. Export JSON still needs your edit to be valid first, since there's nothing to export as JSON otherwise.
  • Changed: saving mid-review used to refuse outright if the text you'd typed didn't parse yet ("Fix the source error before saving"). It now saves your in-progress text anyway as a safety checkpoint, with a warning that it wasn't applied to the graph yet — so a typo or a mid-edit pause can no longer block you from saving your work.

6.8.1

  • Added: the read-only-editing warnings added in 6.8.0 now always appear in the same place — the top-right corner of the graph area, with a small countdown ring showing how long it'll stay up — instead of the read-only-source-pane hint showing at the bottom of the page while the "can't edit here, switch to Split view" warning showed in the corner.
  • Added: the read-only-source-pane hint now also covers pasting, cutting, and deleting a word, not just typing — and works whether paste/cut was triggered from the keyboard or a right-click menu.

6.8.0

  • Added: trying to type directly into a read-only source pane (the single-value source panel, or the original/left side while reviewing a self-edit) now shows a note explaining why nothing happened and how to actually make the change — click Edit, or type in the pane on the right. Pasting is left alone, since it wasn't the gesture this was trying to explain.
  • Added: Save now works even if you haven't changed anything yet — useful for saving a copy of something you just pasted, fetched from a URL, or are viewing as sample data, without needing to make an edit first. This only applies to the standalone page; saving inside an embedded host (like the VS Code extension) still requires a real change.
  • Added: the "can't edit here, switch to Split view" warning (shown when double-clicking a value in Unified diff view) now appears in the top-right corner of the graph itself, with a small countdown ring showing how long it'll stay up, instead of the general notification banner at the bottom of the page.
  • Changed: the About popover's description no longer says it packs "nested JSON" — it reads/writes several formats, so this was undersold; now says "nested data".

6.7.6

  • Fixed: collapsing/expanding a section in the graph for an XML/HTML file didn't fold the matching part of the source panel, and double-clicking a collapsible section's opening tag in the source didn't collapse it in the graph either. Both directions already worked for JSON/Python files; now XML/HTML matches.

6.7.5

  • Fixed: for an XML table with named columns (generic_xml.js/ tagged_xml.js), clicking a column header in the graph — or the matching bit of source text — didn't sync at all in either direction. Individual cell values already worked; only the column headers themselves were missed. Fixed.

6.7.4

  • Fixed: XML/HTML selection sync (added in 6.6.0, with a type="null" fix in 6.7.2) was still wrong for any file saved on Windows — clicking a value in the graph would highlight the wrong text in the source panel, worse the further down the file it was. Windows text files use a different line-ending convention than the sync code accounted for; now fixed for real, on either platform.

6.7.3

  • Changed: the raw text of a dropped XML/HTML/etc. file waiting on its interpreter now shows up in the actual source panel (if it's open), instead of a separate preview box — the same place it'll show once the interpreter is found, with nothing else changing when that happens.

6.7.2

  • Fixed: dropping an XML (or HTML/ini/toml/yaml/csv) file before its matching interpreter was available used to show nothing but a message asking you to pick one. Now the raw file contents show up right there too, so you can see what you're working with while you find or write the interpreter for it.
  • Fixed: with the two example interpreters that mark a null value as type="null"/kind="null" (generic_xml.js, keyed_xml.js), clicking that value in the graph didn't sync to the source panel at all — worse, it silently left whatever you'd clicked previously still highlighted, which looked like sync had jumped to the wrong spot. Fixed; a null value now highlights its own element.

6.7.1

  • Fixed: editing a value that belongs to a set (rather than a list/dict) through the graph — e.g. one of the tags in generic_xml.js's type="set" fields — silently did nothing: no error, but the value stayed unchanged everywhere (graph, source pane, saved file). Editing a set member now actually commits.

6.7.0

  • Fixed: the XML/HTML selection sync added in 6.6.0 didn't actually work for a normal XML file — almost every real .xml file starts with an <?xml version="1.0"?> line, and that alone was enough to silently turn sync off for the whole file. Now fixed; sync works the way 6.6.0 intended it to.

6.6.0

  • Clicking a value in the graph now highlights the matching text in the source pane for XML/HTML files too, not just JSON and Python — and vice versa: clicking in the source text highlights the matching graph value. This works whenever the interpreter you're using supports it (all of the bundled example interpreters do); if you're using a custom one that doesn't, sync just quietly doesn't happen for that file, the same as before. Collapsing/expanding a section in the source pane also stays in sync with the graph for these files now, including through the VS Code extension's real-editor view.
  • Two new example XML interpreters are bundled alongside the existing three: one where a whole record lives in one element's attributes (the common spreadsheet-export style), and one that needs no special attributes at all — it just reads a tag's own name as the key and its text as the value, the way most hand-written XML already looks.

6.5.1

  • Fixed: dropping an XML (or HTML/ini/toml/yaml/csv) file before its matching interpreter was available used to show nothing — just a message asking you to pick one. Now the raw file contents show up right away in a preview box, so you can see what you're working with while you find or write the interpreter for it.

6.5.0

  • The [?] About popover now shows a "Baked-in data" line whenever the HTML file you're looking at has data built into it — from "Save as HTML…" or from opening it via structile in Python — telling you its size in MB and how many individual values it contains.

6.4.1

  • Fixed: dropping a saved .view.json file before opening any data used to do nothing visible, with no explanation. Now, if there's no data loaded yet, it just opens the .view.json file itself so you can see what's in it; drop it again once your data is loaded and it applies as a view like normal.

6.4.0

  • The Save button now has a small ▾ menu next to it with two new options: "Export JSON…", which saves your data as plain JSON even if you opened it from XML, Python, or another format; and "Save as HTML…", which bundles your data (and its interpreter, if any) into a single HTML file you can send to someone else — they can open it directly, with nothing else to install.
  • Save now stays put in the same spot while you're reviewing an edit, instead of disappearing and being replaced by a separate Save button elsewhere. On the standalone page, it's now labeled "Save As…" to be clear that it always asks where to save, since there's no original file it can silently overwrite.

6.3.0

  • Interpreters can now identify themselves: the [?] About popover shows the name and version of whichever interpreter loaded your current data, and, in a custom/branded build, the name and version of every bundled interpreter too.