🚀 The launch-day checklist
Favicons generated with the HTML to paste, the sitemap built for Search Console, and the crawlers told where they may go. Three of the most forgotten launch items, done in fifteen minutes.
Thirty tools for the daily grind: format JSON, test regex, diff text, decode Base64, generate CSS, build favicons, convert data formats, and understand the ML you are being asked to ship. Everything runs locally in your browser, which means pasting production data here is not a security incident.
The list starts with the tabs that stay open all day (JSON, regex, diff), runs through the front-end and data utilities, and finishes with a seven-tool interactive corner that builds real ML intuition. All free, all local, all safe for the data you actually work with.
Format, validate, and minify JSON with errors pinpointed by line and column.
The tab every developer keeps open. Paste the blob, get it beautified, and when it will not parse, see exactly which line and column broke. The collapsible tree view makes deep structures navigable, key sorting tames messy objects, and minify squeezes it back down for shipping. Most importantly: it runs locally, so the API response full of customer data you just pasted stayed on your machine. Your security team would like a word with whoever uses the other kind.
Live match highlighting, capture-group breakdown, and code export for 5+ languages.
Write the pattern, watch matches highlight in real time, and inspect every capture group in a side-by-side breakdown instead of guessing which parenthesis grabbed what. When it finally works, copy ready-to-run code for Python, JavaScript, R, Java, and more, escaping included. Test against real log lines and real user data without either leaving your machine.
Compare two texts line by line and word by word, side-by-side or inline.
Two configs that should be identical, two versions of a contract, the response you expected versus the one you got: paste both sides and see every difference highlighted at the line and word level. Toggle case and whitespace sensitivity to silence the noise, and read the change stats at a glance. Nothing is stored, nothing is sent, and there is no "document history" feature quietly keeping copies of what you compared.
Text or files, UTF-8 safe, with URL-safe and data-URI output.
The classic quick job: decode the token payload, encode the file, build the data URI. Handles text and whole files, gets UTF-8 right (which half the quick scripts out there do not), offers URL-safe output for the web, and decodes back into a downloadable file in one click. Since decoding often involves credentials and tokens, local-only processing is not a nicety here.
HEX, RGB, HSL, HSV, and CMYK all at once, with a WCAG contrast checker.
Type a color in any format and read it back in every other one simultaneously, with channel sliders and alpha support for fine-tuning and copy-ready CSS strings for each. The built-in WCAG contrast checker answers the follow-up question before it is asked: yes, but can people actually read it on that background?
Linear, radial, and conic gradients designed visually, CSS copied instantly.
Nobody writes gradient syntax from memory. Drag color stops, pick the angle or position, flip between linear, radial, and conic, and watch the live preview until it looks right. Then copy the CSS and move on with your day. The fastest path from "make the hero section less boring" to done.
Placeholder text by paragraphs, sentences, words, or list items, with HTML tags.
The mockup needs text and the copy does not exist yet. Generate exactly the amount you need, in the shape you need it: paragraphs for articles, short sentences for cards, list items for menus, optionally wrapped in HTML tags ready to paste into a template. The classic opening line is there for traditionalists.
Image, emoji, or text in; the complete favicon kit and HTML tags out.
Every launch checklist has the favicon line, and doing it properly means a half-dozen sizes and formats. Start from a logo, an emoji, or styled text and get the whole kit zipped: favicon.ico, every PNG size, apple-touch-icon, a web manifest, and the exact HTML tags to paste into your head. Thirty seconds, checked off.
MD5 and SHA-256 hashes for text strings and files, computed locally.
Verify a download against its published checksum, generate a cache key, or confirm two files really are identical. Paste text or drop a file and read the hash. Running locally matters twice here: the file you are hashing stays private, and you can trust the hash you get because your own machine computed it.
Layered box-shadows designed visually: offset, blur, spread, inset, copy the CSS.
Good shadows are the difference between a flat page and a designed one, and they are nearly impossible to write blind. Stack multiple shadow layers, tune offset, blur, spread, color, and opacity against a live preview, toggle inset for pressed states, and copy the finished CSS. Subtle depth without the trial-and-error deploy cycle.
Live side-by-side Markdown preview, including Mermaid diagrams.
Write the README, the docs page, or the wiki entry with the rendered result live beside your cursor, so the tables and nested lists come out right the first time. Mermaid support means flowcharts and sequence diagrams render too, which most quick editors skip. Drop in an existing file or start clean, and download when done.
Pie, bar, line, area, radar, and more from an editable built-in spreadsheet.
The chart for the slide deck, without firing up a whole BI tool. Type or paste data into the built-in spreadsheet, pick from seven chart types, and style everything: titles, axes, legends, palettes, fonts. Export the image and drop it into the deck. Numbers you would not email to a vendor stay on your machine.
Crisp PNGs from SVG files or pasted markup, at 1x to 4x or exact widths.
The design system speaks SVG; the readme, the app store, and the email template do not. Convert files or paste raw SVG markup directly, choose a scale or an exact pixel width so edges stay sharp, keep transparency or add a background, and batch a whole icon set into a ZIP.
CSV, TSV, JSON, JSONL, Excel, Parquet, and Feather/Arrow, converted locally.
The data arrives in whatever format the other system felt like exporting, and your pipeline wants something else. Drop the file, let the auto-detection identify it, and convert between seven formats including the columnar ones (Parquet, Feather/Arrow) that most online converters have never heard of. Datasets full of real records never leave your machine, which is the only acceptable way to convert them.
Build the table visually, copy clean Markdown table syntax.
Markdown tables are wonderful to read and miserable to type, with every pipe and dash in exactly the right place. Build the table in a normal visual editor instead, then copy syntax that renders perfectly in GitHub, wikis, and docs. The five minutes of pipe-alignment fiddling becomes thirty seconds.
Clean UTM-tagged URLs for Google Analytics, with a QR code included.
Campaign attribution lives and dies on consistent tagging. Fill in source, medium, campaign, term, and content; get a clean tagged URL that GA4 will parse correctly; copy it or generate a QR code for the print side of the campaign. No spreadsheet of hand-assembled links with a typo in utm_medium quietly splitting your data in half.
Drop a CSV, JSON, or Excel file and explore it with interactive charts, locally.
First contact with an unfamiliar dataset: load it, let the column types auto-detect (and override them when the detection guesses wrong), and explore with interactive bar, box, scatter, and even 3D charts. It is the look-before-you-model step, minus the part where you upload the company's data to someone's cloud to do it.
Browse, search, and download free icons for sites, slides, and docs.
The button needs an icon and the design system does not have one. Search the library, grab what fits, and drop it into the site, the slide deck, or the doc. No attribution scavenger hunt, no license anxiety, no account between you and the download.
Design the 1200x630 share image and preview the card on X, Facebook, and LinkedIn.
The first impression of every link you share is the card, and an unstyled one reads as abandoned. Design the share image at exactly 1200 by 630, watch live previews of how the card renders on Twitter/X, Facebook, and LinkedIn, and copy the og: and twitter: meta tags ready to paste. Ship links that look shipped.
Create, edit, and export XML sitemaps so search engines see every page.
Search engines index what they can find, and the sitemap is the map you hand them. Build one from scratch or manage an existing list of URLs, set the metadata, and export clean XML ready for your site root and Search Console. A ten-minute job that quietly compounds forever.
Build a correct robots.txt without memorizing the directive syntax.
One misplaced directive in robots.txt can deindex your whole site, which makes it a strange file to hand-edit from memory. Pick which crawlers may access what, point to your sitemap, and export a correct file. Takes two minutes, prevents one very bad Monday.
A value per state in, a color-coded choropleth map out, PNG download included.
Sales by state, users by state, anything by state: type the numbers and the choropleth renders instantly, with color schemes, a live legend, and a custom title. Download the PNG for the deck or the report. The alternative is fighting a mapping library for an afternoon, and nobody bills that honestly.
Your UI through 8 types of color vision deficiency, with a before/after slider.
Roughly one in twelve men will not see your red/green status colors the way you do. Drop in a screenshot of the dashboard and view it through research-grade simulations of eight vision types, with a draggable comparison slider and an all-types grid. The moment your error and success states collapse into the same shade is the moment you redesign them, before a user files the ticket.
Seven interactive simulations that build real intuition for machine learning and statistics. Not videos, not blog posts: live experiments you can poke at. Built for every developer who is being asked to ship, integrate, or evaluate AI features and wants to actually understand what the model is doing.
Train a tiny next-word predictor and watch it work. This is how LLMs think.
Strip an LLM down to its essence and it predicts the next token from context. Train a miniature model on any text right in the browser, watch live probability bars for the next word, and drag the temperature slider to see exactly what that API parameter you keep setting actually does to the distribution. The hallucination intuition arrives free of charge: confident prediction with zero understanding.
Why your 99% accurate alert fires mostly false positives, shown with 1,000 people.
Every engineer who owns an alerting system, a fraud model, or an anomaly detector eventually rediscovers this the hard way: when the thing you are detecting is rare, most positives are false, no matter how accurate the detector. Set base rate, sensitivity, and specificity, and watch 1,000 dots make the argument no meeting slide ever could. This is the math behind alert fatigue.
Precision, recall, RMSE, silhouette: what they mean and where they lie.
Before you sign off on "the model is 96% accurate," find out what that number hides. Pick classification, regression, or clustering, choose a metric, and play with live simulations: move the decision threshold and watch precision and recall trade against each other, add an outlier and watch RMSE panic while MAE shrugs. The vocabulary you need for every model review, made concrete.
Crank the complexity and watch training error fall while test error climbs.
The failure mode behind most disappointing models, live on one screen. Control model complexity, training data size, noise, and regularization, and watch training and test error diverge as the model starts memorizing noise instead of learning signal. The bias-variance U-curve emerges from your own experiment, which beats reading about it every time.
A real CART tree grows on live data: the questions and the regions, side by side.
Random forests and gradient boosting run half the production ML on tabular data, and they are all made of this: a tree of yes/no questions carving the feature space into boxes. Watch a real Gini-splitting CART tree grow, see the flowchart and the decision regions update together, and use the depth and noise sliders to reproduce overfitting in its most visual form.
Learning rate, momentum, local minima: the optimizer, finally visible.
Every training run you have ever launched was a ball rolling down a loss landscape, and here you can watch it. Set the learning rate too high and see divergence instead of reading about it in a stack trace; get trapped in a local dip and discover what momentum is actually for. Four landscapes, a live loss curve, and the intuition behind every optimizer flag you have ever copy-pasted.
20+ probability distributions with live parameters, plus realistic test data.
Pick normal, exponential, Poisson, gamma, Weibull, Pareto, or twenty more, set the parameters, and watch random samples pile into the theoretical shape. Half reference, half generator: build a feel for which distribution models your latencies or arrival times, then sample realistic test data for the load test or the seed script.
The tools hand off to each other. These are the four combinations that come up in real work weeks.
Favicons generated with the HTML to paste, the sitemap built for Search Console, and the crawlers told where they may go. Three of the most forgotten launch items, done in fifteen minutes.
Convert whatever format arrived into what you need, inspect and validate the structure, then explore it visually before deciding what to do with it. All without the data touching a server.
Design the share card with live platform previews, copy the meta tags, then tag the campaign URL so GA4 attributes every click. The difference between posting a link and launching one.
Nail the palette with contrast checked, generate the gradient, and layer the shadows, all visually, all copied as CSS. The page stops looking like a prototype in about twenty minutes.