100% client-side · 957 tools · Your data never leaves your browser.
Paste a CSV, pick a column, and get one downloadable CSV per unique value in that column. Handles RFC 4180 quoting, embedded newlines, tab/comma/semicolon/pipe delimiters, and CRLF vs LF line endings. Ideal for regional sales files, per-tenant exports, or splitting a fixture into test groups — 100% in-browser, no upload.
Paste CSV or TSV and get a per-column data profile — inferred type (integer, float, boolean, ISO date, email, URL, UUID, IP, JSON, string), null and unique counts, min/max/mean, sample values, and a starter CREATE TABLE for PostgreSQL, MySQL, or SQLite.
Drag-and-drop reorder columns in a CSV, hide unwanted columns, rename headers, and re-emit clean CSV — auto-detects delimiter, handles quoted fields and embedded newlines.
Convert a JSON Schema (draft 4–2020-12, OpenAPI 3) into clean TypeScript interface and type declarations — resolves $ref, $defs, oneOf / anyOf / allOf, tuples with prefixItems, enum, const, additionalProperties, and emits JSDoc from title / description.
Convert CSV / TSV to a GitHub-flavored Markdown table with auto column alignment, pipe escaping, header detection, and <br> folding for multi-line cells.
Compare two YAML documents structurally — order-insensitive maps, list identity keys (name), and add/remove/change reporting for Kubernetes manifests and Helm values.
Flatten nested JSON into KEY=value for .env files, docker --env-file, Kubernetes Secrets, or shell export. Configurable separator, prefix, casing, quoting, and array handling.
Format, validate, minify, and beautify JSON with syntax highlighting.
Generate Swift Codable structs or classes with CodingKeys, Optionals, and nested types.
Convert JSON objects to Go structs with proper json tags.
Convert JSON objects to TypeScript interfaces instantly.
Convert between JSON and XML formats instantly in your browser.
Compare two JSON objects side by side with structured diff highlighting.
Generate RFC 6902 patch operations from JSON diff.
Evaluate JSONPath expressions against JSON data in real-time.
Repair malformed JSON — remove comments, fix quotes, strip trailing commas.
Generate JSON Schema from any JSON data instantly.
Convert between JSON arrays and CSV format. Download results instantly.
Parse, filter, and inspect JSON Lines / NDJSON data.
Convert between YAML and JSON formats with syntax validation.
Convert between TOML and JSON formats for config files.
Convert CSV data to SQL INSERT statements and CREATE TABLE queries.
Parse CSV into JSON with header detection, type inference, and custom delimiters.
View, sort, filter, and edit CSV data in a sortable table.
Beautify, minify, and syntax-highlight SQL queries.
Evaluate XPath expressions against XML data with real-time results.
Format, minify, and validate GraphQL queries, mutations & subscriptions.
Test jq-like filter expressions against JSON data in real-time.
Convert JSON objects to Python dataclasses, Pydantic models, or TypedDicts.
Convert JSON objects to Rust structs with serde derive macros.
Format, validate, and minify XML documents with syntax highlighting.
Apply XSLT stylesheets to XML documents and preview the transformation result.
Convert between nested JSON and flat dot-notation key-value pairs.
Convert between JSON and YAML formats with live validation and formatting options.
Convert between JSON and MessagePack binary format. View hex dumps and compare sizes.
Generate Zod validator schemas from JSON with inferred types, unions, and z.infer export.
Convert TypeScript interface and type declarations into Zod schemas — handles unions, intersections, tuples, literals, optional / readonly props, nested objects, and built-in generics like Record, Partial, Array.
Profile CSV columns — count, min/max, mean, median, stddev, type detection, and top values.
Generate Kotlin data classes with nullable types, kotlinx.serialization, Gson, or Moshi annotations.
Generate C# classes or records with System.Text.Json or Newtonsoft.Json attributes.
Generate Java POJOs, Lombok classes, or records with Jackson or Gson annotations.
Apply or generate RFC 7396 merge patches between JSON documents — null fields delete keys.
Build and validate JSON-RPC 2.0 requests — single, batch, notifications, and live POST.
Evaluate RFC 6901 JSON Pointer expressions against a document — with an interactive browser of every pointer.
Write JsonLogic rules and evaluate them against JSON data — comparisons, arithmetic, arrays, var access.
Recursively sort JSON object keys for stable, diff-friendly output — with natural order, case modes, and optional array sorting.
Validate RFC 7946 GeoJSON documents — count features, summarize geometry types, compute the bounding box, and preview on a minimap.
Find which keys, paths, and arrays hog your payload — group by path or key name, see byte-level shares.
Turn a JSON array of objects into SQL INSERT statements — Postgres, MySQL, SQLite, or MSSQL, with CREATE TABLE and batching.
Parse, format, and convert INI configuration files to and from JSON. Supports sections, quoted values, dotted nesting, and array-style repeated keys.
Parse Java .properties files with unicode escapes, line continuations, and comments. Convert to JSON or ASCII-escape like native2ascii.
Convert between TSV, CSV, PSV, JSON, NDJSON, and Markdown tables with a live preview, column stats, and download.
List every unique JSON path with types and sample values. Supports dot, bracket, and JSONPath notation with filtering.
Strip // comments, /* block comments */, and trailing commas from JSONC files like tsconfig.json and VS Code settings.
Convert XML documents to JSON with customizable attribute handling, text node options, and array detection.
Pivot CSV data — pick row, column, value fields and an aggregation (sum, mean, count, median) to build a cross-tab.
Compare two CSV files row-by-row by a chosen key column — added, removed, and changed rows with cell-level highlighting.
Convert Excel/Sheets column letters (A, AA, ZZ) ↔ numbers, and translate A1 ↔ R1C1 cell references in bulk.
Recursively strip null, empty strings, empty arrays, empty objects, false, and zero values from JSON with stable re-cleaning.
Round-trip OPML feed lists ⇄ JSON, URLs, or Markdown for RSS reader exports, backups, and Feedly→FreshRSS migrations.
Parse JSON5 — JSON with comments, trailing commas, unquoted keys, single quotes, hex literals, NaN/Infinity, and multi-line strings — and emit strict RFC 8259 JSON. Also pretty-prints strict JSON as ergonomic JSON5.
Visualize env(safe-area-inset-top / right / bottom / left) live on a fake device — drag sliders for notch size, home indicator, status bar, and side inset, toggle viewport-fit=cover and landscape, and see red bands mark exactly which pixels get letterboxed. Copies working CSS with the max(16px, env(…)) minimum-padding pattern and the iOS 11 constant() fallback.
Convert between CSS’s four angle units — deg, rad, grad, turn — with a draggable compass dial, live rotate() and conic-gradient() preview, toggle between the CSS clockwise-from-top convention and the atan2 math convention, and a reference chart of common angles (0°, 45°, 90°, 180°, 360°).
Give me a value at two viewport widths and I'll fit clamp(min, preferred, max) — slope in vw, intercept in rem, live curve plot, and a viewport-slider preview. Presets for fluid H1, body, gap, radius, and button padding.
The long-awaited parent selector. Type any :has() expression and see exactly which elements in your HTML match, with the rendered preview, recipes, and specificity breakdown.
Type an an+b formula and watch matched children highlight in real time. Switch between :nth-child, :nth-of-type, :nth-last-child, and :nth-last-of-type; mix child types to see how of-type changes the count; try Selectors 4's of S filter syntax.
Pick a named area and click cells to paint a layout — get the matching grid-template-areas string with rows aligned column-by-column, dot placeholders for empty cells, and automatic validation that every area is rectangular. Live preview, copy-ready CSS, and Holy Grail / Dashboard / App Shell presets.
Compare text-box-trim and text-box-edge values side by side — see exactly how trimming the half-leading down to cap-height & baseline finally centers text inside a button. Live preview, edge cheat sheet, and a copy-ready text-box shorthand with an @supports fallback.
Build the border-image shorthand with a live nine-slice preview — slice, width, outset, and per-axis repeat (stretch / repeat / round / space). Includes nine ready SVG patterns embedded as data URIs.
Build a CSS linear() timing function for spring, bounce, elastic, or stepped animations — adjust physics (stiffness, damping, mass, velocity), preview the curve and animation live, and copy a Chrome 113+ ready value with @supports fallback.
Style list bullets and numbers with the ::marker pseudo-element — color, font-size, font-family, replace the bullet with a custom string, emoji, or a counter() expression like 'Step ' counter(list-item) '. '. Pair with 25+ built-in list-style-type values (decimal-leading-zero, lower-roman, lower-greek, hiragana, hebrew, …) and copy ready CSS with the inheritable-only property guardrails baked in.
Stack multiple box-shadow layers visually — offset, blur, spread, color, opacity, and inset per layer with live preview on light, dark, photo, and checker backgrounds. Material-tier (1dp / 3dp / 8dp / 16dp), neumorphism, glow, focus-ring, and long-shadow presets, then copy a clean rule.
Reorder messy Tailwind utility classes into the canonical prettier-plugin-tailwindcss order — layout, spacing, typography, background, border, effects, then variants — with dedupe, character-count delta, and inline rewriting of every class="…" in an HTML / JSX snippet.
Build magazine-style multi-column layouts with live preview — pick column-count or column-width, set column-gap, column-rule, column-fill, toggle column-span: all headings, and lock items together with break-inside: avoid. Copy-ready CSS plus a news-layout recipe that never strands an orphan heading.
See exactly how scrollbar-gutter: auto vs stable vs stable both-edges changes layout at the moment the scrollbar appears — toggle content length to watch the shift (or not), pair with scrollbar-width & overflow-y, and copy the recipe that stops the page from jumping when a modal opens.
Compose CSS feature queries clause by clause — combine property tests with and / or / not, test selector(:has()), font-tech(), font-format(), see live whether your browser passes each clause via CSS.supports(), and copy a clean rule with presets for :has, subgrid, anchor positioning, view transitions, color-mix, OKLCH, and more.
Generate a consistent spacing scale — linear, geometric, modular, Fibonacci, T-shirt, or 4-/8-pt grid — and export as custom-property tokens, Tailwind config, Sass map, JSON design tokens, or utility classes with a visual step preview.
Compare hyphens, word-break, overflow-wrap, and line-break on the same text at the same column width — tune hyphenate-character & hyphenate-limit-chars, spot which combo actually breaks the unbreakable URL.
Convert CSS px to rem, em, pt, %, vw, vh with adjustable base font size — bulk rewrite CSS values, reference scale, and a live size preview.
Compare text-wrap: balance / pretty / stable / wrap / nowrap side-by-side at the same width — live ragged-edge metrics, orphan detection, and copy-ready CSS for headings & prose.
Design text-emphasis marks (dot, circle, sesame, triangle, double-circle, custom string) with color, position, and skip rules — live preview for horizontal and vertical (CJK) writing modes.
Generate CSS for a footer that stays pinned to the viewport bottom when content is short and scrolls naturally when long — flexbox, CSS Grid, legacy negative-margin, and dvh variants with a live device-sized preview.
Build custom CSS list markers with the @counter-style at-rule — pick system (cyclic, numeric, alphabetic, symbolic, additive, fixed, extends), symbols, prefix/suffix, range, pad, and fallback with a live ordered-list preview.
Generate CSS for animation-timeline: scroll() and view() — pick axis, scroller, view inset, and animation-range (cover, contain, entry, exit, *-crossing) with a live scrolling iframe preview.
Generate CSS for single-line ellipsis, multi-line clamping (line-clamp + -webkit-line-clamp fallback), or soft fade-out endings with a live resizable preview.
Measure perceptual color difference between two sRGB colors with CIE76, CIE94, and CIEDE2000. Includes L*a*b* breakdown and a just-noticeable-difference verdict.
Design same-document view-transition-name morphs with custom ::view-transition-old/new keyframes — morph, slide, flip, zoom presets, reduced-motion fallback, and a live startViewTransition() sandbox.
Build CSS rules that auto-size textarea, input, and select to their content with field-sizing: content. Live preview, ch/lh guardrails, and an @supports fallback.
Build dual-theme CSS variables with the light-dark() function — one declaration, both themes, no @media (prefers-color-scheme). Live light/dark/auto preview and copy-ready CSS.
Generate @scope blocks with a scoping root and optional donut limit for component-scoped styles. Presets, live iframe preview, and copy-ready CSS.
Build image-set() declarations for responsive backgrounds, masks, and cursors — DPI variants (1x, 2x, 3x) and optional AVIF/WebP/JPG format negotiation with type().
Animate elements as they appear — dialogs, popovers, and display: none entries — with @starting-style and transition-behavior: allow-discrete. Live preview and copy-ready CSS.
Generate pure-CSS tooltips driven by data-tooltip with configurable position, arrow, padding, easing, and colors. Live preview and zero-JS output.
Interactive playground for object-fit (fill, contain, cover, none, scale-down) and object-position with a click-to-set 2D pad and live CSS output.
Create beautiful linear, radial, and conic gradients with live preview.
Build counter-reset / counter-increment / content rules with a live preview — roman, alpha, greek, and nested counters.
Design box shadows with multiple layers, inset support, and live preview.
Interactive CSS flexbox playground with live container & item properties.
Build grid layouts visually with presets, custom placement, and CSS export.
Build CSS keyframe animations visually with live preview.
Visually build CSS transforms: translate, rotate, scale, skew, perspective.
Interactive cubic-bezier easing function generator with visual curve editor.
Visual border-radius generator with individual corner control and live preview.
Visually create polygon, circle, ellipse, and inset clip-path shapes.
Create beautiful CSS text-shadow effects with multiple layers.
Visually design outlined text with -webkit-text-stroke or a cross-browser text-shadow ring — paint order, thickness, and presets included.
Generate frosted glass CSS effects with live preview.
Generate soft UI / neumorphic CSS effects with live preview.
Visually adjust blur, brightness, contrast, grayscale, and more.
Minify or beautify CSS and JavaScript. Shows compression ratio.
Calculate and compare CSS selector specificity scores instantly.
Generate harmonious color palettes with contrast checker and export.
Pick colors and convert between HEX, RGB, HSL, CMYK formats.
Test foreground/background color combinations for AA and AAA accessibility.
Preview how images and colors appear to people with color blindness.
Generate seamless, tileable SVG background patterns for your website.
Generate beautiful SVG wave dividers. Customize layers, colors, and height.
Convert between px, rem, em, vw, vh, % and more with live preview.
Convert between HEX, RGB, HSL, HWB, and CMYK color formats with live preview.
Generate harmonious color palettes — complementary, analogous, triadic, and more.
Interactive box model editor — adjust margin, border, padding & content dimensions with live preview.
Blend two colors with adjustable ratio in RGB or HSL color space with gradient steps.
Generate Tailwind-style 50–950 color scales from a base color for design systems.
Generate harmonious modular type scales for web typography with CSS export.
Browse, search, and copy all 148 CSS named colors with hex, RGB, and HSL values.
Generate fluid, responsive CSS values using clamp() for typography, spacing, and sizing.
Build responsive CSS media queries visually with breakpoint presets and live testing.
Paste CSS code to extract all colors with previews, deduplication, and format conversion.
Define CSS custom properties visually, preview on live components, and export a clean theme.
Generate CSS-only loading spinners, progress bars, and skeleton screens with customizable styles.
Pick colors from an interactive HSL wheel with saturation, lightness sliders and format export.
Convert flat CSS to native nested syntax and nested CSS back to flat with & selectors.
Write CSS selectors and test them against HTML with real-time match highlighting.
Analyze CSS code for metrics — selectors, specificity, colors, fonts, media queries, and complexity.
Pick colors in the OKLCH perceptual color space with live preview and format conversion.
Visually build CSS transitions with custom timing, easing presets, and live preview.
Build scroll-snap containers visually — axis, strictness, alignment, padding — with live preview.
Compose @container queries with a drag-to-resize preview that responds to container width, not viewport.
Convert Tailwind utility classes to plain CSS with selector, variant, and live preview support.
Create pure-CSS triangles for tooltips and arrows with the border trick or clip-path.
Build the HTML viewport meta tag with zoom, scaling, and notch safe-area controls.
Design custom scrollbars with live preview — modern scrollbar-color plus full WebKit styling.
Convert Kelvin color temperature to RGB, HEX, and CSS with a live gradient preview and common reference points.
Experiment with every mix-blend-mode and background-blend-mode value over gradients and images with live preview.
Design frosted-glass backdrop-filter effects — blur, brightness, saturate, hue-rotate, and more — with -webkit- prefix.
Visualize stroke-dasharray and stroke-dashoffset, preview line-drawing animations, and copy the SVG + CSS.
Generate harmonious color palettes — complementary, analogous, triadic, split, tetradic — with shade ramps and CSS/SCSS/Tailwind export.
Design custom CSS buttons with live preview — colors, padding, borders, shadows, hover effects, and presets. Copy clean CSS code.
Test WCAG contrast ratios for all foreground/background color pairs in one grid — AA, AAA, and large text compliance.
Convert between CSS properties and JavaScript/React style objects — camelCase, vendor prefixes, and px units.
Visualize which elements match :nth-child(), :nth-last-child(), and :nth-of-type() selectors with a live grid.
Create gradient borders using border-image, background-clip, or pseudo-elements with live preview and CSS export.
Create stunning gradient text effects with live preview — adjust colors, direction, and font properties.
Generate CSS @font-face declarations for custom web fonts with weight, style, display, and unicode-range options.
Generate pure-CSS repeating background patterns — stripes, dots, checkerboard, diamonds, zigzag, and more.
Build CSS cascade layers visually — define layer order, drag to reorder, and preview how cascade priority resolves conflicts.
Create CSS keyframe animations visually with live preview and code export.
Preview every CSS cursor value — hover to see it live, click to copy the CSS property.
Interactive cubic-bezier() editor with draggable control points and animation preview.
Visually design CSS Grid layouts — set columns, rows, gaps, and named areas, then export clean CSS.
Tune mass, stiffness, damping, and velocity to emit CSS @keyframes that mimic react-spring physics — live preview, copy CSS.
Align nested grid rows or columns to the parent's tracks — live RTL/LTR preview and clean exported CSS for card grids.
Convert margin-left, padding-top, border-right to logical equivalents (margin-inline-start, padding-block-start) for RTL and vertical writing modes.
Build mask-image declarations visually — gradient fades, vignettes, polka dots, and SVG shape masks with size, position, and mode controls.
Mix two colors in oklch, lab, hsl, hwb, srgb and more — adjustable percentage and hue interpolation, side-by-side preview, copy-ready CSS.
Build anchor-name, position-anchor, and position-area declarations for tooltips and popovers — drag-to-test stage, fallback flips, copy-ready CSS.
Register typed CSS custom properties with syntax, inherits, and initial-value — then watch a transition animate because the property is registered.
Build a @media print stylesheet — hide nav, set @page size and margins, manage page breaks, expand link URLs — with a live preview iframe.
Paste any SVG and interactively tune its viewBox and preserveAspectRatio — auto-fit to the drawing’s bounding box, zoom, pan, and toggle each of the nine align keywords (xMinYMax, xMidYMid, …) with meet or slice to see exactly which pixels the container keeps and which it letterboxes.
Apply 3×3, 5×5, or 7×7 convolution kernels (sharpen, blur, Sobel, Laplacian, Gaussian, emboss…) to an image. Edit any cell, tweak divisor/bias/edge mode, and see the result in real time.
Drop an image to inspect its RGB and BT.709 luminance histograms with min, max, mean, median, mode, σ, and clipping warnings for blown highlights and crushed shadows. Linear / log / √ Y-scale, 256–32 bin presets, transparent-pixel toggle, paste-from-clipboard.
Convert images to Base64 data URIs for embedding in HTML & CSS.
Convert any image to ASCII art with adjustable width and character sets.
Compress JPEG, PNG, and WebP images in your browser.
Convert images between PNG, JPG, WebP, BMP, and GIF formats.
Crop, resize, and export images right in your browser.
Generate custom placeholder images with any size, color, and text.
Add custom text watermarks to images with adjustable font and opacity.
Create favicons from text, emoji, or images. Download all sizes as ZIP.
Generate iOS, Android & web icons in all sizes from one image.
Draw pixel art in your browser with customizable grid and color palette.
Apply retro dithering effects: Floyd-Steinberg, Atkinson, Bayer, and more.
Create Open Graph social media preview images for Twitter, Facebook, etc.
Extract dominant color palettes from any image.
Create Code 128, EAN-13, UPC-A, Code 39, and more barcode formats.
Generate QR codes instantly. Custom colors, sizes, download PNG/SVG.
Share your Wi-Fi via a scannable QR code — WPA, WEP, or open networks.
View camera info, GPS location, and all EXIF metadata from photos.
Drop a PNG to walk every chunk — IHDR, IDAT, tEXt, iTXt, pHYs, sRGB, gAMA, PLTE — with CRC32 verification and decoded text metadata.
Upload audio files to see real-time waveform and frequency spectrum.
Record your screen, window, or browser tab with optional microphone.
Create, inspect, decode, and optimize data URLs for HTML and CSS.
Draw, edit, and export SVG paths visually with M, L, C, Q, Z commands.
Create beautiful code screenshots like Carbon with syntax highlighting.
Compare two images pixel-by-pixel with slider, side-by-side, difference, and onion skin modes.
Clean and optimize SVG code — remove metadata, comments, editor data, and reduce file size.
Resize images by dimensions or percentage with aspect ratio lock, format conversion, and preview.
Generate inline SVG sparklines from numeric data — line, area, or bar variants with full styling.
Generate responsive image markup — srcset with w/x descriptors, sizes, and picture elements with format fallbacks.
Shift and rescale SRT, WebVTT, and SBV subtitle timestamps — constant offset and framerate conversion (23.976↔25 etc.).
Combine multiple images into a grid collage with customizable columns, gap, fit mode, and export to PNG/JPEG.
Strip personally identifiable information from any log, ticket, or transcript — emails, phone numbers, Luhn-validated credit cards, US SSNs, IPv4 / IPv6, mod-97-validated IBANs, UUIDs, and optionally URLs and MACs — replaced by consistent tokens ([EMAIL_1], [PHONE_2]…), typed placeholders, same-length stars, or salted deterministic hashes. 100% in-browser.
Edit distance that also counts adjacent transpositions — one operation for the classic teh → the typo instead of two. Colour-coded DP matrix with the optimal path, per-op traceback (match / substitute / insert / delete / transpose), Unicode-code-point mode, and case-insensitive toggle.
All 24 Greek letters (uppercase, lowercase, plus the seven Unicode-encoded math-italic variants like ϐ, ϑ, ϖ, ϱ, ϵ, ϕ, ϰ, and final sigma ς) with their LaTeX command, HTML entity, Unicode codepoint, transliteration, and the physics / statistics / math contexts where you’ll actually meet them. Click any value to copy.
Compute the score of any word in Scrabble (TWL/SOWPODS), Words With Friends, or Boggle. Tap tile multipliers (DL, TL, DW, TW) per letter, flag blank wildcards as zero-point tiles, and add the 50-point bingo bonus for laying down all seven rack tiles in one turn.
Compute Jaro and Jaro-Winkler scores between two strings with adjustable prefix length and scaling factor — plus Jaro distance, Sørensen-Dice on bigrams, and normalized Levenshtein — with a character match map that highlights prefix, matched, and transposed letters.
Type an ICU MessageFormat string — {count, plural, one {# item} other {# items}}, select, selectordinal, currency, and date placeholders — set variables and watch the rendered output update side-by-side across English, Spanish, French, German, Polish, Arabic, Chinese, and more, powered by Intl.PluralRules.
Spell numbers in English — cardinal, ordinal, currency (cheque format), US short-scale or UK long-scale. Handles negatives, decimals, fractions, percentages, and arbitrarily large integers via BigInt.
Build a word cloud from any text — adjustable stopwords, min length and frequency, rotation, color schemes, fonts, and a seeded spiral layout. Live frequency table on the side, export the cloud as SVG or PNG.
Convert text between CRLF (Windows), LF (Unix / macOS), and CR (classic Mac) — visualize hidden newline bytes, detect mixed endings, strip trailing whitespace, and download with the right encoding.
Combine emoji with the Zero-Width Joiner (U+200D) — family combos, professions, gendered & skin-tone modifiers, with codepoints, UTF-8 bytes, and JS / HTML escapes.
Build GitHub-style alerts — [!NOTE], [!TIP], [!IMPORTANT], [!WARNING], [!CAUTION] — with a live preview that mirrors GitHub's rendering and a wrap-at-column formatter.
Read text rapidly one word at a time at your chosen WPM, with adjustable focus letter, chunking, and pause-on-punctuation. Keyboard controls included.
Write Markdown and see it rendered live. Supports GFM tables, tasks & code.
Check if text uses every letter of the alphabet and see which letters are missing.
Convert Markdown to beautifully formatted PDFs instantly.
Count words, characters, sentences, reading time, and word frequency.
Summarize long text instantly with TF-IDF extraction. No API needed.
Generate placeholder text by paragraphs, sentences, or words.
Compare two texts side by side with highlighted additions and deletions.
Convert text between UPPER, lower, Title, camelCase, snake_case, and more.
Analyze word frequency, character distribution, bigrams, and trigrams.
Convert speech to text in real-time using your microphone.
Convert text to natural speech using your browser's TTS engine.
Measure your WPM and accuracy with real-time feedback.
Turn Markdown into beautiful presentation slides instantly.
Create, edit, and format Markdown tables visually.
Generate shields.io badges for your GitHub README.
Generate ASCII and Unicode file tree diagrams for README files.
Convert text to ASCII art banners with multiple font styles.
Convert text to Morse code and back with real-time audio playback.
Apply multiple find-and-replace rules to text with regex support and diff preview.
Sort, deduplicate, shuffle, reverse, and filter text lines instantly.
Convert HTML to clean Markdown — headings, links, images, lists, tables, and code.
Strip HTML tags while preserving structure — headings, lists, links, and paragraph breaks with optional 80-col wrapping.
Generate a clickable table of contents from Markdown headings with GitHub-compatible anchors.
Chain text transformations together — uppercase, base64, regex replace, sort, and 30+ operations.
Wrap text at a specified column width, unwrap paragraphs, add line prefixes for commit messages and comments.
Fill templates with {{variable}} placeholders — great for emails, messages, and code snippets.
Test Jinja2-style templates with variables, loops, conditionals, and filters.
Render logic-less Mustache templates against JSON — sections, inverted sections, loops, partials, dot notation, custom delimiters.
Analyze text readability with Flesch-Kincaid, Gunning Fog, Coleman-Liau, SMOG & ARI scores.
Convert titles and text into clean, URL-friendly slugs with transliteration and bulk mode.
Convert BBCode forum markup to HTML and back with live preview and common tag support.
Convert text to and from the NATO / ICAO phonetic alphabet (Alpha, Bravo, Charlie…) for voice and radio.
Spot and strip invisible Unicode — zero-width spaces, joiners, BOMs, bidi overrides, and tag-character smuggling.
Count SMS characters with GSM-7 / UCS-2 detection and segment math — see exactly how many messages a Twilio send will cost.
Convert between SubRip and WebVTT captions with time shifting, frame-rate rescaling, cue renumbering, and tag stripping.
Convert straight quotes to curly quotes, fix dashes and ellipses, or strip typographic punctuation back to ASCII.
Live preview for Discord-flavored markdown — spoilers, code blocks, mentions, and timestamps with character limits.
Render Slack-flavored mrkdwn exactly like a Slack thread — single-asterisk bold, underscore italics, tilde strikethrough, <url|label> links, user / channel / subteam mentions, :emoji: shortcodes, and message-cap warnings.
Encode words with Soundex, Metaphone, NYSIIS, and Caverphone phonetic algorithms for fuzzy name matching.
Split Markdown into frontmatter + body, parse YAML / TOML / JSON, edit fields as JSON, and rewrite the document in any format.
Click-to-copy box drawing chars plus a builder for ASCII boxes and tables in light, heavy, double, and rounded styles.
Count syllables, words, and sentences with Flesch reading ease, grade level, and per-word breakdowns.
Convert text to and from Grade 1 Unified English Braille with capital and number indicators, plus an alphabet reference.
Build n-gram Markov chains from sample text and generate new text that mimics the style. Explore chain states and probabilities.
Remove duplicate lines, count frequencies, and extract unique or repeated lines from text.
Draw boxes, arrows, and lines using ASCII/Unicode characters. Click & drag to draw, export as text.
Generate large ASCII art text banners with multiple styles — perfect for code headers and READMEs.
Flip Markdown between inline [text](url) and reference-style [text][1] with deduplicated definitions, slug labels, and image support.
Encode and decode every NIP-19 identifier used on Nostr — npub, nsec, note, nprofile, nevent, naddr, nrelay — with full TLV parsing for embedded relay hints, author pubkeys, and 32-bit event kinds. Round-trips 100% in your browser.
Break any string into UTF-8 bytes and any byte stream into code points — see lead bytes, continuation bytes, code point boundaries, and every failure mode the spec catches: overlong, unpaired surrogate, out-of-range, truncated, and stray continuation. Perfect for mojibake diagnosis.
Split a secret into N shares of which any K can rebuild it — one byte at a time over GF(2⁸) (the AES field). Text / hex / base64 secrets, share format XX-HEX, and a round-trip combiner that verifies Lagrange interpolation reconstructs the original. Uses crypto.getRandomValues for share randomness.
Compute and validate Damm check digits — a decimal checksum built on a weakly totally anti-symmetric 10×10 quasigroup. Catches every single-digit substitution and every adjacent-digit transposition (unlike Luhn), needs only one lookup table (unlike Verhoeff's three), and the check digit falls out as the interim value itself. Step-by-step trace, generator, and side-by-side comparison with Luhn and Verhoeff.
Compute Fletcher-16, Fletcher-32, and Fletcher-64 with a live block-by-block accumulator trace, hex/text/ASCII input, tail-padding options, and side-by-side comparison against Adler-32, XOR sum, and the RFC 1071 IP checksum. Used by OSI CLNP, DECnet, TLS, and ZFS.
Convert decimal numbers to and from packed BCD (COBOL COMP-3), unpacked BCD, Excess-3, and Aiken 2-4-2-1 encodings — per-digit nibble grid, hex byte layout with sign-nibble highlight, and a reverse hex-bytes-to-decimal decoder.
Watch a Feistel network encrypt block by block — split into L and R, apply F(R,K), XOR into L, swap, repeat — then decrypt with the same circuit and reversed keys. Choose block size, round count, F function, and key schedule to see why F itself never has to be invertible.
Compute and validate Verhoeff check digits — a decimal checksum that catches every single-digit error and every adjacent-transposition error, unlike Luhn. Full step-by-step trace against the dihedral-group d, p, and inv tables. Used by India's Aadhaar 12-digit ID.
Solve simultaneous linear congruences x ≡ aᵢ (mod mᵢ) — handles the classic coprime case and Gauss's generalized non-coprime case, with full extended-Euclidean derivation and BigInt arithmetic that survives RSA-sized moduli.
Compute 18 standard CRC checksums in one pass — CRC-8 (SMBus, MAXIM, ROHC, CDMA2000), CRC-16 (ARC, CCITT-FALSE, KERMIT, MODBUS, USB, XMODEM, GENIBUS, MCRF4XX), CRC-32 (IEEE 802.3, BZIP2, MPEG-2, POSIX, Castagnoli, JAMCRC). ASCII or hex input, full Rocksoft parameter display (poly, init, refIn/Out, xorOut).
Validate Bitcoin addresses across every format — Legacy 1… (P2PKH), Script 3… (P2SH), Native SegWit bc1q… (P2WPKH/P2WSH), and Taproot bc1p… (P2TR Bech32m). Decodes the version byte, witness program, HRP, checksum, and recognises testnet, regtest, signet, and Litecoin variants.
Hash any string with Austin Appleby's MurmurHash3 — 32-bit and 128-bit (x86 & x64) variants, configurable seed, hex / decimal / base36 outputs, shard-bucket modulus, and reference vectors that match Python's mmh3, Guava, and Cassandra.
Crack a monoalphabetic substitution cipher (cryptogram) by hand or let a hill-climbing solver guess the key from English letter and bigram frequencies. Interactive A→? mapping with lockable cells, live frequency table vs ETAOIN ranking, and one-click ROT13 / classic-cryptogram presets.
Decode WebAuthn registration and authentication responses — clientDataJSON, CBOR attestationObject, authenticatorData flags, AAGUID lookup, credential ID, and the COSE-encoded public key (EC2/RSA/OKP).
Inspect JSON Web Encryption tokens (RFC 7516) — split the five compact segments, decode the protected header, surface key-management (alg) and content-encryption (enc) algorithms, and validate IV/tag lengths.
Compute every step of an AWS SigV4 signature — canonical request, string-to-sign, kDate→kRegion→kService→kSigning HMAC chain, and Authorization header or pre-signed URL. Includes AWS sample-vector presets.
Decode PASETO v1–v4, public and local. Split version, purpose, payload, and footer; surface registered claims (iss, exp, nbf, kid) and the exact cryptographic primitives a verifier needs.
Run the full RFC 5869 HKDF pipeline — Extract then Expand — with SHA-1/256/384/512, configurable salt, info, and output length. Includes the four appendix-A test vectors.
Parse JSON Web Keys and JWKS documents, classify public vs private material, and compute canonical RFC 7638 SHA-256 thumbprints for RSA, EC, OKP, and oct keys.
Encode text or files to Base64 and decode Base64 strings. Supports UTF-8.
Encode and decode text with the classic A↔Z substitution cipher. Latin & Hebrew.
Encrypt and decrypt with the Playfair digraph cipher — 5×5 key square, visual digraph breakdown, J/I merge.
Encode with E(x) = (ax + b) mod 26, auto modular inverse, substitution table, and brute-force all 312 keys.
Francis Bacon's biliteral (5-bit) cipher with 24- and 26-letter variants and a live steganographic cover generator.
Encode and decode URLs and query strings. Auto-detect and parse parameters.
Convert between binary, octal, decimal, hexadecimal, and custom bases.
Encode and decode HTML entities with a reference grid of common characters.
Escape strings for JS, Python, SQL, JSON, HTML, Shell, and more.
Debug invisible characters, inspect code points, and normalize Unicode text.
Search 500+ emojis by name, copy to clipboard, view Unicode code points.
Generate MD5, SHA-1, SHA-256, SHA-384 & SHA-512 hashes from text or files.
Paste a hash and identify likely algorithms (MD5, SHA-1, bcrypt, Argon2, NTLM, sha512crypt, SSHA, JWT, and more) by length, charset, and prefix markers.
Generate HMAC signatures with SHA-1, SHA-256, SHA-384, or SHA-512.
Encrypt and decrypt text using AES-256-GCM. No data leaves your device.
Decode and inspect JSON Web Tokens. View header, payload, and expiration.
Generate Subresource Integrity hashes for scripts and stylesheets.
Generate strong random passwords with custom rules and strength meter.
Generate UUID v4, nanoid, ULID, short IDs, and custom random strings.
Inspect any file's binary contents as a hex dump with ASCII pane.
Visualize AND, OR, XOR, NOT, left/right shift operations interactively.
Generate and verify HMAC webhook signatures for JSON payloads.
Interactive ASCII character reference with decimal, hex, octal, and binary lookup.
Redact PII — emails, phones, IPs, credit cards, SSNs, and API keys from text.
Validate credit cards, IMEI, and identifiers with step-by-step Luhn checksum calculation.
Generate time-based one-time passwords (TOTP) from a secret key for testing 2FA.
Decode raw Protocol Buffer binary data without a schema. View field numbers, wire types, and values.
Create and sign JSON Web Tokens with custom headers, payloads, and HMAC signatures.
Generate code_verifier & code_challenge pairs for OAuth 2.0 (RFC 7636).
Generate HTTP Basic Auth credentials for Apache and Nginx with SHA-1, SSHA, and MD5 hashing.
Compress text to gzip or decompress gzip data using the browser's native CompressionStream API.
Encode internationalized domain names to Punycode (xn--) and decode them back to Unicode.
Encode and decode ASCII85 (Base85) data with Adobe, Z85, and RFC 1924 variants.
Generate RSA and ECDSA cryptographic key pairs. Export as PEM or JWK format.
Decode PEM blocks to DER — shows block labels, byte length, SHA-1/256 fingerprints, and hex dumps.
Decode and inspect SAML assertions, responses & metadata for SSO debugging.
Encode and decode Base58 and Base58Check with Bitcoin, IPFS, Ripple, and Flickr alphabets.
Encode and decode Base32 strings — RFC 4648, Base32Hex, and Crockford alphabets with optional padding.
Generate lexicographically sortable 128-bit IDs and decode timestamp & randomness. Supports monotonic mode.
Decode Twitter, Discord & Instagram Snowflake IDs. Extract timestamp, worker ID, and sequence bits.
Generate URL-friendly, cryptographically secure unique IDs with custom alphabet, length, and collision stats.
Generate and decode Segment KSUIDs — 27-character base62 IDs with 32-bit timestamp and 128-bit payload.
Encode and decode BitTorrent Bencode format — strings, integers, lists, dicts with binary-safe hex round-trip.
Compute CRC-32 (IEEE), CRC-32C (Castagnoli) & CRC-32/BZIP2 checksums for text, hex, or files.
Measure randomness in text or passwords — Shannon entropy, total bits, and symbol frequency distribution.
Decode PHP serialize() strings to JSON and re-encode JSON to the PHP wire format. Supports nested arrays and objects.
Generate memorable, high-entropy passphrases from the EFF Diceware wordlist with entropy meter and crack-time estimates.
Encode, decode, and brute-force Caesar shift ciphers — includes ROT13 preset and all-26-shifts table.
Apply ROT13, ROT5 (digits), ROT18, or ROT47 across all printable ASCII, plus a brute-force panel that scores likely plaintexts.
Polyalphabetic keyword cipher with Beaufort and Autokey variants and an interactive tabula recta.
Break down TLS cipher suite names into key exchange, auth, bulk cipher, MAC, and security notes.
Compute Adler-32 (zlib, PNG) and Fletcher-16/32 checksums for text, hex, or files.
Derive keys from passwords with PBKDF2-HMAC-SHA1/256/384/512 — tune iterations, salt, and output length.
Encode and decode Base45 (RFC 9285) — the compact alphanumeric encoding used by QR codes and EU Digital COVID Certificates.
Encode, decode, and brute-force zigzag transposition ciphers with a visual rail diagram and 2–10 rail brute force.
Build Merkle trees from any leaves with SHA-1/256/384/512, view every hash, and generate inclusion proofs.
Generate ready-to-run OpenSSL commands for keys, CSRs, self-signed certs, PKCS#12 bundles, format conversion, and hash/HMAC operations.
Generate bcrypt password hashes with adjustable cost factor and verify passwords against existing hashes — fully in-browser.
Encode text, hex, or integers to Base62 for URL shorteners, short IDs, and compact tokens — with selectable alphabets.
Validate and generate mixed-case checksums for Ethereum addresses per EIP-55, with optional EIP-1191 chain-specific mode.
Convert between Ethereum unit denominations with arbitrary-precision BigInt math and a gas-cost calculator.
Convert between binary and reflected Gray code with a visual bit transition table — used in rotary encoders and Karnaugh maps.
Generate counter-based one-time passwords (RFC 4226) from a Base32 secret. Produce a window of codes for provisioning hardware tokens and resync testing.
Build Huffman trees from any text — inspect per-symbol frequencies, prefix codes, the encoded bitstring, and compression ratio vs. fixed 8-bit.
Encode and decode text with classic, single-omit, or brace-style run-length encoding — live size comparison and round-trip verification.
Encode letters as row/column pairs in a 5×5 grid — with optional keyword, 6×6 alphanumeric, and ADFGX variants and a live square preview.
Linear-algebra cipher using a 2×2 or 3×3 invertible key matrix mod 26 — with automatic determinant, modular inverse, and presets.
Convert text to and from 1337 with basic, advanced, and ultimate substitution presets, randomization, and a fully customizable table.
Ancient Spartan transposition cipher — wrap plaintext around a rod of any diameter, visualize the wrap, and brute-force all diameters.
Keyword transposition cipher with complete and incomplete modes, live grid visualization, and alphabetical column read order.
Delastelle's fractionation cipher — combine a 5×5 Polybius square with an adjustable period and see every row/column breakdown.
Encode and decode basE91 — a compact binary-to-text format denser than Base64 with ~23% overhead. Basic and extended alphabets.
Compute FNV-1 and FNV-1a (32-bit & 64-bit) Fowler–Noll–Vo hashes for text, hex, or files — fast non-cryptographic hashes used in hash tables and Bloom filters.
Normalize strings to NFC, NFD, NFKC, NFKD and inspect every code point — spot combining marks, homoglyphs, and zero-width characters.
Swap bytes between little-endian and big-endian and view int/uint/float 16/32/64 interpretations of any hex byte sequence.
Convert between JSON and RFC 8949 CBOR binary format with hex dump, diagnostic view, and size comparison.
Spot homoglyphs, invisible characters, and mixed-script spoofing. Computes ASCII skeletons, scores spoofing risk, and compares two strings for visual collisions.
Analyze password entropy, crack time estimates, character composition, and common pattern weaknesses.
Compose or parse an RFC 7240 Prefer request header — toggle respond-async, wait=N, handling=lenient/strict, return=minimal/representation, add custom directives with parameters, and see the matching Preference-Applied response the server should echo back. Includes a token-aware parser that quotes values correctly and flags non-standard preferences.
Compute an RFC 7616 / RFC 2617 Authorization: Digest … value from a server's WWW-Authenticate challenge — MD5, MD5-sess, SHA-256, SHA-256-sess — with qop=auth or auth-int, nonce counting, random cnonce generation, and a full step-by-step trace of HA1, HA2, and the final response hash.
Send the same request timeline through five classic rate limiters — token bucket, leaky bucket, fixed window, sliding window log, and sliding window counter — and watch which requests each one allows or rejects, side by side. Presets for steady load, bursts, and the window-boundary attack that fixed-window is famous for.
Build and verify RFC 9530 Content-Digest, Repr-Digest, and their Want-* hint counterparts. Hash any body with sha-256, sha-512, or the deprecated legacy algorithms (md5, sha, adler, crc32c, unixsum) and emit the exact structured-field syntax gateways and HTTP Message Signature verifiers expect.
Paste raw RSS 2.0, Atom 1.0, or JSON Feed 1.1 and preview the parsed feed the way a reader would — channel metadata, item titles, links, publish dates, authors, categories — with format auto-detection and spec-conformance warnings for missing required fields.
Plan an IP, CNAME, MX, or NS change as a three-step cutover — lower the TTL well ahead of time so old caches drain fast, flip the record, then restore a healthy long TTL. Prints a timeline with UTC or local timestamps, the worst-case stale-answer window, and a copy-paste runbook.
Turn any IPv4 or IPv6 address into its in-addr.arpa / ip6.arpa reversed lookup name, with zone origin picked from the CIDR prefix, a starter BIND $ORIGIN block, and the RFC 2317 classless-delegation form for /25–/31 sub-allocations.
Parse and round-trip libpq postgres:// URIs and keyword=value DSNs into structured fields with sslmode warnings, then convert to JDBC, Npgsql, Node pg, psql, PG* env vars, .pgpass, and Docker Compose snippets.
Split a media-type into type, subtype, structured-syntax suffix (+json, +xml, +cbor, …), and parameters per RFC 7231 / 6838 — flag charset on JSON, missing multipart boundary, misplaced q=, and identify the registration tree (standards / vendor / personal / private). Compose new headers with a parameter builder and generate WebKit / hex / base64 multipart boundaries.
Compose a spec-compliant application/problem+json error payload — the five standard members (type, title, status, detail, instance), the RFC 9457 errors array, and custom extension members — with a linter that flags missing fields, non-URI type, and bad JSON Pointers. Copy as JSON, full HTTP response, curl, fetch, or Spring ProblemDetail.
Parse traceparent and tracestate headers from OpenTelemetry, Jaeger, Zipkin, and AWS X-Ray — see the version, 128-bit trace-id, 64-bit span-id, and the sampled flag, validate against the spec, or generate a fresh header to inject into a curl request.
Decode the Fetch Metadata request headers — Sec-Fetch-Dest, Sec-Fetch-Mode, Sec-Fetch-Site, Sec-Fetch-User, Sec-Fetch-Storage-Access — classify each request as same-origin / cross-site / nav / preflight / CSRF-shaped, and generate a Resource Isolation Policy middleware snippet (Express & Nginx) to block suspicious combinations.
Generate <link rel="preload / prefetch / preconnect / dns-prefetch / modulepreload"> with the right as, type, crossorigin, fetchpriority, imagesrcset, and media — and the equivalent HTTP Link: header.
Convert a curl command to Invoke-WebRequest or Invoke-RestMethod — method, headers, JSON / form body, basic auth, cookies, and a -SkipCertificateCheck fallback for PS 7 and Windows PowerShell 5.1.
Generate require-trusted-types-for 'script' and trusted-types CSP directives plus the createHTML / createScript / createScriptURL policy code — with default fallback, Report-Only rollout, and a violation listener.
Walk through the RFC 8628 Device Authorization grant — build the initial POST, render the user_code with a QR for verification_uri_complete, plan the polling loop with slow_down/expired_token handling, and copy curl/fetch snippets.
Test the URLPattern web API against URLs — named groups (:id), wildcards, modifiers (?/+/*), and inline regex. Shows captured groups and copy-ready JavaScript.
Parse a raw multipart/form-data, multipart/related, or multipart/mixed HTTP body — auto-detect boundary, surface per-part headers, filename, content-type, and download binary parts.
Build COOP, COEP, and CORP combinations and see exactly what each unlocks — SharedArrayBuffer, high-resolution timers, full isolation. Includes Nginx, Apache, and Worker snippets.
Interactive reference for all HTTP response codes with descriptions.
Analyze security, caching & performance headers with scoring.
Build Access-Control headers and debug CORS policy mismatches.
Generate Content-Security-Policy headers and meta tags.
Build and test Cache-Control headers for websites, APIs, and CDNs.
Build Accept headers and simulate server-side content negotiation.
Build Accept-Encoding headers and simulate server compression negotiation.
Build Accept-Language headers and test locale negotiation.
Build Alt-Svc headers for HTTP/2 and HTTP/3 upgrade planning.
Parse Cookie/Set-Cookie headers, inspect attributes, validate __Host- rules.
Build valid Content-Disposition headers for downloads and inline files.
Generate strong/weak ETags and test conditional request headers.
Build RFC 7239 Forwarded headers and inspect X-Forwarded-* chains.
Generate safe idempotency keys and plan retry windows.
Generate HTTP Link headers and HTML resource hint tags for preload/preconnect.
Look up MIME types by extension and generate Content-Type headers.
Build offset, page, and cursor pagination responses with sample data.
Configure browser feature access policies for modern web apps.
Build HTTP Range headers and test 206 partial content responses.
Build a Referrer-Policy header and preview referrer data behavior.
Build Server-Timing headers and plan backend performance budgets.
Build Surrogate-Control headers for CDN cache planning.
Build a correct HTTP Vary header and understand cache key impact.
Paste a curl command and get readable JavaScript fetch() code.
Build HTTP requests visually and generate cURL, fetch, axios, and Python code.
Build HTTP requests visually with auth, headers, and JSON body.
Create realistic HTTP responses with status codes, headers, and JSON.
Define event fields and generate sample JSON, TypeScript, schema & cURL.
Build, validate, and test redirect rules with wildcard matching.
Design exponential, linear, or fixed retry schedules with jitter.
Connect to WebSocket servers, send messages, and inspect responses in real-time.
Interactive reference for HTTP methods — compare properties, use cases, and sample requests.
Connect to Server-Sent Events endpoints and inspect streaming events in real-time.
Calculate TTL values for DNS, HTTP cache, Redis, CDN, JWT. Convert units and see expiry times.
Build and decode Authorization: Basic headers. Copy-ready curl, fetch, axios & Python snippets.
Tag campaign URLs with UTM parameters for analytics with validation, presets, and history.
Encode Redis commands to RESP wire format or decode raw RESP bytes. Supports RESP2 arrays, bulk strings, integers, and errors.
Test MQTT subscription filters with + and # wildcards against sample topics and validate filter syntax.
Compose Prometheus queries visually — metrics, label matchers, rate/range, aggregations, histogram_quantile.
Compose RFC 6068 mailto links with recipients, CC/BCC, subject, body, and custom headers — copy or open directly.
Protect email addresses from scrapers with HTML entities, percent encoding, ROT13, Base64, and CSS reversal — with live previews of every technique.
Expand RFC 6570 URI templates with live variable substitution. Supports all four levels including reserved, fragment, path, and query expansion.
Visualize DNS, TCP, TLS, TTFB, and download phases as a waterfall. Paste curl -w output or DevTools timings for instant analysis.
Compose SPF DNS TXT records mechanism by mechanism — lints the 10-DNS-lookup limit, length, and parses existing records.
Build and decode _dmarc DNS TXT records (RFC 7489) — policy, pct, alignment, rua/ruf aggregate reports, with tag-level lint.
Compose selector._domainkey TXT records (RFC 6376), wrap public keys to 255-char chunks, and lint every tag in an existing record.
Compose Strict-Transport-Security headers (RFC 6797), parse existing ones, and verify hstspreload.org submission requirements with nginx, Apache, and Caddy snippets.
Build DNS Certification Authority Authorization records (RFC 8659) — issue, issuewild, iodef tags with quick-add for Let's Encrypt, DigiCert, Google, and more.
Compare two sets of response or request headers. Spot added, removed, and changed entries — handles multi-value headers and list-valued splitting.
Craft or parse raw HTTP/1.1 messages. Inspect the request line, headers, and body, and export to curl, fetch(), or HTTPie snippets.
Split URLs and hostnames into subdomain, registered domain (eTLD+1), and public suffix using a built-in public suffix list.
Build an RFC 9116 /.well-known/security.txt file with contact, expires, encryption, policy, and CSAF fields — with live validation and optional PGP wrapper.
Build and parse HTTP Retry-After headers for 429 and 503 responses with delta-seconds or HTTP-date and client backoff previews.
Craft RFC 8297 Early Hints responses with Link preload/preconnect headers and server snippets for Node, Nginx, and Workers.
Parse Apache & Nginx Common/Combined Log Format access logs into structured rows with status, method, path, top IPs, and error highlighting.
Parse Sentry DSN strings into public key, host, and project ID. Generate envelope/store ingest URLs, X-Sentry-Auth header, and SDK init snippets.
Parse BitTorrent magnet: URIs — extract info hash (v1 & v2), display name, trackers, web seeds, and peer addresses, or assemble a new one from parts.
Pick a polling interval that respects rate limits, daily budgets, and freshness SLAs. Compare intervals, add jitter, and copy a backoff-ready snippet.
Convert an HTTP request to code in fetch, cURL, Python, Go, PHP, Ruby, C#, and Java with one click.
Build JavaScript fetch() calls visually — configure method, headers, body, and auth, then copy the generated code.
Build OAuth 2.0 authorization URLs, parse callback responses, and decode access tokens.
Estimate query complexity, depth, and resolver call count — spot N+1 traps and size rate limits before clients hit them.
Inspect WebRTC SDP offers and answers — break out media sections, codecs, ICE candidates, DTLS fingerprints, and bandwidth limits.
Edit URL query strings as key/value pairs. Switch between repeat, bracket, indexed, and comma array styles, with JS, Python, and curl snippets.
All 17 canonical gRPC codes with HTTP mapping, retry guidance, and ready-to-paste handler snippets in Go, Python, Node, and Java.
Bound retry amplification the Google-SRE / Envoy / gRPC way — cap retries at budget × successful RPS over a rolling window, with a minimum floor for low-volume clients. Simulates a partial outage side-by-side (naïve vs budgeted), shows the origin-load blowout you avoid, and prints copy-ready policy for Envoy, gRPC-Java, Istio + JS / Python client budgets.
Interactive hexagonal grid — convert between axial (q,r), cube (x,y,z), and offset row/column coordinates, click any two hexes to see the shortest-path line and distance, highlight rings and spirals, and grab pixel-perfect corner coordinates (or a CSS clip-path) for both pointy-top and flat-top orientations.
Compose a valid COPY FROM or COPY TO without hunting through the docs — pick text / csv / binary format, DELIMITER, NULL, HEADER, QUOTE, ESCAPE, FORCE_QUOTE, FORCE_NOT_NULL / FORCE_NULL, ENCODING, and PG 17's ON_ERROR ignore. Emits both the server-side statement and the equivalent psql \copy meta-command, with warnings for common mistakes.
Compute an Apdex (Application Performance Index) score from a latency target T. Enter satisfied / tolerating / frustrated counts, or paste raw latencies and let the tool bin them, and get Apdex, verdict, per-zone breakdown, and a histogram.
Compute MTBF, MTTR, and inherent availability from a list of incidents — or start from an availability SLO (percent or "nines") and see the allowed downtime per hour, day, month, and year, plus the implied MTBF for a given MTTR.
Bloom-style approximate-membership filter with true delete support. Watch fingerprints slot into one of two candidate buckets (i₁ and i₁ ⊕ h(fp)), see the kick chain cascade when both are full, and tune bucket count, slots-per-bucket, and fingerprint bits against the 2b / 2ᶠ false-positive bound.
Stream items into a d×w Count-Min counter grid, watch each row's independent hash light up a bucket, query point frequencies with the min-over-rows rule, and compare estimates against the exact top-K to see the one-sided εN over-count bound in action. Tune w for ε, d for δ.
Walk a directed graph in one DFS pass, watch DFS index and low-link propagate up each subtree, see the open-vertices stack grow and shrink, and pop every SCC in reverse topological order — the algorithm behind cyclic-import detection, call-graph clustering, and 2-SAT.
Watch the Edmonds-Karp BFS pick the shortest augmenting path, push the bottleneck through, and update the residual graph iteration by iteration — then, once BFS can no longer reach the sink, surface the s-t min-cut with the max-flow-min-cut theorem confirmation.
Compose Elasticsearch / OpenSearch bool queries by dropping term, match, range, prefix, wildcard, and exists clauses into must / should / must_not / filter buckets — every change re-renders runnable JSON, the equivalent Lucene / KQL fragment, and a copy-paste curl.
Parse PostgreSQL INTERVAL expressions in any accepted form — verbose (1 year 2 mons 3 days 04:05:06), ISO 8601 (P1Y2M3DT4H5M6S), the @ … ago shorthand, plain HH:MM:SS.fff, or a bare seconds count — into months / days / microseconds, total pg-standard seconds, human summary, and re-emitted SQL literal.
Decode amqp:// and amqps:// connection strings into scheme, credentials, host, port, vhost (with the %2F default-vhost pitfall called out), and query params like heartbeat, channel_max, connection_timeout, frame_max — or build a URI from a form and copy it back.
Watch Kruskal's greedy algorithm sort every edge by weight, then walk the list adding each one only if its endpoints belong to different union-find components. See DSU roots merge, cycle-rejecting edges get skipped, and the minimum spanning tree (or forest, if the graph is disconnected) emerge step by step.
Solve shortest paths between every pair of vertices in a single O(|V|³) triple loop — watch the distance matrix update per intermediate k, tolerate negative edges, detect negative cycles automatically when the diagonal drops below zero, and click any cell to reconstruct the path.
Generate and decode UUID v7 (RFC 9562) — the time-ordered, k-sortable identifier that packs a Unix millisecond timestamp into the leading 48 bits. Batch up to 1024 IDs, or paste any UUID to see its embedded timestamp, version, variant, and random bits colour-mapped.
Watch the O(nW) dynamic-programming table fill cell by cell for the 0/1 knapsack problem — green when taking an item beats skipping it, orange for the traceback path, blue for the optimal answer. Presets included; edit items and capacity live.
Watch the greedy min-heap settle vertices in outward-wave order on any non-negative weighted graph. Every step shows the priority queue, per-edge relaxation, the shortest-path tree, and the final target path — with a negative-edge warning that steers you to Bellman-Ford when the assumption breaks.
Sort every suffix, build the LCP array in linear time via Kasai, and get instant substring search (binary-search range in SA), the longest repeated substring, distinct-substring count, and inverse-rank column — the same index behind grep -r, bioinformatics BWT, and full-text search engines.
Search every pattern from a dictionary in one text pass. Watch the trie get built, failure links wired via BFS (KMP generalized to a keyword tree), dictionary links surface shorter suffix matches, and the automaton stream through the text in O(|patterns| + |text| + matches) — the algorithm behind fgrep, keyword filters, and signature scanners.
Step through the rolling-hash string search — polynomial hash slides window-by-window in O(1) per shift, and every hash-match runs a character verification with spurious-collision counts called out. Tune base, prime q, and watch the trace log.
Watch the classic O(n·m) DP table fill cell-by-cell for two strings, then backtrace to recover the LCS with ↖↑← arrows drawn on the grid. Enumerates alternate optimal solutions when ties in the max allow them — the same table that underlies diff and Needleman-Wunsch alignment.
Break down a 17-character Vehicle Identification Number: WMI (region + manufacturer), VDS, VIS, plant, and serial, plus the ISO 3779 position-9 check digit with full weighted-sum table. Decodes model year using the 30-year rollover rule (position 7 disambiguates pre-/post-2010).
Turn a target throughput and retention window into a partition count, per-broker log footprint, and a starter kafka-topics.sh / Strimzi KafkaTopic config. Peak-vs-average burst, replication factor, compression ratio, on-disk overhead, single-partition write ceilings — all live, plus a warn box flagging >4k partitions/broker or a hot-partition risk.
Add columns, tick nullability, and see the on-heap tuple size — 23-byte header, null bitmap, per-column MAXALIGN padding, TOAST-threshold check, rows-per-page at any fillfactor, and heap + PK-index footprint for a target row count. Presets for users, orders, jsonb events, pgvector 1536-dim tables, and PostGIS geometry.
Pick a common SRE alert template (error rate, p95 latency, memory pressure, filesystem-fill prediction, crash-loop, CPU saturation, target-down, multi-window budget burn), tune expr, for, keep_firing_for, add routing labels and Alertmanager annotations, and copy a ready-to-paste groups: YAML block or a Kubernetes PrometheusRule.
Slice a hex, binary, decimal, or octal value into named bit fields — pick MSB-first or LSB-first packing, mark fields as signed or unsigned, and see every field's dec / hex / bin plus a colour-coded bit map. Presets for IPv4, TCP flags, ARM PSR, x86 CPUID, and RGBA8888.
Step through the Boyer-Moore search — right-to-left pattern comparisons with two precomputed shift tables (bad character and good suffix). Watch each mismatch pick max(bcShift, gsShift) for jumps that push toward the sub-linear O(n/m) best case that makes grep fly.
Draw the Hilbert space-filling curve at orders 1–8 and see how a 1-D distance d maps to a 2-D grid coordinate. Hover any cell to read (x, y) ↔ d, contrast the Morton / row-major indexes, and see why PostGIS, Bing quadkeys, and R-tree bulk-loaders sort along it for tight range-scan clustering.
Insert, find, and delete keys in a live splay tree — every accessed node is splayed to the root by zig / zig-zig / zig-zag rotations. Watch the self-adjusting O(log n) amortized behaviour emerge with no stored balance metadata, and see the sequential-insert worst-case shape recover in one find.
Build a disjoint-set forest live. Run makeSet, union, and find operations, watch union-by-rank flatten trees, see path compression collapse chains in a single find, and track the near-constant O(α(n)) amortized cost.
Run Bellman-Ford on any weighted directed graph — negative edges welcome. Watch distance/predecessor tables tighten across |V|−1 relaxation passes, detect negative cycles on pass |V|, and trace the exact edges relaxed at every step.
Interactive k-means: paint 2D points, pick k, seed centroids (Forgy / Random / k-means++), then step through the assign/update loop. Watch WCSS drop, Voronoi cells recalculate, and clusters converge — plus a live elbow curve to pick k.
Build a Binary Indexed Tree from any array and watch prefix-sum queries, point updates, and range queries walk the tree in O(log n). Every node highlights the exact (i − lowbit(i), i] range it covers so you can see which cells contribute.
Watch the Z-function get built one character at a time and see how the [L, R] mirror window skips comparisons. Concatenate pattern$text, and any Z[k] equal to |pattern| is an exact-match hit — all in linear O(n + m) time.
Find every palindromic substring in linear O(n) time using Manacher's algorithm. Watch the sentinel-interleaved transform, per-center radius array, and the sliding [C, R] mirror window feed the longest-palindrome result live.
Approximate ∫ₐᵇ f(x) dx with Left / Right Riemann, Midpoint, Trapezoid, Simpson's 1/3, and Simpson's 3/8 side-by-side — with a live plot of the panels and a log-log convergence chart showing each rule's empirical order.
Watch the classical recursive solve unroll into the minimum 2ⁿ − 1 moves, or grab a disk yourself and race the optimal solver. Step, pause, rewind, and read the full hanoi(n, src→tgt via aux) recursion trace side-by-side.
Race A*, Dijkstra, BFS, and Greedy Best-First on the same grid. Paint walls and weighted terrain, pick a heuristic (Manhattan / Chebyshev / Euclidean / Octile), toggle 8-way movement, and compare expansions vs path cost.
Sort a number's digits descending and ascending, subtract, repeat — and watch it fall into the Kaprekar constant 6174 for 4 digits or 495 for 3 digits in at most seven steps. Handles 3- to 8-digit inputs and flags cycles that longer widths get stuck in.
Step through the Knuth-Morris-Pratt algorithm — first the failure function lps[] is built for the pattern, then the search runs against the text with every comparison, mismatch fallback, and match highlighted on a single strip in O(n + m) time.
Solve dy/dx = f(x, y) initial-value problems with classical RK4, then compare against Euler and Heun on the same plot. Inspect the four kᵢ slopes at every step, supply an optional exact solution, and see max |error| at a glance.
Build a segment tree over any integer array and pick an aggregate — sum, min, max, gcd, xor. Run a range query and watch which internal nodes light up green (contribute) or blue (walked into); run a point update and watch the O(log n) yellow chain of re-aggregated ancestors climb back to the root.
Insert, delete, and search keys in a live probabilistic skip list — coin flips promote towers, express-lane pointers grow, and the O(log n) search path zig-zags right-and-down from the header. Adjustable promotion probability p, tower height histogram vs the geometric expectation, and per-op hop counter.
Compare FCFS, SJF, SRTF, Round Robin, and priority (preemptive and non-preemptive) scheduling on the same process set. Edit arrival, burst, and priority per PID, pick a quantum for RR, and get a color-coded Gantt chart plus per-process start / finish / turnaround / waiting / response times and CPU utilization.
Insert, extract-root, peek, or bulk-heapify a min or max binary heap and watch every sift-up and sift-down step both on the tree and on the backing array — with parent/child index arithmetic (2i+1, 2i+2) called out at each swap. Includes a Floyd O(n) build-heap demo and a heap-sort playthrough.
Push, pop, or peek on a fixed-capacity circular buffer and watch the head / tail indices wrap modulo capacity. Pick reject-on-full or overwrite-oldest policy, see the ring and linear array views update in lock-step, and read a canonical C implementation for reference.
Plot complex impedances on an interactive Smith chart and read off VSWR, return loss, mismatch loss, and reflection coefficient at a glance. Pick any characteristic impedance Z₀ (50, 75, 300 Ω…), enter values as R + jX, |Γ|∠θ, or G + jB, toggle the constant-VSWR rings and the admittance overlay, then export an SVG.
Drag the Kp / Ki / Kd sliders and watch the closed-loop step response update in real time on a FOPDT, second-order, or integrator+delay plant. Snap to a classic tuning rule — Ziegler-Nichols, Cohen-Coon, AMIGO, IMC, or Tyreus-Luyben — and read off rise time, settling time, overshoot, SSE, plus IAE/ITAE/ISE indices. Anti-windup and derivative-on-measurement built in.
Enter the numerator and denominator coefficients of H(s) = N(s)/D(s) (highest-power-first) and see the magnitude (dB) and phase (°) on a log-frequency axis. The tool extracts DC gain, −3 dB bandwidth, peak |H|, gain crossover ωgc, phase crossover ωpc, and the gain and phase margins, plus the full pole/zero list. Built-in presets for LPF, HPF, lead, lag, notch, and Butterworth.
Type one flow per line as Source [value] Target and get a clean Sankey diagram with auto-laid columns, proportional node heights, and curved flow ribbons. Cycle detection, hover totals, SVG/PNG export.
Decode the 1-, 2-, 3-, and 4-digit numbers printed on ceramic and film capacitors (104 → 100 nF), trailing tolerance letters (J, K, M), and EIA voltage prefixes (2A, 1H). Expand EIA-96 SMD markings (10C, A2) and reverse-build the code for any capacitance, with a full tolerance and voltage reference.
For a given focal length, aperture, and subject distance, find the hyperfocal distance, the near and far in-focus limits, and the total depth of field. Pick a sensor format (medium format → 1/2.3″) and the circle of confusion is set for you, with a log-distance focus scale and a diffraction-limit warning that catches you stopping down past usefully sharp.
Paste raw numbers and get a proper Tukey box plot — Q1, median, Q3, IQR fences, mild and extreme outliers, mean diamond, optional 95% CI notch — for one series or several groups stacked side-by-side. Five-number summary, mean, stddev, and an SVG you can screenshot.
Convert wind speed between m/s, km/h, mph, knots, and ft/s; get the Beaufort force 0–12 with the WMO description, the matching sea state, and an animated breeze preview. Click any row of the scale to jump to it, or drag the force slider to read off the equivalent speed.
Watch the classic N-queens problem solve itself row by row — every column tried, every conflict flashed, every backtrack logged. Speed control, pause/resume, attack heat-map, instant all-solutions enumeration (92 for 8×8, 14 200 for 11×11, 73 712 for 12×12) with clickable thumbnails up to 16×16.
Insert, delete, and prefix-search words in a live trie — watch the autocomplete branch light up, see how much memory shared prefixes save versus a flat word list, and inspect node/edge/depth stats. Sample dictionary included, character labels on every edge.
Stream items into an interactive HLL sketch, watch the 2ᵖ register histogram fill in, and see the estimate converge on the true count — with LinearCounting low-range fix, αm bias correction, and an estimate-vs-truth trend chart. Pick p from 4 to 16 to tune the σ ≈ 1.04/√m error.
Insert, delete, and search keys in a live self-balancing AVL tree — every node shows its height and balance factor, imbalanced ancestors flash red, and the LL / LR / RL / RR rotation case fires with a labelled log entry. Worst-case ascending preset to see the height stay flat.
Compute the trajectory of a projectile from initial velocity, launch angle, height, and gravity — get range, max height (apogee), time of flight, impact velocity and angle, with an interactive SVG parabola and 10-step time-position-velocity table. Gravity presets for Earth, Moon, Mars, Jupiter, the Sun, plus drag-free textbook physics.
Convert between wavelength λ, frequency ν, photon energy E, and wavenumber ν̃ across the whole electromagnetic spectrum — radio, microwave, IR, visible, UV, X-ray, gamma. Auto-identifies the band, shows approximate sRGB colour for visible light, and lists references (Lyman α, HeNe, CO₂ laser, CMB peak, Cu Kα, 511 keV annihilation).
Play Dual-Tone Multi-Frequency touch-tone signals for digits 0-9, *, #, and A-D. Tap a keypad key or dial a full sequence like a phone number — tune tone duration, pause length, and volume, see each key's row + column Hz pair light up. Web Audio API, no files needed.
Click to drop sites and watch a Voronoi tessellation form in real time — switch between Euclidean (L²), Manhattan (L¹), Chebyshev (L∞), and Minkowski p=3 metrics, drag sites, and see how the cell boundaries bend.
Build Lindenmayer-system fractals from an axiom and production rules: Koch snowflake, dragon curve, Sierpinski, Hilbert curve, plant, tree, bush, Levy C, and Gosper presets, with adjustable iterations, angle, step length, and rainbow gradient stroke.
Click points and watch the convex hull form using Andrew's monotone chain, Graham scan, or Jarvis march (gift wrapping). Side-by-side comparison of orientation tests, runtime, and hull size for the same input set.
Synthesize any signal (sum of sines, square, triangle, sawtooth, chirp, DTMF, white noise) and watch the Fast Fourier Transform reveal its frequency content — adjustable sample rate, FFT size, dB / linear magnitude, top-peak detection, and 5 window functions (Hann, Hamming, Blackman, Flat-top, Rectangular).
Convert between decibels and linear ratios (10·log for power, 20·log for voltage / SPL), sum and subtract dB levels for noise sources, and round-trip dBm ⇄ W, dBW, dBu, dBV, dBµV, dBFS — with a reference table of common SPL and signal levels.
Compute the sun's altitude and azimuth for any lat/lon and instant, plus sunrise, sunset, solar noon, golden & blue hours, and civil / nautical / astronomical twilight — using NOAA's solar position algorithm with live sky-dome and daily-arc visualizations.
Convert calendar date ⇄ Julian Date (JD), Modified JD, Reduced JD, Truncated JD, Dublin JD, J2000 days, ANSI Date, and Unix epoch — handles proleptic vs. historical Julian/Gregorian, with day-of-year, day-of-week, and JDN integer view.
Evaluate sin/cos/tan, csc/sec/cot, asin/acos/atan, atan2(y, x), and the hyperbolic family for any angle. Live unit-circle diagram, degrees/radians toggle, exact-value table, and identity cheat sheet.
Convert across eight scales at once — Celsius, Fahrenheit, Kelvin, Rankine, Réaumur, Newton, Delisle, and Rømer — with reference-point presets (absolute zero → sun surface) and an absolute-zero violation warning.
Parse and build syslog messages in RFC 5424 and RFC 3164 (BSD) formats — split the PRI value into facility and severity, walk structured-data elements ([SD-ID@PEN k="v"]), and compose new lines field by field with NILVALUE handling and a live binary/hex view of the PRI.
Pick a root and quality (major, minor, dim, aug, sus, 7, m7, maj7, m7♭5, dim7, 9, 11, 13, add9, …) and read off the chord's notes, semitone intervals, MIDI numbers, Hz frequencies, every inversion, plus a piano visualization and Web Audio chord / arpeggio playback.
Convert WGS-84 lat/lon ↔ XYZ slippy-map tiles at any zoom — see the tile's NW/SE bounds, pixel offset within the tile, ground resolution in m/px, TMS-flipped Y, Bing quadkey, and copy-ready URL templates for OSM, CartoDB, Stamen, Esri, Bing, and Google Maps.
Compose a Caddy v2 Caddyfile by clicking instead of memorising directives — site blocks can mix reverse_proxy, file_server, redirects, custom headers, gzip / zstd encoding, basic auth, request logging, and TLS overrides. Automatic HTTPS is on by default for real hostnames.
Paste a strategy.matrix block and see every job the runner will spawn. Handles cartesian product, include entries that either extend an existing combination or append a brand-new job, and exclude filters — the same order and semantics the real GHA runner uses.
Build a Proxy Auto-Config FindProxyForURL with a rule editor — match by host suffix, exact host, IP range, scheme, glob, or substring, then route to DIRECT, PROXY, SOCKS5, or HTTPS. Live single-URL and batch test runners use the same evaluation order browsers do.
Paste an edge list — A -> B, A B, or A: B C (Makefile-style) — and watch Kahn's algorithm produce a topological ordering step by step, with in-degree table, parallel-execution layers, cycle detection that pinpoints the offending nodes, and Graphviz .dot export.
Turn an array of strings into a localized list — “A, B, and C”, “A, B o C”, “A・B・C” — with live conjunction / disjunction / unit & long / short / narrow options, a formatToParts breakdown, and a 21-locale side-by-side.
Interactive reference for all 21 built-in TS utility types — Partial, Pick, Omit, Record, ReturnType, Awaited, Uppercase & friends. Pick a utility, paste your own type, and see the resolved shape plus a ready-to-paste snippet.
Build a .gitlab-ci.yml from a checklist — stages, default image, caches, services, workflow:rules, Docker-in-Docker, parallel:matrix, JUnit artifacts, and per-job rules. Presets for Node CI, Docker build & push, and GitLab Pages.
Compose the <iframe sandbox="…"> attribute token by token — each flag explained with its risk level, live preview in a real sandboxed iframe, and warnings for the allow-scripts allow-same-origin escape and other risky combos.
Parse an HTML document into its h1–h6 tree and audit for skipped levels, multiple h1s, empty headings, and headings inside aria-hidden regions. Exports the outline as Markdown or plain text.
Fit a straight line or polynomial (degree 2–10) to (x, y) data with OLS — get R², adjusted R², residual SE, F-test, per-coefficient t-stats, and a scatter chart with the fitted curve and 95% confidence band. Built-in ln / log₁₀ / √ / 1/x transforms linearize exponential and power-law data.
Generate a native HTML <dialog> with the right opener — showModal() for blocking modals with focus trap and ::backdrop, or show() for non-modal panels. Wire a method="dialog" form so the submit button auto-closes and returns returnValue, customize ESC and outside-click behavior with the new closedby attribute, and animate entry with @starting-style. Live preview plus copy-ready HTML, CSS, and JS.
Compute Jaccard, Sørensen–Dice, Overlap (Szymkiewicz–Simpson), Tversky T(α,β), and cosine similarity between two line-based sets — plus |A|, |B|, |A∩B|, |A∪B|, and the elements unique to each side. Toggle dedupe vs multiset mode, case-insensitive matching, and whitespace trimming. Useful for fuzzy duplicate detection, retrieval thresholds, and asymmetric tag-overlap scoring.
Validate the format and checksum of EU, UK, Swiss, and Norwegian VAT registration numbers — 30+ country prefixes with country-specific regex plus working checksums (MOD-11/10 for DE, MOD-97 for BE/NL, Luhn for IT/SE, the historical MOD-97 +55 branch for GB, and 20+ more). Single-input or paste-many batch mode with CSV export.
Solve Vout = Vin · R2 / (R1 + R2), pick the closest E12 / E24 / E48 / E96 resistor pair for a target output, and check how a load resistance sags the output — quiescent current, power, and Thévenin equivalent included.
Lock any two of bitrate, file size, and duration to solve the third. Presets for YouTube 1080p / 4K, Twitch, Netflix HDR, Blu-ray, MP3, AAC, FLAC, plus a codec efficiency table (H.264 → H.265 → AV1) and transfer-time check on common upload pipes.
Convert between Hz / kHz / MHz / GHz / THz and m / mm / µm / nm / Å for EM waves (uses c) or sound in air / water / steel — shows period, wavenumber, photon energy in eV, the spectrum band (radio → γ-ray), and a quarter-wave dipole length for RF antennas.
Watch the Closed → Open → Half-Open state machine in action — tune failure threshold, recovery probes, and reset timeout, stream simulated requests, and copy production-ready config for Polly, Resilience4j, opossum, or gobreaker.
Watch Algorithm R (Vitter) and Algorithm L pick k uniformly random items from a stream of unknown length — step through every accept/reject decision, then run a Monte Carlo of 10,000 trials to verify the k/n inclusion guarantee with a per-position histogram and χ² goodness-of-fit.
Place nodes and keys onto a SHA-1 hash ring, tune virtual nodes per real node, and watch the load distribution flatten. Live churn simulator shows exactly which keys move when a node joins or leaves — used by Dynamo, Cassandra, Riak, and libketama.
Build a distributed-systems time-space diagram — drop local events, send messages between processes, and watch Lamport scalars and vector clocks update by the textbook rules. Pick any two events to see whether they're causally ordered (a → b) or genuinely concurrent (a ∥ b).
Searchable reference for 130+ POSIX / Linux / macOS / FreeBSD errno values — look up EAGAIN, EACCES, EPIPE, ECONNRESET by number, symbol, or message and see which platforms agree on the number and which don't.
Score LCP, INP, CLS (plus FCP, TTFB, legacy FID) against Google's official Good / Needs Improvement / Poor thresholds — see a pass/fail per metric, an overall verdict for the URL, and a focused optimization checklist for whichever metric is failing.
Generate a production-ready sw.js with per-route caching — cache-first, network-first, stale-while-revalidate, network-only, cache-only — plus precache list, version-bump cleanup, navigation preload, and an offline fallback page. Vanilla JS, zero dependencies, no Workbox.
Compute pixel density (PPI), dot pitch, physical size, and the minimum viewing distance at which the human eye stops resolving individual pixels — for any width × height × diagonal. Includes presets for popular phones, monitors, and TVs plus in-browser DPR / screen detection.
Compose an IntersectionObserver with custom root, rootMargin, and threshold list — scroll a live target through the viewport box, watch every IntersectionObserverEntry fire in real time with ratio + isIntersecting state, copy a ready-to-paste snippet with presets for lazy-load, infinite scroll sentinel, sticky-on-pin, and scrollspy patterns.
Parse key=value log lines (Heroku, Go slog, Splunk) into a structured table — handles quoted values, \" / \\ escapes, repeated keys — then re-serialize edited pairs with correct quoting. Copy as JSON or TSV.
Stack tunnel headers (WireGuard, IPSec ESP, GRE, PPPoE, VXLAN, 6in4) on top of an Ethernet link and see the effective inner MTU, TCP MSS for v4/v6, UDP payload, and PMTUD blackhole warnings.
Flip the 8 bits of the IP ToS / Traffic Class byte — DSCP code points (EF, AF, CS), ECN state (Not-ECT, ECT(0/1), CE), legacy IP precedence — with iptables / tc / setsockopt snippets for any value.
Build native HTML popovers — auto / manual / hint types, popovertarget triggers, anchor positioning, ::backdrop styling, and @starting-style entry animation. Live preview, zero JS required.
Test JS Intl.NumberFormat with live locale, style (decimal / currency / percent / unit), notation, sign & rounding options — formatToParts breakdown and 15-locale side-by-side.
Render “3 days ago” / “in 2 hours” across locales — auto-bucket a date diff into the right unit, compare numeric: auto vs always, copy a ready-to-paste JS snippet.
Build accessible zero-JS disclosures and exclusive accordions with name= — chevron presets, interpolate-size animation, FAQPage JSON-LD schema option, and copy-ready HTML + CSS.
Paste any YouTube URL and build a clean embed iframe — start/end time, autoplay, captions, loop, controls, related-off, and privacy mode (youtube-nocookie.com). Live preview, iframe / URL / oEmbed output.
Searchable reference of Stripe's test card numbers — successful charges, declines (insufficient_funds, lost_card, stolen_card, expired, CVC), 3D Secure / SCA challenge flows, AVS failures, and dispute triggers. Click to copy.
Trigger navigator.share() with custom title, text, URL, and files. Probe canShare() per MIME type, inspect AbortError/NotAllowedError/DataError, and copy a ready-to-paste JS snippet.
Inspect navigator.storage.estimate() plus a per-API breakdown of localStorage, sessionStorage, IndexedDB, Cache Storage, and cookies. Includes a stress-test writer and a persistent-storage toggle.
Decode JavaScript source maps — parse VLQ mappings, browse embedded sources, and look up the original location for a generated line:column from a stack trace.
Probe the signals your browser exposes — UA, screen, canvas hash, WebGL renderer, audio stack, font list, timezone, client hints — and compute a stable SHA-256 fingerprint. Useful for privacy audits and bot-detection research.
Experiment with AbortController, AbortSignal.timeout(), and AbortSignal.any() — timeout, manual cancel, or race multiple signals against a live fetch() or sleep helper.
Add, multiply, divide, power, and root complex numbers in rectangular or polar form. Modulus, argument, conjugate, exp, log, and Argand-plane plot.
2D/3D vector math — dot, cross, magnitude, normalize, angle, projection, and lerp with a live 2D preview.
Convert between quaternions, Euler angles, axis-angle, and rotation matrices with a live 3D cube preview.
Plot PMF/PDF/CDF for normal, binomial, Poisson, gamma, beta and more, with tail probabilities and quantiles.
Parse ObjectIDs to extract timestamp, random value, and counter — or generate new IDs from any date.
Parse SSH public keys to extract key type, bit length, SHA-256/MD5 fingerprints, and comments.
Test regular expressions with real-time highlighting, capture groups, and presets.
Paste a regex and get a plain-English explanation of every token — anchors, groups, quantifiers, and lookaheads.
Find regex matches and apply replacements with capture groups, backreferences, and live diff preview.
Interactive Venn diagrams for INNER, LEFT, RIGHT, FULL OUTER, and CROSS JOINs with live sample data.
Compare two equal-length strings, binary words, or hex values bit by bit.
Validate International Bank Account Numbers via mod-97 with country detection and BBAN parsing.
Validate ISBN-10 and ISBN-13 checksums, convert between formats, and detect the registration group.
Parse, validate, and format international numbers in E.164, international, national, and tel: URI.
Convert between lat/lon and geohash strings, view bounding boxes and neighbor cells.
Encode lat/lng coordinate lists to Google's encoded polyline format, or decode back to points. Precision 5 and 6 supported.
Encode lat/lng into Google Plus Codes (Open Location Codes) at adjustable precision and decode them back to coordinates.
Compute great-circle distance and initial/final bearing between two lat/lng points — km, miles, nautical miles, and compass direction.
Build RFC 5545 recurrence rules with FREQ, INTERVAL, BYDAY, BYMONTH, COUNT, UNTIL — with a live preview of the next occurrences.
Parse Amazon Resource Names into partition, service, region, account, and resource — and build new ARNs from scratch.
Compute Levenshtein, Hamming & Jaro-Winkler with optimal alignment visualization.
Convert between Unix timestamps and dates. Live clock, auto-detect ms/s.
Build cron expressions visually. See next run times and human-readable descriptions.
Convert Unix file permissions between numeric and symbolic formats.
Generate .gitignore files for any project. 50+ language and framework templates.
Build complex git commands visually. Select operations and copy the result.
Generate GitHub Actions workflow YAML with triggers, matrix builds, and caching.
Generate production-ready Dockerfiles for Node.js, Python, Go, Rust, Java, and more.
Generate Nginx configs for reverse proxy, static sites, SSL/TLS, and more.
Compare, sort, and validate Semantic Versioning strings.
Check whether a version satisfies an npm-style range — caret, tilde, hyphen, wildcards, comparator sets, and OR. Includes batch testing.
Test glob patterns against file paths in real-time.
Calculate network address, broadcast, host range, and wildcard mask.
Merge a list of IPv4 CIDRs and IP ranges into the smallest equivalent set of prefixes — same algorithm as aggregate6.
Calculate download times, convert bandwidth units, and estimate data transfers.
Find your public IP, geolocation, ISP, and timezone.
Query A, AAAA, MX, CNAME, TXT, NS, SOA, SRV, and CAA records.
Parse browser user-agent strings and detect browser, OS, and device type.
Test keyboard events: key, code, keyCode, which, and modifier states.
Evaluate math expressions with variables, hex/binary/octal, and bitwise ops.
Calculate days, weeks, months, business days, countdowns, and date math.
Convert times between any time zones. World clock and meeting planner.
Convert length, weight, temperature, area, volume, speed, data, and time.
Calculate and convert aspect ratios for images, video, and screens.
Create bookmarklets from JavaScript. Minify and generate drag-and-drop links.
Parse, edit, compare, sort, and validate environment variable files.
Paste logs, auto-detect formats, filter by level, search, and highlight patterns.
Write HTML, CSS, and JavaScript and see results instantly.
Convert HTML to JSX: class→className, style strings to objects, self-close tags.
Design and preview terminal color themes. Export to iTerm2, Windows Terminal.
Preview and compare Google Font pairings for web projects.
Preview and compare fonts with custom text, sizes, weights, and styles.
Combine multiple PDFs into one or extract specific pages. All client-side.
Generate robots.txt files with user-agent rules, allow/disallow paths, and sitemaps.
Paste a robots.txt and a list of URLs to see which paths each user-agent can crawl. Implements Google's longest-match precedence with Allow/Disallow tie-breaking.
Generate valid XML sitemaps with priority, change frequency, and last modified.
Generate a professional privacy policy for your website or app in seconds.
Generate realistic fake data: names, emails, addresses, phone numbers, IPs, UUIDs.
Create professional invoices with line items, taxes, discounts, and PDF export.
Paste CSV or JSON data and instantly create bar, line, pie, and radar charts.
Create flowcharts, sequence diagrams, class diagrams, and Gantt charts.
Generate SEO meta tags, Open Graph & Twitter Cards with live social previews.
Convert 99.9%, 99.95%, 99.99% availability targets to downtime budgets.
Generate white noise, pink noise, rain, ocean waves, and more.
Build clean docker-compose.yml files for dev stacks, databases, apps, and supporting services.
Convert between ms, seconds, minutes, hours, days & parse duration strings.
Build ~/.ssh/config entries visually with host aliases, proxy jumps, and tunnels.
Model token bucket, sliding window, and fixed window rate limiters with visualization.
Create .editorconfig files for consistent code style across editors and IDEs.
Compare JavaScript code snippet execution speed with ops/sec and statistics.
Build connection URIs for PostgreSQL, MySQL, MongoDB, Redis, SQLite & MSSQL.
Decode mongodb:// and mongodb+srv:// strings into hosts, auth, database, and options.
Generate systemd service, timer & socket unit files for Linux daemons.
Generate Makefiles for Go, Node.js, Python, Rust, C/C++ & Docker projects.
Test date, number, currency, and relative time formatting across locales via the Intl API.
Create and download .ics calendar files for Google Calendar, Apple Calendar, and Outlook.
Generate TypeScript config files visually with presets for React, Node, Next.js, and more.
Build Apache .htaccess files with redirects, security headers, caching, and CORS.
Expand, compress, validate, and analyze IPv6 addresses with subnet info.
Convert IPv4 addresses between decimal, hex, octal, binary, and integer formats.
Minify HTML to reduce file size or beautify compressed HTML for readability.
Parse any URL into components — protocol, host, port, path, query params, hash — and rebuild.
Parse raw email headers to trace delivery hops and check SPF, DKIM, DMARC authentication.
Convert <style> blocks to inline style attributes for maximum email client compatibility.
Visualize how floating-point numbers are stored in binary — sign, exponent, and mantissa bits.
Add, multiply, transpose, invert matrices and compute determinants with live results.
Calculate p-values, confidence intervals, and sample sizes for A/B test experiments.
Design database schemas visually — define tables, columns, constraints, and relationships. Export SQL DDL.
Visualize folded stack traces as interactive flame graphs. Zoom, search, and analyze performance profiles.
Generate Web App Manifest (manifest.json) for Progressive Web Apps with icons, theme colors, and display modes.
Generate Schema.org structured data in JSON-LD format for SEO rich snippets.
Build HTML tables visually — edit cells, add rows and columns, export HTML or Markdown.
Plan page weight budgets by resource type and estimate load times across connections.
Check HTML for WCAG accessibility issues — missing alt text, bad ARIA, low contrast, and more.
Format, beautify, and minify SQL queries with keyword casing, indentation, and syntax highlighting.
Calculate network address, broadcast, host range, and subnet mask from CIDR notation.
Paste a list of IPv4 CIDR blocks and detect overlaps, containment, adjacency, and compute the merged union coverage.
Parse, validate, and lint .env files. Detect duplicates, bad formatting, and export to JSON/YAML/Shell.
Generate YAML manifests for Deployments, Services, ConfigMaps, Secrets, Ingress, and PVCs.
Build package.json files visually with presets for Node.js, React, Express, CLI tools, and libraries.
Build accessible HTML forms visually — add inputs, selects, checkboxes, radios, and export clean HTML.
Build complex FFmpeg commands visually — select codecs, resolution, bitrate, and more.
Count lines of code, comments, and blanks with automatic language detection and file upload.
Convert code into VS Code custom snippets with tab stops, placeholders, and variables.
Upload HAR files to inspect network requests, timing waterfalls, headers, and response bodies.
Generate a styled GitHub profile README with bio, tech stack badges, stats, and social links.
Convert between bytes, KB, MB, GB, TB, PB in decimal (SI) and binary (IEC) units.
Write DOT language and render directed graphs, flowcharts, and dependency diagrams.
Detect leaked API keys, tokens, passwords, and credentials in code and text.
Run JavaScript code in your browser with live console output, REPL, and code snippets.
Build and preview SVG path commands visually with control points, handles, and live preview.
Browse ASCII and extended characters with decimal, hex, octal, binary, and HTML entity values.
Build finite state machines visually with states, transitions, and export to JSON or Mermaid.
Check HTML for errors, deprecated elements, missing attributes, and accessibility issues.
Step through JavaScript execution to understand the call stack, microtasks, and macrotasks.
Convert between Unix epoch timestamps and human-readable dates with timezone support.
Live multi-timezone clock for distributed teams. Pick any IANA zones and preview a future meeting instant across all of them.
Press any key to see its JavaScript event properties — key, code, keyCode, and modifiers.
Convert between bytes, KB, MB, GB, TB with binary (1024) and SI (1000) unit support.
Minify or beautify JavaScript code with size stats and configurable options.
Searchable collection of common regex patterns — email, URL, IP, dates, and more. Test live & copy.
Clean untrusted HTML by stripping dangerous tags, attributes, and scripts. Configure allow/deny lists.
Analyze HTML for SEO: meta tags, heading structure, Open Graph, SERP preview.
Convert between decimal numbers and Roman numerals with subtractive and vinculum notation (1–3,999,999).
Roll tabletop RPG dice — 3d6+2, 4d6kh3, advantage/disadvantage, exploding dice — with history.
Convert GPS coordinates between Decimal Degrees (DD), DMS, DDM, UTM, and map URL formats.
Compute CVSS v3.1 base score, severity, and canonical vector string from metric selections.
Build Calendar Versioning strings — YYYY.MM.DD, Ubuntu, pip, and custom patterns with tokens.
Size Bloom filters — derive bit array, hash count, FPR, and memory cost from any two parameters.
Detect file types from magic byte signatures — drop any file or paste hex to identify 80+ formats.
Encode names with Soundex, Metaphone, NYSIIS, Caverphone, and Match Rating Codex for fuzzy matching.
Audit first-digit distribution for fraud detection — χ², MAD conformity, and live distribution chart.
Convert between raw scores, z-scores, p-values, percentiles, and confidence intervals with a bell curve.
Factor big integers into primes, list divisors, compute GCD/LCM, Euler's totient, and divisor sum with BigInt.
Decode 4, 5, and 6-band resistors into resistance, tolerance, and temperature coefficient with a visual resistor and reverse lookup.
Build truth tables for boolean expressions — AND, OR, XOR, NAND, implication — with tautology detection.
Compute precision, recall, F1, specificity, MCC, and Cohen's κ from a binary confusion matrix.
Convert between musical notes, frequency (Hz), and MIDI numbers with cents offset, adjustable A4, and tone playback.
Generate a vCard 3.0 / 4.0 contact file (.vcf) with name, phone, email, address, and a scannable QR code for instant phone import.
Convert terminal output with ANSI escape codes into styled HTML — supports 16, 256, and 24-bit true color plus bold, italic, underline.
Convert source code between tabs and spaces, normalize mixed indentation, detect existing style, and trim trailing whitespace.
Pick items from a list with custom weights. Run Monte Carlo simulations and compare observed vs expected distribution.
Searchable reference for POSIX signals with default actions, plus a kill / pkill / killall command builder.
Generate Fibonacci, Lucas, primes, Catalan, Collatz, Pell, factorials, perfect numbers, and 15+ more integer sequences with BigInt precision.
Escape arguments for POSIX sh, Bash ANSI-C, PowerShell, Windows cmd, and JSON exec form — handles quotes, spaces, and metacharacters.
Expand bash brace patterns like file{1..10}.txt or {dev,prod}/app.{js,ts} — supports ranges, steps, padding, and nesting.
Test ${var:-default}, ${var/pat/repl}, ${var##*/}, ${#var} and every other bash parameter expansion form on your variables — built-in cheatsheet, no shell needed.
Drop a .tar file to list every entry — names, sizes, modes, owner, mtime, link targets — with ustar/POSIX/PAX/GNU header parsing entirely in your browser.
Generate, validate, normalize, and inspect MAC addresses. Convert between formats, detect multicast/local bits, and build EUI-64 identifiers.
Compute union, intersection, difference, and symmetric difference of two lists of lines. Case-insensitive, sort, and duplicate detection options.
Arbitrary-precision GCD, LCM, modular inverse, modular exponentiation, extended Euclidean, and Chinese Remainder Theorem — crypto and number theory essentials.
Compute exact age or date diff in years, months, days, weeks, hours, minutes, and seconds — with next birthday countdown.
Arbitrary-precision integer math — add, multiply, modpow, gcd, lcm, factorial, isqrt — with bin/oct/dec/hex/base64 output.
Paste numbers and get p50, p90, p95, p99, p99.9, min, max, mean, stddev and an inline histogram.
Apply L = λW to size queues, thread pools, and connection pools. Solve for any variable given the other two.
Size call centres, thread pools, and connection pools with the Erlang C formula. Given arrival rate λ, mean service time, and c servers, get utilization, probability of any wait, average wait time, queue length, service level, and the minimum staffing to hit a wait-time SLA.
Birthday-problem calculator for UUIDs, MD5, SHA-256, and custom bit sizes — compute collision risk at any scale.
Shoelace-formula area, perimeter, centroid, bounding box, and self-intersection detection for any simple polygon — with live canvas preview.
Apply the 3n+1 rule to any positive integer. BigInt-aware stopping time, max value, parity counts, and a log-scale trajectory chart.
Compute posterior probabilities from prior, sensitivity, and specificity. See PPV, NPV, likelihood ratio, and a confusion matrix for 10,000 people.
Calculate monthly payments, total interest, and full amortization schedules with optional extra payments — see how much time and interest you save.
Convert raw SVG markup into a ready-to-use React or TypeScript component — camelCases attributes, swaps class → className, supports forwardRef, currentColor, and React.memo.
Visually design a Bash prompt — drag segments for user, host, path, git branch, time, and exit code. Live preview with ANSI colors and a copy-ready export line for your .bashrc.
Spell out any number in English — cardinal, ordinal, currency, and check-writing styles. Handles integers, decimals, and negatives up to one vigintillion.
Write LaTeX math and see it rendered live with KaTeX — display/inline modes, the mhchem chemistry package, MathML and SVG export, and shareable URLs.
Exact fraction arithmetic with BigInt — add, subtract, multiply, divide, and simplify. Converts between fractions, mixed numbers, decimals (with repeating-digit detection), percent, and LaTeX.
Add tip and tax, split any bill between any number of people, and round the total to clean cash amounts. Supports multiple currencies and shareable URLs.
Build a .prettierrc config interactively with a live sample preview — JSON, JSON5, YAML, and package.json output formats.
Generate an eslint.config.js flat config for ESLint v9+ with plugins, globals, common rules, and ignore patterns.
Check if two words are anagrams, generate every distinct permutation of a string, and group word lists into anagram families.
Tokenize text into character or word n-grams with frequency, type/token ratio, Shannon entropy, and CSV export.
Postfix calculator with live stack visualization, math/bitwise ops, history, and an infix → RPN converter via the shunting-yard algorithm.
Compute factorials, nPr, nCr, multiset, multinomial, Stirling S(n,k), and Catalan numbers with arbitrary-precision BigInt math.
Generate Fibonacci or Lucas sequences with BigInt precision, fast-doubling nth term, golden-ratio convergence, and CSV export.
Solve ax² + bx + c = 0 with real or complex roots, discriminant, vertex form, axis of symmetry, and a live parabola plot.
Tap along to measure beats per minute with stability tracking and note-value delay times for quarter, eighth, dotted, and triplet notes.
Project savings growth with monthly contributions, custom compounding frequency, and a year-by-year breakdown of contributions vs. interest.
Compute the greatest common divisor and least common multiple of any number of integers, with full Euclidean algorithm steps and BigInt support.
Every common percent operation in one place — percent of, percent change, increase/decrease, tip, markup vs. margin, and reverse percentage.
Browse every AWS region — codes, locations, availability zones, launch year, and partition. Search, sort, and copy region codes instantly.
Enter any two of voltage, current, resistance, or power and instantly solve the remaining values with unit prefixes and step-by-step formulas.
Compute the current-limiting resistor for an LED — supply voltage, forward voltage, series count, nearest E12/E24 value, and power dissipation.
Solve a right triangle from any two inputs — sides, angles, area, perimeter, altitude, with the Pythagorean theorem and a live diagram.
Solve for time, distance, or pace — with km/mile splits, speed, VO₂ estimate, and quick presets for 5K, 10K, half marathon, and marathon.
Turn a BPM into delay times in ms, seconds, and samples for every note value, with dotted and triplet variations for music producers.
Compute dew point, heat index, wet-bulb temperature, frost point, and thermal comfort from temperature and relative humidity.
Parse and build ISO 8601 durations like P1Y2M3DT4H5M6S. Convert to total seconds, human-readable form, and add them to a calendar date.
Fire synthetic events and visualize which reach a debounced or throttled callback. Tune wait, leading/trailing edges, and copy a reference implementation.
Generate Pascal's triangle to 200 rows with BigInt precision. Highlight odd/even (Sierpinski), primes, and powers of 2, and read out any C(n,k).
Find the day of the week for any date using Zeller's congruence, with ISO week, day-of-year, days from today, and a mini calendar.
Flip a coin once or up to a million times with running heads/tails stats, longest-run detection, and a chi-square fairness test.
Compute Western (Gregorian) and Eastern (Orthodox) Easter for any year with related movable feasts and multi-year tables.
Translate DNA or RNA to amino acids in all three reading frames, reverse-complement, and see GC content with the standard codon table.
Solve any 9×9 Sudoku puzzle instantly with backtracking — enter digits in the grid or paste an 81-char puzzle string.
Generate random rectangular mazes with recursive backtracker, Prim's, or Kruskal's. Seeded, solvable overlay, SVG export.
Step through GET/PUT operations on a Least-Recently-Used cache and watch evictions, aging, and hit-ratio stats update live.
Interactive Game of Life simulator — draw cells, step or run, load classic patterns (glider, pulsar, Gosper gun), and tweak speed & wrap.
Watch bubble, insertion, selection, shell, merge, quick, and heap sort animate on any array size with live comparison and swap counters.
Pan, zoom, and color the Mandelbrot fractal with adjustable iterations, five palettes, smooth coloring, and PNG export.
Run, step, and debug Brainfuck programs with a live 30,000-cell tape, adjustable speed, stdin, and classic example programs.
Minimize 2–5 variable Boolean expressions with an interactive K-map, Quine–McCluskey solver, and both SOP and POS output.
Animate the classic prime-finding algorithm — step through multiples, highlight twin primes, and export the list up to 10,000.
Build DFA/NFA state machines, define transitions, and test input strings with step-by-step animation and drag-to-arrange states.
Real-time clock in BCD and true binary with hex, octal, Swatch beats, Unix timestamp, and day progress views.
Build complex find commands visually — paths, filters, sizes, times, permissions, and actions.
Build AWK one-liners visually and test them against sample input right in your browser.
Build sed commands visually — substitutions, deletions, and transformations — then test them live.
Build rsync commands visually — configure source, destination, flags, excludes, and SSH options.
Build GnuPG commands visually — generate keys, encrypt, decrypt, sign, verify, and manage keys.
Build SQL queries visually — SELECT, JOIN, WHERE, GROUP BY, ORDER BY, LIMIT — with instant syntax-highlighted output.
Build iptables, ufw, nftables, and Windows Firewall rules visually with common presets and copy-paste commands.
Write GLSL fragment shaders and see them render in real-time with uniforms for time, resolution, and mouse position.
Convert between decimal and two's complement binary for 8, 16, 32, and 64-bit signed integers with interactive bit toggling.
Define named bit flags, combine bitmask values, and decode masks back to flag names — for permissions, feature flags, and binary protocols.
Merge base, left, and right text versions with automatic conflict detection and resolution — like git's three-way merge.
Build complex docker run commands interactively — ports, volumes, env vars, networks, and presets for common images.
Compare two URLs component by component — protocol, host, path, query parameters, and fragments highlighted side by side.
Build AWS IAM policy JSON visually — add statements, pick actions, set resources, and export valid policies.
Build AWS CLI commands visually for S3, EC2, Lambda, IAM, ECS, DynamoDB, and more — configure flags and copy ready-to-run commands.
Visually build Linux iptables firewall rules — configure chains, tables, protocols, ports, and targets with quick presets.
Generate valid package.json files visually — set metadata, scripts, dependencies, engines, and more with project presets.
Plot mathematical functions interactively — sin, cos, log, polynomials with zoom and pan.
Toggle TCP flags (SYN, ACK, FIN, RST, etc.) and calculate hex/decimal/binary byte values.
Browse ZIP file contents — view file list, sizes, compression ratios, and preview text files.
Test date format patterns for strftime, Go, Java, and JavaScript Intl with live output.
Live HTML, CSS & JavaScript editor with instant preview — like CodePen but fully offline.
Parse and convert between AWS S3 URL formats — s3://, virtual-hosted, path-style, ARN, and CLI commands.
Merge multiple .env files, detect conflicts, choose resolution strategy, and export the merged result.
Create visual event timelines for projects, incidents, or releases. Export as SVG or HTML.
Build responsive, table-based HTML email templates with live preview. Compatible with all major email clients.
Visualize your team's technology choices across Adopt, Trial, Assess, and Hold rings.
Build BIND-compatible DNS zone files visually — A, AAAA, CNAME, MX, TXT, SRV, NS, CAA records with SOA config.
Build tcpdump packet capture commands visually — protocols, hosts, ports, TCP flags, and BPF filter output.
Build .dockerignore files with language presets for Node.js, Python, Go, Java, Rust, and common patterns.
Paste a SQL query to see each clause highlighted, explained, and ordered by execution sequence.
Visually build Redis commands — select data type, operation, and parameters, then copy the redis-cli command.
Estimate network latency for distributed systems — propagation delay, serialization, and multi-hop chains.
Browse all 118 elements with atomic number, mass, electron configuration, and category. Click any cell for details, search by name or symbol, filter by category.
Convert between target FPS and millisecond frame budget, slice into JS / style / paint / GPU phases, and live-measure your real frame time.
Compose OVER (PARTITION BY ... ORDER BY ... ROWS BETWEEN ...) clauses for ROW_NUMBER, RANK, LAG, SUM and friends — generated SQL plus live result on sample data.
Compare O(1), O(log n), O(n), O(n log n), O(n²), O(2ⁿ), O(n!) at any input size — plot operation counts and runtime budgets on a log–log chart.
Convert between SMPTE timecode HH:MM:SS:FF and frame counts at 23.976 / 24 / 25 / 29.97 (DF + NDF) / 30 / 50 / 59.94 / 60 fps. Drop-frame compliant with the standard Heidelberger formula — add or subtract timecodes, measure runtime between two points, and see the real-seconds drift vs the wall clock.
Generate or verify the check digit for EAN-13, EAN-8, UPC-A, UPC-E, and GTIN-14 barcodes — step-by-step mod-10 weighted sum, schematic bar preview, and bulk validation of mixed-format codes pasted one per line.
Convert any number between standard decimal, scientific (1.23×10⁶), engineering (multiples of 3), SI prefix (k, M, μ, n, …), and E-notation. Arbitrary precision via string arithmetic — values like 0.1 + 0.2 stay exact — with sig-fig control and bulk conversion.
Stagger N scheduled jobs across a jitter window using a deterministic hash of the job ID — every job keeps the same offset every fire, so retries hit the same slot and the aggregate load flattens instead of stampeding at :00. FNV-1a / djb2 / murmur3-32, bucket histogram, per-second peak, and copy-ready Python / Node / Go / bash snippets.
Plan a zero-downtime rotation for JWT signing keys, webhook secrets, API tokens, DB credentials, or OAuth client secrets. Wall-clock timeline for issue → dual-accept deploy → cutover → verify soak → revoke, with rollback budget, per-fleet rollout math, dual-verify code snippet, Markdown runbook, and .ics calendar export.
Run Pearson's χ² goodness-of-fit and independence tests without leaving the browser. Paste observed counts (with optional expected proportions) or an r×c contingency matrix, pick α, tick Yates' correction for 2×2, and get χ², df, p-value, critical value, Cramér's V / φ, plus a per-cell standardised-residual heat map to see which cells drive the statistic.
Find the vital few — paste category, count rows and instantly get a sorted bar chart with the orange cumulative-percentage line, configurable 80% threshold, vital-few highlight, and SVG / PNG / TSV export.
Lay out Strengths, Weaknesses, Opportunities, and Threats; drag to reorder; weight each item 1–5; and auto-derive the TOWS strategy matrix (SO grow, WO improve, ST defend, WT survive). Markdown, JSON, and PNG export, saved locally.
Build a RACI / RASCI responsibility matrix for project tasks and stakeholders — assign Responsible, Accountable, Consulted, Informed (and optional Support) per task, validate that every row has exactly one Accountable, flag overloaded owners, and export as Markdown, CSV, HTML, or JSON.
Write Architecture Decision Records in MADR, Nygard, or full template format — capture context, decision drivers, options with pros & cons, the chosen path, positive and negative consequences, and references. Auto-numbered filename, live Markdown preview, download as NNNN-slug.md.
Plug in customers, ARPU, gross margin, churn, expansion, and CAC — get the full unit-economics scorecard: MRR, ARR, NRR, customer LTV (simple & discounted), CAC payback, LTV:CAC ratio, quick ratio, and burn multiple with rule-of-thumb verdicts.
Async story-point estimator for distributed teams — Fibonacci / modified-Fibonacci / T-shirt / power-of-two decks, hidden votes per voter, reveal-together flow, median & mode & spread, consensus verdict, and a locked-stories backlog with copy-ready Markdown summary.
Drill from the symptom of an incident, bug, or process failure to the underlying root cause — guided why chain, corrective-action list, common pitfalls, and copy-ready Markdown for your postmortem.
Turn commit notes into polished release notes, customer updates, and changelogs.
Create reusable prompt templates with {{variables}} — fill in, preview, and copy.
Build well-structured git commit messages with Conventional Commits format.
Turn a bug report or feature request into a crisp triage summary.
Convert commits into clean changelogs with grouping and formatting.
Turn git diffs and PR summaries into crisp release notes.
Turn a release summary into a risk score, rollout plan, and go/no-go checklist.
Generate a clean pull request brief from feature notes and changed files.
Generate polished PR descriptions with summary, changes, testing, and risks.
Generate a focused PR review checklist with risk flags and deployment notes.
Estimate PR review time from file count, diff size, and complexity.
Split a large feature into shippable PR slices with scope and dependencies.
Scan code diffs for risky changes and flag hotspots.
Generate a build-ready developer handoff pack from feature notes.
Compare two OpenAPI specs and surface breaking changes and removed fields.
Generate beautiful, professional README.md files for GitHub projects.
Plan safer feature launches with staged rollouts and freeze windows.
Estimate capacity, velocity, and task fit for your sprint.
Turn raw retro notes into action items and themes.
Sort tasks by impact, effort, urgency, and risk.
Turn meeting notes or transcripts into a clean action item list.
Decode API errors into plain English with status-aware advice and retry hints.
Compare two API specs and surface breaking changes.
Turn release chaos into a clean bug bash plan with priorities and owners.
Polish rough review notes into clear, kind, actionable comments.
Build a clean context pack for coding agents, handoffs, and project briefs.
Turn a vague bug report into a structured debug plan with hypotheses.
Turn a bug report into ranked hypotheses, quick checks, and log clues.
Capture decisions, options, rationale, owners, and next steps.
Compare dependency manifests and spot version drift.
Plan dependency upgrades with risk notes and rollback steps.
Compare local, staging, and production settings to spot drift.
Estimate engineering tasks with effort, risk, and confidence scoring.
Build a launch checklist for developers and product teams.
Prioritize code review comments by severity, effort, and risk.
Rank developer tasks by impact, effort, risk, urgency, and unblock power.
Generate polished PR review replies and follow-up comments.
Turn PR details into a focused review prep brief with risks and test ideas.
Timebox code reviews and track review time per PR.
Estimate PR review size, split risk, and likely review effort.
Triage PR review comments into grouped action items and priority buckets.
Estimate the blast radius of a release from file paths and risk flags.
Build a release meeting agenda with decisions, risks, and follow-ups.
Score a release for readiness with checks for risk and confidence.
Analyze a repo snapshot, score health signals, and generate action items.
Plan a sane PR review queue from urgency, size, risk, and wait time.
Cut a bloated feature into a realistic release scope and parking lot.
Turn a feature request into a practical implementation plan with slices.
Paste a stack trace and get likely error type, hot spots, and probable causes.
Triage stack traces and error logs by fingerprint, severity, and root cause.
Turn rough notes into a concise standup update with blockers and goals.
Split a feature or bug into actionable subtasks with effort estimates.
Create a focused test plan from a feature, bug fix, or diff.
Turn feature ideas, bug reports, and tickets into crisp acceptance criteria and test cases.
Triage bug reports fast: score severity, assess reproducibility, group duplicates, and generate next steps.
Compress scattered task notes into a compact developer brief with priorities, constraints, and risks.
Plan prompt, context, and output token budgets for AI-assisted development tasks.
Plan a realistic deep work day by estimating how much interruption budget you actually have.
Review a pull request with a sharper lens: summarize scope, flag risk, and generate a focused checklist.
Turn PR review comments into thoughtful, concise reply drafts with action tracking and tone control.
Triage incoming developer tasks and requests into do now, schedule, delegate, or decline.
Estimate token counts for GPT-4, Claude, Llama & Gemini — with cost estimates and context window usage.
Compare per-call and monthly cost across Claude, GPT, Gemini, Llama and others — with editable prices, prompt-cache savings, and side-by-side ranking.
Build a retention matrix from raw user activity — paste user_id,date pairs and see weekly or monthly retention curves with weighted averages.
Compute expected score and K-factor rating change after a chess game — supports FIDE's auto K schedule (40 / 20 / 10), fixed 32-online defaults, or a custom K. Batch mode processes a list of results and shows a per-game breakdown plus a sensitivity curve.
Generate a batch of unique coupon, voucher, gift-card, invite, or licence codes with a customisable alphabet (no-confusables, Crockford base32, hex, URL-safe…), chunk pattern like XXXX-XXXX-XXXX, optional prefix/suffix, Luhn or mod-N check digit, uniqueness enforcement, entropy report, and CSV / TXT / JSON export. Verifier included.
Convert between nominal APR and effective APY across any compounding frequency — annual, semi-annual, quarterly, monthly, bi-weekly, weekly, daily, and continuous — with a live per-frequency comparison table and an N-year balance projector.
Estimate your true 1RM from any sub-maximal set using all seven classic regression formulas (Epley, Brzycki, Lander, Lombardi, O'Conner, Mayhew, Wathen) plus their averaged consensus. Full training-percentage table from 50 % warmup to 105 % overload with target reps, plus an RPE / RIR cheat sheet of working loads for 1, 3, 5, and 8-rep targets.
Convert dates between the Islamic (Hijri AH) and Gregorian calendars in either direction using the tabular calendar (Kuwaiti / Umm al-Qura type-IIc, 30-year leap cycle). Get the weekday in Arabic and English, day of year, year length, and a month-grid view with both calendars overlaid. Includes Ramaḍān, ʿĪd, Mawlid, and Hajj key-date lookups.
Count business days between two dates, or add / subtract working days from a reference date for SLA & deadline planning. Customizable weekend pattern (Sat/Sun, Fri/Sat for GCC, Sun-only, none), built-in US federal / UK bank / EU common holiday calendars (with Easter math), and a per-month calendar view that colors business days, weekends, and holidays.
Discount any cash-flow series to find Net Present Value, Internal Rate of Return (Newton's method with bisection fallback), modified IRR, discounted & undiscounted payback period, and profitability index — with a cumulative-flow chart that shows exactly when the project turns the corner.
Millisecond-accurate stopwatch with split / lap tracking, keyboard shortcuts, best & worst highlighting, and CSV / Markdown export — state survives reloads.
Stay focused with customizable work/break intervals, audio alerts, and tracking.
Log clock-in / clock-out shifts and compute total hours, regular vs overtime, gross pay, and weekly breakdowns.
Live countdown to any target date and time — days/hours/minutes/seconds with progress bar, presets, and shareable URL.
Calculate the precise duration between two dates — years/months/days breakdown, total in every unit, plus weekday vs weekend counts.
Drag-and-drop Kanban board with customizable columns and local storage.
Track daily habits, build streaks, and view a GitHub-style heatmap.
Plan a focused work session from a messy task list.
Save, organize, tag, and search code snippets with syntax highlighting.
Freehand drawing, shapes, text, arrows, layers, zoom/pan, and undo/redo.
Wrap up your workday with a focused shutdown checklist and open-loop triage.
Plan focused dev sessions with goals, time blocks, and a clean exit checklist.
Plan realistic focus blocks and batch shallow work for a productive day.
Estimate the real cost of a meeting in engineering hours and salary burn.
Balance meetings, focus blocks, and admin work into a realistic day plan.
Build clean shell aliases and functions for productivity.
Plan a focused dev day with timeboxes, task estimates, and a realistic buffer.
Score tasks by impact, urgency, effort, and energy to build a realistic plan.
Generate a bootstrap plan for a new dev workspace with setup commands.
Shuffle a 52-card deck (or 54 with jokers) using a seeded Fisher-Yates shuffle, then deal hands of any size for poker, blackjack, or bridge.
Compute moon phase, illumination percentage, and the next full/new moon for any date — with a lunar calendar grid and SVG phase preview.
Multiple labelled tally counters with per-counter step size, keyboard shortcuts (1–9, Shift to decrement), history with undo, autosave, and CSV / Markdown / JSON export. Useful for bug bashes, code review nits, inventory, or habit counts.
Plan the cleanest way to tidy a git branch and detect stale commits.
Estimate branch divergence, merge risk, and sync cost.
Turn rough bug notes into a clean reproduction script.
Score bugs by severity, impact, reproducibility, and workaround quality.
Plan cherry-picks with confidence — map commits, spot conflicts.
Estimate the hidden cost of task switching and plan deeper work blocks.
Plan how much time a dev task can safely take before a deadline.
Plan a deep work sprint with goals, blockers, and a focus schedule.
Plan a realistic developer day: focus time, meetings, and interruptions.
Compare two .env files and see missing, extra, and changed variables.
Estimate focus debt from meetings, interruptions, and task switches.
Build a clear incident timeline from loose notes and severity flags.
Estimate your interruption budget and protect deep work windows.
Turn meeting notes into decisions, action items, owners, and blockers.
Turn a messy meeting into a crisp prep brief with agenda and talking points.
Plan safe PR merge order, track dependencies, and identify risks.
Plan a focused pair programming session with goals and role swaps.
Find likely port conflicts and generate clean port plans.
Draft a clear incident postmortem with timeline, impact, and action items.
Estimate PR impact, review load, risk, and rollout readiness.
Turn messy branch notes into clean, conventional pull request titles.
Turn a git rebase situation into a clean step-by-step plan.
Plan the safest release window by weighing team coverage and risk.
Plan a safe production rollback: score severity, compare rollback vs hotfix.
Build a clean keyboard shortcut cheat sheet for any app or workflow.
Plan, label, and prioritize Git stashes before they pile up.
Group tasks into smart batches to reduce context switching.
Score tasks by impact, effort, urgency, and risk to find the best next action.
Plan realistic work-in-progress limits for dev and productivity workflows.
Generate a copy-ready branch handoff for developers: scope, status, risks.
Generate clean Git branch names from issue summaries and task notes.
Plan the safest way to recover a Git branch after a bad rebase or reset.
Check Git branch names, spot risky patterns, and generate a clean summary.
Analyze commits for risk, churn, and review load before merging.
Summarize git diffs into review-ready briefs with file stats and risk flags.
Simulate pre-commit, commit-msg, and pre-push hooks and estimate pass/fail.
Plan safe git reverts for commits, merge commits, and release hotfixes.
Analyze merge conflicts, classify each hunk, and generate a resolution plan.
Check whether a PR is ready to merge with risk scoring and checklist.
Plan the safest time to merge by weighing release timing and CI status.
Plan parallel git worktrees, branch names, and cleanup commands.
Audit git branches for staleness, cleanup priority, and safe next steps.
Plan a fast, sane git bisect session with suspected ranges, test signals, and a copyable command sequence.
Plan a safe git cleanup session. Prioritize stale branches, merged branches, local-only work, and risky refs.
Split a large code diff into review-friendly chunks with size estimates and ordering hints.
Estimate the risk of a code or product change, spot blast-radius issues, and generate a mitigation plan.
Parse any GitHub URL and convert between HTTPS, SSH, API, raw content, and github.dev formats.
Parse, filter, sort, and analyze git log output with author stats and search.
Build .gitattributes files visually — configure line endings, diff drivers, merge strategies, and GitHub Linguist overrides.
Paste a unified diff or patch and see per-file change statistics with visual bars.
Visual builder for ~/.gitconfig — configure user, core, aliases, merge, diff, and more.
Visualize Git branch history as a graph — see commit topology, merges, and divergence points.
Validate commit messages against the Conventional Commits spec with real-time feedback and scoring.
Compare MIT, Apache 2.0, GPL, BSD, MPL, ISC, Unlicense and more side-by-side, then generate a ready-to-use LICENSE file with your name and year.
Stamp every source file with an SPDX-License-Identifier plus a copyright notice — pick MIT, Apache 2.0, GPL, BSD, MPL, ISC, Unlicense, CC0, or paste a custom preamble. Auto-detects comment syntax from the file extension (50+ languages), preserves shebangs and UTF-8 BOMs, and can replace an existing top header instead of stacking.
Build a GitHub CODEOWNERS file rule by rule with patterns and team / user owners, then probe any file path to see which rule (and which reviewers) GitHub would route a PR to. Catches invalid @org/team handles, shadowed-by-later-rule patterns, and paths with no required owner — handles required [Section] and optional ^[Section] blocks.