Documentation

Before you start

Use a current browser. Desktop Edge or Chrome supports direct file saving where your device allows it; other browsers can use downloads. Keep an original copy of any file you edit. All checksum names are visible in Basic; 8-bit checksums and hashes calculate with Basic access; wider CRCs, sums and XORs require Pro. File contents and script execution stay on your device. Account checks and saving account scripts need an Internet connection. Scripts can change the selected bytes: review every proposed change before applying it. For help or a security report, contact support@pollux.lt and include the app version and a debug report; avoid sending passwords, payment details or private binary files.

Getting started

PolluxTool opens with an empty workspace. Use Editor mode: before Data width to open editor properties and choose Simple or Advanced for the current file. Choose Open file to select one or more files, or drop a .bin / .epr, Intel .hex / .ihx, or Motorola .s19 / .s28 / .s37 / .srec / .mot file into the workspace. Other binary extensions load as raw bytes. Drop .ptmap files to load bookmarks, and .js / .mjs files to import scripts; .txt drops in Scripts also import script text. Files are read into browser memory and never uploaded. Defined file data is limited to 64 MiB per file; encoded input is limited to 192 MiB. Widely separated addresses use segments, so a gigabyte-wide address span does not allocate a gigabyte of memory. HEX and S-record checksums, lengths and addresses are validated. Motorola files may omit the termination record and mix S1, S2 and S3 data records. Binary files open in Simple mode. Intel HEX and Motorola imports show a warning that Advanced mode will be used, followed by import properties: base offset (from file by default), blank handling (FF, 00, custom byte, or blank), and the gap compression threshold (0x400 by default). Only the first row must start at a multiple of 0x10; leading padding is added if needed. Row widths can then be any supported number of bytes. Large gaps appear as amber separators. If small-gap padding would exceed the 128 MiB working memory cap, additional gaps are compressed automatically. Type X or - in an Advanced-mode value cell to mark it blank; Options → Editor properties chooses XX or -- display. Blank bytes are omitted from calculations. HEX and S-record exports preserve absent bytes and regenerate record checksums; binary save requires all bytes and address gaps to be filled.

Drag the divider between hex and ASCII to change bytes per row (4–128, aligned to the current data width). Focus the divider and use arrow keys for precise adjustment; double-click restores 16. The toolbar Row width menu offers the same sizes. The default grid shows 16 bytes per row as 8-bit hexadecimal values, with hexadecimal offsets on the left and ASCII on the right. Non-printable characters appear as a dot. A selected range has a purple highlight. Changed bytes use red text, with no corner marker. Purple selection overrides annotation fills. The selected range uses inclusive endpoints. Hover a bookmark, search result or checksum storage fill to see its thin gray rounded boundary and one tooltip. Checksum data zones keep their normal appearance without an added hover outline. Overlapping fills choose the item whose centre is nearest the pointer. Equal-length overlaps divide the shared area into portions so each item can be inspected separately; the active item uses its own colour throughout its range.

Desktop layout, themes & value colors

The menu bar provides File, Edit, View, Bookmarks, Options, Tools, Window, and Help. Common commands are also available on the toolbar. Choose a high-contrast light or dark theme in Options, or use the sun/moon button. Your theme and color-scale preferences are saved to your signed-in account. Click a bookmark column heading to sort by name, address, length, value or type; click it again to reverse direction. Bookmark value interpretation, defined values and accompanying inverted copies require Pro.

Data inspector, Checksums, and Bookmarks & checksum zones are independent tool windows. Scripts opens a dockable tab with a filterable script list, Run, Stop and Open workbench; the workbench edits source and shows run output. Find Results, Find checksums and Compare keep their results in docked tabs. Bookmarks also has Maximize and Restore controls. Its maximized list uses the available screen, while bookmark and group editors remain on top. Escape restores a maximized list when no editor is open; closing an editor returns to the list. Drag a title bar to move, float or dock its tool; resize a floating window from its lower-right corner. A focused floating title bar also accepts arrow keys. Tabs → Restore docked layout restores the default tools. On narrow screens the tools stack below the editor.

Enable Color values to shade cells blue at the minimum, green at the midpoint, and red at the maximum. The data-type scale is 0–255 for unsigned 8-bit values, 0–65,535 for 16-bit, and 0–4,294,967,295 for 32-bit. Signed views use their signed ranges; floating-point views default to 0–1. Options → Value color settings lets you enter a custom decimal minimum and maximum. Values outside a custom range use the endpoint colors. NaN, Infinity, and incomplete values remain neutral. Endianness is respected. Colors only affect display; selected cells use a distinct purple fill and bright outline.

Bookmarks → Bookmark selection opens the full definition form: set name, address, length, type, colour, scaling and definitions before adding the bookmark. Add and Edit share the same fixed layout. The bookmark and checksum-zone tabs have independent filters for names, types and addresses; calculated checksums can be filtered by name or result without changing enabled algorithms. Alt+F2 and Alt+Shift+F2 in the editor move between bookmarks. F2 opens Pro checksum discovery. Bookmarks sort by ascending address by default. Choose Name, Type, Value or Length and ascending or descending order in the bookmark list. Value uses the first interpreted value; text compares its first 160 displayed characters. Group headers remain separate from member ordering. Use Manage bookmarks to edit a range, its type and its data, including exact-length ASCII text. Bookmarks → Save .ptmap exports all current bookmarks, checksum zones and template blocks, including every copy and its member definitions. Filtering or collapsing the lists does not limit the export. The Templates tab counts master blocks and copies together; its list shows the number visible out of the total. Save reports the exported counts. Changes made while a save is being written remain unsaved and need another save. Existing .bkmrk files can still be imported; Load .ptmap or dropping a bookmark file opens a review before adding its definitions. Ranges are stored relative to the binary, and the file length must match on import. Bookmark files do not contain the binary bytes or verify their contents. Opening another binary clears the current bookmark list. Deletion adjusts or removes intersecting bookmarks, and Undo restores them.

Binary bookmarks and named values

In a bookmark’s definition, choose Binary for 8-, 16-, 32- or 64-bit values. The value editor shows zero-padded bits, most significant bit first, and uses the selected byte order for multi-byte storage. Enter bits with optional spaces or a 0b prefix, or use 0x for hexadecimal. Values must fit the chosen width; factors and offsets apply to numeric types, not binary bit strings.

For binary bookmarks, use the inline Bit definitions table to name individual bits and optionally describe their zero and one states. Bit 0 is the least significant bit, independent of byte order. The custom binary value window has clickable bit switches, a stored-byte hex preview, and a free-entry binary field. Click Apply bits to commit the draft in one Undo operation or Cancel changes to discard it. For bookmarks containing several values, choose the value by offset first; switching values discards an unapplied draft. Definitions apply to each value of the chosen width and are saved in .ptmap.

For non-binary types, use Named values (optional) in the bookmark definition. Binary bookmarks use only bit definitions. Enter one value = label; per line, for example 0x01 = Off; and 0x02 = On; for an unsigned 8-bit bookmark. Values follow the chosen data type and, for calibrated numeric bookmarks, refer to the displayed value after factor and offset. Definitions are formatted as value = label; with consistent spacing. Extra spaces, missing semicolons and separated 0x prefixes are normalized; invalid values are rejected. The list shows a matching label beside the current value. Edit value shows Address, an active Value field, and Choose defined value. Matching presets are selected automatically while typing, including calibrated values. Choose a preset, then press Enter or leave the input to apply; you can always type another valid value. These definitions are suggestions, never an enforced list. Duplicate stored values are rejected; combine their descriptions into one label. Up to 128 named values are kept per bookmark and saved in .ptmap files.

Save and Save As

Save (Ctrl+S) writes to the current data-file target after an in-app overwrite confirmation. Save As (Ctrl+Shift+S) opens a file dialog; after the write finishes successfully, that file becomes the new Save target and the tab takes its name. Both preserve the document’s binary, Intel HEX or Motorola format. Enabled checksum zones are calculated and verified before writing. Use Export for a copy in another format; Export does not switch the Save target.

The bookmark toolbar and Bookmarks menu also have separate Save and Save As actions. They write all current bookmarks and checksum zones to .ptmap. File metadata includes creation and edit history, the saving program version and https://pollux.lt. Custom CRC parameters are included only when a saved checksum zone uses them. Loading a native .ptmap through the file picker sets its Save target when the import is accepted. After Save As, the new .ptmap becomes the target. Foreign HBK/POS/CSV imports require Save As; their original files are not overwritten with another format.

Direct overwrite requires a browser with file-handle support and permission to write the file. Open uses the native handle-aware picker when available. Files opened by drag-and-drop or a fallback input need Save As on first save. Where the browser cannot provide a writable handle, Save As uses a download and cannot retain access to that location. Handles stay in this tab’s session; reopening the app requires selecting the files again. Cancelling or failing a save keeps the previous target.

Bookmark groups and layout

Right-click a group or use its settings button beside the colour button to rename it or change its colour. Delete group only moves its bookmarks and checksum zones to Ungrouped; Delete group and entries removes them after confirmation. Right-click selected bookmarks to move or delete the selected batch. Filters match bookmark and checksum fields, not group names; group headings stay visible. Modified bookmark values are bold red. Imported bookmarks open in the last location you chose without moving the panel.

Import modified data

Open the original file and define or load its bookmarks and checksum zones, then choose File → Import modified file. The selected modified binary replaces changed bytes in the current document and can be undone. The original comparison data, bookmarks, checksum definitions and save target stay in place; enabled checksum zones recalculate. Byte length must match. Structured files must also keep the same addresses and blank positions; raw binaries require a complete, contiguous document. Use a separate document for files with a different layout.

Browser access permissions

At startup, the app checks available local storage and access to selected file or bookmark-folder handles. A nonblocking warning offers Allow where the browser supports a permission request. Each request follows your click. If access stays denied or cannot be requested, use the browser’s site settings or choose the file again with Open or Save As. Persistent storage is recommended for settings and local recovery; regular file backups remain necessary. These checks do not upload file contents or grant access to unselected files.

Editing & navigation

When insertion or a longer replacement moves later data, a dialog offers Shift affected entries or Keep addresses for bookmarks and checksum zones. Shift follows their bytes, including inverted copies and covered ranges; Keep addresses remaps the original displayed addresses. Do not ask me again for current file remembers only that open document’s choice. A new document asks again. Cancel makes no changes. Overwrite does not show this dialog. Use N for the next difference or edited-byte range and V for the previous range while focused in the editor. In Free Simple comparison, applying a right-file shift compares immediately; ordinary byte edits keep the last result until Recompare. Width, format and byte order are shared by both files, starting with the left file’s settings; changing them compares again. Right-click selected bytes and choose Transfer from the other file to overwrite those addresses as one undoable edit. Close Compare exits comparison; Minimise hides its results while keeping marks active. Already visible navigation targets keep their position and receive the orange cursor outline.

Changes: Ctrl+Left / Right goes to the previous / next changed byte. Ctrl+Up / Down skips to the start of the previous / next contiguous changed range. Both work for edited bytes and file comparison.

Click a numeric or ASCII cell to position the edit caret without selecting bytes. The mouse uses a text cursor. In hexadecimal view, physically highlight both characters of a byte to select it; one highlighted digit does not count. Checksums remain idle with no selected bytes. Drag across cells or Shift-click to extend a selection. Use Set range to enter exact start and end offsets, or select the entire file. Go to uses hexadecimal only, with a fixed 0x label beside the input. Other address fields accept decimal or hexadecimal with 0x. Go to offset selects the current address text automatically; type a replacement and press Enter to jump and return focus to the selected value.

Click the digit where you want to start. OVR mode replaces the character under the caret without selecting the whole value. Completing a value commits it and advances automatically to the next cell; ASCII typing advances after each character. Clipboard paste operates on explicitly selected bytes only, and the byte count must match. Ctrl+C copies uppercase raw 8-bit bytes without spaces, such as 0012ABFF, independently of the displayed data type and byte order. Press Insert, or click OVR / INS, to toggle between character overwrite and normal value-entry typing. INS permits characters within a value. In hexadecimal view, typing a valid hex digit after the final character inserts a new cell, including at the end of the file. The new cell is padded with zeroes to the selected data width and follows its byte order. Decimal and floating-point entry stay within their current cell. Press Enter to commit early, Escape to cancel the current unfinished value, or Tab / Shift+Tab to commit and move to the next / previous value. Use Undo for values already committed by automatic advance. Clicking elsewhere commits valid input. Invalid values display an inline error and are never applied. ASCII cells accept one ASCII character. Typing and clipboard paste overwrite existing bytes. The right-click menu also offers Delete selected bytes, Add bookmark, Invert bits, XOR with a one-byte key, and byte swaps within 2-, 4-, or 8-byte groups. Swap selection lengths must be a multiple of the group size. Delete removes bytes and shifts the remaining data; Undo restores them. Each selection operation is one undoable action. An incomplete word at the end of a file displays “—”; switch to 8-bit view to edit its remaining bytes.

While the editor is active, search shortcuts are intercepted even when a cell or search field has focus. Browsers or operating systems that reserve a shortcut may prevent it from reaching the page; the search controls remain available. Search accepts whitespace-separated hex bytes, such as DE AD BE EF, or ASCII / UTF-8 text. Find next continues forward and stops at the end of the search area; use Restart from chosen position to begin again. Save preserves the current file format; binary output refuses unresolved blanks or address gaps. Every save/export updates enabled checksum zones and verifies them again before writing. Save As and Export suggest names ending with _mod_YYYYMMDD_HHmmss; direct Save keeps the chosen filename. Save As shows a native file dialog where supported, otherwise a download. A successful Save As gives the active tab the new filename and releases the previous source so it can be opened separately. Save and Save As make the written bytes the new original for change highlighting and Restore original; ordinary Undo remains available. Later edits made during saving remain unsaved. Export creates a separate copy and keeps the active source and original baseline. File → Export offers binary, Intel HEX and Motorola S-record outputs. S-record export chooses S1/S2/S3 address widths automatically, with the corresponding termination record. Imported execution start addresses are retained. Export does not preserve original text formatting, header descriptions ; enhanced imports preserve sparse gaps in HEX and S-record output. The original file on disk is not overwritten.

Account preferences and editor properties

Display, font, byte order, row width, blank symbol, import defaults, checksum sorting/algorithms, custom CRC and tool-window modes are saved to your account. Editor properties includes Reset all preferences to defaults and an undoable Reset all bytes to original action. A save failure is shown in account/properties so it can be retried. Starting offsets can be changed in Simple or Advanced mode.

Options → Hex font & colour offers monospace font families, size (10–22 pixels), text colour and bold weight. Bold is enabled by default. Font preferences are saved to your signed-in account. Modified bytes have vibrant light-red text and a red corner marker. Open Options → Editor properties, or right-click an address in the grid, to change the hexadecimal start address and relocate displayed and exported addresses. Go to and Set range use these displayed absolute addresses; bookmark files keep relative byte positions. The execution start address, if imported, is preserved independently.

Bookmarks, checksum zones and original data

The Bookmarks & checksum zones window lets you edit bookmark names, addresses, lengths, data types, byte order and stored values. Range bubbles mark bookmarks in amber and checksum zones in green. Save .ptmap includes both lists and per-zone CRC parameters; older bookmark files still load.

Select the stored checksum bytes, right-click and choose Mark selection as checksum. Enter the covered range’s start address and length, algorithm, checksum length and stored byte order. Enable automatic updates to recalculate after data edits. The covered range cannot include its own checksum. Overlapping checksum storage and circular zone dependencies are rejected. Dependent checksums update in order. Exports wait for valid enabled zones to finish. Pausing a zone stops live updates; saving still recalculates and verifies it. Right-clicking a detected green adjacent checksum prefills a zone from that match.

Original data is the snapshot from opening the file or its latest successful Save / Save As. Red markings compare current bytes with that snapshot, so Undo removes red when a byte is restored. The Original button shows the snapshot at current addresses, including interpreted bookmark values. Editing is disabled in Original view; switch to Current data to edit. Modified bookmark tooltips show their original value and the current value as a percentage of it. A zero or unavailable original has no percentage. Select bytes and press F10, or choose Restore original, to restore them. After insertions/deletions, differences compare the same relative addresses; use Undo to restore the original layout. Automatic zones still recalculate after restoration.

The Difference Δ and Difference % views interpret values using the selected numeric type and byte order (hex uses unsigned integers). Percentage differences divide by the absolute original value. A changed zero baseline has an undefined percentage; unmapped or non-finite values have no difference. Ctrl+C in a difference view copies typed difference data. Ctrl+V onto an equal-length selection applies those deltas or percentages to its current values, including in Current data view. Integer results round to the nearest integer; overflow is rejected atomically. Copy in Current or Original view remains compact raw hex.

Right-click → Insert bytes before cursor inserts a chosen count and fill value, shifts following bytes, and adjusts bookmark and zone ranges. A structural edit that changes a checksum’s storage length pauses that zone. Undo restores data, masks, ranges and zone settings. Checksums and checksum searches concatenate only defined bytes, skipping blank bytes and compressed gaps. Byte transforms and scripts still require a fully defined selection.

Comparing and advanced searches

Open multiple files into tabs. With exactly two files open, Compare automatically uses both. With more files, select two tabs using their checkboxes (or Ctrl-click), then Compare selected. Both editors remain editable and use a shared address layout. Simple byte comparison is free; resynchronised comparison requires Pro. Different bytes are yellow by default, including differing blank bytes; edited bytes have red text. Missing addresses display blank padding. Linked scroll is on by default. N/V go to the next/previous difference or edited range; Ctrl+Right/Left also navigate differences. Width and byte-order controls apply to both files. Color values shades the difference magnitude, using the left file as the reference. Applying a shift or changing value settings compares again automatically. Ordinary byte edits keep the last Simple results until Recompare. Options → Editor colours configures the comparison colours. End compare restores the tabbed view. Scripts also has a tab and opens the script editor in a floating window.

Hex pattern search accepts spaced or compact patterns such as 01 02 XX XX 06 or 0102XXXX06. XX (or ??) matches any byte position, including a sparse gap. An odd number of characters is rejected. Value search scans common signed, unsigned and floating-point formats in both byte orders, at every byte alignment. It matches stored value × factor against your target, with a default ±1% tolerance. Edit the factor list to search scales such as 2, 10, 100, 256, 1000 or 0.25.

To discover checksum coverage, select the suspected stored checksum and right-click → Search for checksum coverage. Choose algorithms, stored order, minimum/maximum payload lengths, length step, and directions. It tests defined-byte payloads before or after the checksum, skipping blank positions and address separators. Lengths count defined bytes. Find all hits is on by default, so a coincidental early match does not stop the search. Progress and Stop remain available. Results can be highlighted or converted into zones. The first 2,000 hits are displayed; all hits are counted. Changing data invalidates results.

In Advanced mode, Delete marks selected bytes blank without shifting addresses; Simple mode removes them. Page Up and Page Down scroll the editor by one viewport with a line of overlap. Stored checksum values show one spinner per checksum and an Updating label while their background worker recalculates. Stored automatic checksums have green markers; hover a zone to see its boundary. Mark as checksum is available only for supported digest lengths.

Selections keep a fixed anchor and a moving end. Shift + Arrow extends or contracts from the last selected cell, including backward selections, and keeps that end visible. Find all highlights every pattern match in yellow, including overlapping matches. Clear highlights removes the result markers; editing the file or changing the query clears stale results.

Options → Editor colours controls the grid, selections, bookmarks, checksums, search hits, changed-byte text, and the value gradient. A bookmark’s definition window also lets you choose its individual colour. Colours are saved separately for each theme in your account. Selections, bookmarks, stored checksums and search matches share continuous range bands. Overlapping marks use stripes; hover to see all labels. Checksum data uses a green outline. Modified bytes use coloured text without corner markers. Delta and percent views use red for increases and blue for decreases; hover a shortened number for its exact value.

App window opens a separate workspace with compact browser controls; open documents remain in the original window. Use the always-visible Install app button (it opens instructions if an automatic prompt is unavailable) for a standalone window without address or bookmarks bars. Full screen hides browser chrome for the current workspace; Escape exits. Browser support determines which options are available.

Ctrl+O opens files and Ctrl+S saves the active file. Paste at the caret overwrites in OVR or inserts in INS. With a selection, its length must match the clipboard exactly and paste overwrites. Mismatches are rejected. Large copies above the conservative 8 MiB text threshold, or copies rejected by the browser, stay in the internal clipboard shared by tabs in this workspace. Use Paste internal copy from the right-click menu if needed; it is cleared when the page closes.

Drag tool title bars to the right or bottom edge to dock them, or into the editor to float. Drag dock dividers and individual panel edges to resize; the comparison divider also resizes the two files. Right-click a separator’s address to relocate that segment. Overlap is rejected and Ctrl+Z restores its old address. Select 1–8 bytes representing an address, then right-click Go to address or Peek. Raw hex bytes use file order; grouped numeric values use the chosen byte order. If the address is unavailable, leading hex nibbles are removed until an available address is found. Addresses smaller than the file start are treated as relative. Peek shows up to 0x80 bytes and closes when focus leaves it.

Editing data inspector values

Click the pencil beside a data inspector value to open a compact edit window. It shows the current value, fixed address and byte order. Enter decimal or 0x-prefixed hexadecimal for integers, or a floating-point value for floats. The stored-byte preview shows exactly what Apply will write. Enter applies; Cancel or Escape discards the draft. Apply uses the usual Undo history and triggers enabled checksum zones. The cursor and selection stay in place.

The binary editor has eight clickable bits, with bit 7 on the left. Edit the binary string or hex byte directly, preview unsigned and signed interpretations, invert all bits, reverse bit order, swap nibbles, or set 00/FF. Reset restores the value from when the window opened. Nothing is written until Apply. Incomplete values, blank bytes and values crossing compressed address gaps cannot be edited here. If the underlying bytes change while the window is open, Apply rejects the stale draft. Unchanged floating-point values preserve their original bits, including NaN payloads and negative zero.

Find, replace and numeric search

Ctrl+F opens one floating window with Find, Find & replace and Find numeric value tabs. Hex patterns accept spaces or compact text, for example 01 02 XX XX 06 or 0102XXXX06. XX and ?? each match one byte, including a blank byte; concrete bytes only match defined data. Every byte needs two characters. ASCII and UTF-8 text are available in both Find and Find & replace. Choose Pattern type for both the search and replacement. ASCII is one byte per character (0–127); UTF-8 may use multiple bytes per character.

For next-match operations, choose Top of file, Current cursor or Custom address (decimal or 0x hexadecimal). The starting byte is included. Subsequent next operations continue forward without wrapping. Restart from chosen position resets the search. Find All and Replace All ignore that starting position and process the entire file. If bytes are selected, enable Only in selected area to capture that range; showing a match does not change the captured scope. Use current selection replaces the scope with a new selection.

Replacement data uses the selected hex, ASCII or UTF-8 encoding and may be shorter, equal in byte length or longer than the search pattern. For example, ASCII find ABC and replace XYZ changes those literal characters. The following XX rules apply only to hex mode. Replacement XX preserves the current byte at the same position inside each match, including its blank state. Example: find 01 XX 03 and replace AA XX BB CC preserves the second byte and adds CC. XX cannot appear beyond the matched length because there is no byte to preserve. A replacement resizes the matched range regardless of the editor’s OVR/INS setting. It cannot cross a sparse separator or grow a segment into another segment; a failed validation changes nothing.

Find & replace next highlights one match and shows current and proposed bytes. Choose Replace this match, Skip / next or Cancel. Replace All scans non-overlapping matches from a snapshot, does not search newly inserted bytes, reports the occurrence count, and creates one Undo step. Bookmarks and checksum data ranges follow structural changes. Checksum zones whose storage length or explicit storage positions are disrupted are disabled. Enabled checksum zones recalculate normally after the edit.

Search original values is off by default. When enabled, matches use the original data at the same displayed addresses, including after structural edits. Missing original addresses are excluded. Replacements still change the current document; replacement XX preserves current bytes, and the original snapshot remains unchanged.

Find All keeps the current editor position and opens Find results docked at the bottom. Matching bytes are highlighted using the search colour. The results window can be resized, floated or docked like other panels. Closing it removes search highlights. Pattern results are paged in groups of 100, with every match accessible. Numeric results retain the best 2,000 ranked matches while highlighting all matches. Edits invalidate old results.

Find numeric value is the former immediate-value search: it searches multiple integer/float formats and both byte orders for stored value × factor within the target’s allowed deviation. Results show type, byte order where relevant, raw value, factor, calculated value and accuracy. Mark as bookmark carries the type and factor into the bookmark. All search and replacement calculations run in a worker; the results list only renders the current page.

Use Data inspector → Settings to choose visible data types and big endian (BE), little endian (LE), or both. These preferences save to your account. Single-byte types appear once; each multi-byte value is labelled with its byte order, including when editing it.

The data overview beside the right scrollbar shows the current file in grayscale: 00 is white and FF is black. Blue-gray checks represent blank bytes. Click a location to scroll there while keeping your cursor and selection. Shift-click a byte in the new view to extend the selection. The blue outline marks the visible region. Large files use a sampled overview. Focus the overview to navigate with arrows, Page Up/Down, Home or End.

Numeric formats & byte order

Choose hexadecimal, unsigned decimal, signed decimal, or floating point. Integer groups support 8, 16, and 32 bits. Floating point supports IEEE 754 binary32 and binary64. The inspector interprets bytes beginning at the cursor independently of the selected grid type.

Selecting a 16- or 32-bit editor width starts in Big Endian. You can then choose either byte order. At 8 bits the byte-order buttons stay visible and disabled. Changing the display or byte order never changes the underlying bytes. The data overview follows the selected value width and byte order: zero is white, the largest unsigned value is black, and incomplete or blank values are blue-gray. Normal scrolling keeps rows aligned; at the end of the file the view can stop between rows to show the complete final line. Signed values use two’s complement. Floating point may display Infinity or NaN for some bit patterns. NaN payload editing is best done in hexadecimal view.

Checksums & custom CRC

Ordinary edits recalculate only checksum zones that read the changed bytes and any checksums that depend on their results. If template values are linked, the zones covering the values actually changed also update. Calculation and dependency selection run in background workers. Saving or exporting still checks every enabled checksum. The Checksum zones tab shows how many zones the last update processed and its elapsed time. Full check identifies initialization or changed definitions. Right-click the Bookmarks window title and choose Copy checksum update report if an edit is slow or appears to update unrelated zones. The report includes the app version, work counts and timings, without file bytes, names or checksum values.

Repeat checksum blocks: when a checksum’s covered data touches its storage, use its small green corner handle, the Copy action in the checksum list, or Repeat checksum blocks in its context menu. Handles appear only on the first and last blocks where complete copies fit without overlapping existing checksum or template zones. Drag outward to preview complete blocks; the preview stops before a conflict. Then review the addresses before applying. Copies are independent checksum definitions over existing bytes; the data is not copied. Verification changes nothing. Choose to review mismatches, skip failing or problematic blocks, or explicitly recalculate mismatching checksums. Invalid pointer ranges and unreviewed scripts cannot be recalculated. Pointer-based copies must still resolve to touching data inside each copied block. Undo restores the definitions and any checksum bytes changed by acceptance.

Custom CRC-8, CRC-16, CRC-32 and CRC-64 are separate algorithms. Checksum settings → Custom CRC parameters has an independent tab for each width, with polynomial, initial value, output XOR and reflection settings in hexadecimal. Restore defaults resets only that tab. CRC-64 values remain exact throughout account saving, bookmark export and worker calculation. Algorithm choices form one compact alphabetically sorted list. Automatic marking has its own option to ignore checksum bytes made entirely of 0x00 or 0xFF.

Bosch CRC V3: a custom checksum with a two-byte result. For the supplied RH850 records, select all six payload bytes and exclude the final two stored checksum bytes. Choose the stored byte order when defining the zone.

Bosch CRC V1 / V2: V1 covers the eight-byte Dflash header and produces two checksum bytes. V2 covers the payload and produces four checksum bytes. Select the payload alone for automatic detection of the four preceding V2 checksum bytes. Required block context is handled automatically; no separate bookmark or editor mark is needed.

Liebherr PME CRC: a custom checksum with a two-byte result. The supplied records use a 72-byte payload and two checksum bytes stored Little Endian. Select the covered payload separately and choose the stored byte order in the checksum zone.

Chatenet Dash Checksum: three stored bytes: a big-endian 16-bit sum of the selected payload, followed by XOR of the payload and those two sum bytes. In the supplied 24C02 images, select 0x10–0x2C, 0x40–0x5C, 0x70–0x8C, 0xA0–0xBC or 0xD0–0xDC; the three checksum bytes follow each range. Exclude those checksum bytes from the selection.

Select the suspected data payload, excluding its stored checksum. After calculation, PolluxTool compares each enabled result with raw bytes immediately before and immediately after the selection. CRCs and sums are checked in both big- and little-endian order; MD5 and SHA digests use their standard byte sequence. Matching bytes receive green rounded markers in the grid and a MATCH label in the checksum table. Hover a marker to see all matching algorithms, byte orders and exact addresses. Blank bytes between a payload and its stored checksum are skipped. ASCII-encoded checksum text, appended file lengths and implicit padding are not included. Short checksum matches can occur by coincidence and do not establish the file format.

Every explicit selection change or edit within a selected range recalculates checksums locally after a brief debounce. An edit caret by itself does not select bytes or calculate checksums. The highlighted range alone is included; all-blank selections skip calculation. Length sorting uses the digest size in bytes. Choose the entire file to calculate a file-wide checksum. Calculations run in a worker, keeping the editor available while larger ranges are processed.

The catalog contains 20 named CRC presets; MD5, SHA-1, SHA-256, SHA-384, SHA-512; Adler-32; Fletcher-16; SUM-8/16/32; and XOR-8. CRC-32 is the ISO-HDLC preset. All enabled results appear together in the Checksums window as Type and Value rows. Choose Select algorithms to enable or disable calculations; the choices are saved to your signed-in account. This is a defined catalog, not a claim to include every checksum ever invented.

CRC families include CRC-8/SMBUS, MAXIM-DOW and SAE-J1850; CRC-16/ARC, MODBUS, USB, IBM-3740 (CCITT-FALSE), XMODEM, KERMIT, IBM-SDLC (X-25), AUG-CCITT, DNP and BUYPASS; CRC-32/ISO-HDLC, ISCSI (CRC-32C), MPEG-2, BZIP2, JAMCRC, POSIX and BASE91-D.

Open Select algorithms, enable Custom CRC-8, CRC-16, CRC-32 or CRC-64, choose its Custom CRC parameters tab, and configure polynomial, initial register, output XOR, input reflection and output reflection. Parameters are hexadecimal. Use a normal polynomial without its highest term: enter 1021 for x¹⁶ + x¹² + x⁵ + 1. Do not enter the reflected polynomial even when reflection is enabled.

Results contain only the selected bytes: no implicit padding, address prefix, or appended length. CRC-32/POSIX is the bare CRC model; the POSIX cksum command additionally processes a file length, so its result can differ. SUM values wrap to their indicated width. Fletcher-16 uses two modulo-255 accumulators initialized to zero.

Checksums detect accidental corruption; they do not prove authenticity. MD5 and SHA-1 are supplied for legacy compatibility. Use SHA-256 or stronger when cryptographic integrity is required.

Custom checksums: M3C requires at least 16 defined bytes, Rotax at least 32, and Subaru exactly 8. Unsupported lengths are excluded from matching and search. Outputs retain the original routine’s byte order; zone byte swapping is applied afterward. Rotax excludes relative bytes 0x0E–0x11 as in the original. The 32-bit odd/even-index sums are limited to 33,686,019 / 33,686,018 defined bytes respectively so the result always fits four bytes.

LR BCM PIC18F

Select the data only, excluding all four stored checksum bytes. This calculation returns the HC9S12 rolling checksum followed by a bit-position XOR with even parity, in file byte order (for example 76 5A EF 07). It supports 1–4094 defined data bytes; blanks are skipped. The parity calculation includes the two generated HC9S12 bytes. Its parity flag is the smallest power of two greater than or equal to the total bit count, including those two bytes. Verified against all 42 checksum fields in three supplied Land Rover dumps; other lengths use the agreed extension. Larger blocks would require a wider parity field. Automatic suggestions, checksum search and defined checksum zones use this same calculation.

New checksum calculations and automatic marking

Checksums → Settings opens Automatic marking, where you can enable or disable possible-checksum suggestions and set the maximum gap before and after selected data. Default: enabled, 0 bytes. A gap of 0 means adjacent; decimal and 0x are accepted, up to 4096. Blank bytes are skipped and do not count toward this gap. Settings save to your account. Disabling suggestions keeps calculations, explicit coverage searches and defined checksum zones active.

Both Quadro calculations accept any nonempty defined payload. Quadro Dash V1 was verified on 6- and 28-byte payloads. It sums each byte XORed with a countdown from payload length to 1, wraps the sum to 16 bits, and stores the two-byte result little endian. Do not include the metadata byte between payload and checksum. Quadro Dash V2 adds every fourth byte (relative offsets 0, 4, 8, 12, 16 and so on) modulo 256. V2 is a candidate supported by two supplied 17-byte examples. Other lengths use the same equations but have not been verified against dashboard dumps. V1 uses the full countdown value, including above 255.

New standalone calculations also include CRC-8/AUTOSAR (H2F), CRC-32/AUTOSAR (P4), CRC-32/SIMOS, CRC-64/ECMA-182, CRC-64/XZ (also AUTOSAR CRC64), LIN checksum, Subaru Denso SH7xxx and EDC17 CRC32 / ADD32 / ADD16. These use the existing worker. LIN classic uses payload only; enhanced includes its protected identifier. Internet checksum is already available as Prius JBL Radio; Haldex word sum is ALPS CHK with reversed storage.

Custom checksums operate on your selected region; they do not automatically locate every firmware block or repair a complete firmware image. EDC17 CRC32 and ADD32 require a multiple of 4 defined bytes. ADD16 requires an even count, shifts the last word into the high half and returns four bytes. Subaru accepts any nonempty selection and subtracts big-endian uint32 words from 5AA5A55A, modulo 2^32. A final 1–3 bytes are zero-padded on the right for calculation only; file bytes are not changed. This partial-word extension is not verified against source samples. Unsupported input lengths are excluded from matching and automatic updates.

Other tools: script compatibility

Research checked 5 October 2026. Importing a script is not the same as reproducing its host application. A language engine, editor API, user interface, hardware transport and packaged-file format can all be separate dependencies. PolluxTool never runs an imported script automatically.

Running an iProg Lua script

1. Open a contiguous file with no blank bytes, up to 16 MiB. Import a plain UTF-8 .lua file, or choose one of the iProg Lua examples.
2. The language selector must show iProg Lua (experimental). Check any fixed offsets and file-size assumptions before running.
3. Lua receives a private copy of the whole file. Offset zero means the first byte of that file, regardless of the displayed base address. It is not rebased to the selection. JavaScript keeps its existing selection-relative behavior.
4. Run the source. Top-level statements execute; merely defining a function does not call it. To adapt a UI callback, call that function explicitly after its definition only when its required inputs have been replaced or supplied.
5. Review proposed byte changes, then Apply. Errors, unsupported adapter calls and timeouts discard the proposed changes. Undo works normally after Apply.
6. Save to account retains the selected language. Export writes plain .lua source for your own keeping.

The Lua VM loads on demand and runs in a worker inside the no-network sandbox. It does not run during scrolling, selection changes or file loading. Each run has fresh globals, a five-second outer timeout and the existing limit of 100,000 proposed byte changes. Event handlers such as OnEditorSelect and OnLoadFile are not installed.

Implemented iProg Lua editor API

Use dot calls, for example Editor.Read(0), not colon calls. Address and write-value inputs must be safe integers. PolluxTool deliberately stops on out-of-bounds access; it does not imitate iProg’s ignored writes or undefined reads. Adapter errors still fail the run if caught inside Lua with pcall.

Language and numerical limits

This adapter uses Fengari’s Lua 5.3 semantics: 32-bit signed integers and double-precision floating-point numbers. The vendor documentation examined does not establish one Lua version and integer configuration for every iProg release. Therefore this is not a claim of universal binary or numerical compatibility. Validate source against known input/output pairs, especially arithmetic near integer overflow.

Unsigned Read32 values above 0x7FFFFFFF are returned as floating-point numbers representing the exact integer. Use the supplied bit32 helpers for those patterns rather than relying on native Lua integer conversion. Available helpers: band, bor, bxor, bnot, btest, lshift, rshift, arshift, lrotate, rrotate, extract and replace. They accept integer inputs and produce unsigned 32-bit results (btest returns a boolean). Fractional bit-operation inputs are rejected. Negative shift counts reverse direction; logical shifts of 32 or more produce zero; rotation counts wrap modulo 32.

Base language facilities, math, string, table and utf8 are available. No io, os, package, debug, JavaScript interop, require, dynamic chunk loading or compiled Lua bytecode is exposed. No programmer identity is invented. DeviceID, network requests, ShellExecute, dialogs, captions and closing windows are unsupported. Editor highlights and selection mutation are also unsupported. Lua GUI component definitions and callback wiring need an actual source-level port, not just a renamed extension.

UPA-USB: what can be adapted

ELRASOFT documents Pascal Script and editor calls including GetByteHexEdit, SetByteHexEdit, GetSizeHexEdit and RefreshHexEdit. Buffer algorithms are candidates for a source port. Device registration, reading/programming hardware, forms and file operations require additional host behavior. PolluxTool currently has no Pascal interpreter, so it does not strip these calls or pretend that Pascal is JavaScript.

For a manual port on a selection covering the whole file, GetByteHexEdit(n) maps to api.read8(n); SetByteHexEdit(n,v) maps to api.write8(n,v) for values already in 0–255; and GetSizeHexEdit maps to api.length. Writes remain staged until Apply, so there is no direct RefreshHexEdit call. Pascal typed arithmetic, overflow, shifts, string indexing, procedure parameters and byte order must be verified individually. These mappings do not constitute an automatic converter.

iProg Emvima and compiled scripts

The official Emvima documentation describes a C-like language with .e source, a .epr project and a separate interface definition. Building produces .ipp, optionally encrypted. Its EDITOR/EDITOR2 objects, typed variables, UI callbacks, dependencies and hardware interfaces are not the Lua API. The documented ability to embed a Lua helper inside an .ipp does not make the .ipp itself a Lua script.

Public documentation is sufficient to plan a source interpreter, but not to claim a tested replacement for packaged scripts. Needed next: your programmer/software version, one representative source project with companion files, and a small input plus expected output. An encrypted/compiled package alone is insufficient for the current adapter. No package decryption or programmer-licence emulation is implemented.

Other hex editors

WinHex’s line-oriented .whs language is a promising next importer for bounded buffer commands. Commands that open disks, save files, operate on many windows or use external paths would need explicit host handling. 010 Editor is a larger undertaking: its .1sc C-like scripts and .bt templates depend on typed data, file I/O and template state. Hex Editor Neo already uses JavaScript/TypeScript, but that does not supply its document model or Windows automation objects inside a browser.

Primary references

• ELRASOFT — Pascal Script editor functions and UPA-S product documentation.
• iProg — Lua calculator API, embedded Lua helpers, Emvima language, project and output formats, Emvima editor API.
• WinHex scripting; 010 Editor scripts; Hex Editor Neo scripting.
• Fengari runtime and numerical semantics; runtime licence; Lua bit32 reference.

Scripts: a practical workflow

Scripts are JavaScript function bodies. They receive bytes, a private Uint8Array copy of the selection, and api, the helper object described below. Start with an example in Scripts, change one assumption at a time, then run it on a small known sample. Inspect the log and change preview before pressing Apply. A script run never changes the live file by itself. Apply creates an undoable edit and causes enabled checksum zones to update.

1. Select the complete record or table. Scripts require defined bytes; fill or exclude XX/-- first.
2. Open Scripts and choose an example. Give your version a meaningful name.
3. State the expected length, alignment and value ranges using api.assert().
4. Read and log a few values before adding writes. Always specify byte order for multibyte values.
5. Run, inspect the preview, then Apply. If the document changed since the run, run again.
6. Save to account for reuse, or export a .js file. Imported scripts are drafts and do not execute automatically.

Offsets inside a script are zero-based relative to the selection. If the selection begins at address 0x1000, api.read16(2,true) reads bytes at 0x1002 and 0x1003. To print an absolute address, add api.start. Range helpers use an exclusive end: api.fill(0,4,8) writes four bytes at relative offsets 4–7. The editor’s displayed selection endpoints remain inclusive.

Integer read/write helpers default to little endian independently of the editor’s display setting. An 8-bit value has no byte order. A write checks the full value; it does not silently truncate. Use api.wrap(value,16) for a deliberate modulo-65536 accumulator. JavaScript’s native bitwise operators use signed 32-bit integers and reduce shift counts modulo 32; the helpers avoid those surprises and return unsigned results.

Creating custom checksums

Custom algorithms used by checksum zones travel inside the .ptmap file. After loading, open Create / edit custom algorithms and look under From this file. Choose the stored definition, review its source and click Save algorithm to add it to My algorithms. Check Account storage for the save result, and retry if it failed. Imported JavaScript zones stay disabled until you explicitly review and enable them.

Open Checksums → Select algorithms → Create / edit custom algorithms. Choose JavaScript or Custom CRC preset. Enter a name, output byte count and payload length limits. JavaScript supports 1–64 output bytes; CRC presets support 8, 16 or 32 bits. Numeric fields accept decimal, or hexadecimal prefixed with 0x. An empty maximum means no configured maximum. The normal editor file-size limits still apply.

For JavaScript, paste a function body and return its result. Accepted results are an unsigned integer that fits the output width, an exact-length hex string, or a Uint8Array of exactly the configured byte count. A 16-bit algorithm can return 0x1234, "1234", or Uint8Array.of(0x12,0x34). Returning a negative number, too many digits, no result, or an invalid byte count fails the calculation. Use return api.wrap(-sum,16) for two’s complement.

Checksum code gets a compact copy of defined payload bytes; blank positions and compressed gaps are omitted. Its offsets begin at zero, even when the original file begins elsewhere. Thus odd/even indexes refer to this compact payload. Exclude stored checksum bytes from the zone’s payload unless your algorithm explicitly handles embedded checksum bytes. Changes made to bytes inside a checksum function only affect its private copy, not the file.

1. Begin with a known binary payload and its expected checksum. Enter the payload as hex byte pairs in Test bytes.
2. Enter the expected digest as hex and press Test algorithm. Check both ordinary data and boundary cases: all zeroes, all FF, minimum length, odd length and maximum length.
3. If your algorithm requires complete words, reject odd lengths explicitly with api.assert(bytes.length % 2 === 0, "Needs pairs").
4. Save the algorithm. It becomes available in selection results, adjacent matching, checksum coverage search and automatic zones.
5. Select the checksum storage bytes and mark a zone. Choose the algorithm, payload and stored order. Normal order writes the displayed digest; reversed order reverses its bytes once.

CRC presets use a normal polynomial: 0x8005 for the reflected implementation commonly described by 0xA001, or 0x1021 for reflected 0x8408. Do not reflect the polynomial twice. Reflection reverses bits; stored byte order reverses bytes. They are separate operations. As a reference, ASCII 123456789 (hex 313233343536373839) gives CRC-16/MODBUS 4B37 with width 16, poly 0x8005, init 0xFFFF, xor 0, refin/refout true; little-endian storage is 37 4B. CRC-16/XMODEM with poly 0x1021, init/xor 0 and no reflection gives 31C3.

When adapting older VB/C routines, write down accumulator width, initial seed, byte traversal order, skipped header fields, carry/borrow rules, reflection, final XOR and stored byte order separately. Preserve unusual off-by-one rules until a known test vector proves they are wrong. A byte sum and a word sum are not interchangeable. The built-in custom checksums retain their original conventions and have explicit length limits.

Wildcard checksum bytes

Return ** for a complete output byte whose value is unrelated to the checksum. Wildcards count toward the output length. They match any stored byte and are never written by automatic zone updates, including when that position is blank. At least one output byte must be concrete; half-byte wildcards and all-wildcard results are rejected. Use a hex string for outputs wider than JavaScript’s exact integer range.

Automatic adjacent matches and Find checksum coverage both understand wildcards. Select the full stored record, including wildcard positions, when searching for coverage or manually defining a zone. Right-click a green suggestion and choose Mark as checksum to keep its payload, storage offsets and algorithm. For generic custom checksums, reversing storage order reverses the wildcard positions too. Hyster uses its fixed record order without reversal.

Example: choose 4 output bytes, minimum 1 and maximum 65535 for this Hyster-style record. The first byte belongs to the surrounding format. The next two encode the defined payload length little-endian; the last is the checksum. For payload 0123456789ABCDEF, the result is **080038.

const hexByte = n => (n & 255).toString(16).padStart(2, '0');
const low = bytes.length & 255;
const high = bytes.length >>> 8;
let sum = low + high - 1;
for (const byte of bytes) sum = (sum + byte) & 255;
return '**' + hexByte(low) + hexByte(high) + hexByte(~sum);

A second example keeps two unrelated bytes inside a 5-byte record. Choose 5 output bytes and minimum 1. For input 010203, it returns A5**06**F9. Existing bytes at wildcard positions survive editing, verification and file export.

const h = n => (n & 255).toString(16).padStart(2, '0');
let sum = 0;
for (const byte of bytes) sum = (sum + byte) & 255;
return 'A5**' + h(sum) + '**' + h(~sum);

Custom wildcard code saves to account preferences and travels with checksum zones in .ptmap. Imported code still requires review before enabling. A wildcard is not the editor’s XX/-- blank-byte marker: it describes which output positions to ignore.

Built-in checksum details

Hamm accepts 1–20 defined payload bytes and produces five bytes. M3C requires at least 16, Rotax at least 32 and Subaru exactly 8. Hyster requires 1–65535 defined bytes so its length fits the two-byte field. Its leading ** byte is preserved. Bosch CRC V1 and V2 support individual block headers and payloads; they do not automatically repair a complete firmware image.

Volvo SRS MC9S12 stores two bytes in fixed order: the modulo-256 sum of the selected defined bytes, then their 8-bit XOR. Both accumulators start at zero. Exclude the two stored checksum bytes from the payload. For the supplied layout, select 0x1D800–0x1DFFD (0x7FE bytes); checksum storage is 0x1DFFE–0x1DFFF. These addresses describe that file, not an algorithm restriction. The checksum requires at least one defined byte. Automatic matching and zones preserve sum-first / XOR-second order.

Portable bookmarks and algorithm identity

.ptmap remains PolluxTool’s export format. Built-in algorithms are stored by permanent opaque IDs rather than readable names. This obscures the identity in the bookmark file; it is not encryption or a security boundary. User-written code and custom CRC parameters are included so recipients can reproduce the result. Existing version 1/2 bookmarks still load.

Each zone keeps a snapshot of its algorithm definition and CRC settings. Editing or deleting the account preset does not alter an existing zone. To replace a zone’s stored implementation, open Edit and choose the updated preset again. Bookmark exports also carry your custom presets and current custom CRC settings. Importing scripted zones pauses them: open Edit, inspect the stored source and enable automatic updates when you trust it. Export refuses to run an unreviewed imported script. Keep an external .ptmap backup of valuable definitions.

A script runs in a worker inside an opaque-origin frame, without network or account access, with a five-second deadline. Ordinary scripts accept up to 16 MiB and preview up to 100,000 changed bytes per run. Custom checksum routines are also timed out. Avoid expensive nested loops, logs in every iteration, and giant temporary arrays. Start checksum coverage searches with a narrow length interval; a custom function is invoked separately for each candidate, so a large search can take much longer than a built-in CRC.

Shared API reference

These functions work in both Scripts and custom checksum code. bits means 8, 16 or 32 bits; read/write width means bytes. All offsets and integer inputs must be safe integers. Out-of-bounds accesses throw rather than reading or writing a neighboring region.

Checksum walkthroughs

// XOR every byte with a seed. Return an unsigned number.
return api.xorBytes(0xA5);

// Unsigned 16-bit accumulator, wrap after every addition.
let sum = 0x1234;
for (const byte of bytes) {
  sum = api.rol(sum, 1, 16);
  sum = api.wrap(sum + byte, 16);
}
return sum;

// Reflect each byte, XOR it, then rotate right twice.
let acc = 0;
for (const byte of bytes) {
  acc = api.xor(acc, api.reflect(byte, 8), 8);
  acc = api.ror(acc, 2, 8);
}
return api.not(acc, 8);

api.assert(bytes.length % 2 === 0, "Needs complete 16-bit words");
let sum = 0;
for (let i = 0; i < bytes.length; i += 2) {
  sum = api.wrap(sum + api.read16(i, true), 16);
}
// Return two’s complement, in normal displayed order.
return api.wrap(-sum, 16);

// Keep bytes unchanged; transform a private copy.
const data = api.slice();
for (let i = 0; i < data.length; i++) {
  data[i] = api.xor(api.reflect(data[i], 8), 0x5A);
}
return api.crc(data, {width:16, poly:0x1021, init:0xFFFF, xor:0, refin:false, refout:false});

// Ignore a 4-byte header. Shift and mix into 32 bits.
let acc = 0;
for (let i = 4; i < bytes.length; i++) {
  acc = api.xor(api.shl(acc, 3, 32), api.shr(acc, 29, 32), 32);
  acc = api.wrap(acc + bytes[i], 32);
}
return acc;

Script walkthroughs

// Select a record containing at least eight bytes.
api.assert(bytes.length >= 8, "Select at least 8 bytes");
const flags = api.read8(0);
api.log("Enabled:", api.and(flags, 0x01) !== 0);
api.log("Mode (bits 4–6):", api.and(api.shr(flags, 4), 7));
api.log("Counter LE:", api.read16(2, true));
api.log("Signed correction:", api.readSigned(4, 2, true));
api.log("Header:", api.toHex(api.slice(0, 8)));
// No writes: this is a read-only inspection script.

// Reversible transform. Work on a private selection; Apply commits it.
const key = 0x5A;
for (let i = 0; i < bytes.length; i++) {
  const encoded = api.xor(api.rol(api.reflect(api.read8(i)), 3), key);
  api.write8(i, encoded);
}
api.log("Transformed", bytes.length, "bytes");
// To reverse: reflect(ror(xor(encoded, key), 3)).

const needle = api.fromHex("DE AD BE EF");
const found = api.find(needle);
api.assert(found >= 0, "Signature not present; no changes made");
api.log("Found at absolute address", "0x" + (api.start + found).toString(16));
api.write32(found, 0x12345678, false); // explicit big endian
api.log("Replacement:", api.toHex(api.slice(found, found + 4)));

api.assert(bytes.length % 4 === 0, "Select complete float32 values");
const factor = 1.05;
for (let i = 0; i < bytes.length; i += 4) {
  const oldValue = api.readFloat(i, 4, true);
  api.assert(Number.isFinite(oldValue), "Invalid float at " + i);
  const next = oldValue * factor;
  api.writeFloat(i, next, 4, true);
  if (i < 32) api.log(i, oldValue, "=>", next);
}
// Review rounding and the preview before applying.

api.assert(bytes.length >= 3, "Need a payload and two checksum bytes");
const payload = api.slice(0, bytes.length - 2);
const checksum = api.crc(payload, {
  width: 16, poly: 0x8005, init: 0xFFFF,
  xor: 0, refin: true, refout: true
});
api.write16(bytes.length - 2, checksum, true);
api.log("MODBUS CRC:", checksum.toString(16).padStart(4, "0"));
// For continuous maintenance, use an automatic checksum zone instead.

api.assert(bytes.length >= 32, "Select at least two 16-byte records");
api.copy(0, 16, 16); // source offset, destination offset, byte count
api.fill(0xFF, 24, 32); // end is exclusive
api.log("First record:", api.toHex(api.slice(0, 16)));
api.log("Second record:", api.toHex(api.slice(16, 32)));
// copy() also handles overlapping source/destination safely.

Troubleshooting and verification

• Result reversed: check stored byte order; do not change RefIn/RefOut merely to swap bytes.
• Only odd lengths fail: inspect word reads and padding conventions. Never assume an omitted trailing byte is zero.
• Negative or truncated result: wrap at the intended width and return an unsigned value. The helper widths are explicit.
• Matches a test vector but not a file: verify the exact covered range, excluded headers, seed, skipped blanks and final complement. A matching checksum alone does not prove the algorithm.
• Length not supported: the algorithm’s configured minimum or maximum excludes the defined-byte count. It is omitted from automatic matches rather than returning a misleading zero.
• Timed out: reduce the data or search interval and replace repeated scans with one accumulator loop. No partial script edits are applied.
• New preset does not change a zone: zones deliberately retain their saved definition. Select the updated preset in the zone’s Edit window.

In Compare, Ctrl+Right and Ctrl+Left search from the active cursor, skip its current contiguous difference block, and jump to the next or previous block. Searches do not wrap. A message reports when no further differences exist toward the end or start of the file. Address gaps separate difference blocks.

ZD Dash produces four bytes and requires at least one defined input byte. Up to the first four bytes form an unsigned little-endian 32-bit initial value; missing high bytes are zero. Remaining bytes are added with 32-bit wrap. The algorithm swaps the result, so storage uses normal / BE with no additional reversal. Example: 78 56 34 12 01 02 → 7B563412, stored 7B 56 34 12. Automatic nearby-checksum suggestions ignore candidate storage made entirely of 00 or entirely of FF. Explicit checksum calculations and coverage searches remain available.

Bookmarks, factors and offsets

The Bookmarks & checksum zones panel has separate Bookmarks and Checksum zones tabs. Compact rows show the name and current value. The pencil edits a bookmark’s values, the settings button opens its definition, and the arrow jumps to its address. Right-click a row to delete it. Checksum rows have an enable checkbox, a definition button and a go-to arrow; each updating checksum has one spinner. Imported scripts still require review before enabling.

Numeric bookmarks support a factor (default 1) and value offset (default 0): displayed = stored × factor + offset. Edit these in the bookmark definition. Changing these properties changes the interpretation, not the file bytes. Editing a displayed value reverses the formula: stored = (displayed − offset) / factor. Factor and offset accept arithmetic such as 1/3600^2, parentheses and either . or , for decimals. Evaluated numeric values are saved in .ptmap files. The factor must be finite and nonzero; negative and fractional factors are supported. Integer edits round to the nearest stored value, with half-way ties away from zero. Out-of-range values use the nearest storage limit. Decimal integer scaling retains exact 64-bit precision; floating-point values round to their storage precision. Text, raw hex and date/time bookmarks use their existing interpretations without numeric calibration.

For example, stored 12350 with factor 10 and offset 0 displays 123500. Editing it to 124000 stores 12400. A stored value of 1234 with factor 0.1 and offset −40 displays 83.4. Factors and offsets are saved in .ptmap files and are part of duplicate detection. Immediate-value search’s Mark as bookmark button automatically carries the matched type, width, byte order and factor into the bookmark, with value offset 0. Adding a bookmark does not move the editor.

Editing bookmark values

Creation preselects the type width matching your selection when supported: 4 bytes selects 32-bit, for example. Compact definition and value dialogs use expandable sections for interpretation, inverted copies, named values, description and bookmark information. New bookmarks record creation and modification time, user, PolluxTool version and source filename. Imported creation details are preserved.

The value-edit window includes Factor and Value offset for numeric types, plus Custom XOR and Use inverted hex for all types. Choose Apply interpretation to save those settings without changing file bytes. Custom XOR accepts a byte in decimal or 0x hexadecimal (0–255) and applies to each stored byte before decoding. Use inverted hex additionally XORs each byte with 0xFF. Numeric scaling then uses the decoded value. Editing a value reverses scaling and both XOR transforms before storing it. These controls are also available when adding a bookmark or editing its definition, and custom XOR is saved in .ptmap files.

Hex/blob bookmarks use one hex string in file byte order, with no width or byte-order control. Up to 0x20 bytes can be edited here; complete byte pairs and the exact byte length are required. Spaces are accepted and removed. For longer hex/blob bookmarks, choose Edit in hex editor to select the range, navigate to its address and focus the editor. File drops are accepted across the whole app window, including tabs, empty workspaces and floating tools, in browser and standalone modes. Files are routed by extension.

Click the pencil beside a bookmark and modify its existing value. Enter applies numeric and date edits; Ctrl+Enter applies strings. Leaving the field also applies an edit; Escape cancels. PolluxTool encodes the value in the selected type and byte order, records Undo, and updates automatic checksums. Changes affect only that value, and unchanged values retain their exact bits, including NaN payloads. Strings must encode to the existing byte length. Invalid dates, malformed strings, incomplete values and blank bytes are identified rather than silently converted. Choose raw hex in bookmark properties to repair data. Integer widths cover 8, 16, 32 and 64 bits; 64-bit arithmetic is exact. Half floats use nearest-even rounding. ANSI uses Windows-1252, Unicode uses UTF-16. DOS times have two-second resolution. FILETIME preserves seven fractional second digits; time_t uses whole UTC seconds; OLE DATE editing uses millisecond precision. Numeric fields accept decimal or 0x; raw hex fields use hexadecimal. Imported zero-length bookmarks have no value to edit.

Right-click marked bytes to modify/delete an annotation or reveal it in the bookmark panel. Ordinary bookmarks do not hide suggested checksums. Only defined checksum storage suppresses a matching suggestion. Multiple suggestions share one green fill and are all listed in the tooltip. Purple selection still takes priority.

Fill all selected bytes works in both modes. In Advanced mode, Fill selected blank bytes appears only when the selection contains blank bytes, and Mark as blank removes their defined status without shifting addresses. Checksum coverage search appears only for a supported number of defined checksum bytes.

CRC/CCITT Init.Val FFFF uses polynomial 0x1021, initial value 0xFFFF, no reflection and XOR-out 0 (123456789 → 29B1). This replaces the duplicate IBM-3740 / CCITT-FALSE label; saved algorithm IDs remain unchanged. XMODEM, KERMIT and AUG-CCITT remain separate because their parameters differ.

Bookmark folder and checksum filters

Options → Bookmark folder lets you choose a default local folder for bookmark Open and Save As dialogs. The folder is remembered for your account in this browser on this device; choose it separately on other devices. Browsers without file-system pickers use their normal open/download locations. Save to an already opened bookmark file continues to overwrite that source after confirmation.

Checksum algorithm lists have text filters: calculation settings, coverage search, zone definitions, custom algorithms and suggested checksum matches. Search ignores case and punctuation: CRC16 also finds CRC-16. Filtering never deselects hidden algorithms. Select filtered and Clear filtered affect only matching choices. Go to bookmark/checksum in panel reveals the matching list row and briefly highlights it green; Modify opens its definition.

Import bookmarks from other editors

Opening or dropping .hbk and .pos files automatically imports bookmarks into the active document without moving the view. CSV, TSV and text imports retain the column-mapping preview. The bookmark panel also offers Import. These imports create bookmarks with no checksum algorithms or executable code; HBK preserves supported numeric types. Choose Append or Replace ordinary bookmarks; existing checksum zones are kept. Import does not move the view or change bytes. Export remains .ptmap and preserves imported colours and descriptions.

• WinHex: native POS versions 1.0, 1.1, 2.0 and 2.1 for ordinary file positions. Names, ranges and RGB colours are preserved where present. Extended v2.0 records and logical archive/text-extract offsets are rejected rather than guessed.
• Hex Editor Neo: export bookmarks as CSV. Choose comma, semicolon or tab and map Start, Length or End, Name, Group and optional #RRGGBB Colour. Headers are detected when recognised; check every mapping in the preview. Native .hexbook binary files require a sample before support can be added.
• HxD: manual location-list transfer is available; a native HxD bookmark-file importer is not provided because no documented export format has been identified. Choose Offset list and paste one location or inclusive range per line, followed by an optional name.
• Hex Workshop: HBK imports support the sample-verified 448-byte header / 656-byte record layout. Literal hexadecimal locations with count 1 are accepted; expressions, repeated arrays and other layouts are rejected. Descriptions, ranges, byte order and supported numeric interpretations are preserved. Signed/unsigned integers and floating-point values map to editable native types. ANSI (Windows-1252), UTF-8, UTF-16, signed/unsigned 64-bit integers, half floats, DOS date/time, FILETIME, Unix time_t and OLE DATE are also supported. Unknown type codes remain raw hex. Zero-length entries remain location-only bookmarks, navigate without selecting bytes, and have no data to edit. These details survive .ptmap export.

0x100 Header
0x200-0x20F Calibration
# Comment

Unprefixed numbers default to decimal. Select Hexadecimal for bare hex addresses; 0x prefixes and h suffixes always denote hex. The chosen base applies to lengths too. Choose zero-based file offsets for binary positions, or absolute displayed addresses for relocated or segmented files. Ranges outside the document or across compressed separators are rejected as a whole. There is no 100-bookmark collection limit; imported files are limited to 2.5 MB and CSV/TSV tables to 10,000 rows. Large import previews show the first 100 entries; all valid entries are imported. Imported descriptions can be edited in the bookmark panel.

Bookmark templates

Offset is available on the Bookmarks, Checksum zones and Templates tabs. Its All option moves bookmarks, checksum storage and covered data, template masters and copies together, including empty templates. The preview lists the affected entries; Undo restores the entire move.

Select any complete block and choose Bookmarks → New template, or press Ctrl+T where the browser allows it. A template can start empty. Its bookmarks, checksums, copies and name patterns are saved in .ptmap. Apply a template at a new address, or drag its blue corner up or down. The preview grows in complete blocks; release to review locations and checksums. Escape cancels.

Add a bookmark or checksum in the master or any copy to add the corresponding definition in every block immediately. Saving shows the number of additional definitions and asks for confirmation. Complete bookmark data and checksum storage must fit inside their block. Covered checksum data may be outside it. Shift covered data with template copies moves static data ranges by the same distance; turn it off for shared data at fixed addresses. Pointer fields inside the block move with it, and each copy reads its own stored pointer values. Pointer fields outside the block keep their location.

Clone rows have Go and Delete buttons. Collapse or expand copies beside each master in the Templates tab to see other template types. Drag column dividers to resize; widths stay saved on this device. The master also has Apply, Settings and Find similar zones. Search opens in a floating window. It compares fixed bytes, normally ignoring bookmark values, pointer fields and checksum storage. Adjust the search range, byte step and minimum similarity, or include those bytes. If the template has checksums, only candidates whose checksums match are shown. Search is read-only. Use a result to open the normal copy review. Stop cancels; file or definition changes invalidate the search. Results are limited to the first 200 matches.

Right-click a template entry or its editor area to edit the master, add as a named template, create a new template or delete definitions. Editor template actions follow checksum actions; Add as a named template appears only at an available location. The repeat hint moves above the bytes when it would cover the bottom of the editor. Deleting leaves file bytes in place; Undo restores definitions. Copied settings open the master after a warning. Settings donors omit generated copies. Detach the master from its context menu to keep all definitions independently. Template blocks cannot overlap or cross compressed address gaps.

Value linking starts disabled. Same value writes corresponding values together; By difference adds the same numeric change; By percent applies the same ratio. Difference and percent work only with supported numeric types. Percent cannot start from zero; blank, out-of-range or conflicting values stop the edit. Pro interpretation requirements still apply. Structural damage pauses links until repaired. New checksum placements verify before acceptance; explicitly accept recalculation when a checksum differs. Enable Skip problematic blocks in Apply template to omit conflicting addresses, invalid ranges and blocks with failed checksums. Other complete blocks are added; skipped blocks keep all bytes and definitions. The operation has one Undo step.

Pointer bookmarks and checksum ranges

Choose a Pointer bookmark with an 8-, 16-, 24-, 32- or 64-bit unsigned value and its byte order. Double-click it in the editor or bookmark list to go to its target without editing bytes. Checksum pointer fields also support double-click navigation; a length field goes to the covered data start. The value-edit button still changes the stored address. Navigation and checksum start pointers use the same address resolution as Peek: first try the stored address, interpret values below the file base as relative, then remove leading hexadecimal nibbles until a defined address is found. Missing pointer bytes or values with no valid target show an error. The stored value is never rewritten.

Checksum properties can read the covered range start, length, or both from pointer fields. Choose a pointer bookmark, enter the field address, width and byte order, or use Pick pointer in editor. Select 1, 2, 3, 4 or 8 defined bytes, then Use this selection; Cancel keeps the draft. A start pointer can contain a file address, including its base, or a byte offset from the beginning. Length pointers contain byte counts. The resolved data range is shown before saving. Pointer fields use a faded checksum colour. Empty lengths, unavailable bytes, address gaps, self-overlap and out-of-file values stop the calculation. Dependencies are resolved on a worker snapshot; a failure never applies a partial correction.

Repeat bookmarks

Drag the small corner handle above or below a bookmark to repeat its complete block, then choose Create bookmarks. Copies keep the original settings and group; their addresses shift to each block. File bytes stay unchanged. Only the outer bookmarks in a matching series have handles, and dragging stops before existing bookmarks, checksum zones, templates, address gaps or the end of the file. Inside a template, dragging a bookmark adds the new members to the master and every template copy, even when you drag from a copy. The review shows the total number of bookmarks. Repetition stays within the template block and stops before other bookmarks or checksum storage; checksum data coverage can contain bookmarks. Matching series have their own end handles in each template instance. Undo removes all new copies together.

Variables in names

Use *addr* for the entry’s short address, such as 0x4D, *count* for the template block number starting at 1, and *offset* for the signed byte distance from the master. For example, Record *count* @ *addr*. The master is 1 and copies follow their creation order; deleting a copy renumbers the remaining list. Independent bookmarks and checksums count in definition order. Ordinary names remain unchanged. Variables are literal substitutions, never executable expressions.

Saving, modifying & exporting scripts

Give a script a name and choose Save to account. Saving an opened account script updates that script. New script creates a separate draft. You may keep up to 100 scripts, each with a name up to 80 characters and source up to 100,000 characters. Saved scripts are scoped to the signed-in user on the server.

Use the download icon to export plain .js or .lua source for your own archive. Import script reads .js, .mjs, .txt or .lua source without executing it. The account copy retains the selected language. JavaScript processes your selection; the experimental iProg Lua adapter processes a whole contiguous file. Read Other tools / Lua for supported APIs and limitations. Export does not include file bytes or log output. A failed account save preserves the open draft so you can retry or export it.

Device settings and separate folders

Binary and bookmark Open/Save dialogs use separate folder histories in browsers with native file pickers. A selected bookmark directory applies only to bookmarks. Browsers without native pickers retain ordinary file input and download fallbacks. Dock layout, floating window positions/sizes and table columns stay in this browser’s local storage; account preferences keep algorithms, units and interpretation choices. File handles use browser-managed permissions and IndexedDB where a bookmark directory is retained. Cookies remain for authentication.

Bookmark definition and groups

The Edit selected values window shows how many bookmarks will be edited. Choose Set all to a value, Multiply by factor, Add, Subtract, Increase by percent or Decrease by percent. Arithmetic changes each numeric value from its current value using its factor and offset. Integer storage rounds to the nearest stored value. Select bookmarks with Ctrl/Cmd-click or Shift-click, then right-click and choose Edit selected values. Right-click a group and choose Edit selected values to include every bookmark in that group, including collapsed or filtered entries. Enter a displayed value: numbers accept decimal, 0x hexadecimal or 0b binary and convert for each type and byte order; text and dates use their own format. Hex bytes applies an exact byte sequence. Every repeated value inside each bookmark is set. Scaling, XOR, inversion and linked inverted copies are preserved. Values that do not fit, conflicting overlaps, location-only bookmarks and maps are skipped with an expandable report. The whole edit is one Undo step. Pro bookmark features still require Pro.

Offset is available for bookmarks and checksum zones, with a signed decimal or 0x byte offset. A group Offset button beside its colour button applies to bookmarks and checksum zones in that group. Checksum storage, covered data and inverted copies move together. The preview warns about unavailable addresses and blank data. You can retain problem entries as Invalid bookmark / Invalid checksum or leave those addresses unchanged. Active checksums can be disabled, verified before applying, or corrected together. Verification makes no byte changes; failed zones remain disabled unless you explicitly correct them. Offset changes and corrections are one undoable operation. Addresses are stored after the offset is applied: moving entries to another group or Ungrouped does not change their address. Invalid entries cannot write bytes and can be repaired in properties or by another offset. Imports offer the same keep-invalid choice.

Adding and editing use the same fixed-height, non-scrolling window with five tabs: General, Interpretation, Inverted copy, Defined values and Description. General contains name, group, address, length, Big Endian / Little Endian, inversion and filterable type labels. A new group name creates a group when you save. Numeric and date values require complete data-type widths. Use uint24 or int24 for three-byte integers. Yellow warnings explain invalid settings and block saving. Unsupported types disable the Interpretation fields. File-level history stores the creator’s email, creation time, program version, last editor’s email and changed-save edit count; individual bookmarks do not carry history tags. Original author details in imported files are preserved.

The bookmark panel shows address, Length and interpreted value. Length is shown in decimal and hex. Checksum zones show CS Length and Data Length in decimal and hex; checksum-zone Data Length is the covered address range, including blank positions. Use the colour button on a group heading to choose one of ten presets or a custom colour and override its members’ colours. Individual colours remain saved. In bookmark properties, inherited colour controls are gray; Ignore bookmark group settings enables the individual colour. Clear the group override to restore member colours. Group colours and per-bookmark exceptions save in the bookmark file. Groups open and close with +/−. When a loaded bookmark set exceeds the panel’s available space, its groups start collapsed. Smaller sets open normally. When at least one group exists, Close all groups and Open all groups control every group, including Ungrouped. Ctrl+A selects matching entries in the focused Bookmarks, Checksum zones or Templates list; with no filter it selects all entries, including collapsed groups or copies. Matching off-screen rows are included. Right-click a row for Select all visible, or a group to select all bookmarks or checksum zones within that group. The editor selects all bytes while focused, including when a numeric or ASCII byte cell is being edited. Right-click in the editor and choose Select all for the same action. Other text fields, including filters and dialogs, keep normal text selection. Closing all clears the bookmark filter so the collapsed headings are visible; drag bookmarks onto a group or onto Ungrouped to move them. Ungrouped is the default category and its heading only appears when another group exists. Its name is reserved. Drag a column boundary anywhere along the header or rows to resize names, addresses and values. Tables remain within their tab width. Bookmarks have a fixed Actions column; checksum zones have a fixed Functions column. Right-click a header or boundary to choose visible columns. Widths and visibility stay in this browser. New group also creates an empty group. Groups save with the bookmark file. Filters search only visible columns. Group names are searched when the bookmark name column is visible. Go to highlights the matching row even when bookmark names repeat.

Right-click a bookmark and choose New bookmark based on this to copy its settings to a new address and length, or use Select in editor. Add bookmark also offers Copy settings from bookmark. Copies get new identities and creation information; inverted-copy links move relative to the new range. Right-click Modify bookmark value opens value editing directly. The value window shows address, byte length, raw hex and formatted value with read-only units. Choose defined value is available, with Edit bookmark properties for interpretation changes. The unit sits inside the value field border and is not editable. Double-click a single bookmark value in the panel for quick editing; Enter or leaving the field applies a valid edit, while invalid, out-of-range or stale input restores the current display. Escape cancels. Multi-value bookmarks open the value editor. Editor tooltips show interpreted values. Numeric values can be edited using add, subtract, multiply, divide, increase-by-percent and decrease-by-percent operations. Use original data chooses the baseline from the original file using matching addresses; unchecked uses current bytes. Restore original, beside Apply, restores the exact opened bytes without a rounding or scaling conversion and supports Undo. The value window keeps a fixed height and reserves room for its result and error messages. Operations use interpreted values, then reverse the bookmark scale and write through the normal Undo path. Unused custom algorithms and unset Custom CRC parameters are omitted from bookmark files.

Files, Find and account access

Open file tabs share the menu row. New creates an empty binary file. Closing the last file keeps the menu and command bars available. Value format is in View; Simple / Advanced is beside New and Open. Each open file retains its format, data width, line length, byte order, ASCII, overwrite mode and appearance while switching tabs. Changes become defaults for newly opened files. Canvas V2 is the editor for every account. Editing mode belongs to the current file; switching Simple / Advanced does not change a saved default. New appearance defaults use Consolas, 16 px, normal weight. Existing saved font choices remain unchanged.

Find shares the last value across files, selects the entire value whenever opened and saves up to ten recent searches to your account. Recent values include hexadecimal, text and numeric searches. Right-click decoded text and choose Copy ASCII to copy the selected bytes when the clicked byte belongs to the selection, or the clicked byte otherwise.

Sign in opens a compact editor popup, including authenticator verification, and preserves open files. Account and security controls open pollux.lt/account in the normal browser outside the installed editor.

Bookmark units, precision and presets

The Interpretation tab provides factor, offset, unit and precision with a live preview. Precision is 0–20 decimal places, or empty for automatic formatting. It rounds display only; edits round to the nearest stored value. Presets include Speed (1/256, 0, 2, km/h), Hours (1/3600, 0, 2, h), and Odometer factors 1, 0.5, 1/10, 1/100 and 1/1000 with precision 0, 2, 1, 2 and 3 respectively, unit Km. Save current values to account creates a reusable preset. Custom presets can be deleted without changing existing bookmarks. Factors and offsets accept decimal points or commas and arithmetic formulas.

Custom and repeated paste

Right-click the editor and choose Custom paste to take a chosen prefix of clipboard bytes and repeat it a specified number of times. Repeated paste fills the entire selection, trimming the final repetition when necessary. A selection is overwritten from its start; without a selection OVR / INS applies. Paste is one undo operation. The compact fixed-height window keeps pattern bytes, repeat count and paste mode on one row. Fill selection disables repeat count. The clipboard hex field also accepts manual Ctrl+V when direct clipboard access is unavailable.

Find results and inspector

Find All results appear in one scrollable, filtered list. Address, bytes, numeric type, byte order and value can be filtered. Only visible result rows are rendered; filtering and result indexing stay in the worker. Numeric searches retain the best 2,000 matches and highlight all matches. The byte-order badge in Data inspector cycles BE → LE → BE + LE and saves the setting to your account.

Microcar checksum

Microcar is a licensed custom checksum with a one-byte result and a minimum of two source bytes. Select the covered data separately from its stored checksum, then choose Microcar when defining or verifying the zone. Validate the covered range against known records before enabling automatic updates.

Autonomous checksum discovery · Pro · F2

Open a file and press F2, click Find checksums beside Find, or choose Tools → Find checksums. Configuration floats separately; progress and results remain in the bottom tab. Choose one algorithm with Only or tick a custom combination. The search tests file structures and repeated records in a dedicated worker. Percentage estimates planned work; 100% appears only when a non-stopped operation finishes. Pause and Stop retain completed matches. Likely and Discarded show exact matches, ranking scores and reasons; scores are not proof. Filter by algorithm, select individual rows and use Accept selected, or use Accept shown likely for the current filter. Acceptance verifies current bytes and excludes existing or conflicting zones. Save bookmarks to persist accepted zones. Each file supports up to 5,000 checksum zones and 5,000 bookmarks within its plan allowance.

Settings, filters, progress and results belong to each open file. Closing the window/tab or switching files preserves them. File or settings changes retain stale results with a warning; search again before inspecting or accepting. Clear results removes search metadata without deleting defined zones. Inspect focuses one exact candidate: green suggestions and the editor right-click menu show only that checksum until you make another selection. Defining it uses the original covered range even when you inspected its storage bytes.

Search area defaults to Whole file. Choose Custom range to enter inclusive hexadecimal Start and End addresses, or Select from editor, highlight bytes and choose Use this selection. The configuration moves aside while you select. Word-addressed cells support +byte to identify an individual byte inside a cell. Pattern analysis and checksum calculations stay inside the chosen area; result addresses remain unchanged. The search area is remembered for each open file.

Maximum skipped bytes defaults to 0, so data and its checksum must touch unless you change it. Before calculating checksums, the search looks for exact adjacent copies of complete records to propose their boundaries and lengths. It verifies each physical copy and raises confidence when several different records form a gapless map with the same algorithm. Identical copies count as one experiment, and weak copied sums or cancelling XOR patterns remain excluded. The search can also learn recurring lengths, spacing, padding and terminal-byte patterns from independently varied exact matches, then verify additional ranges with the supported algorithm. No particular terminal byte is built in, and repeated values alone do not establish a checksum layout. Byte-swapped matching changes stored output order only. Uniform data remains eligible when a nonblank CRC matches, including checksum bytes beginning with 0x00 or 0xFF. Local CRC chains, independently varied duplicate pairs and adjacent boundaries support a consistent checksum map; a nonzero initial value alone is not proof. XOR coincidences from identical repeated blocks are discarded. Search is bounded and reports limits. Scripts still require explicit checksum zones.

Find CRC parameters · Pro

Choose Tools → Find CRC parameters with or without an open file. Provide at least two sample zones, each including its suspected checksum. Paste complete hexadecimal bytes, or choose Select in editor and then Use this selection when a file is open. Selection capture uses current file bytes and rejects unknown positions and address gaps. Add more samples to reduce accidental matches. The search first checks existing named CRC-based checksums against every sample. When a known checksum matches, it shows its name and stops without exposing its parameters or starting parameter recovery.

Choose CRC-8, CRC-16 or CRC-32, whether the checksum is at the start or end of every sample, and whether to check swapped stored values. Changing CRC length resets the polynomial to the default for that width: 07, 1021 or 04C11DB7. Enter a custom polynomial after choosing the length. Known polynomials only uses a researched private catalogue; Custom polynomial only tests the hexadecimal polynomial you enter. Leave both unchecked to infer unknown polynomials algebraically where samples permit. Unknown inference needs different equal-length samples, uses zones up to 8 KiB and has computation limits; longer samples still verify candidates. It is not an exhaustive sweep of every possible 32-bit polynomial.

If no named checksum matches, the worker solves initial value and final XOR with both reflection settings and verifies every returned model against all supplied zones. Final XOR defaults to Automatic (unrestricted). Choose Common to test zero and all-one final XOR values, select either value alone, or enter a custom hexadecimal XOR. The worker then solves the initial value under that assumption and checks every sample. A constrained result does not prove that the original algorithm used the assumed XOR. Equal-length samples often leave init and XOR ambiguous; different lengths can help, but some equivalent parameter pairs remain indistinguishable at every length. Results show one valid representative and its undetermined bits. A match is evidence, not proof of the original implementation. Pause/Resume and Stop keep the editor responsive; Close cancels active work while retaining the sample draft.

For a recovered unknown CRC, Set Custom CRC-8, -16 or -32 applies that result to the corresponding account setting and enables its checksum entry. Known named matches do not expose parameters or offer this action. Other widths and file bytes stay unchanged. Swapped storage is separate from reflection: choose Little Endian storage when defining a zone for a swapped result. Changed samples/settings disable applying stale results until you search again. Finding CRC parameters requires an active, verified Pro account.

Ordered split data

Bookmarks and checksum zones can cover several ranges in a specific order. Enable Split data ranges in the bookmark General tab or checksum definition. Enter hexadecimal Start–End pairs, one per line, with inclusive end addresses. For example, place the end-of-file range first and the middle-of-file range second. Values and checksums use the concatenated bytes in that order; the spaces between ranges are excluded. Ranges must not overlap, and each range must stay within one contiguous address segment. Up to 256 ranges are supported.

Bookmark value widths and byte order apply across range boundaries. Editing a value updates only its actual bytes; Go to navigates to the first listed range. An inverted copy is a contiguous copy of the combined data. Data length is the sum of the ranges. Save .ptmap preserves the order using format version 4 for split definitions; ordinary single-range files keep their existing format. Offsets, structural edits and replacement move each range, while invalid mappings stay marked for review. Checksum verification reads the current data without changing it; enabled updates and Save recalculate using the same ordered ranges.

Defining checksum zones

Choose Select in editor for covered data or Select checksum bytes in editor for storage. The properties window moves to the side at 50% opacity. Use this selection applies the highlighted range; Cancel returns to the draft. The last chosen algorithm is remembered when its storage size matches the new selection. Saving validates only the proposed checksum, while checking storage conflicts and circular dependencies against other enabled zones. If the stored checksum is wrong, the dialog shows stored and expected hex values and waits for Continue. Automatic updates may then correct the stored bytes. Each cluster of suggested checksums has its own count and right-click results. Hover or focus a checksum menu item to outline its exact storage bytes in red. The menu is placed outside the cluster, with scrolling if needed; clusters before and after the selected data stay separate.

Importing and repairing checksum zones

Import verification keeps file bytes unchanged until you choose Import and fix checksums. That action recalculates valid imported zones, including checksum dependencies, verifies the result in a worker, and applies one Undo operation. Invalid zones and unreviewed scripts remain disabled. The Skip and Keep actions never repair bytes.

Editor overview and resizing

Options → Hex editor appearance includes Show visual data overview beside the scrollbar. This preference saves to your account. Turning it off removes its drawing and navigation handlers while preserving cursor and selection. Dock dividers preview directly during dragging and save their size on release. Column dividers transfer width between neighboring columns so tables cannot exceed the tab.

Windows Open with

Install PolluxTool V2 through Microsoft Edge’s Apps menu and allow file handling. The installed web app registers common binary, EEPROM, HEX, S-record and bookmark extensions, including .bin and .epr. In File Explorer, right-click a supported file and choose Open with → PolluxTool V2. File access remains local and requires the browser’s permission. Browser and operating-system support determine availability; the ordinary browser tab does not register Windows file associations.

Dim blank bytes

Undefined data appears white in the visual data overview. Use the toolbar Dim blank bytes toggle to make repeated identical 00, FF or undefined bytes gray. Options → Hex font & colour… sets the minimum consecutive run, 16 bytes by default. Different blank values do not combine. Alternating 00/FF stays visible, and an isolated 00 following FF padding stays visible. Runs stop at physical segment boundaries. Bookmarks, defined checksum blocks, search marks and differing comparison bytes keep their emphasis. Difference and percentage views keep their normal delta colours. Modified bytes keep their red text even inside a dimmed blank run. The setting changes presentation only.

Connection & local recovery

Returning from a file picker or a suspended window starts a fresh account check when the previous request expired. Transient server/network failures allow 30 continuous seconds to reconnect without interrupting editing. A successful refresh cancels the countdown. The first retry is prompt, followed by retries every five seconds during this grace period. If the recovery window stays open, Copy debug info includes request timing and error codes without file bytes or account credentials. Program settings → Copy file-launch debug info reports separate per-window launch counts and shared-inbox enqueue, pending and acknowledgement counts without filenames. Program settings → Combine Explorer launches in one window is a device setting, off by default to preserve the original startup animation. Enable it if Explorer misses files or opens separate editors. Enabled launches use a short opening screen and shared inbox, then close the extra receiver after acknowledgement. Save your work, close every app window and reopen after changing it.

PolluxTool periodically confirms your account access. If a connection failure or overdue refresh persists for 30 seconds, the editor is blurred and locked until a fresh response confirms access. Explicit server access rejection and confirmed permission changes take effect immediately. Your open data stays on this device.

Use Refresh connection to retry without reloading. Reconnecting and the normal timer also retry. While waiting, Backup work downloads a local recovery ZIP for an open document, including its current bytes, bookmarks, checksum zones, script draft and any unfinished cell text stored separately. Backup does not recalculate checksums, overwrite the original file or clear unsaved changes. Read the ZIP’s README when restoring sparse data or unfinished input. A successful refresh restores your current account permissions; update prompts resume afterward.

Background sync records necessary authenticated session/access times, approximate connected duration, app version and recent connection addresses for account security and licence compliance. New records do not measure keystrokes, commands or active/idle interaction. File bytes, names, selected addresses, typed text and script contents are not sent.

Security, performance & current limits

My account → Subscription shows your access, included functions and file/bookmark allowances. Pro functions are available with a timed pass or subscription. Saved scripts have a name filter and Load more control; open a script to view or run it.

Create a free account to calculate Basic checksums and hashes and save your preferences. Pro adds the functions marked Pro in the interface. Binary contents, checksum calculations and script execution stay on your device.

Files are held in browser memory, so memory use is greater than file size. Your plan’s file allowance and the editor’s technical limits both apply. The defined-data limit is 64 MiB per file; script selections are limited to 16 MiB and 100,000 changed bytes per run. Only enabled checksums are calculated. Checksum settings → Automatic marking includes an option to ignore checksum candidates made entirely of 00 or FF. Turn it off to include them. A crashed checksum worker retries once automatically. Persistent failures show an error code, the browser error, Copy error report and Retry current selection. Expand Error report to copy manually if needed. Retrying preserves the selection. Very large selections take longer; disable unneeded algorithms in Select algorithms. Undo retains up to 100 operations with an approximately 16 MiB history budget, always retaining the latest operation; older operations are discarded when the budget is exceeded.

This release supports overwrite, insertion, deletion, sparse address maps and file comparison. Bookmark templates are supported; streaming multi-gigabyte files are not implemented. An empty file can be opened, downloaded or populated using Insert bytes. Closing or refreshing the page loses unsaved binary edits and unsaved script drafts. Export files and scripts before leaving.