List Tools

Decode a list of space-separated binary bytes back into UTF-8 text, item by item.

Find the intersection of two lists: items present in both.

Build a list from a start number, step, and count, with an optional prefix or suffix on each item.

Find items that appear in exactly one of two lists, not both.

List every duplicate occurrence beyond the first, in original order.

Generate a list of N items, each a chosen placeholder (blank by default, or custom text).

Remove items that are empty or whitespace-only from a list, preserving the order of the rest.

Decode each Base64 item in a list independently, with per-item error reporting.

Base64-encode each item in a list independently, preserving the item count.

Return just the first item of a list, the classic Lisp "car" operation.

Return every item of a list except the first, the classic Lisp "cdr" operation.

Render your list as a word-cloud-style layout, sized by how often each item repeats.

Compare two lists: items only in A, only in B, and in both.

Gzip-compress a list's text with the browser's real CompressionStream API and download it as a .gz file.

Repeat an entire list N times, concatenated together into one longer list.

Insert, delete, or replace a single item at a given position in a list.

Randomly introduce typos into a chosen percentage of list items, for testing fuzzy matching or validation.

Keep only list items matching a condition, with an invert option.

Flatten one level of bracketed sub-lists, e.g. "[a,b],c,[d,e]" becomes a, b, c, d, e.

Apply one built-in function (uppercase, lowercase, reverse, trim, length) to every item in a list.

Reverse the characters within each item ("hello" becomes "olleh") while item order stays the same.

Append one or more new items to the end of an existing list.

Prefix every list item with a bullet character (•, -, or *) you choose.

Strip a leading bullet character (•, -, *, and common variants) from every list item that has one.

Deterministically hash each list item to a color, with a visual swatch preview and a copyable hex list.

Prefix every list item with its 1-based index, in a configurable format.

Strip a leading number/counter prefix (like "1. ", "1)", "1:") from every list item that has one.

Delete every item equal to or matching a given value or pattern.

Search a list for items matching a term and see each match's position.

Group list items into chunks of a chosen size, each chunk joined into one output line.

Prepend a chosen indent string (default two spaces) once to every item in a list.

Join list items into a single string using a configurable glue, like Array.prototype.join(), e.g. " | " turns a, b, c into a | b | c.

Pair up consecutive items in a list (item1+item2, item3+item4, ...) joined by a glue string.

Pick one item uniformly at random from a list, with a Pick Again button to re-roll.

Remove the last N items from a list, showing both the remaining list and the popped items.

Prepend a chosen text string to the start of every item in a list, with a configurable separator.

Strip a chosen text string from the start of every list item that has it, with a configurable separator.

Push (prepend) one or more new items to the front of an existing list.

Wrap every item in a list in single or double quotes.

Find and replace a substring within every item of a list.

Shift a list by N positions: pad with empty items or drop leading items, no wrap-around.

Append a chosen text string to the end of every item in a list, with a configurable separator.

Strip a chosen text string from the end of every list item that has it, with a configurable separator.

Trim leading and trailing whitespace from every item in a list.

Strip surrounding matching quotes (single or double) from every list item that has them.

Strip a chosen prefix string and suffix string from every list item that has both.

Wrap every list item with a chosen prefix and suffix string, like "(" and ")".

Pad every item in a list on the left to a fixed width using a chosen fill character.

Change a list to an exact target length, padding with a filler value or truncating as needed.

Quickly find a list's item count and total character count.

Concatenate two lists into one, in order, using a configurable separator.

Output the list followed by the list reversed, so item order becomes a palindrome.

Generate every possible subset (the powerset) of a list's items, capped at 12 items.

Shuffle the order of list items with a Fisher-Yates shuffle and re-roll on demand.

Reduce a whole list to a single value: concatenate, count, sum, min, or max.

Reverse the order of items in a list using a configurable separator.

Pad every item in a list on the right to a fixed width using a chosen fill character.

Rotate a list left or right by N positions with true wrap-around, e.g. [1,2,3,4] left 1 becomes [2,3,4,1].

Preview your list as a CSS auto-scrolling ticker, horizontal or vertical.

Parse a list using one separator and rejoin it using a different one, e.g. newline-separated to comma-separated.

Split messy input that mixes commas, semicolons, newlines, and tabs inconsistently, then rejoin it with one clean separator.

Remove the separators entirely, concatenating every list item directly together into one unbroken blob.

Progressively increase indentation per item, creating a staircase/skewed visual shape.

Extract a range of items using exact JavaScript Array.prototype.slice(start, end) semantics.

Sort list items alphabetically (A-Z or Z-A), numerically, or by length.

Remove a run of items starting at an index and optionally insert replacements, JS splice semantics.

Split one list into two lists at a chosen 1-based index.

Get full statistics for a list: count, characters, average length, extremes, and duplicates.

Remove every item found in List B from List A, keeping the remainder of List A.

Lay a list out into N side-by-side, monospace-padded text columns, reading down each column then across.

Build a real downloadable .xlsx spreadsheet with one list item per row in column A.

Wrap list items as an HTML <ul> or <ol> list, with each item as an escaped <li>.

Render your list as monospace text lines on a canvas and download it as a PNG.

Wrap list items as a LaTeX itemize environment, escaping LaTeX's reserved characters automatically.

Prefix list items as a Markdown list, with an Unordered (- ) or Ordered (1., 2., ...) toggle.

Build a real downloadable .pdf with one list item per line of text, using a hand-rolled minimal PDF writer.

Lay a single-column list out into a grid of N items per row, each row's items joined by a configurable glue.

Wrap list items as <list><item>a</item><item>b</item></list>, escaping XML's special characters.

Convert a plain list into a YAML block sequence, quoting items that need it.

Keep only the first N items or the last N items of a list, dropping the rest.

Split a list of paired items back into two separate lists.

URL-decode each item in a list independently, with per-item error reporting.

URL-encode each item in a list independently using encodeURIComponent.

Render your list as a vertical stack of indexed cards, easier to scan than raw text.

Interleave two lists item-by-item into pairs, like Python's zip().

Frequency-count every value and sort by count descending, most popular first.

Pick N random items, sampled without repeats from your pool or generated with repeats allowed.

List every distinct value that appears more than once, each shown with its count.

De-duplicate a list, keeping the first occurrence of each value and dropping later repeats.

Arrange your list's items along a simple SVG Archimedean spiral, one item per angle step.

Extract items from a 1-based inclusive start index to end index, clamping out-of-range bounds.

Generate a numeric palindrome sequence that counts up to N and back down again.

Convert every item in a list to its UTF-8 binary representation, byte by byte.

Compare three lists: items in all three, in exactly two, and unique to one.

List every item that appears exactly once in the list.

Remove items that appear exactly once, keeping only items that repeat two or more times.

Parse simple <item>...</item> elements (or any single repeated tag, auto-detected) out of pasted XML into a plain list.

Parse a flat YAML block sequence back into a plain list with your choice of separator.

Add random Unicode combining marks to every character of every list item, creating a glitchy "zalgo text" effect.

Arrange list items in an alternating left/right indentation zigzag, as copyable plain text.