Hex Viewer & Editor

Reading the two panes

The left pane is each byte in hexadecimal; the right is the same byte as a character where one is printable. Printable here means the ASCII range 0x20–0x7E; everything else shows as a dot, which is a placeholder rather than a full stop in the data.

Viewing bytes

Content is shown in the classic three-pane layout: the offset of each row, the bytes in hexadecimal, and the same bytes rendered as characters. You can set how many bytes appear per row, group them in twos, fours or eights, switch offsets between hexadecimal and decimal, and shift the displayed offsets by a base address when you are looking at a region that was loaded somewhere else in memory.

The character pane can decode bytes as ASCII, Latin-1, UTF-8 or EBCDIC, and non-printable bytes are shown as a placeholder you choose. Turning on colouring tints each byte by what it is — nulls, printable ASCII, whitespace, control codes and high bytes each get their own shade — which makes headers, padding and string tables easy to pick out at a glance.

Editing bytes

Click a byte to place the cursor, then type over it. In the hex pane two keystrokes make a byte; in the character pane one keystroke writes the character's code. Overwrite mode replaces bytes in place so the file keeps its size, and insert mode grows the buffer as you type.

To change a run of bytes, drag or shift-click to select it and enter a replacement value. The replacement can be typed as hex, plain text, Base64, binary, decimal or a C array, and it does not have to be the same length as the selection. You can also fill a selection with a repeating pattern, delete it outright, or insert new bytes at the cursor without disturbing anything after it.

Every edit can be undone with Ctrl+Z and redone with Ctrl+Shift+Z, and bytes that differ from the file you loaded stay highlighted so you can see exactly what you have changed. Revert puts everything back.

Moving around

The grid is fully keyboard navigable: arrow keys move a byte at a time, Page Up and Page Down jump a screen, Home and End go to the start and end of the row, and Ctrl+Home and Ctrl+End go to the start and end of the file. Tab switches between the hex and character panes. The "go to offset" box accepts absolute offsets in either hexadecimal ( 0x1F4 ) or decimal ( 500 ), as well as relative jumps such as +16 and -16.

Searching

You can search the buffer four ways. A hex pattern such as 4D 5A matches those bytes exactly. A text search matches the characters you type, optionally ignoring case. A wildcard pattern such as 4D 5A?? 00 matches any byte where you write ??, which is useful when a field in the middle varies. A regular expression matches against the text the bytes decode to, so you can look for structure rather than a fixed value.

Every match is highlighted in both panes, with the one you are currently on picked out, and you can step forwards and backwards through them. Replace swaps the match under the cursor; replace all rewrites every match at once as a single undoable change, and the replacement does not have to be the same length as what it replaces.

Inspecting values

The data inspector reads the bytes at the cursor as every integer and floating point width — 8, 16, 32 and 64 bit, signed and unsigned, plus 32- and 64-bit floats — and shows each one in both little endian and big endian, so you do not have to work out the byte order by hand. Alongside those it decodes the byte in binary and octal, reads Unix and MS-DOS timestamps, formats 16 bytes as a GUID, and shows four bytes as an RGBA colour with a swatch.

All of these are editable. Type a new value into any field and press Enter and the bytes underneath are rewritten in the byte order of the column you typed into. Values outside the range of the type are rejected rather than silently wrapped. There is also a row of bit toggles for the byte at the cursor, so you can flip a single bit without doing the arithmetic.

Analysing a file

Analysis identifies the file from its magic bytes — PNG, JPEG, GIF, PDF, ZIP, GZIP, ELF, Windows PE, Mach-O, WebAssembly, SQLite, MP3, MP4, TAR and others — regardless of what the file is called. It also measures Shannon entropy in bits per byte, which tells you at a glance whether a region is plain text, structured binary, or compressed or encrypted; reports what proportion of the bytes are printable; and draws a histogram of how often each byte value occurs.

The same pass computes CRC32, MD5, SHA-1 and SHA-256, and extracts printable ASCII and UTF-16 strings with their offsets, which you can click to jump straight to. You can run all of this over the whole buffer or over just the selection. Because these describe the bytes as they were, editing after a run marks the results as out of date rather than showing you a hash of bytes that have since changed.

Comparing two files

The bar at the top holds two file slots. Drop a second file into the right-hand one and the two open side by side, each with its own offsets, hex and character panes. Both stay fully editable: type in either one and the differences update as you go. Bytes that differ are highlighted in both grids, and the bar above them tells you how many differences there are and how many bytes they cover.

You can step through the differences one at a time, and push the bytes of the current one from either side to the other with the arrow buttons, which is how you merge a change without retyping it. A strip between the two grids maps every difference across the whole file, so you can see at a glance whether changes are clustered or spread out, and click it to jump. Swapping the sides re-orients the comparison without reloading, and the "only differences" filter hides the matching rows so you see just the regions that changed with a little context around each.

Scrolling is synchronised by default so the same offsets stay level in both grids; turn it off when you want to look at two different regions at once. Each side keeps its own undo history and its own revert, so an edit on one never disturbs the other. Where one file is longer, the extra bytes are reported as a single difference rather than one per byte. You can also compare against the bytes as they were when you loaded them, which shows exactly what your edits changed.

Getting bytes back out

Copy the whole buffer or just the selection as a hex string, an xxd -style hex dump, plain text, Base64, binary, decimal values, a C array or a Python bytes literal. You can also download the edited result as a binary file, or save the hex dump as a text file.

Common uses

• Checking a file's magic bytes to work out what it really is, regardless of its extension.
• Patching a single byte in a binary, a save file or a firmware image.
• Reading the header of a format you are implementing, field by field.
• Inspecting exactly what bytes an encoder produced, including invisible characters, byte order marks and line endings.
• Converting between hex, Base64, binary and text representations of the same data.
• Confirming padding, alignment and null termination in a structure.
• Working out which two builds of a binary differ, and by how many bytes.
• Reading a length or timestamp field without working out the byte order by hand.
• Checking whether a blob is compressed or encrypted before trying to parse it.
• Pulling the readable strings out of a binary to see what it references.
• Verifying a file's checksum against one you were given.