Drop an XML file. Any size.
safe · secure · no server · works offline · fast
…or just start typing at the cursor.
safe · secure · no server · works offline · fast
…or just start typing at the cursor.
OmniViewer opens an XML file right in your browser. Drop an
.xml file and you immediately get it
pretty‑printed plus a small toolkit: a
JSON converter, a structural tree, a live
XPath query playground, a stats report, and
the raw and hex views. There is no upload and no server — the text is
read directly by your browser, and the parsing runs in a background Web Worker
so the page never freezes. The raw and hex views read only the bytes needed to
paint the screen, so even a multi‑gigabyte document opens instantly and
privately.
<tag/>. Mixed text‑and‑element content is left inline so nothing significant is invented or lost. This is the default view; copy or download the result.@name keys, repeated child elements become arrays, and text mixed with elements becomes #text. Syntax‑highlighted, copy or download./a/b, //a), wildcards (*, @*), node tests (text(), comment()) and predicates ([2], [last()], [@id='x'], [child='v']).
The classic way to read XML — build a DOM tree in memory — needs
several times the file’s size in RAM, so it simply cannot open a 20 GB
document. OmniViewer’s raw and hex views are windowed: they read
only the bytes needed to paint the screen, so they open a 20 GB
.xml as readily as a 2 KB one. The formatter, JSON converter,
tree, XPath and stats tabs parse a bounded prefix in memory (and tell you when
they do). If you want the full story — how XML parsing works, the
difference between DOM and SAX, and the streaming, event‑based parser that
lets you read a file far larger than RAM with real code — read
how to read a 20 GB XML file.
XML — the “Extensible Markup Language” — was standardised
by the W3C in 1998, a simplified descendant of
SGML designed to carry structured data in a plain‑text, tag‑based
form that both machines and people can read. For a decade it was the backbone of
the web’s data plumbing: SOAP web services, RSS and Atom feeds, SVG,
office document formats (.docx, .xlsx), Android layouts,
Maven pom.xml files and countless configuration files are all XML.
JSON has since taken over most new APIs, but XML remains everywhere in feeds,
documents and enterprise systems.
A tiny example of XML:
<note importance="high"> <to>OmniViewer</to> <body>Drop any file. Any size.</body> </note>
| Aspect | XML | JSON | YAML | TOML |
|---|---|---|---|---|
| Shape | Nested elements & attributes | Nested objects & arrays | Nested, indentation-based | Sections & key-values |
| Attributes | Yes (on elements) | No (keys only) | No (keys only) | No (keys only) |
| Comments | Yes (<!-- -->) | No | Yes (#) | Yes (#) |
| Query language | XPath / XQuery | JSONPath (informal) | None standard | None standard |
| Typical use | Documents, feeds & legacy APIs | APIs & config | Config & CI | Config |
OmniViewer opens every file format; XML is one of the formats with dedicated tooling, powered by the same viewing engine as fastjsonviewer.com and hugecsv.com.
No. OmniViewer is a static page with no server-side processing: your .xml file is read directly by your browser, and every tab — formatted, JSON, tree, XPath and stats — runs locally in a Web Worker. The file never leaves your computer.
The raw and hex views are windowed — they read only the bytes needed to paint the screen — so they open files of effectively unlimited size, up to 20 GB and beyond; the engine behind them has been tested in-browser with a 40 GB file. The formatter, JSON conversion, tree, XPath and stats parse the document in memory, so on very large files they work on a bounded prefix and tell you when they do.
Yes. The JSON tab parses your XML and re-emits it as pretty-printed, syntax-highlighted JSON, ready to copy or download. Attributes become @name keys, repeated child elements become arrays, and text mixed in with child elements is kept under a #text key. A pure-text element becomes a plain string.
Yes. The XPath tab is a live query playground: type an expression such as //item/title, //@href, /root/*[2] or //item[@id="3"] and it shows every matching node with its path and a preview. It supports absolute, relative and descendant (//) location paths, the *, @name, text(), comment() and node() tests, and predicates including position, last(), attribute tests and child-element tests. It is a pragmatic XPath 1.0 subset, evaluated entirely in your browser.
Yes. A bar above the views reports whether the file parses as well-formed XML, how many elements it contains and its root element — or, if it does not parse cleanly, the first error. Past a size threshold the check is skipped to stay fast, and it says so.
XML (Extensible Markup Language) is a W3C standard from 1998 for storing and transporting structured data using custom tags. Unlike HTML, which has a fixed vocabulary of tags meant to be displayed by a browser, XML lets you define your own tags to describe data, and it is strict about being well-formed: every tag must be closed and properly nested. RSS and Atom feeds, SVG, office documents and many config files are all XML.