generator

Generate a structured JSON route config and Markdown docs stub from a list of routes.

Generate a full OpenAPI 3.1 YAML document from a list of paths and an auth scheme.

Generate a Swagger 2.0 YAML document with example responses, for Swagger UI.

Build a valid Postman Collection v2.1 JSON file from a list of requests.

Generate GraphQL SDL types, queries, and mutation stubs from a described data model.

Render a short piece of text as large block letters made of # characters.

Output the full ASCII character set as text, filtered to printable, control, or all 128 codes.

Turn newline/comma/tab-delimited data into a bordered ASCII text table with auto-sized columns.

Plot an outward Archimedean spiral onto a grid using a chosen ASCII character.

Build a regex that matches exactly a given set of ASCII literal strings, via alternation.

Turn a 2-space or tab-indented list into a Unix tree-style ASCII directory diagram.

Plot a sine wave as ASCII art across a configurable width, height, and frequency.

Validate strict-ASCII input, then layer random Unicode combining marks onto it for a zalgo effect.

Generate pronounceable fake 'words' from ASCII consonant/vowel syllables for placeholder text.

Generate a random string of a chosen length, sampled from a chosen ASCII code range.

Generate a random sample string matching a regex pattern, guaranteed strict printable ASCII.

Build a BIND-style DNS zone file from SOA fields and a list of resource records.

Generate domain name ideas from a keyword by combining prefixes, suffixes, and TLDs.

Generate a paragraph of pseudo-random filler text and download it as a .txt file.

Randomly corrupt a percentage of characters in a text file to simulate bit rot or a bad download.

Download a zero-byte placeholder file with any filename you choose.

Generate a file of cryptographically random bytes and download it as .bin, with a hex preview.

Generate a random hexadecimal string of a chosen length using your browser's secure random number generator.

Generate a random sample string and its 512-bit Whirlpool digest, entirely in your browser.

Generate a random sample string and its withdrawn SHA-0 digest, entirely in your browser.

Generate a random sample string and its SHA3-224/256/384/512 digests, entirely in your browser.

Generate a random sample string and its 224-bit SHA3-224 digest, entirely in your browser.

Generate a random sample string and its 256-bit SHA3-256 digest, entirely in your browser.

Generate a random sample string and its 384-bit SHA3-384 digest, entirely in your browser.

Generate a random sample string and its 512-bit SHA3-512 digest, entirely in your browser.

Generate a random sample string and its NTLM password hash, entirely in your browser.

Generate a random sample string and its 256-bit BLAKE3 digest, entirely in your browser.

Generate a random sample string and its 32-bit Adler-32 checksum, entirely in your browser.

Generate a random sample string and its raw Keccak-256 digest, entirely in your browser.

Generate a random sample string and its 64-byte SHAKE256 output, entirely in your browser.

Generate a random sample string and its BLAKE2b digest, entirely in your browser.

Generate a random sample string and its original BLAKE-256 digest, entirely in your browser.

Generate a random sample password and salt, and their bcrypt hash, entirely in your browser.

Generate a random sample password and its legacy MySQL PASSWORD() hash, entirely in your browser.

Generate a random sample password and its legacy MariaDB PASSWORD() hash, entirely in your browser.

Generate a random sample username and password, and their Postgres md5 password hash, entirely in your browser.

Generate a random sample username and password, and their MONGODB-CR hash, entirely in your browser.

Generate a random sample string and its 160-bit SHA-1 digest, entirely in your browser.

Generate a random sample string and its 256-bit SHA-256 digest, entirely in your browser.

Compute MD5, SHA-1, SHA-256, SHA-384, SHA-512, SHA3-256, RIPEMD-160, CRC32, and BLAKE3 for one input at once.

Compute an HMAC (MD5, SHA-1, SHA-256, SHA-384, or SHA-512) for a message and secret key.

Compute MD5, SHA-1, SHA-256, or SHA-512 for multiple uploaded files at once, entirely in your browser.

Generate a random hex value with a custom length, case, prefix, and digit grouping.

Generate a full rows x columns ASCII hex grid, each cell labeled with its sequential hex index.

Generate a run of consecutive hex values from a start value, with custom separator and padding.

Arrange consecutive hex values into a square ASCII grid, filled in clockwise spiral order.

Generate a decorative ASCII-art zigzag of consecutive hex values, indentation tracing a wave.

Render a simplified illustrative triangle-strip net for a hexaflexagon, labeled with hex digits.

Procedurally generate one example connected polyhex (N edge-connected hexagons) as ASCII art.

Generate realistic fake JSON data from a template whose values are type-hint keywords.

Deliberately corrupt valid JSON with random syntax mutations for testing error handling.

Generate a random flat JSON array of numbers, strings, booleans, or a mix.

Generate a random flat JSON object with a chosen number of realistic-looking keys.

Build a Markdown table in an editable grid, no manual pipe alignment.

Fill in link text, a URL, and an optional title to get valid Markdown link syntax.

Build Nginx rewrite and redirect rules from a list of from/to paths.

Build a CIDR-based allow or deny list for Nginx, HAProxy, or iptables.

Build firewall rules for UFW, iptables, or nftables from port/protocol/source/action rows.

Generate an RSA or ECDSA key pair with the Web Crypto API and export it as standard PEM.

Build a JWT from a JSON payload and sign it with HS256, HS384, or HS512.

Generate live RFC 6238 TOTP codes from a Base32 secret, or create a new secret with a scannable QR code.

Build a Content-Security-Policy header as the exact config snippet for Nginx, Apache, Express, or Next.js.

Build a CORS configuration as real syntax for Express, Next.js, Nginx, Apache, or Spring Boot.

Generate raw HTTP security header lines: HSTS, X-Frame-Options, Permissions-Policy rows, and COOP/COEP.

Build a ~/.ssh/config file from repeatable Host blocks: alias, HostName, User, Port, IdentityFile, ProxyJump.

Get the exact local ssh-keygen command for Ed25519 or RSA, with your chosen comment and filename. Commands only, no key material.

Generate a hardened TLS config (protocols, ciphers, session settings) for Nginx, Apache, HAProxy, or Caddy, per Mozilla's SSL profiles.

Generate a high-entropy HMAC secret sized correctly for HS256, HS384, or HS512, output as hex and base64.

Get the exact local openssl req command to generate a CSR and private key for your subject, key type, and SANs. Commands only, no key material.

Convert plain text into Unicode Mathematical Bold letters and digits.

Convert plain text into flowing Unicode Mathematical Script (cursive) letters.

Generate classic lorem-ipsum-style placeholder paragraphs.

Convert plain text into Unicode Mathematical Italic letters.

Generate a random string with a chosen length and character sets.

Generate a random sample string that matches a regex pattern.

Generate a self-contained HTML+CSS snippet that scrolls text horizontally.

Convert digits and a small set of letters into real Unicode subscript characters.

Convert digits, letters, and a few symbols into real Unicode superscript characters.

Convert plain text into fancy Unicode letters: bold, italic, script, double-struck, or fullwidth.

Generate filler text that is exactly N characters long.

Generate a self-contained scrolling marquee banner as an HTML/CSS snippet.

Add a strikethrough effect to plain text using a Unicode combining overlay mark.

Underline plain text using the Unicode combining low line character.

Convert text into tiny, condensed Unicode characters popular on social media.

Turn text into creepy, glitchy 'zalgo' text using random Unicode combining marks.

Generate random UUIDs (v4 or v7) or validate one and inspect its version and variant.

Generate short, random, human-friendly IDs with an unambiguous character set.

Generate ULIDs: 26-character, timestamp-prefixed, lexicographically sortable IDs.

Generate compact, URL-safe unique IDs with a customizable length and alphabet.

Generate CUID2-format IDs: a lowercase letter followed by random base36 characters.

Generate random API keys with a custom prefix, length, and character set.

Generate memorable, high-entropy passphrases from the EFF's short Diceware word list.

Generate random adjective-noun usernames with optional numbers and case styles.

Generate strong, random passwords with crypto.getRandomValues(), no modulo bias, with an entropy estimate.

Generate a real, scannable QR code from text, or decode one from an uploaded image.

Generate a real, scannable 1D barcode (CODE128, EAN-13, UPC, ITF-14, and more) from text.

Generate realistic-looking random YAML for testing and demos.

Fill in a form to generate a complete Kubernetes Deployment manifest, with env vars, resources, probes, and rolling updates.

Generate a Kubernetes Service manifest for ClusterIP, NodePort, LoadBalancer, or headless service types.

Generate a Kubernetes Ingress manifest with host/path routing rules, TLS, and common controller annotations.

Generate a Kubernetes ConfigMap manifest from key/value pairs or a single file's contents.

Generate a Kubernetes Secret manifest (Opaque, TLS, or Docker config) from plain-text key/value entries.

Generate a Kubernetes HorizontalPodAutoscaler (autoscaling/v2) manifest targeting a Deployment by CPU and/or memory utilization.

Generate a Kubernetes PodDisruptionBudget manifest with either minAvailable or maxUnavailable, as a count or percentage.

Generate a Kubernetes ResourceQuota manifest capping a namespace's compute requests/limits and object counts.

Generate a Kubernetes Namespace manifest with repeatable labels and annotations.

Generate a raw, standalone Kubernetes Pod manifest with a custom command, ports, env vars, and restart policy.

Build a Kubernetes PersistentVolume manifest with hostPath or NFS storage, access modes, and a reclaim policy.

Build a Kubernetes PersistentVolumeClaim manifest with access modes, storage size, storage class, and an optional selector.

Build a Kubernetes StatefulSet manifest with a headless service name, replicas, a volumeClaimTemplate, and a pod management policy.

Build a Kubernetes DaemonSet manifest with env vars, a node selector, tolerations, and an update strategy.

Build a Kubernetes Job manifest with a command, parallelism, completions, backoff limit, and a restart policy.

Build a Kubernetes CronJob manifest with a cron schedule, concurrency policy, and history/deadline limits.

Build a Kubernetes NetworkPolicy manifest with pod/namespace selectors, IP block rules, and separate ingress/egress rules.

Build a Kubernetes Role or ClusterRole with rules, plus its matching RoleBinding or ClusterRoleBinding.

Build a starter Helm values.yaml with image, service, ingress, resources, env vars, and a secrets placeholder block.

Build a kustomization.yaml with a resources list, optional bases, commonLabels, a namespace override, and a configMapGenerator.

Generate a Kubernetes ServiceAccount manifest with labels, annotations, token automounting, and image pull secrets.

Build a multi-service docker-compose.yml from a form: ports, volumes, env vars, healthchecks, and resource limits.

Generate a single-stage Dockerfile from a language preset: WORKDIR, install steps, EXPOSE, non-root user, and CMD.

Generate a two-stage Dockerfile: a build stage with your toolchain and a minimal runtime stage that copies only the build output.

Generate a .dockerignore file from a stack preset so node_modules, .git, .env, and build artifacts never reach your build context.

Generate a docker stack deploy YAML with replicas, rolling update_config, placement constraints, an overlay network, and secrets.

Generate a Compose/Swarm secrets block (file-based or external), a service reference, and a BuildKit --secret build snippet.

Generate a matching Dockerfile HEALTHCHECK directive and Compose healthcheck block from a curl, script, or TCP test.

Generate standard org.opencontainers.image.* LABEL lines plus custom labels, as both Dockerfile and Compose syntax.

Build a .gitlab-ci.yml with stages, jobs, caching, artifacts and branch rules, no YAML by hand.

Build a declarative Jenkinsfile with an agent, stages, environment variables and a post block.

Build a .circleci/config.yml with a Docker executor, jobs, a workflow, and optional orbs.

Build an azure-pipelines.yml with triggers, a pool, stages, variables and common tasks.

Build a bitbucket-pipelines.yml with default steps, branch pipelines, caches and a PR pipeline.

Build a Buildkite pipeline.yml with steps, agent targeting, a wait step and manual approval.

Build a .drone.yml Docker pipeline with steps, volumes, and from_secret references.

Build a .travis.yml with a language/version matrix, install/script steps, stages and deploy.

Generate a starter main.tf with a provider block, one resource, a variable, and an output for AWS, Azure, or Google Cloud.

Generate a reusable Terraform module's file set: main.tf, variables.tf, outputs.tf, and a README usage snippet.

Generate a variables.tf file with typed variable blocks, defaults, descriptions, sensitivity, and validation rules.

Generate a terraform.tfvars file with correctly formatted string, number, bool, list, and map values.

Generate an outputs.tf file with repeatable output blocks: name, value expression, description, and a sensitive toggle.

Generate a Terraform backend block for S3 with DynamoDB locking, GCS, Kubernetes, or Postgres remote state.

Generate a basic Pulumi program skeleton in TypeScript, Python, Go, C#, or YAML for AWS, Azure, or GCP.

Generate a playbook.yml with a hosts group, vars, repeatable tasks (apt/copy/service/template), and a wired-up restart handler.

Generate a Chef recipe.rb with repeatable package/service/template/file resources and node attribute references.

Generate a Puppet .pp manifest: a class wrapping repeatable package/service/file resources, variables, and an if/else example.

Build a valid AWS IAM policy JSON document from Allow/Deny statements without hand-writing the JSON.

Generate an EC2 instance's user data as a bash script or cloud-init YAML, with packages, a user, and hostname.

Generate an S3 bucket policy JSON with HTTPS enforcement, KMS encryption enforcement, and a custom access statement.

Build EC2 security group ingress/egress rules as JSON, with one-click presets for SSH, HTTP, HTTPS, Postgres, and MySQL.

Generate a starter CloudFormation template with Parameters, one Resource block, and Outputs, in YAML or JSON.

Generate an ECS task definition JSON with one or more containers, port mappings, env vars, and awslogs logging.

Generate a Lambda function configuration template with handler, runtime, memory/timeout, env vars, VPC, and DLQ settings.

Build a prometheus.yml with global intervals, repeatable scrape configs, alerting, and remote_write.

Build a Grafana dashboard JSON model from a form: panels, PromQL queries, grid layout, and a templating variable.

Build an alertmanager.yml with routing, repeatable Slack/PagerDuty/email/Teams receivers, and inhibit rules.

Build a Loki config YAML with auth, a filesystem/S3/GCS storage backend, and ingestion/retention limits.

Build a Grafana Tempo config YAML with an OTLP/Jaeger/Zipkin receiver, a storage backend, and metrics-generator.

Build an otel-collector-config.yaml with OTLP receivers, batch/memory_limiter processors, and a wired pipeline.

Build a fluent.conf with a source, record_transformer filter, and elasticsearch/loki/kafka/s3 output.

Build a fluent-bit.conf with SERVICE, INPUT, FILTER, and OUTPUT sections, plus optional TLS.

Build a logstash.conf with input {}, filter {} (grok + mutate), and output {} blocks.

Build a vector.toml with a source, a VRL remap transform, and an elasticsearch/loki/console sink.

Generate a postgresql.conf with key connection, memory, and logging settings plus a matching pg_hba.conf.

Generate the [mysqld] section of my.cnf: server-id, buffer pool, connections, charset, and binary logging.

Generate a mongod.conf YAML file: networking, authorization, WiredTiger cache, replication, and logging.

Generate a redis.conf: networking, maxmemory + eviction policy, RDB/AOF persistence, and ACL user lines.

Generate rabbitmq.conf, a matching definitions.json, and commented clustering hints from one form.

Generate server.properties with core broker settings, toggling between KRaft mode and legacy ZooKeeper mode.

Build a valid package.json with scripts, dependencies, and engine constraints filled in through a form.

Generate a tsconfig.json tuned for a React app, Node backend, or publishable library.

Generate an ESLint 9 flat config for React, Node, or TypeScript with plugins and rule overrides.

Generate a .prettierrc and matching .prettierignore from printWidth, quotes, semicolons, and trailing commas.

Generate a babel.config.js with preset-env browserslist targets, preset-react, preset-typescript, and plugins.

Generate a vite.config.ts with a framework plugin, path aliases, dev-server proxy rules, and build options.

Generate a webpack.config.js with entry/output, mode, babel-loader/css-loader rules, devServer, and plugins.

Generate a rollup.config.js with ESM + CJS output, externals, and typescript/node-resolve/commonjs plugins.

Generate Husky v9 .husky/pre-commit and .husky/commit-msg scripts plus the package.json prepare line.

Generate a commitlint.config.js extending @commitlint/config-conventional with custom type/scope enums.

Generate a lint-staged config mapping glob patterns to command arrays, as .lintstagedrc.json or a package.json block.

Generate a .editorconfig file with per-glob indent style, indent size, charset, line endings, and whitespace rules.

Generate a jest.config.js or vitest.config.ts with test environment, coverage, setup files, and path aliases.

Combine Node, Python, Java, .NET, Go, Rust, React/Next.js and IDE presets into one .gitignore.

Build a GitHub Actions workflow with triggers, a job, a matrix strategy and permissions.

Generate a pre-commit, commit-msg or pre-push hook script for native Git or Husky v9.

Build a properly formatted Conventional Commits message from type, scope, subject and body.

Paste commit messages or PR titles and group them into a Markdown release notes document.

Generate a tailwind.config.ts with content globs, theme colors/fonts, dark mode, and official plugins.

Generate a next.config.mjs with reactStrictMode, image remote patterns, security headers, redirects, and rewrites.

Generate a .env file with the correct CRA/Vite/Next.js prefix, plus a matching Zod validation schema.

Generate an angular.json build target snippet with outputPath, size budgets, environment file replacement, and a serve proxy.

Generate a svelte.config.js with the right adapter (node/vercel/static) and a matching CSP example for that host.

Generate the right Vue config for your version: vite.config.ts (Vue 3) or vue.config.js (Vue 2), with aliases and proxy.

Generate a .env file for an OpenAI app plus a matching Python or Node.js client-init snippet.

Generate a LangChain RunnableConfig with tags, callbacks, a tools list, retries, and a timeout.

Generate a docker-compose.yml for a local Ollama service, with an optional NVIDIA GPU reservation.

Generate an mcpServers JSON block for a stdio-based Model Context Protocol server.

Generate a Hugging Face .env plus a local transformers pipeline or Inference Endpoint snippet.

Generate connection/setup code for Pinecone, Qdrant, Chroma, or pgvector, each with its own real fields.

Build a .env or .env.example file from key/value rows, grouped into sections, with framework-aware notes.

Generate an AES-256 key and IV for one secret env var, with matching openssl, Node, and PowerShell decrypt commands.

Generate AWS Secrets Manager CLI commands, Kubernetes External Secrets YAML, or Vault kv commands for one named secret.

Build a Cloudflare Pages _headers file from repeatable path-pattern and header rows.

Build a Cloudflare Pages _redirects file from repeatable from/to/status rows, an SPA fallback, and a domain redirect.

Build a wrangler.toml with name, entry point, routes, KV/D1 bindings, and a [vars] block.

Generate a Cloudflare Pages _headers snippet with HSTS, CSP, Referrer-Policy, and more, with sensible defaults.

Generate Cache-Control _headers rules per asset type: static assets, HTML, API JSON, images, and fonts.

Generate a robots.txt for a production Cloudflare Pages domain (allow + sitemap) or a pages.dev staging subdomain (disallow all).

Build a Content-Security-Policy header string for Cloudflare Pages, with toggles for common sources and a report-only mode.

Generate the combined robots.txt + _headers + _redirects to stop a pages.dev staging subdomain from being indexed.

Paste your robots.txt, classify AI vs search crawlers, and get a suggested allow/block policy plus an llms.txt skeleton.

Generate an Nginx server block with an upstream pool, WebSocket, gRPC, and caching toggles.

Generate the Certbot install and certonly commands for Nginx or Apache.

Generate Certbot's renewal systemd timer and an equivalent cron entry.

Generate a TCP or HTTP load balancer config for Nginx, HAProxy, or a Kubernetes LoadBalancer Service.

Generate a rate limiting config for Nginx (limit_req), HAProxy (stick-table), or Traefik (ratelimit).

Generate an Apache VirtualHost with ServerName, DocumentRoot, an SSL toggle, and ProxyPass.

Generate a Caddyfile with automatic HTTPS, a reverse_proxy target, file_server, and headers.

Generate an haproxy.cfg with global/defaults, a Host-header ACL frontend, and a balanced backend.

Generate a Traefik static config (entryPoints + provider) or a dynamic routers/services YAML.

Generate a systemd unit file with Restart policy, sandboxing (ProtectSystem/NoNewPrivileges/PrivateTmp), and WantedBy.

Build a cron schedule line from minute/hour/day/month/weekday fields, with common presets, flock locking, and log redirection.

Generate a Bash script skeleton with set -euo pipefail, an error/cleanup trap, getopts argument parsing, and a logging function.

Generate a portable /bin/sh script skeleton with set -eu and getopts, avoiding bashisms so it runs on Alpine/BusyBox ash and dash.

Render a short sequence of random-frequency oscillator tones and download it as a WAV file.

Generate random bytes and base64-encode them with the browser's real btoa() — both input and output shown.

Generate a random integer shown in base-2, with a configurable bit length.

Generate a random cartoon bird SVG with a random body shape, wing tilt, feather color, and beak color.

Generate a string of N random bits, each independently 0 or 1.

Generate a random-noise bitmap image at any size, in full color or monochrome, and download it as a PNG.

Generate a batch of random true/false boolean values, each with an independent 50/50 chance.

Generate a random document and hand-encode it as real BSON bytes, shown as a hex dump alongside a JSON preview.

Generate N random bytes (0-255), shown as hex pairs, a decimal array, or comma-separated decimal values.

Generate a random cartoon cat face SVG with a random ear shape, fur color/pattern, eye color, and whiskers.

Pick a random name for a cat from a built-in list of common cat names.

Play out a random chess game from the standard opening position using real piece-movement rules, N plies at a time.

Generate a random, sanity-checked arrangement of chess pieces as FEN notation and a visual board.

Generate a random circle with random radius, position, and fill/stroke color, as an SVG.

Generate random real-world city names spanning every inhabited continent.

Generate a random color and see its hex, RGB, and HSL values together with a visual swatch — constrain to pastel, vivid, or dark.

Generate pairs of positive integers (a, b) with gcd(a, b) = 1, within a configurable range.

Generate random real country names from a curated list of about 160 countries.

Generate a random crossword grid from a small built-in word list using simple greedy intersection placement, with a structural clue list.

Generate a random CSV file with a chosen number of rows and typed columns (name, number, boolean, date).

Generate random cylindrical (r, θ, z) coordinate triples, with the angle in degrees or radians.

Generate a random date within a configurable min/max range, in ISO or locale-style format.

Generate random base-10 decimal numbers with a configurable integer digit count and decimal place count.

Generate a list of random single digits from 0 to 9, one per line.

Generate pairs of two independent random digits (0-9), one pair per line.

Pick one random digit from a pool you supply, or the default 0-9 range.

Generate a random cartoon dog face SVG with random floppy or erect ears, fur color, and snout shape.

Pick a random name for a dog from a built-in list of common dog names.

Play out N random non-capturing checkers moves from the standard setup and see the move list plus final board.

Generate a random arrangement of checkers pieces on the dark squares of an 8x8 board, with a configurable piece count.

Generate random email addresses at RFC 2606 reserved example domains, safe for test data.

Generate random Unicode pictographic emoji from a built-in list, like 😀🎉🚀.

Generate random text-based emoticons and kaomoji from a built-in list, like :) and (╯°□°)╯︵ ┻━┻.

Generate a random linear or quadratic equation with one unknown, plus its solved value(s) of x.

Generate random even integers within a min/max range, one or many at a time.

Generate a random .xlsx workbook with a header row and randomly typed text, number, and date columns.

Generate an abstract, geometric cartoon avatar face with a random head shape, eye style/color, nose, mouth, and hair.

Generate a random flower SVG with a configurable petal count, random petal color/shape, a center, and a stem.

Generate random fractions a/b with configurable numerator/denominator bounds, optionally reduced to lowest terms.

Generate a random mathematical function definition, like "f(x) = 2x^2 - 3x + 1".

Generate random (latitude, longitude) pairs within valid Earth bounds, with configurable precision.

Simulate N random alternating Go moves with a simplified single-stone capture check, on a configurable board size.

Generate a random arrangement of black and white Go stones on a configurable 9x9, 13x13, or 19x19 board.

Generate Microsoft-style GUIDs: uppercase hex, hyphenated, wrapped in curly braces by default.

Generate a random integer shown in base-16, with configurable digit length and letter case.

Generate a small, complete random HTML page with a heading, paragraphs, a list, and a link.

Generate random <table> markup with a chosen number of rows and columns of random cell content.

Procedurally generate a brand-new abstract image every time, with a random gradient background and scattered shapes.

Pick one at random from a small fixed set of 10 built-in generative SVG patterns, no images are fetched from the internet.

Generate a single random whole number between a minimum and maximum you choose.

Generate a batch of random whole numbers within a min/max range, one per line.

Generate random IPv4 or IPv6 addresses, restricted to any, private, or public-looking ranges.

Generate random ISBN-10 and/or ISBN-13 numbers with a correctly computed check digit.

Generate a random nested JSON object with configurable depth, key count, and array length.

Generate a layered SVG landscape with a sky gradient, a sun or moon, a jagged hill silhouette, and a few trees.

Generate a random LaTeX document skeleton with a title, a math equation, and an itemized list.

Generate random 'Lenny face' style kaomoji, like ( ͡° ͜ʖ ͡°), from a built-in list.

Generate a batch of random letters with control over case and vowels vs. consonants.

Generate one or more random line segments with random endpoints, color, and width, as an SVG.

Generate a random list of N items, sampled without repeats or generated with repeats allowed.

Generate a full fake address combining a random street, city, and country.

Generate random 6-byte MAC addresses with a colon or hyphen separator and correct locally-administered bits.

Build a random arithmetic expression from +, -, *, / and parentheses, with its evaluated result.

Generate a random m x n matrix of numbers within a configurable range, as an aligned text grid.

Generate random input bytes and compute their real MD5 digest — both shown, clearly labeled.

Generate random letters or words and see both the source text and its Morse code encoding.

Generate random human first + last name combinations from built-in name lists, in either name order.

Generate random numbers between a min and max, as whole integers or decimals with configurable precision, one or many at a time.

Generate N pairs of random integers (a, b) within a min/max range — useful for coordinates or paired test data.

Generate a random integer shown in base-8, with a configurable digit length.

Generate random odd integers within a min/max range, one or many at a time.

Generate random paragraphs made of several grammatically plausible sentences.

Generate clearly-fake, non-dialable phone numbers using officially reserved fictional ranges.

Generate one or many random numeric PIN codes, 4-8 digits long, using a cryptographically secure random source.

Generate a random gradient-shaded planet SVG with an optional ring system, craters, and cloud bands.

Generate fictional sci-fi-style planet names by combining random syllables.

Generate random 2D (x, y) points within a configurable bounding box.

Generate random polar (r, θ) coordinate pairs, with the angle in degrees or radians.

Generate a random prime number within a min/max range, using trial division and Miller-Rabin.

Generate a random, syntactically valid regex pattern composed from character classes, quantifiers, and groups.

Generate grammatically plausible random sentences built from subject/verb/object templates.

Generate random input bytes and compute their real SHA-1 digest — both shown, clearly labeled.

Generate random input bytes and compute their real SHA-256 (SHA-2 family) digest — both shown, clearly labeled.

Generate a random polygon (3-10 sides) with a random size, rotation, and fill color as an SVG.

Generate a random square with random size, position, rotation, and fill/stroke color, as an SVG.

Generate random fake street names with house numbers, like '482 Maple Avenue'.

Generate a random, genuinely solvable 9x9 Sudoku puzzle with easy/medium/hard difficulty and a one-click solution reveal.

Generate a random 3D surface formula z = f(x, y), combining sin/cos/polynomial terms.

Generate a random time of day in 12-hour or 24-hour format, with optional seconds.

Generate a random TOML document with nested tables and key/value pairs, configurable depth and breadth.

Draw a random stylized treasure map with a blob island coastline, a dotted route, an X mark, and a compass rose.

Generate a randomized branching tree with configurable branch count and depth, rendered as SVG lines and leaf blobs.

Generate random tab-separated data with a chosen number of rows and typed columns (name, number, boolean, date).

Generate random text drawing from Greek, Cyrillic, symbol, box-drawing, and emoji ranges.

Generate random text (including spaces, symbols, and unicode) and URL-encode it with the real encodeURIComponent().

Generate plausible-looking URLs from random scheme, subdomain, path, and query combinations.

Assemble realistic-looking browser User-Agent strings for Chrome, Firefox, Safari, and Edge.

Generate usernames by combining a random adjective and noun from built-in word lists, with an optional number suffix.

Generate random UTF-16 text including surrogate-pair emoji, with a code-unit breakdown.

Generate random text and see its UTF-32 code-point breakdown, one 32-bit value per character.

Generate random multi-byte UTF-8 text and see its per-character byte breakdown.

Generate random n-dimensional vectors with a configurable dimension count and component range.

Animate random moving, colored shapes on a canvas and capture a few seconds of it as a downloadable WebM video.

Generate a random .docx Word document with a heading, procedurally generated paragraphs, and a list.

Generate a list of random English words drawn from a varied built-in dictionary.

Draw an abstract SVG 'world map' with a lat/lng-style graticule grid and random blob-shaped landmasses.

Generate a random nested XML document with a mix of child elements and attributes.

Generate random 3D (x, y, z) coordinate triples within a configurable numeric range.

Enter a regex pattern and generate random strings that actually match it.

Generate a single-pixel PNG in any RGBA color, including fully transparent, and download it.

Give an uploaded PNG a pseudo-3D extruded look by stacking shaded offset copies of it behind the original.

Generate a full hue x lightness color spectrum sweep as a PNG, at fixed full saturation.

Generate a 3-color analogous palette PNG from a hex color, with an adjustable hue angle.

Turn pasted ANSI-colored terminal art into a full-color PNG image, right in your browser.

Combine several same-size PNG frames into a real Animated PNG (APNG), entirely in your browser.

Turn pasted ASCII text art into a grayscale PNG image, right in your browser.

Calculate the alpha-weighted average color of every pixel in a PNG.

Turn pasted Unicode braille pattern art back into a black-and-white PNG image, right in your browser.

Blend two hex colors together at a precise, adjustable ratio from 0 to 100.

Mix any number of hex colors together by averaging their RGB channels equally.

Turn a list of CSS color names (like cornflowerblue or rebeccapurple) into a grid of PNG swatches.

Sort a list of hex colors by hue, lightness, saturation, or perceptual luminance.

Generate a full horizontal rainbow spectrum strip PNG, sweeping every hue from 0 to 360 degrees.

Generate a strip of evenly-stepped color swatches between exactly two hex colors, with hex codes.

Generate a circular HSL color wheel PNG at any size and lightness, entirely in your browser.

Generate a colorful diagonal rainbow-gradient PNG of any size, seeded for repeatable variety.

Generate a two-color complementary palette PNG from any hex color, using true HSL hue math.

Create a solid-color PNG at any size, with an optional colored border of any pixel width.

Design a custom ring-bordered rubber-stamp PNG with your own text, shape, color, and size.

Isolate a PNG's dark/shadow pixels into their own transparent-masked image, by luminance threshold.

Generate a 'RECEIVED'-style stamp PNG showing a date on top and a time below it.

Turn an uploaded PNG into a real animated APNG where it dissolves away pixel by pixel.

Turn any emoji into a ring-bordered stamp PNG using your browser's own color emoji font.

Render a single emoji as a downloadable icon-sized PNG, using your system's own color emoji font.

Render a single emoji as a downloadable PNG at any size, using your system's own color emoji font.

Generate a blank PNG at any size, fully transparent, solid white, or solid black.

Add reproducible, seeded row-shift glitch art effects to a PNG, right in your browser.

Generate a green-ink ring-bordered stamp PNG, the classic 'approved'/'paid' color.

Mask a PNG down to only the pixels within a chosen hue, saturation, and lightness range.

Turn a list of HSL colors (like hsl(210, 100%, 50%)) into a grid of PNG swatches.

Turn an icon into a postage-stamp graphic with a perforated edge, right in your browser.

Isolate a PNG's light/bright pixels into their own transparent-masked image, by luminance threshold.

Turn a logo into a worn, single-ink rubber-stamp impression with a ragged, distressed edge.

Deliberately pixelate and posterize a PNG to give it a deep-fried, low-quality look, right in your browser.

Generate a monochromatic palette PNG with 2-10 lightness steps from a single hex color.

Turn 1-3 initials into a bold, ring-bordered monogram stamp PNG.

Create a smooth, continuous horizontal gradient PNG across 2 to 6 hex color stops.

Mask a PNG down to only the pixels near any of several target colors, within an adjustable tolerance.

Generate a ring-bordered stamp PNG showing a single whole number, like an ID or reference number.

Simulate mixing physical paint colors using a subtractive multiply blend instead of averaging.

Generate a classic placeholder.com-style PNG with its own WIDTHxHEIGHT dimensions stamped on it.

Turn a PNG's alpha channel into a grayscale visualization: white is opaque, black is transparent.

Extract the single most frequently occurring color in a PNG.

Extract the most common colors in a PNG as a ranked list of hex codes.

Tile 1-20 copies of a PNG side by side or stacked into a single strip image, right in your browser.

Turn an uploaded PNG into a real animated APNG that fades in from transparent to fully visible.

Turn an uploaded PNG into a real animated APNG that fades out from fully visible to transparent.

Sample a 2 to 6 stop color gradient into a strip of discrete numbered swatches, with hex codes.

Turn a PNG into a honeycomb-style hexagonal mosaic, right in your browser.

Combine multiple uploaded PNGs into a single grid-layout mosaic (contact sheet) PNG.

Multiply a PNG into a columns x rows grid of repeated copies, right in your browser.

Split a PNG into a grid of separate downloadable parts, like cutting a picture into puzzle pieces.

Randomly shuffle a PNG's pixel positions with a seeded, reproducible glitch effect.

Apply the classic pixel-sorting glitch art effect to a PNG, right in your browser.

Wrap a PNG in a classic white Polaroid-style frame with a caption strip, right in your browser.

Render a single wipe-reveal frame of a PNG at any percentage, in any direction, right in your browser.

Combine multiple uploaded PNGs into a single looping animated APNG slideshow.

Repeat a PNG across a columns x rows grid to create a tiled pattern image, right in your browser.

Combine a sequence of same-size PNG frames into a single looping animated GIF, right in your browser.

Turn a PNG into colored ANSI terminal art using 24-bit truecolor escape codes, right in your browser.

Turn a PNG into classic character-based ASCII art, right in your browser.

Turn a PNG into dense, compact Unicode braille pattern art, right in your browser.

Convert a PNG into a real, valid Windows .ico icon file, with full alpha transparency preserved.

Turn a PNG into a Voronoi-cell mosaic, sampling each cell's color from the source image, right in your browser.

Turn a PNG into a low-poly triangle mosaic, right in your browser.

Mask a PNG down to only the pixels matching its single most frequent exact color.

Generate a PNG of colorful random pixel noise at any size, from a reproducible numeric seed.

Generate a rectangular double-ring rubber-stamp PNG with your own text and ink color.

Generate a red-ink ring-bordered stamp PNG, the classic 'rejected'/'urgent'/'void' color.

Crop an icon into a circular avatar-style shape, right in your browser.

Crop a PNG to a centered square and mask it into a circle, ideal for avatars, right in your browser.

Generate a circular double-ring rubber-stamp PNG with your own text and ink color.

Turn an uploaded PNG into a real animated APNG that scrolls horizontally or vertically and loops seamlessly.

Turn a signature into a worn rubber-stamp-style impression with ink color and distress effects.

Generate 3-9 subtly varied shades around a hex color's own lightness, as a downloadable PNG.

Generate a solid-color PNG of any size from a hex color code, right in your browser.

Slice a grid-tiled sprite sheet PNG into individual frames and assemble them into an APNG.

Pad a non-square icon into a perfect square by centering it on a transparent background, right in your browser.

Pad a PNG to a square canvas with transparent bars, centering the original content, right in your browser.

Crop and mask a PNG into a customizable multi-point star shape, right in your browser.

Mirror one half of an icon onto the other to force perfect left-right or top-bottom symmetry.

Generate a 4-color tetradic (rectangle) palette PNG from a hex color, spaced 90 degrees apart.

Generate a brand-new PNG icon from a short line of text, tightly cropped, no upload needed.

Render a company name or short text as a simple wordmark-style logo PNG, entirely in your browser.

Render text as a standalone PNG using a built-in pixel font, no design tool required.

Convert a line of plain text into a ring-bordered rubber-stamp PNG in one step.

Generate a 3-color triadic palette PNG from a hex color, spaced evenly 120 degrees apart.

Mask a PNG down to only the pixels whose exact color appears nowhere else in the image.

Mask a PNG with a wavy top and bottom edge using a sine wave, right in your browser.

Generate a grayscale PNG of classic black-and-white TV static, from a reproducible numeric seed.

Generate a rows x columns random integer array as compact JSON-style nested array notation.

Generate a depth x rows x columns random integer array as compact JSON-style triple-nested array notation.

Generate random BigInt values with an exact digit length (5 to 100 digits), one per line.

Print a strictly decreasing arithmetic sequence starting at a value, subtracting a fixed step.

Print a strictly increasing arithmetic sequence starting at a value, advancing by a fixed step.

Draw a hollow rectangle border filled with consecutive integers, walked clockwise from the top-left.

Draw an ASCII ring shape of consecutive integers, using a simple distance-from-center threshold test.

Draw the classic ASCII diamond shape, filled with consecutive integers instead of a fixed character.

Independently mutate each digit of every integer in a list at a controlled rate, for controlled parser corruption testing.

Generate randomized digit-level fuzz input from a list of integers, for stress-testing parsers.

Deterministically corrupt a chosen number of whole integers in a list, for testing parser error handling.

Generate a curated list of numeric edge cases (boundaries, safe-integer limits), padded with extra values as needed.

Generate a rows x columns grid of random integers within a chosen range, as space-separated ASCII rows.

Generate random integer tuples of a fixed size within a chosen range, one tuple per line.

Arrange consecutive decimal integers into a square ASCII grid, filled in clockwise spiral order.

Build a regex that matches exactly a given set of integers, via literal alternation.

Generate a single line of random integers within a chosen range and length, space-separated.

Generate an odd-order magic square (3-9) via the Siamese method, with every row/column/diagonal sum shown.

Generate several arithmetic sequences sharing a start value but with diverging step sizes.

Generate a triangle-wave integer sequence that bounces back and forth between a min and max value.

Generate example integers matching a numeric regex pattern (a documented, restricted subset).

Generate random small integers symmetrically around zero, within a chosen max magnitude.

Generate a valid, fully-solved 9x9 Sudoku grid and blank out a chosen number of cells as a puzzle.

Print the first N von Neumann ordinals in labeled and (for small counts) fully recursive set notation.

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

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

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

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

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

Generate a repeating 0101... or 1010... pattern of a chosen length.

Color-code every individual bit of a single binary number: one color for 1s, another for 0s.

Randomly shuffle the positions of the bits in a binary string, keeping the same count of 1s and 0s.

Generate a list of random labeled binary choices, like Yes/No or Heads/Tails.

Arrange binary digits around a circular ring outline within a text grid.

Color a list of binary numbers, one per line, each with its own distinct swatch.

Generate the classic look-and-say sequence starting from a binary seed, one term per line.

List every binary number of a chosen bit width, in ascending order.

Trace an outward spiral curve through a grid, plotting your binary digits along the way.

Wrap a binary string's digits into an N x N square block of text, padding with a filler character if needed.

Turn a string of 0s and 1s into a downloadable black-and-white pixel image.

Turn binary digits into an actual, downloadable monochrome .bmp file with correct BMP headers.

Arrange a binary string's digits into a zigzag pattern across multiple lines.

Randomly flip a chosen number of bits in a binary string to simulate noise or bit errors.

Generate a batch of random 8-bit bytes, space-separated.

Generate a batch of random 32-bit double words (dwords), space-separated.

Generate a batch of random 16-bit computer words, space-separated.

Generate a batch of random 4-bit nibbles, space-separated.