Use every part of CodePrettify

CodePrettify turns supported code, data, configuration, documentation, and feed files into a read-only working view. It keeps the original text available while adding formatting, validation, navigation, conversion, and inspection tools.

The extension can also activate when a supported response MIME type is returned without a recognizable filename. It intentionally leaves normal HTML pages alone. The Windows app can use Paste & Prettify to detect a format even when no filename exists.

Representations

• Prettified shows indentation, syntax highlighting, folding, links, and inline helpers. Raw shows the original text.
• Markdown, XML/feed, and app HTML use Rendered/Source where a safe rendered view is available.
• The formatting indicator reports whether formatting succeeded. A validation alert provides an exact line/column when the parser can locate the problem.
• Ctrl+B toggles the two views. Your first-install default remains Prettified/Rendered until changed in Settings.

Editor and status

Line numbers, word wrap, folding, the minimap, and the floating toolbar can be enabled independently. The Windows app’s status bar reports line and character totals, cursor line/column, selection size, detected type, encoding, and line-ending style; in the extension, line and size totals are available through Statistics & Diagnostics.

Floating toolbar

The toolbar exists in the Prettified/Rendered view (it is hidden in Raw/Source) and combines the copy menu, live search, Go to Line, and More Actions. More Actions is split into two groups:

• For this file — the heading names the detected format, for example For this file · JSON — contains actions that analyze or operate on the active document: Export, Statistics & Diagnostics, Security Scan, and, when folding is available, Collapse All and Expand All on one paired row, plus tools specific to the detected format. For example, JSON adds Table View, JSON Path Inspector, and Schema Validator, while JavaScript adds Document Navigator and Inspect Runtime. HTTP response metadata and timing, when available, appear as a section inside Statistics & Diagnostics.
• General tools contains always-available utilities that work without the open document: Compare, JSON to Code Generator, JSON Repair & Transform, JavaScript Playground, Data Converter, Regex Playground, and HTTP Client. Compare, JSON to Code Generator, JSON Repair & Transform, and JavaScript Playground can load a compatible current document, and Regex Playground tests against the current document by default (switchable to custom text). This column is visually subdued until hovered or focused.

On wider windows, the primary file-actions column is centered above the More Actions button; constrained windows keep the menu inside the viewport, and very narrow windows stack both groups.

Up to three tools you repeatedly use can become adaptive quick buttons: an action qualifies after about ten uses, and the three most-used win. On narrow windows those learned buttons are hidden to keep the core controls on one row; all tools remain in More Actions or the Command Palette.

View full size

Command Palette

Press Ctrl+Shift+P and type part of an action name. Document-specific commands follow the active format, while general tools such as JSON to Code Generator and JSON Repair & Transform stay available everywhere. This is also the fastest way to find less-visible functions such as Security Scan.

View full size

Automatic activation

The extension examines the resource URL and response content type. Supported raw documents are enhanced automatically; ordinary web pages are not. Disabling a type in Settings affects newly opened resources.

Launcher and local files

The launcher can open a supported file by picker or drag-and-drop without broad file access. It can also start the Editor, JSON to Code Generator, HTTP Client, JavaScript Playground, Regex Playground, or Data Converter. If the tab you clicked from is a supported viewer, the tool opens on that document in the same tab; otherwise the tool opens on a hosted sample document in a new tab. Launcher files are limited to 10 MiB. Encoding is detected from a UTF-8 or UTF-16 (LE/BE) byte-order mark; without one, strict UTF-8 is tried with a Windows-1252 fallback.

View full size

Persisted and shareable state

For the same resource, CodePrettify can restore search text, highlighted line, folds, scroll position, and the Prettified/Raw (or Rendered/Source) choice without changing the URL. This state is short-lived: it is kept for about one hour and only for the ten most recently viewed resources. Display settings follow your global Settings. Share Configuration URL explicitly encodes selected viewer configuration, including a settings subset, in the hash for an HTTP/HTTPS resource; it does not include the resource body.

What’s New

After a release with substantial new functionality, the extension can show the changes since the last version you used. The announcement appears once, in the first CodePrettify viewer tab you open after the update, and lists every feature release since the version you last used. Never show again stores that preference locally. Small maintenance releases do not need their own announcement.

Tabs and sessions

Open several files in native tabs. Opening the same path reuses its tab. Close with the tab button, middle-click, or Ctrl+W; closing the final tab returns to the open-file landing surface. The app keeps up to ten recent files, integrates with Windows Recent Documents, and can restore the previous window, tabs, and active tab when session restore is enabled. Session state is checkpointed continuously, so restore also works after a crash, and opening files from Explorer reuses the running window instead of starting a second instance.

Paste & Prettify

Press Ctrl+N — the dialog pre-fills with your current clipboard text, which you can replace or edit — and either keep Auto-detect or choose a type. Detection checks JSON, JSON Lines, tolerant JSONC, HTML/XML, fenced Markdown, high-confidence JavaScript, TOML, JavaScript statements, CSS, YAML, CSV, and Markdown/plain text. The dialog accepts up to 16 MiB; larger clipboard content should be saved and opened as a file so large-file safeguards can be used.

View full size

Save and Save As

• Raw/Source saves the original source. Prettified/Rendered/Table saves the document representation, never the viewer’s interface HTML.
• If another program changed the disk file, choose Overwrite, Save As, or Cancel.
• Saving formatted JSONC warns that comments and trailing commas will be removed; No is the default.
• The app preserves the original encoding/BOM when possible, writes saves atomically, and warns when a legacy encoding would lose characters. Unsaved and native large-file tabs use Save As; comparison tabs cannot be saved.

External changes

A file watcher reloads the tab automatically when the file changes outside CodePrettify, follows renames, and reports deletion in the status bar and window title. This is separate from the app’s session recovery.

View full size

Tools that cannot operate on the current format are disabled. Web overlays are unavailable while a tab is in native Raw or native large-file mode; return to Prettified when possible.

Find

Press Ctrl+F, enter text, and use Previous/Next — or Enter for the next match and Shift+Enter for the previous; Esc clears the query and highlights. Plain text matches case-insensitively; wrap the query as /pattern/flags to search with a regular expression — invalid or runaway patterns are rejected safely. The toolbar shows match count (up to 10,000, then shown as 10000+). Ctrl+F temporarily reveals the search field even when the floating toolbar is turned off. Search operates on the document representation, not hidden modal content. The Windows native large-file viewer has paged search with progress, cancellation, and wrap behavior.

Go to Line

Press Ctrl+G, enter a source line, and confirm. The dialog remembers your last entry, and out-of-range values jump to the last line. The viewer scrolls and highlights the requested location. Diagnostic, inspector, schema, security, and navigator result rows can jump directly without opening this dialog.

Folding

Use gutter fold controls for one block or More Actions > Collapse All / Expand All for the complete document. Fold state can be restored for the same browser resource.

Document Navigator differences

• Extension: exposed for JSON (including JSON Lines), JavaScript/TypeScript, and XML/RSS. JSON entries show path/preview/depth/line; XML entries show the element outline; JavaScript entries list named functions, classes, and objects. The Markdown builder is not currently exposed in its menu.
• Windows app: supports JSON, JSON Lines, JavaScript/TypeScript, Markdown headings, and XML/RSS/Atom. Selecting an outline item jumps to its source line.

View full size

View full size

In-depth guide: See local and remote file workflows, rendered/source examples, and privacy behavior in Markdown Viewer for Chrome, Edge, and Windows.

View full size

Structured JSON adds folding, clickable URLs, human-readable timestamp hints (for integer Unix values dated 2000–2050 and ISO-like strings), and hover/click decoding for likely JWT or Base64 strings. Enable the hover breadcrumb (off by default) to see the path under the pointer; the click inspector, on by default, opens JSON Path Inspector when you click a property name.

Run a JSON Path query

1. Open JSON Path Inspector from More Actions, the Command Palette/Tools menu, or by clicking a property name. Breadcrumb segments jump to that node in the document; hovering also sets the inspector’s starting path.
2. Start with $. Use dot properties, quoted bracket properties, numeric indexes, or [*]. Autocomplete suggests keys.
3. Run the query. Copy the current path or a compact JSON/display value, or select a result to jump to its source line.

Scope: the inspector intentionally does not implement filters, slices, recursive descent, or script expressions. It renders at most 200 results and autocomplete shows at most 50 keys. It also works on JSON Lines documents, where $[0] addresses the first record, and a leading $ is optional in queries.

In-depth guide: Follow a complete JSON workflow with formatting, folding, JSONPath samples, schema validation, comparison, and export in JSON Formatter and Viewer.

View full size

Table View is available for compatible JSON arrays of objects and repeating XML/RSS structures; the app also uses it for CSV (CSV files open directly in Table View when CSV formatting is enabled) and for HTML documents with a repeating tabular structure. In the extension, mixed JSON arrays are rejected rather than silently dropping primitive rows; the app shows the object rows and omits primitive entries.

• Search the entire table or filter individual columns.
• Click a column to sort; drag columns to reorder them.
• Expand long cells and optionally show column summaries such as dominant type, unique values, and empty counts. Summaries cover the first 12 columns, and the toggle state is remembered.
• Select individual rows or all rows matching the current filter, then export the selection as CSV or JSON in the current column and sort order. Export the current filtered/sorted table as HTML.
• Large tables use virtual rendering from roughly 1,000 rows so the view remains responsive.

View full size

CSV export: JSON must be a nonempty top-level array of flat objects; nested arrays/objects are not flattened. XML/RSS needs a repeating structured element.

Diagram Generator is a contextual tool for structured documents. Open it from For this file in More Actions or from the Command Palette; the Windows app also exposes it in Tools. Both products support JSON, JSON Lines, YAML, TOML, and XML/RSS documents. The Windows app additionally supports CSV files.

View full size

1. Open a JSON, JSON Lines, YAML, TOML, XML/RSS, or, in the Windows app, CSV document in the prettified view and choose Diagram Generator.
2. Choose Left to right for a compact reading flow or Top to bottom for a conventional hierarchy. Use Include compact values to show or hide short primitive values, XML text/attributes, and CSV cells.
3. The near-full-window workspace keeps direction, value options, generation status, and downloads in the compact left sidebar so the live diagram can use the remaining width and full height.
4. Normal clicks never change the viewport; clicking within a card only selects that card, and each field row highlights when you hover over its key and value. Click the minus button on a reference row to collapse its child branch, or the resulting plus button to restore it. Click a more fields row to reveal the remaining bounded fields in that card. These interactions preserve the parent card's screen position and the current zoom. Double-click a card heading to smoothly center and focus that element; focus the heading and press Enter or Space for the keyboard equivalent, or Shift-double-click the heading to zoom out around it. Drag the dotted canvas to pan, use the mouse wheel or a pinch gesture to zoom around the pointer, press the arrow keys to nudge the view, or use the floating zoom and Fit controls to return to the complete hierarchy.
5. Type in the sidebar Search box to find cards and fields. Matching cards are ringed and their matching rows highlighted while everything else dims, and a counter reports the match total. Press Enter or use the previous and next controls to step through the matches; each step centers and focuses that card. Press Escape in the search box to clear the query without closing the tool.
6. Click any field row to open the Field details panel with the full untruncated value and its document path; Copy value and Copy path put either on the clipboard. Selecting a card also highlights its complete ancestor chain of cards and connectors, so you always see where a record sits in the hierarchy.
7. Use the Levels control to bound the diagram to two, three, or four card levels for a quick structural overview, or Collapse All to fold every branch behind re-expandable plus buttons and Expand All to restore them.
8. Choose Download SVG for a scalable, self-contained diagram or Download PNG for a bitmap image. The Windows app routes both formats through its native Save dialog. Copy Mermaid puts the same cards, fields, and connections on the clipboard as a Mermaid class diagram for documentation, wikis, and issue trackers. The export includes every field of each card, even rows the on-screen card keeps behind its more fields disclosure.

JSON objects and array records become cards with primitive properties grouped into field rows; primitive arrays such as regions show their compact entries directly, while nested objects and record arrays branch from the exact reference row. YAML mappings and TOML tables map the same way, YAML and TOML timestamps render as date values, and a multi-document YAML source becomes one card per document. JSON Lines becomes a root card connected to one card per record. XML elements use the same card structure for attributes, direct text, and child elements. CSV becomes a root card connected to one record card per row, with columns shown as fields; comma, semicolon, tab, and pipe delimiters are detected automatically. The interactive preview is a live DOM scene: cards and fields are semantic HTML elements and connectors are inline SVG paths, rather than a scaled preview image. This keeps focused text crisp and provides a foundation for future editing. Pastel headers distinguish cards, hexadecimal color values include swatches, and the dotted canvas is preserved in exported images.

Local and bounded: the source never leaves the device. Input is capped at 5 Mi characters, diagrams at 160 cards, 14 nesting levels, and 12 visible fields per card by default. A card can reveal up to 40 fields through its disclosure row; any remaining safety limit is reported as limited for readability. Text is escaped before SVG rendering. PNG output is scaled to stay within an 8,192-pixel edge and a bounded pixel budget.

1. Open a normal JSON or JSONC document (JSON Lines is not supported).
2. Open JSON Schema Validator, paste a schema, and choose Validate or press Ctrl+Enter.
3. Inspect each violation’s instance path, keyword, message, schema path, and source line. Select a result to jump.

Core types, enum/const, numeric/string/object/array constraints, composition, conditionals, dependencies, safe regular expressions, and common formats are supported. Validated formats are email, hostname, ipv4, ipv6, uuid, date, time, date-time, uri, uri-reference, and regex; unrecognized format names are ignored rather than validated. Regular expressions with backreferences, lookarounds, repeated groups containing alternation or inner quantifiers, consecutive overlapping quantifiers, or more than 512 characters cause the schema to be rejected as too complex. Validation is completely local.

Limits: schema input is capped at 2 MiB, with depth 80, 100 reported errors, 100,000 validation operations, and about 2.5 seconds — the operation and time budgets apply separately to schema checking and to document validation. Only local # references/anchors are resolved; remote schemas are never downloaded. unevaluatedProperties is reported as unsupported. The pasted schema is kept for the session, and a run that hits any limit is never reported as valid.

In-depth guide: See a real schema produce path- and line-specific violations in JSON query and validation examples.

View full size

Open Statistics & Diagnostics from More Actions or the Command Palette; the Windows app also lists both in the Tools menu. They are two sections of one combined panel — the Diagnostics command opens it scrolled to the Diagnostics section.

Statistics

All formats report original/formatted/minified estimates, lines, characters, and characters without whitespace. JSON adds structure depth and value counts; JavaScript adds declarations/modules/comments; CSS adds rule/property/variable/import/color counts; XML/feed adds element, attribute, namespace, text, comment, and CDATA counts.

Diagnostics

Diagnostics combines syntax status with warnings for long lines (over 300 characters), large documents (over 5,000 lines), and mixed indentation. Depending on format it can identify duplicate JSON keys, JSONC, suspicious timestamps (10–13 digit values outside the recognized Unix range, or invalid ISO-like dates) and URLs, embedded JWT/Base64/URL values, pagination/GraphQL/OpenAPI/schema shapes, feed issues, JavaScript/CSS summaries, HTTP response context and timing in the extension (for documents served over HTTP/HTTPS), and practical quick-fix guidance. Every report also includes a CSV readiness check that states whether the document can be exported to CSV and why.

View full size

Security Scan

Run Security Scan from More Actions or the Command Palette; the Windows app also lists it in the Tools menu. It looks locally for likely cloud/API keys, tokens, private-key blocks, credential-bearing URLs, connection strings, API routes, paths, and file references. Secret findings are masked (leading and trailing characters plus length only) and sorted by severity; endpoint findings are deduplicated and grouped by kind. Every finding links to its source line, and rows also activate with Enter or Space. Selecting a finding reveals any folded parent blocks and centers the exact displayed line while leaving unrelated folds closed; Copy endpoints copies only the endpoint list.

View full size

Important: this is heuristic assistance, not a security guarantee. It may produce false positives and false negatives. A scan examines at most 5,000,000 characters and reports at most 1,000 secret findings and 1,000 endpoint findings; partial results are clearly marked.

Open Data Converter from More Actions, the Command Palette, Tools, or the extension launcher. Its four tabs keep related conversion utilities together: Convert, Hash & HMAC, Timestamp, and ID Generator. On Convert, Use document loads the active text. Choose an operation and press the Convert button beside it. Reverse moves the output into input and selects the inverse. Copy and Download sit together beside output. Inside the dialog, Ctrl+Enter generates on the Hash tab, Enter converts on the Timestamp tab, and the arrow keys cycle the four tabs.

Hash & HMAC

Choose the Hash & HMAC tab to create SHA-256, SHA-384, or SHA-512 output from pasted text or the current document. Hash mode produces a normal digest. HMAC mode also requires a secret key and produces a keyed authentication code. Both hex and Base64 representations can be copied. Text and keys are interpreted as UTF-8, remain in memory only for the open page, are never saved or transmitted, and are capped at 16 MiB each.

Unix / ISO timestamps

The Timestamp tab converts Unix seconds, Unix milliseconds, or ISO 8601 values with Z or an explicit ±HH:MM UTC offset; ISO seconds and fractions (up to nine digits) are optional, and negative or fractional Unix values are accepted. Auto-detection treats absolute values below 100,000,000,000 as seconds and larger values as milliseconds; choose the unit explicitly for far-future dates or early-epoch millisecond values. Use current time fills the present moment in milliseconds. Results include UTC ISO 8601, Unix seconds, Unix milliseconds, and local system time. Ambiguous date strings without a timezone are rejected instead of silently assuming one.

UUID & ULID generation

The ID Generator creates 1–100 UUID v4, UUID v7, or ULID values per batch. UUID v4 is random; UUID v7 and ULID embed the current Unix-millisecond timestamp and use monotonic random portions so a same-millisecond batch remains lexicographically sorted. Generation requires the platform’s cryptographically secure random source and never falls back to Math.random().

Compatibility and safety

Operations proven incompatible with the current input are disabled with a reason; other choices remain selectable. JSON conversion refuses unsafe integers, -0, out-of-range values, and decimals that JavaScript would silently change. CSV/TSV requires flat tabular data and protects spreadsheet-formula-leading text: import treats the first row as a unique header row, rejects rows longer than the header, and returns every field as a string without type inference, while export unions all object keys into the header and leaves missing values empty. YAML conversion cannot preserve comments, anchors, tags, or scalar styling, and aliases that reuse arrays or objects are rejected outright to prevent unsafe expansion.

View full size

Limits: 10 Mi characters input, 32 Mi characters output, plus YAML bounds of 500,000 values and 512 nesting levels. Base64 decode must produce valid UTF-8.

JSON to Code Generator is a general tool, so it remains available in More Actions and the Command Palette for every file type. The extension also exposes it from the launcher, and the Windows app includes it in Tools. Paste any strict JSON sample or choose Example; when opened on a JSON document, the sample is loaded automatically the first time, and Use document reloads it at any point. Generation runs entirely on the device.

1. Enter one JSON object, value, or array of sample records in JSON sample.
2. Choose a Target, set the Root type name, and, where supported, adjust the package or namespace. That field appears for C# (Namespace, default Generated), Java and Kotlin (Package, default com.example.generated), and Go (Package, default main); invalid entries are normalized automatically.
3. Optionally enable Make every property optional. Otherwise, properties missing from some array samples become optional automatically, while an explicit null becomes nullable.
4. Review the live generated code and any inference warning, then Copy to clipboard, Open as document, or Export. Press Ctrl+Enter in the sample box to generate immediately.

The example below converts an advanced order payload—with nested customer data, line items, nullable discounts, tracking events, payment totals, tags, and metadata—into ready-to-use C# models with System.Text.Json annotations and a project namespace.

View full size

Inference behavior

Nested objects become named models. When the root is an array, all array entries contribute to inference rather than only the first record. Different compatible shapes are merged; genuinely mixed values become unions where the target supports them and a safe general type where it does not. Empty arrays cannot reveal their element type: they are counted into a single informational warning, and the target's safe unknown type is used only when no sample populates the array — otherwise a populated sample's element type wins. Property names such as user-id, reserved words, and other invalid identifiers receive the target's normal field-mapping annotation instead of changing the JSON contract. Array property names are singularized when naming element types (addresses becomes Address), and integers map to 64-bit types in typed targets. Make every property optional goes beyond adding ?: it removes JSON Schema required lists and uses Option, pointer, or nullable forms with defaults where the target needs them.

Limits: input is capped at 5 Mi characters, generated output at 16 Mi characters, nesting at 100 levels, and inspected JSON values at 100,000. Invalid or incomplete JSON reports its line and column when available. Limits fail closed and never alter the source document.

In-depth guide: Compare TypeScript and Python/Pydantic output from the same multi-sample payload in JSON to Code Generator.

Open JSON Repair & Transform from General tools in More Actions or from the Command Palette; the Windows app also exposes it directly in Tools. It is available for every supported document type because pasted JSON-like input works independently of the active document; in the Windows app it requires an open document tab in prettified view. A compatible current document remains an optional starting point through Use document. All processing stays on the device. Its two tabs are designed as one workflow: review and normalize the source in Repair & Salvage, then pass that result to Transform. Both tabs retain the same dialog height when switching, and the Repair input, repaired output, and live Transform result use the shared compact code-text scale while preserving useful editor space.

In-depth guide: Walk through fenced, Python-style JSON repair and a filter-and-sort recipe in JSON Repair & Transform.

Repair & Salvage

1. Review or replace Input to analyze. Use document restores the active document text.
2. For JSON Lines only, enable Salvage valid JSON Lines records when some records are invalid if you deliberately want invalid records excluded. Leave it off when every record must survive.
3. Choose Analyze & repair. Review the confidence, each recorded repair, warnings, and any discarded source-line numbers before using the result.
4. Copy or download the repaired JSON, or choose Use result in Transform.

The repair engine can remove a byte-order mark or Markdown fence, extract the first balanced object/array from surrounding prose, remove JavaScript comments, convert single-quoted strings, quote unquoted object keys, replace recognized JavaScript/Python literals (True/False become true/false; None, NaN, undefined, and ±Infinity become null), add leading zeros to bare decimal numbers, close unterminated property strings, insert missing commas and closing brackets, remove trailing commas or a final semicolon, and escape raw controls inside strings. Every applied change appears in the report; extraction, semantic literal replacement, structural insertion (missing commas/brackets, closed strings), and excluded JSON Lines records lower confidence from high to medium so they receive extra scrutiny.

Partial salvage is destructive: invalid JSON Lines records are never discarded silently. Without explicit opt-in, one invalid record blocks the result. With opt-in, the report identifies every excluded line. Mismatched brackets and structure that cannot be resolved safely are rejected; within JSON Lines, a record that would need bracket insertion or extraction is treated as invalid rather than repaired.

View full size

Inputs normalized for the pipeline

Build a transformation pipeline

After choosing Use result in Transform, the guided workspace shows the recipe builder beside a Live result. Common transformations are one-click choices under Add a transformation; less common choices stay under More transformations. Each step includes a plain-language summary, and Field controls suggest fields detected in the current data with their types and sample values. Labels, helper text, fields, and actions follow the same compact form scale used by other CodePrettify dialogs. Move steps up or down to change the result, remove individual steps, or choose Clear all. The most recent pipeline recipe is retained locally, while the source document itself is never modified.

An incomplete step does not empty or damage the preview: the previous valid result remains visible and the status explains which field or value is still needed. If a completed step removes every row, a prominent No rows matched explanation identifies that step and offers to remove it.

View full size

In most cases, choose a detected field instead of writing a path. In Filter, the label any item represents an array wildcard — owners[].name checks the name of every item in owners — and Filter also accepts the forgiving form owners.name, crossing the array automatically; other operations expect a concrete path. Advanced paths use familiar dot/index notation such as customer.address.city, items[0].sku, or $["odd.key"]. Filter values accept JSON literals such as true, 42, null, arrays, and objects; other text remains a string. Use "" to match an empty string.

Use Copy, Export, or Open as document when the live output is ready. Opening the result creates a separate document or tab; it does not replace the source.

Safety limits

Fail-closed safeguards: input is limited to 10 Mi characters, output to 20 Mi characters, structure to 250,000 nodes and 512 nesting levels, pipelines to 32 steps, and array output to 250,000 rows. Unsafe integers, lossy or non-finite numbers, overflowing aggregations, and prototype-sensitive path segments are rejected. Limits cannot be bypassed by partial-record salvage.

Copy

The floating copy menu and app Edit menu offer Original, Formatted, and Minified when valid. The main Copy button and Ctrl+Alt+C reuse your last-chosen variant; before any choice they copy the visible representation (Raw copies Original, Prettified copies Formatted). Feedback explicitly identifies what was copied. YAML hides Minified because there is no safe equivalent.

Export

• Download Original, Formatted, or Minified source.
• Export compatible structured data as CSV or the active table as HTML. CSV files use CRLF line endings, quote every cell, and neutralize formula-leading text for safe opening in spreadsheets; the extension additionally prepends a UTF-8 byte-order mark for Excel.
• Convert compatible documents to JSON/YAML/TOML during download; only targets the document can actually be serialized into are offered, while CSV export shows a readiness status with a reason when unavailable. XML/feed tabular projection is best-effort and can be lossy.
• In the extension, export code as a PNG using visible viewport/full code, line-number, wrap, and resolution choices; when a full-code image is too large for a single PNG, it downloads a ZIP containing numbered PNG parts instead. The Windows app’s Save as Image captures the visible viewport as a single PNG.

The Windows app’s Save writes to disk; Export creates a separate representation. In the extension, export always downloads a new file.

Compare any two sources

1. Open Compare or press Ctrl+Alt+D.
2. The left input starts with the current document and the right input starts empty. Edit or paste either side; each side has its own Use current document and Clear controls.
3. Use Swap sides before comparing to exchange the actual inputs. Semantic mode is selected automatically when both inputs parse as a supported structured format (the toggle appears only when semantic comparison is possible); switch to Text mode for exact line changes. Semantic availability is detected from the two inputs, not from the open file.
4. After comparing, use Swap Sides or Edit inputs; the Windows app also has Previous/Next difference buttons. (After a comparison, Swap flips only which side is displayed without changing the inputs.) Text mode synchronizes pane scrolling, and in the Windows app it adds an Ignore whitespace option that disregards all whitespace inside lines.

Semantic comparison supports JSON/JSONC/JSON Lines/YAML/TOML where parsing succeeds, even if the active document is JavaScript, CSS, or another format. It ignores formatting and object-key order. (JSONC comments and trailing commas inside JSON Lines records are accepted in the app; the extension requires strict JSON per line.) Arrays whose elements are all objects with a unique primitive id, _id, uuid, or guid — the same key on both sides — are matched by identity; all other arrays are compared positionally. Change sets are capped at 5,000 entries, with a trailing … on the counters when truncated, and invalid inputs fall back to text. Very large text comparisons (over roughly 5,000 combined lines in the extension, 20,000 in the app) use a faster position-based comparison that can overstate changes when lines shift. A structured change can jump to an editor line only while the corresponding left or right source still exactly matches the current document, and only for JSON documents with positionally addressed changes — changes inside identity-matched array elements list the change without a jump; independently pasted or edited text never produces a misleading jump. When the sources are identical, both modes show a centered no-differences message over the result area.

Compare files (app)

The Windows app can browse two files, prefill the current file, remember the pair, and open a dedicated comparison tab. Selecting exactly two supported files in Explorer can expose the Compare command.

View full size

1. Start the Playground from any viewer’s More Actions menu or the extension launcher. Open a JavaScript, JSON, or JSON Lines document first if you want to include it as context.
2. Write scratch code. Optionally include the current document; JSON/JSON Lines becomes const json (invalid JSON Lines records are skipped, and an invalid JSON document provides no json variable). Scratch code and your timeout/include choices are remembered between sessions.
3. For JavaScript choose Safe definitions to expose callable/passive top-level declarations without page startup, or Run entire file to include startup logic. Safe definitions keeps functions and constants with side-effect-free initializers; classes and values computed at startup require Run entire file.
4. Choose a 1, 5, or 15-second timeout and Run, or press Ctrl+Enter.
5. Inspect console output, console.table, errors with mapped lines, duration, and the final expression’s value. Top-level await is supported, and unhandled promise rejections appear as console errors.

Output bounds: the console keeps the last 500 entries, value previews truncate at 10,000 characters, and a timeout hard-terminates the worker so runaway loops cannot linger.

View full size

Inspect Runtime executes the current JavaScript in the same sandbox with a fixed five-second timeout and groups top-level variables, functions, and classes. It captures parameter signatures, bounded values, source previews, console output, and declaration line links. Partial results remain useful if later startup code throws.

Choose inline-value display to add captured values beside source lines and hover details. Use Clear inline values to remove annotations. Runtime Inspect has the same no-DOM, no-Node, no-local-files, and no-network restrictions as the Playground.

View full size

1. Choose Current document or Custom text. Custom text is session-only; document mode highlights matches in the viewer and can jump to them, and moving the editor cursor onto a highlighted match selects it and shows its capture groups.
2. Enter the pattern without surrounding slashes. Toggle global g (on by default), ignore case i, multiline m, dot-all s, Unicode u, or sticky y.
3. Review the matches with line/column. The list shows the first 100 (all matches up to 500 are still counted and highlighted); select a match to see its numbered and named capture groups in the details panel. The right side always shows the complete /pattern/flags form with Copy Regex.
4. Open Advanced for replacement preview ($1 and $<name>), a combined saved-and-recent list holding the last ten patterns (recent runs are recorded automatically; Save pattern adds a named entry to the same ten-slot list), and up to 20 test assertions: Matches, No match, Match count, or Replace equals.
5. Copy generated JavaScript, C#, or PowerShell snippets, or load an example from the guide.

View full size

Safety: patterns run only in a worker, time out after roughly 1.5 seconds, and stop after 500 matches. This prevents a catastrophic expression from freezing the viewer.

In-depth guide: See live named-group matches, replacement preview, tests, and language snippets in Regex Playground.

Build a request

1. Choose GET, POST, PUT, PATCH, DELETE, HEAD, or OPTIONS; enter an HTTP/HTTPS URL and timeout (default 30 seconds).
2. Add query parameters, headers, and authentication: None, Bearer, Basic, or API key in a header/query.
3. For a body choose None, JSON, raw text, URL-encoded form, multipart fields, or GraphQL with variables. GET and HEAD requests never send a body.
4. Use {{variable}} from an environment. Secret fields are masked in the UI.
5. Press Send. This is the moment the browser/app makes the external request. While the request runs, Send shows a spinner and a Cancel button appears beside it.

Reuse and share safely

Save requests, collections, environments, and sanitized history. Import cURL or CodePrettify JSON; export JSON. Generate copyable cURL, fetch(), or PowerShell — generated snippets and response views mask known secret values as ******, so re-insert real credentials before running a snippet. Export warns when authentication/secrets would be written in plain text.

Inspect the response

Review formatted Body, Raw, Headers, Cookies, status, duration/timing, size, and content type. The Body tab formats recognized JSON, JSON Lines, YAML, CSS, HTML, XML, JavaScript, or TypeScript in the embedded viewer; use the Raw tab’s Copy button for the exact response text.

View full size

Limits and behavior: URLs with embedded credentials are refused (the extension explains this directly; the app reports it as a blocked request) — use the Auth controls instead. Cache is disabled and redirects are followed. Response bodies are capped at 50 MiB; anything beyond the cap is discarded and the size chip shows the bytes actually kept. Requests follow each platform’s fetch rules: in Chrome/Edge the extension’s granted host permissions usually exempt its requests from CORS, in Firefox CORS applies unless host access is granted, and the Windows app is subject to standard CORS. A timeout of 0 disables timeout; maximum differs by product (five minutes in the extension, ten in the app).

Local storage is bounded: the extension allows up to 500 collection entries, 50 environments, and 200 variables per environment; the app uses 100 entries, 20 environments, and 50 variables per environment. History keeps the last 10 requests per page (the extension retains the 25 most recent pages, the app 40). In the extension, history strips credentials, sensitive headers/query values, request bodies, and secret text in error messages before replay data is stored; in the app, history masks well-known credential header values but retains request bodies and query strings, so clear it manually after sending sensitive requests.

In-depth guide: Follow a complete request from params and environment values through formatted body, headers, timing, and copyable snippets in HTTP Client.

View full size

View full size

Extension settings apply immediately and are stored through browser storage; app settings are local. They are not synchronized between products.

Inputs, dropdowns, textareas, buttons, and icon buttons throughout CodePrettify use the same small, medium, and large control scale, so padding, type size, field height, and click targets remain consistent when moving between Settings and tools. Technical textareas in Compare, JSON to Code Generator, JSON Repair & Transform, Data Converter, Schema Validator, HTTP Client, Regex, the JavaScript Playground fallback, and JSON decode all use one compact 13px code-text scale and monospace stack. Modal titles, section headings, field labels, help text, and status messages also share one typography system. Task-specific layouts, state colors, badges, editor viewport heights, and result panes remain specialized where their purpose requires it.

Native large-file mode

Files of 64 MiB or more use a read-only native pager instead of loading the full WebView document. Generic pages contain about 750,000 characters; CSV pages contain 500 rows with a synchronized raw view. Previous/Next, page search, forward cross-page search with progress/cancel/wrap, and Go to line/row remain available. Most WebView tools are disabled and Save becomes Save As of the original.

Encoding

The app detects UTF-8/BOM, UTF-16 LE/BE, UTF-32 BOM, BOM-less UTF-16 heuristics, strict UTF-8, then Windows legacy fallback. Click encoding in the status bar to reopen as Auto, UTF-8, UTF-8 BOM, UTF-16 LE/BE, Windows-1252, or ISO-8859-1. Overrides are session-only; a reopened file reverts to auto-detection.

Line endings

The status bar shows Windows (CRLF), Unix (LF), Mac (CR), Mixed EOL, or No EOL. Click it to convert the document (files up to 256 MiB). Conversion asks for confirmation and then rewrites the file on disk immediately — no separate save is needed.

Explorer integration and runtime requirements

The packaged x64/Arm64 app is .NET 10 self-contained, so the main app does not require a separate .NET desktop runtime. It does require the shared Microsoft Edge WebView2 Evergreen runtime; if missing, the recovery screen opens Microsoft’s installer and provides Retry.

File associations and Explorer commands can open supported files, and selecting exactly two supported files can offer Compare. This optional Explorer handler is framework-dependent and may require matching Microsoft.NETCore.App 10.x. Use Help > Explorer Integration Runtime to check/install the official prerequisite, then restart Explorer or sign out if the shell has not refreshed.

• Formatting, validation, conversion, diagram generation, JSON-to-code inference and generation, JSON Repair & Transform, statistics, search, comparison, schema checks, security scanning, and playground/regex processing stay on the device.
• The HTTP Client is the intentional network exception: the request is sent directly to the displayed target only after you press Send. CodePrettify does not proxy it.
• Playground and Runtime Inspect run in a Web Worker inside a script-only sandboxed frame whose content-security policy forbids all network connections; fetch, XHR, WebSocket, and other networking primitives are additionally disabled before your code runs, and there is no page DOM, extension API, local-file, or Node capability.
• Markdown suppresses automatic remote image loading. Remote JSON Schema references are never fetched.
• To repair garbled legacy-encoded JavaScript/TypeScript documents, the extension may automatically re-download the same document URL it is already viewing; this request goes only to the server that served the page. Launcher sample documents are loaded from prettify.cloud.
• HTTP environments and saved authentication are local but not encrypted as a secrets vault. Treat exported HTTP JSON as sensitive because it may contain plaintext secrets.
• Extension host permissions allow CodePrettify to recognize supported resources; they do not upload documents.

For the complete policy and marketplace disclosures, read the Privacy Policy.