Precision Developer Utilities for Web, API, Security & Android.

Format and indent raw or minified JSON strings with customizable indentation and key sorting.

Compress JSON data by removing all unnecessary whitespace, newlines, and indentation.

Validate JSON syntax according to RFC 8259 and pinpoint exact line and column errors.

Beautify complex JSON objects with key sorting, trailing comma cleanup, and human-readable formatting.

Convert JSON arrays of objects into RFC 4180 compliant CSV spreadsheets with flattened nested keys.

Parse CSV data with header detection and automatic type inference into structured JSON arrays.

Transform structured JSON objects and arrays into well-formed, indented XML documents.

Parse XML elements, attributes, and text nodes into a clean JSON object representation.

Compare two JSON payloads semantically to detect added, removed, and modified keys or values.

Escape special characters in JSON strings for embedding in code, or unescape stringified JSON.

Validate a JSON document against a JSON Schema definition (types, required fields, enums, patterns).

Explore deeply nested JSON structures interactively with collapsible nodes, data types, and JSONPath copying.

Count words, sentences, paragraphs, reading time, speaking time, and top keyword density.

Analyze character counts with and without spaces, UTF-8 byte length, grapheme clusters, and social limits.

Convert strings between camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, Title Case, and more.

Eliminate duplicate lines from lists or logs with case-sensitivity and whitespace trimming controls.

Sort multi-line text alphabetically (A–Z or Z–A), numerically, by line length, or shuffle randomly.

Compare two blocks of text or source code line-by-line with highlighted additions and deletions.

Search and replace text patterns across multi-line content with Regular Expression and capture group support.

Generate placeholder paragraphs, sentences, or words for UI prototyping and typography layouts.

Write GitHub-Flavored Markdown and preview sanitized HTML output alongside raw HTML source code.

Convert reserved HTML characters (&, <, >, ", ') and symbols into named or numeric HTML entities and back.

Reverse characters in a string, reverse word order, or flip line order from bottom to top.

Convert article titles and strings into clean, SEO-friendly URL slugs with diacritic transliteration.

Strip trailing spaces, collapse multiple spaces, remove blank lines, and normalize tabs to spaces.

Encode UTF-8 text to standard or URL-safe Base64 and decode Base64 payloads without data corruption.

Percent-encode and decode URI components and full query strings according to RFC 3986.

Encode and decode HTML markup into safe character references to prevent XSS injection.

Decode JSON Web Tokens (JWS) locally to inspect Header, Payload claims, issued/expiry timestamps, and algorithm.

Convert text characters to Unicode escape sequences (\uXXXX, U+XXXX, HTML hex) and back to plain text.

Convert UTF-8 strings into hexadecimal byte representations and decode hex dumps back into readable text.

Translate text strings into 8-bit binary byte sequences (01000001) and decode binary back to UTF-8 text.

Convert characters to decimal ASCII / UTF-8 byte codes and decode numeric ASCII arrays into strings.

Apply ROT13 letter substitution cipher (and ROT47 ASCII variant) to obfuscate or reveal text.

Compute cryptographic SHA-256 digests in hex and Base64 using the native browser Web Crypto API.

Compute 512-bit SHA-512 cryptographic digests in hexadecimal and Base64 formats locally.

Generate 128-bit RFC 1321 MD5 checksums locally for legacy file verification and cache keys.

Generate cryptographically random RFC 4122 UUID v4 identifiers in bulk with formatting options.

Generate Universally Unique Lexicographically Sortable Identifiers (ULID) with 48-bit timestamp and 80-bit randomness.

Generate cryptographically random alphanumeric strings, API keys, nonces, and hex tokens.

Generate high-entropy passwords and passphrases using browser CSPRNG with real-time entropy bit calculation.

Create customizable high-resolution QR codes for URLs, Wi-Fi credentials, vCards, or text with PNG/SVG export.

Test Regular Expressions in real time with match highlighting, capture group extraction, and flag controls.

Build and explain 5-field standard cron schedules with human-readable descriptions and next 5 execution times.

Convert between ISO 8601 dates, RFC 2822, UTC, local timezones, and millisecond/second epochs.

Convert Unix epoch timestamps (seconds, milliseconds, nanoseconds) to human-readable dates and vice versa.

Convert integers of arbitrary size (BigInt) between Binary (2), Octal (8), Decimal (10), Hexadecimal (16), and Base36.

Interactive studio color picker with WCAG 2.1 contrast ratio checker, shade/tint scale generator, and CSS variables.

Convert colors accurately between HEX, HEX8, RGB, RGBA, HSL, HSLA, HWB, and CSS oklch/lab notations.

Design linear, radial, and conic CSS gradients with live preview, angle control, and cross-browser CSS code.

Create layered, smooth CSS box-shadows with customizable offsets, blur, spread, inset, and opacity.

Quickly strip comments, whitespace, and redundant semicolons from CSS stylesheets with compression metrics.

Prettify and indent nested HTML5 markup with clean tag alignment and attribute preservation.

Format minified or messy CSS stylesheets with consistent 2-space indentation and rule spacing.

Format and indent JavaScript ES2024+ code blocks, functions, and object literals for readability.

Format TypeScript interfaces, types, generics, and modules with clean indentation and semicolon normalization.

Compress HTML documents by removing comments, collapsing inter-tag whitespace, and trimming attributes.

Minify CSS stylesheets for production by removing comments, spaces, and trailing semicolons.

Compact JavaScript code by stripping single/multi-line comments and collapsing non-essential whitespace safely.

Generate complete HTML5 SEO meta tags including title, description, canonical, robots, viewport, and charset.

Create Open Graph (og:*) and Twitter Card meta tags with live social card preview.

Generate valid robots.txt crawler directives with User-agent rules, Allow/Disallow paths, Crawl-delay, and Sitemap links.

Generate standard sitemaps.org XML sitemaps from a list of URLs with lastmod, changefreq, and priority attributes.

Create crisp multi-resolution PNG favicons (16x16, 32x32, 180x180 Apple Touch, 192x192, 512x512) from text, initials, or SVG.

Inspect current viewport metrics, device pixel ratio, Tailwind breakpoint status, and simulate common device dimensions.

Deconstruct any URL into protocol, hostname, port, pathname, hash, and a structured table of decoded query parameters.

Parse HTTP User-Agent strings to identify browser name/version, rendering engine, operating system, CPU architecture, and device type.

Full-featured HTTP client supporting GET, POST, PUT, PATCH, DELETE, custom headers, query params, JSON/raw bodies, timing, and request history.

Construct raw RFC 9110 HTTP/1.1 request messages and generate matching Fetch, Axios, Python Requests, and Go net/http snippets.

Parse raw HTTP request/response header blocks or inspect live URL response headers with security & caching explanations.

Searchable reference of HTTP 1xx–5xx status codes with RFC 9110 definitions, retry semantics, and typical API use cases.

Format raw API responses, extract nested data envelopes, inspect field types, and generate TypeScript interfaces automatically.

Convert cURL command lines (-X, -H, -d, --data-raw, -u) into clean modern JavaScript/TypeScript `fetch()` calls.

Transform cURL commands into async/await Fetch, Axios, and Node.js `https` request implementations.

Convert JavaScript `fetch(url, options)` snippets into portable shell-escaped cURL commands.

Inspect webhook JSON payloads (Stripe, GitHub, Slack, Generic), verify HMAC signatures, and extract event metadata.

Analyze IPv4 and IPv6 addresses locally (CIDR range, subnet mask, binary notation, RFC scope) with optional geo/ASN lookup.

Query DNS records (A, AAAA, CNAME, MX, TXT, NS) via DNS-over-HTTPS (DoH) RFC 8484 JSON endpoints.

Check HTTP status codes, redirect chains, response latency, and headers via our SSRF-protected server endpoint.

Evaluate password entropy in bits, character pool diversity, pattern weaknesses, and offline crack-time estimates.

Generate SHA-1, SHA-256, SHA-384, and SHA-512 cryptographic digests simultaneously using Web Crypto API.

Compute Hash-based Message Authentication Codes (HMAC-SHA256, HMAC-SHA384, HMAC-SHA512) with a secret key.

Authenticated AES-256-GCM client-side encryption and decryption using PBKDF2 (100,000 iterations) key derivation.

Generate 2048-bit or 4096-bit RSA-OAEP / RSASSA-PKCS1-v1_5 public and private key pairs in PEM (SPKI / PKCS#8) and JWK formats.

Deep security audit of JSON Web Tokens including HMAC-SHA256 signature verification, `alg: none` detection, and claim lifetime checks.

Generate CSPRNG 128-bit, 192-bit, 256-bit, and 512-bit cryptographic keys in Hex, Base64, Base64URL, and Uint8Array formats.

Inspect PEM-encoded X.509 certificates (-----BEGIN CERTIFICATE-----), compute SHA-256/SHA-1 fingerprints, and parse ASN.1 DER structures.

Interactive reference and generator for CSP, HSTS, X-Frame-Options, X-Content-Type-Options, Referrer-Policy, and Permissions-Policy.

Interactive OWASP ASVS / Top 10 security readiness checklist for Web, API, Mobile, and Cloud deployments with Markdown export.

Compress PNG, JPEG, and WebP images locally using HTML5 Canvas with adjustable quality slider and before/after size comparison.

Resize images to exact pixel dimensions or percentage scales with aspect-ratio locking and high-quality bicubic smoothing.

Crop images to custom X/Y/Width/Height coordinates or aspect ratio presets (1:1, 16:9, 4:3, 3:2) in the browser.

Convert transparent or opaque PNG images to JPEG format with configurable background fill color and quality.

Convert JPEG photographs and graphics into lossless 32-bit PNG images in the browser.

Convert PNG, JPG, or SVG images into modern high-efficiency WebP format (or WebP back to PNG).

Convert image files into `data:image/...;base64` Data URLs, HTML `<img>` tags, and CSS `background-image` snippets, or decode Base64 to image.

Inspect image file properties, intrinsic dimensions, aspect ratio, color depth, MIME signature (magic bytes), and EXIF header segments locally.

Render and inspect raw SVG vector code with zoom, background grid toggle, viewBox analysis, and PNG rasterization.

Clean and minify SVG files by stripping XML comments, editor metadata (Inkscape/Illustrator), empty groups, and redundant whitespace.

Scan QR codes in real time using your device camera (front/rear) or decode uploaded QR images locally in the browser (`jsQR`).

Analyze AndroidManifest.xml files to extract package name, SDK versions, permissions, exported activities, services, receivers, and deep links.

Complete reference table of Android API Levels (API 21 Lollipop to API 35 Vanilla Ice Cream / Android 15), codenames, NDK levels, and behavior changes.

Validate Android `applicationId` and Java/Kotlin package names against Google Play Store and JVM reserved keyword rules.

Inspect local `.apk` files in the browser: list ZIP entries, DEX count, native `.so` ABIs, V1/V2/V3 signature blocks, and extract binary XML strings.

Inspect local Android App Bundle (`.aab`) archives: analyze modules (`base`, dynamic features), `BundleConfig.pb`, native libraries, and asset packs.

Searchable catalog of Android Manifest permissions with protection levels (`normal`, `dangerous`, `signature`), runtime prompt groups, and API level requirements.

Convert Android density-independent pixels (dp/dip) to physical pixels (px) across ldpi, mdpi, hdpi, xhdpi, xxhdpi, and xxxhdpi buckets.

Convert physical screen pixels (px) into Android density-independent pixels (dp) for any source DPI bucket.

Calculate scaled pixels (sp) to physical pixels across screen densities and user accessibility font scale factors (0.85x to 2.0x).

Convert hex colors into Android XML `<color>` resources and Jetpack Compose `Color(0xFF...)` Kotlin declarations.

Convert JSON or key-value translation lists into properly escaped Android `res/values/strings.xml` resource files.

Generate complete Material 3 light and dark `values/colors.xml` palettes from seed brand colors.

Generate Material 3 DayNight `values/themes.xml` and `values-night/themes.xml` boilerplate with status bar and edge-to-edge attributes.

Convert Maven coordinates (`group:artifact:version`) between Groovy DSL, Kotlin DSL (`build.gradle.kts`), and Gradle Version Catalogs (`libs.versions.toml`).

Compute monotonic integer Android `versionCode` values from Semantic Versions (`major.minor.patch`) and ABI/SDK splits.

Generate Android App Links `<intent-filter android:autoVerify="true">`, Digital Asset Links `assetlinks.json`, and `adb shell am start` test commands.

Generate tailored `.gitignore` files for Node.js, Next.js, TypeScript, Python, Go, Rust, Android, macOS, Windows, and JetBrains/VSCode.

Interactive reference of essential and advanced Git commands for branching, rebasing, stashing, cherry-picking, bisecting, and undoing mistakes.

Generate professional open-source `README.md` documentation with architecture overview, installation steps, usage examples, and license sections.

Convert CSV, TSV, or JSON arrays into neatly aligned GitHub-Flavored Markdown tables with column alignment controls.

Parse Conventional Commits (`feat:`, `fix:`, `perf:`, `BREAKING CHANGE`) into a Keep a Changelog compliant `CHANGELOG.md` release entry.

Validate SemVer 2.0.0 strings, calculate major/minor/patch/prerelease bumps, compare version precedence, and test npm range constraints (`^`, `~`).

Convert standard GitHub `blob` file URLs into direct `raw.githubusercontent.com` URLs, jsDelivr CDN links, and `curl -fsSL` download commands.

Fetch public GitHub repository metadata (stars, forks, open issues, default branch, license, size, topics) via the GitHub REST API.

Generate official SPDX open-source software licenses (MIT, Apache 2.0, GPL-3.0, BSD-3-Clause, ISC, MPL-2.0, Unlicense) with custom copyright.

Format, indent, and lint `.github/workflows/*.yml` CI/CD pipelines for valid `on`, `permissions`, `concurrency`, and `jobs` structure.

Prettify complex SQL queries (SELECT, JOIN, WHERE, GROUP BY, CTEs) with uppercase keyword normalization and clean clause indentation.

Compress multi-line SQL queries and strip `--` or `/* */` comments into a single-line statement.

Perform static syntax validation and anti-pattern linting on SQL statements (unbalanced quotes/parens, `SELECT *`, missing `WHERE` on `DELETE`/`UPDATE`).

Parse SQL `INSERT INTO` statements or ASCII table query outputs (`+---+---+`) into structured JSON arrays.

Generate `CREATE TABLE` DDL schemas and batched `INSERT INTO` statements from a JSON array of objects.

Format and validate MongoDB filter queries and aggregation pipelines (`$match`, `$group`, `$lookup`, `$project`).

Generate valid 24-character hex BSON ObjectIds (4-byte unix timestamp + 5-byte random process value + 3-byte incrementing counter).

Extract the embedded creation UTC timestamp, machine/process identifier hex, and counter from any 24-char MongoDB ObjectId.

Format and audit `firestore.rules` security rules with clean indentation and warnings for overly permissive `allow read, write: if true` rules.

Parse PostgreSQL, MySQL, MongoDB, and Redis connection URIs into host, port, user, database, and SSL parameters with passwords masked by default.

Build structured CO-STAR / RISEN prompts (Role, Context, Objective, Constraints, Output Format) locally or enhance with server-side Gemini.

Transform vague one-line prompts into unambiguous, constraint-driven instructions with explicit evaluation criteria.

Construct production `systemInstruction` definitions with persona boundaries, tool-use rules, JSON output schemas, and refusal guardrails.

Wrap complex code snippets into a structured prompt requesting time/space complexity (Big-O), data flow trace, and edge-case analysis.

Combine error stack traces, reproduction steps, and source code into a root-cause analysis prompt.

Generate a staff-level PR review prompt focusing on concurrency hazards, security vulnerabilities (XSS/SQLi/SSRF), type safety, and maintainability.

Create a comprehensive prompt from your `package.json` or file tree to generate developer documentation.

Generate end-to-end full-stack architectural specification prompts covering Tech Stack, Data Model, API Routes, UI States, and Security.

Estimate subword token count, character-to-token ratio, context window utilization %, and API cost across Gemini, GPT, and Claude models.

Curated library of battle-tested engineering prompt templates with `{{variable}}` interpolation for Architecture, SQL Optimization, Regex, and Threat Modeling.