Blog

Compound interest, APR vs APY, validator fees on rewards not principal, and the price-appreciation trap that inflates the USD headline. The formula is FV = P × (1 + APY/n)^(n·t); the hard part is knowing which number to trust.

Convert any crypto to any fiat or coin by routing through USD — and avoid the divide-vs-multiply bug that comes from crypto prices quoted in USD but fiat quoted as units per dollar.

Pack many icons into one image and address each with background-position. Covers the four layouts, the negative-offset math that makes sprites work, retina @2x/@3x with background-size, padding to prevent bleed, and the JSON manifest Phaser and PixiJS load directly.

Sign a JSON Web Token with HS256 or RS256, pick the claims that actually do work, and avoid the one mistake every JWT intro skips: the payload is base64url, not encrypted. Anyone with the token can read it.

Analyze word frequency in any text — and learn why the Unicode tokenizer regex beats split-on-whitespace, why stop words are excluded by default, why hapax legomena is a vocabulary richness metric, why n-grams are a sliding window, and why the diversity ratio is the type-token ratio from linguistics.

Calculate bond yield without fooling yourself — the five yields a bond carries, why current yield understates discount bonds, why the approximation formula is biased, and what modified duration actually predicts.

Calculate your break-even point in units and revenue — and learn why the formula is one division, why contribution margin not gross margin is the number that matters, why price below variable cost means no break-even exists, why the 50% scenario is always a loss, and why fixed costs are only fixed below a capacity ceiling.

Calculate dollar cost averaging outcomes — and learn why DCA buys more shares when prices are low, why the average cost per share is total invested divided by total shares not the average price, why lump sum wins in rising markets and DCA wins in falling ones, and why the future projection uses compound interest not price averaging.

Size a forex trade from account balance, risk percent, stop loss, and pip value — and learn why the lot size formula is one division, why USD/JPY's pip is worth $6.7 not $10, and why the 1% rule is the only input that matters.

Add or remove VAT with country presets for UK, EU, Switzerland, Australia, Canada, UAE — and learn why removing VAT is division by 1.2, not subtraction of 20%, and which rate to pick when a country has standard, reduced, and zero bands.

Check when a domain was first registered — and learn why domain age comes from WHOIS creation_date, why the age formula divides by 365.25 not 365, why CORS blocks browser-based WHOIS lookups, why the 5-year 'established' badge is a heuristic not a Google spec, and why an aged domain with a spam history is worse than a new domain.

Check favicon declarations in your HTML head — and learn why the tool parses pasted HTML instead of fetching your site, why the .ico fallback passes on any unsized icon, why the Apple Touch Icon check ignores its own 180×180 label, and why SVG and mask-icon aren't scored.

Check your website's real HTTP security headers by pasting them from DevTools or curl -I — and learn why the CORS safelist blocks URL-based fetchers, why misconfigured earns 0.4 not 0.5 in the scoring, why ALLOW-FROM is a dead directive, why SameSite=None requires Secure, and why X-XSS-Protection=1 is worse than missing.

Check your website's HTTP security headers — and learn why browsers can't read security headers cross-origin (CORS safelist), why HSTS preload opts into a browser-wide HTTPS list, why CSP allows 'unsafe-inline' for styles, why X-XSS-Protection is deprecated and set to 0, and why COOP, CORP, and COEP exist because of Spectre.

Inline images in HTML, CSS, JSON, and email with Base64 Data URIs — and learn why the 33% size tax means you should encode small images only, re-encode to WebP first, and never inline a hero photo.

Convert between square meters, acres, hectares, square feet, and 19 other area units — and learn why every conversion goes through one base unit, why the acre is 43,560 ft² because of furlongs and chains, and why a bigha in India is not the same number twice.

Convert blood glucose between mg/dL and mmol/L — and learn why the factor is 18.0182 (not 18), why the US uses mass and the rest of the world uses molecules, how the Nathan formula estimates HbA1c from average glucose, and which fasting range puts you in pre-diabetic territory.

Convert between bits, bytes, kilobytes, megabytes, gigabytes, terabytes, and beyond — and learn why there are two standards (binary IEC base-1024 and decimal SI base-1000), why 1 TB shows as 931 GiB in Windows, why ISPs sell in bits not bytes, and why download time is one division the rest is unit conversion.

Convert colors between HEX, RGB, HSL, HSV, CMYK, LAB, LCH, and CSS named colors — and learn why HSL is a cylinder while RGB is a cube, why HSV and HSL disagree on what '100% saturation' means, why LAB exists when RGB already covers everything, why CMYK is subtractive, and why the WCAG contrast formula has a 0.05 in it.

Convert CSV to a real XLSX spreadsheet — and learn why .xlsx is a ZIP archive of XML files not a single format, why numbers must be stored as numbers not strings for SUM to work, why the delimiter is auto-detected not assumed, and why the shared strings table keeps the file small.

Convert cURL commands to 14 languages — and learn why -k and --compressed silently disappear, why -F form data is parsed but never emitted, why the JSON-vs-string decision is a single character, and why the JS output isn't runnable as-is.

Convert data storage across 27 units in four families — learn the byte-as-hub method, why a 1 TB drive shows as 931 GiB, why the SI-vs-IEC gap grows from 2.4% at KB to 15.3% at EB, why 100 Mb is 12.5 MB not 100 MB, and why the download calculator mixes binary sizes with decimal speeds.

Convert energy units across SI, thermal, electrical, mechanical, and atomic domains — learn the joule-as-hub method, why the food Calorie is a kilocalorie, which calorie the tool uses, and why an electron-volt is now an exact number.

Turn HTML into clean Markdown — headings, lists, tables, code blocks, links — and learn what the conversion always loses (classes, styles, alignment, colspans), why the DOM is the intermediate, and which of the four style options to pick.

Convert JSON to YAML in the browser, then learn the four things js-yaml decides for you — key reordering, anchor inlining, line folding, and the big-integer precision trap.

Convert between binary, octal, decimal, hex, and 8 more number bases — and learn why every conversion goes through decimal as the base unit, why BigInt prevents precision loss above 2^53, why hex maps 4 bits per digit and octal maps 3, why two's complement is asymmetric, and why IEEE 754 has a 127 bias.

Convert between 23 speed units — and learn why every conversion goes through meters per second, why km/h is 1/3.6 of m/s, why Mach is not a fixed number, why the Beaufort scale is a lookup table not a formula, and why travel time is one division.

Convert volume across 31 units in six families — learn the liter-as-hub method, why a UK pint is 20% bigger than a US pint while a UK fl oz is smaller, why cm³ and mL are the same thing by definition, and why the UK tablespoon value is wrong for modern recipes.

Edit CSV files in your browser with a table interface — and learn why the naive comma split breaks on quoted fields, why RFC 4180 doubles quotes instead of escaping them, why numeric sort and string sort disagree, why empty cells matter for stats, and why CSV-to-JSON is a one-liner with Object.fromEntries.

Edit a PDF's title, author, subject, and keywords — and learn why the Producer field is silently overwritten, why comma keywords don't split, and why XMP metadata is left untouched.

Encode HTML entities three ways — named, numeric, and hex — and learn why only five characters must be encoded, why the ampersand is always encoded first, why < and < are the same character in two costumes, and which encoding mode prevents XSS without mangling your text.

Extract and analyze YouTube video tags — and learn why tags are only visible to the video owner via YouTube Studio, why the 500-character limit is the real constraint, why 2 to 4 word tags rank best, and why YouTube says tags barely matter but you should use them anyway.

Turn a word or name into real anagrams — the sort-letters test, why most rearrangements are gibberish, and how multi-word anagrams like Clint Eastwood → old west action actually work.

A 7×24 engagement heatmap for Instagram, Twitter, Facebook, LinkedIn, TikTok, and Pinterest — and the reason the aggregated 'best time' chart is a starting point, not your answer.

Generate TikTok hashtags from a keyword and niche — and learn why the ideal count is 5 to 10 not 30, why #fyp doesn't put you on the For You Page, why the -tok suffix beats the generic tag, and why the 2,200-char caption limit is the real ceiling.

Generate TOTP 2FA codes from a Base32 secret — and learn why the dynamic truncation step in HOTP is the one thing that matters, why Base32 uses A-Z and 2-7 (not 0-9), why the counter is floor(unix_time/30), why HMAC-SHA1 is still standard, and why the 0x7f mask prevents signed-bit overflow.

Make Twitter Card meta tags with the generator — and learn why the Fetch button copies your hostname and gives up, why JSON export drops iPad fields and player streams, why image validation fails on images Twitter would display fine, and why the validator link points to a page Twitter retired.

Cross out text anywhere — Twitter, Instagram, Discord — with Unicode combining characters, and learn why ~~markdown~~ is the right choice wherever markdown is supported.

Read the Regex Cheatsheet — and learn why the badge says 68 tokens while the FAQ says 100+, why the inline tester throws on five tokens the Cheatsheet tab teaches, why the four flavors are reading material not validation, and which common patterns lie about what they accept.

Remove extra spaces, tabs, empty lines, and line breaks from text — and learn why there are six kinds of whitespace, why the non-breaking space (U+00A0) survives .trim(), why code mode preserves indentation, and why the pipeline order decides what survives.

Reply to reviews, support emails, and DMs by picking the right approach — agree, clarify, redirect, or acknowledge — and the tone that matches the writer's mood. With the limits a template generator can't see past.

Reverse text by characters, words, sentences, or lines — and learn why naive character reversal destroys emoji and astral-plane characters, and which unit to pick for the job.

Write Facebook posts that get reach and engagement — and learn why the feed truncates at 480 characters, why 1-3 hashtags beat 10, why 8 post types need different templates, why 3 variants beat 1 for A/B testing, and why tone controls the opener and the CTA independently.

Write headlines that earn the click — and learn why the generator's 0-100 score is a deterministic formula you can game with power-word stuffing, why it underrates specific headlines, and why the 40-60 char 'optimal' fights Facebook's 40.

Write a LinkedIn headline that ranks in LinkedIn search and gets clicks — and learn why the 220-character limit is a ceiling not a target, why 180 to 220 characters is the sweet spot, why the pipe separator outperforms the em dash, why a CTA in the headline boosts recruiter messages, and why keyword density is the only score that matters.

Turn three inputs into a structured short story draft — and learn why the protagonist, setting, and conflict you type decide everything, and the 3-act structure does the rest.

Write brand slogans with the generator — and learn why it's ten fixed templates not a model, why 'Rhyme Pattern' doesn't rhyme and 'Alliteration' doesn't alliterate, why tone swaps the entire vocabulary, and why only your first two keywords count.

Split long-form text into Twitter/X threads — and learn why the 280-character limit includes your 1/8 numbering, why the split goes paragraphs then sentences then words, why the first tweet is the only one that shows in the timeline, and why 5 to 10 tweets is the sweet spot.

Write YouTube video descriptions that rank in search and convert viewers to subscribers — and learn why only the first 150 characters show in search results, why chapters improve watch time not SEO, why the 15-hashtag limit is a ceiling not a target, and why 3 CTA templates cover every video type.

Write YouTube titles that survive truncation and earn the click — the 60/70-character rule, which of the 10 title formats fits which traffic source, and why clickbait tanks your retention.

Write AI image prompts for Midjourney, DALL-E 3, Stable Diffusion, and Adobe Firefly — and learn why each platform speaks a different prompt grammar, why Stable Diffusion needs negative prompts while DALL-E ignores them, why the art style tag does more than the subject, and why 3 variants beat 1.

Write TikTok captions with the generator — and learn why the vibe picker only affects the Hook and Trend styles, why the CTA/Emoji/Minimalist are vibe-blind, why the 150-char badge is always green, and why all 15 hashtags ignore your topic.

CSS Grid is the two-dimensional layout system browsers actually shipped, after a decade of people bending Flexbox into doing grid-shaped work it was never designed for. The model is two declarations: display: grid on a container, then grid-template-columns and grid-template-rows to define the tracks. The tracks are the rows and columns; the children fall into the cells where the tracks intersect. The hard part is not the syntax, it is the units. The fr unit distributes free space proportionally — three 1fr columns split the container width into thirds, and a 2fr/1fr/1fr split gives the first column half the space. The px and percent units fix a track to a size regardless of what else is on the page. auto sizes a track to its content. minmax(min, max) sets a floor and a ceiling so a track can shrink to a minimum and grow to a maximum. These units mix in a single declaration: grid-template-columns: 250px 1fr 1fr gives you a fixed sidebar and two equal content columns. Learn the difference between fr and auto (fr distributes leftover space after fixed tracks are sized; auto sizes to content, which means an auto track can grow if its content is wider than the container's leftover space — a common cause of grids overflowing their parent), why minmax(200px, 1fr) is the responsive track pattern that does not need media queries (it collapses to 200px on narrow containers and grows to 1fr on wide ones), why named grid areas beat numbered lines for real layouts (grid-template-areas lets you draw the layout with strings: 'header header header' / 'sidebar main aside' / 'footer footer footer' — readable, refactorable, and impossible to get the line numbers wrong on), how justify-items and justify-content are different things (justify-items aligns children inside their cells; justify-content aligns the grid tracks inside the container when the tracks are smaller than the container), why the gap property replaced margin hacks (gap is the space between tracks, applied once on the container, no nth-child selectors), and what a CSS grid generator does and does not give you (it writes the template-columns, template-rows, gap, alignment, and named-area declarations from a visual editor — but it does not handle responsive breakpoints, subgrid, auto-fit/auto-fill, or the repeat() function, all of which you will need for real layouts).

A study schedule is a defense against the forgetting curve. Hermann Ebbinghaus discovered in 1885 that memory decays predictably: you forget roughly half of what you learn within an hour and 70 percent within a day, unless you review at spaced intervals. Each review flattens the curve and pushes the next drop-off further out. This is the spacing effect, and it is the single most robust finding in the psychology of learning. Cramming fails because it loads everything into short-term memory at once and never triggers the retrieval that consolidates it. A study plan that spaces topics across days, with reviews inserted at expanding intervals, outperforms the same total hours massed into one block. Learn how the forgetting curve works (exponential decay, J ≈ e^(-t/S) where S is memory strength, each review increases S), why active recall beats rereading (retrieval practice is what builds memory, not passive exposure; a 2013 Purdue study found retrieval practice produced 50 percent better retention than rereading), why interleaving beats blocking (mixing related topics in one session transfers better than studying each topic to mastery before moving on; the tool assigns subjects sequentially, which is blocking, not interleaving), how the spacing interval should expand with each review (1 day, 3 days, 7 days, 16 days, 35 days in SM-2, the algorithm Anki uses), why sleep and rest matter (consolidation happens during slow-wave sleep; pulling an all-nighter undoes the benefit), why the tool's difficulty field is computed but not used in scheduling (a known limitation worth knowing), and why a 3-day fixed review cycle is a rough approximation, not true spaced repetition.

The 3-to-6-months rule is a starting point, not a target. A salaried employee with no dependents at a stable company needs 3 months of essential expenses. A freelancer with two kids needs 12 to 15. The difference is not preference — it is the probability of going without income and the time to replace it. Learn how job stability maps to target months (very stable 3, stable 4, somewhat stable 6, volatile 9, freelancer 12), why dependents add 1 month each up to a cap of 3, why emergency funds use essential expenses not total income (you cut discretionary spending during unemployment, not your rent), why the target has a minimum and a recommended (the recommended is 25 percent higher to absorb surprises), why the fund lives in a high-yield savings account not the stock market (FDIC insurance, liquidity, 4-5 percent APY currently), how HYSA interest compounds monthly to shorten the time to reach your target, what actually counts as an emergency (unexpected, urgent, necessary — not vacations or planned purchases), and why over-funding beyond 1.5x your target has diminishing returns.

Aspect ratio is width divided by height, simplified by GCD to its lowest terms. Learn how 1920x1080 becomes 16:9, the proportional scaling formula (new height = new width divided by the decimal ratio), the difference between contain and cover bounding box fits, why PPI measures screen density and DPI measures print density, and how to calculate print size in inches from pixel dimensions at 300 DPI.

Estimate BAC with the Widmark formula: alcohol grams, body water constant, and the 0.015/h metabolism rate. Worked example, the sex difference, and why a calculator is not a breathalyzer.

Crypto profit is not sell price minus buy price. Every trade has two fees — one when you buy, one when you sell — and both are percentages of the transaction value, not flat amounts. A 0.25 percent buy fee and 0.25 percent sell fee on a $10,000 trade costs $50, not $5. Learn how to calculate net profit after fees (buy fee = investment x fee%, sell fee = exit value x fee%), why DCA cost basis is total-invested divided by total-units (not the average of purchase prices), what break-even price means when fees are included (buy price x (1 + buy fee% + sell fee%)), why tax only applies to gains not losses, the difference between ROI (net profit after everything / initial investment) and price multiplier (sell price / buy price), and why short-term crypto gains are taxed as ordinary income in the US (held under 12 months) while long-term gains get lower rates.

Max heart rate is not 220 minus your age. That formula, published by Haskell and Fox in 1971, has a standard deviation of 10-12 bpm — meaning a 40-year-old's actual max HR could be anywhere from 168 to 192, not the 180 the formula gives. Learn why Tanaka (208 - 0.7 x age) is more accurate for most adults, why Gulati (206 - 0.88 x age) was developed specifically for women, why the Karvonen method (target HR = (MHR - RHR) x intensity + RHR) is more personalized than simple percentage-of-MHR, what the five training zones actually do (Z1 recovery 50-60%, Z2 fat burn 60-70%, Z3 endurance 70-80%, Z4 threshold 80-90%, Z5 VO2 max 90-100%), why the fat-burning zone is a myth (Z2 burns a higher percentage of calories from fat but Z4-Z5 burns more total calories), and how to structure a 60-minute workout by goal.

Options profit at expiration is intrinsic value minus premium, times 100 shares per contract. Learn the four basic positions and their risk/reward profiles, why breakeven is strike plus or minus premium, how multi-leg strategies cap risk and reduce cost, and why an at-expiration calculator tells you nothing about time value.

Predict ovulation from your cycle length and luteal phase, find your fertile window, and know when to test. Includes the formula, a worked example, and why calendar math isn't birth control.

A pip is the smallest standardized price move a currency pair makes. For almost every pair that is 0.0001 — one ten-thousandth of a unit of the quote currency. For JPY pairs and for gold and silver, it is 0.01 — one hundredth. The reason for the exception is the yen, which is quoted to two decimal places against every major currency, so the fourth decimal that defines a pip elsewhere is too small to be a useful unit. A pip is not a unit of money. It is a unit of price movement, and its value in money depends on two things: the size of the position and the currency the account is held in. The pip value formula is one multiplication: pip size times position size in units. A standard lot is 100,000 units of the base currency, so a pip of 0.0001 times 100,000 units is 10 units of the quote currency per pip. A mini lot is 10,000 units, which is 1 unit of quote per pip. A micro lot is 1,000 units, which is 0.1 unit per pip. The pip value in the account currency is a second multiplication by a conversion factor that depends on whether the account currency is the quote currency, the base currency, or neither. If the account is in USD and the pair is EUR/USD, the quote is USD, so the conversion factor is 1 and the pip value is 10 USD per standard lot. If the account is in EUR and the pair is EUR/USD, the base is EUR, so the conversion factor is 1 divided by the exchange rate, and a 10 USD pip at a rate of 1.0850 is 9.22 EUR per standard lot. If the account is in GBP and the pair is EUR/USD, the account is neither the base nor the quote, and the conversion requires the GBP-to-USD rate, which the calculator cannot fetch and which you have to supply. The pip value calculation is the foundation of forex risk management, because the stop loss in pips times the pip value in the account currency is the dollar amount you are risking, and that dollar amount divided into your account balance is the percentage risk, which is the number that decides whether you survive a losing streak. Learn what a pip is (0.0001 for most pairs, 0.01 for JPY pairs and metals, and why), the pip value formula (pip size x position size in units, in the quote currency), the three lot sizes that matter (standard 100,000, mini 10,000, micro 1,000, nano 100), the three conversion cases for the account currency (quote, base, or cross), why the cross case needs a manual rate (the calculator cannot fetch live FX rates), how the pip value feeds the risk calculation (SL pips x pip value = dollar risk), why gold and silver use 0.01 (broker convention, not an IEEE rule, and some brokers use 0.1 instead), why the notional value for a base-currency account is just the units (because the base currency is what you are buying 100,000 of), and what a pip calculator cannot do (fetch live rates, accept entry and stop prices, model swap and commission, or tell you where to put your stop).

Position sizing is the one calculation that decides whether a trading strategy survives a losing streak or blows up on it. The math is one division: take the dollar amount you are willing to risk on a trade, divide it by the per-unit distance from your entry to your stop, and the result is the number of units to trade. If you are willing to risk 200 dollars on a stock where your stop is 5 dollars below your entry, you buy 40 shares. That is the entire formula. The discipline is the part that fails, because the formula forces you to decide two things before you enter: how much money you are willing to lose, and where your stop is. Most retail traders invert the order. They pick a position size first (usually a round number of shares or a round dollar amount), then look for a stop that fits, then get stopped out because the stop was placed to fit the size rather than to be where the trade idea is wrong. Position sizing is the practice of making the risk amount and the stop the inputs and the size the output. The percentage-of-balance risk model is the standard: you risk a fixed percentage of your account per trade, typically 0.5 to 2 percent, and the dollar risk is your balance times that percentage. A 1 percent risk on a 10,000 dollar account is 100 dollars, and that 100 dollars is what you divide by the per-unit stop distance. The model compounds correctly: when your balance grows, your position size grows; when your balance shrinks, your position size shrinks, which protects you during losing streaks. The model also caps your drawdown: if you risk 1 percent per trade, you need 69 consecutive losing trades to lose half your account, which is essentially impossible for any strategy with a positive edge. The four asset classes (stocks, forex, crypto, futures) each have a wrinkle. Stocks are the simple case: one share is one unit, and the per-unit risk is the entry-to-stop distance in dollars. Forex introduces the pip: a pip is the smallest standard price increment for a currency pair, and the pip value depends on the lot size and the quote currency, so the per-unit risk has to be converted to pips and then to dollars. Crypto introduces leverage: a 10x leverage on a 5,000 dollar account lets you hold a 50,000 dollar position, but the position size formula does not change, only the margin calculation does, and liquidation is the risk that the formula does not capture. Futures introduce the contract multiplier: one ES futures contract is 50 times the index price, so one point of price movement is 50 dollars, and the per-unit risk has to be multiplied by the multiplier to get the per-contract risk. Leverage and margin are not part of the position size formula. They are a separate calculation: the margin is the notional value divided by the leverage, and the notional value is the position size times the entry price. The formula gives you the position size; the leverage gives you the margin requirement; the two are independent. The risk-of-ruin calculation is what makes the 1 percent rule work: with a 1 percent risk per trade and a strategy that wins 50 percent of the time with a 1.5-to-1 reward-to-risk ratio, the probability of ruin over any finite sequence is effectively zero, because the expected value per trade is positive and the position size shrinks as the balance shrinks. The reward-to-risk ratio is the other input that the calculator uses, but it is not part of the position size formula. It is a separate calculation: the reward per unit is the entry-to-target distance, and the R:R is the reward per unit divided by the risk per unit. A 1.5-to-1 R:R means you make 1.5 dollars for every dollar you risk, and a strategy with a 50 percent win rate at 1.5-to-1 R:R has a positive expected value. Learn the percentage-of-balance risk model (dollarRisk = balance x riskPct, units = dollarRisk / |entry - stop|), why the 1 percent rule exists (it caps drawdown at 50 percent over 69 consecutive losses, which is the practical survival threshold), why the stop is the input not the output (you decide where the trade is wrong, then size to that), how leverage interacts with position size (it does not change the size, only the margin), how the four asset classes differ (stocks are simple, forex has the pip conversion, crypto has liquidation, futures has the multiplier), why the forex pip calculation in the tool is simplified (it treats the entry-to-stop price difference as the pip distance, which only works if you enter the pip count directly), why the exceeds-balance warning only fires for non-leveraged positions (leveraged notional is supposed to exceed balance), why fees are not in the R:R (the calculator's R:R is price-based, fees are added to the loss side but not subtracted from the profit side), and what a position size calculator cannot do (handle multiple open positions, account for correlation, model slippage, model liquidation price, or tell you where to put your stop).

Simple interest charges interest on the principal only, never on accumulated interest. Learn the formula I = P times r times t, why the monthly interest is flat (not declining like an amortizing loan), when simple interest is actually used in real lending, and why the difference between simple and compound interest grows exponentially over time.

Population standard deviation divides by N. Sample divides by N-1. Pick the wrong one and your answer is biased. Learn the formula step by step, why Bessel's correction exists, what the number actually tells you, and when the empirical rule fails.

Time duration arithmetic looks simple until you mix units. Adding 2h 30m to 1h 45m is base-60 carry math, not decimal addition. Converting between seconds, minutes, hours, days, weeks, months, and years requires fixed conversion factors, but months are 28-31 days and years are 365 or 366. The tool uses average values (30.44 days per month, 365.25 days per year) which are correct in aggregate and wrong for specific calendar periods. Learn interval overlap detection (max of starts, min of ends), the speed-distance-time triangle, work hours with overtime, and why UTC offsets are not fixed (DST changes them).

The baseline formula is 35 mL per kg of body weight per day for adults, adjusted for age (40 mL/kg under 18, 30 mL/kg over 55), activity level (0-800 mL bonus), climate (0-700 mL bonus), and pregnancy or breastfeeding (300-700 mL). Learn why the 8x8 rule is a rough approximation that happens to be close for a 55 kg sedentary adult in a temperate climate, why food contributes about 20 percent of daily fluid, what hyponatremia is and why drinking over 1 liter per hour is dangerous, and why thirst is the most reliable guide for healthy adults.

WHR is waist circumference divided by hip circumference — a ratio, not an absolute measure. WHO classifies male WHR below 0.90 and female below 0.80 as low risk, above 1.00 (male) or 0.85 (female) as high risk. Learn why central adiposity (visceral fat around organs) is more metabolically dangerous than peripheral fat (hips, thighs), why BMI cannot distinguish a bodybuilder from a sedentary person at the same weight, what 'normal-weight obesity' (TOFI: thin outside, fat inside) means, how measurement technique affects results (waist at narrowest point above navel, hip at widest point of buttocks), why WHO thresholds are based on European populations and underestimate risk for South Asian and East Asian bodies, and how age and menopause shift fat distribution.

The FIRE number is the portfolio size at which you can live off investment returns indefinitely and stop working for money. The acronym is Financial Independence, Retire Early, and the movement popularized it in the 2010s, but the math is older than the movement. The core formula is annual expenses divided by the safe withdrawal rate, and at the conventional 4% safe withdrawal rate this simplifies to annual expenses times 25 — spend 40,000 dollars a year, multiply by 25, your FIRE number is 1,000,000 dollars. The 4% safe withdrawal rate comes from the Trinity Study, a 1998 paper that tested withdrawal rates against historical market returns and found that a portfolio of stocks and bonds survived 30 years of withdrawals in 95% of historical scenarios when the initial withdrawal rate was 4% of the starting portfolio, adjusted for inflation each year. The 4% rule is a study, not a promise. It is based on US market returns from 1926 to 1995, it assumes a 30-year retirement, it assumes a 50/50 to 75/25 stock-bond allocation, and it has a 5% failure rate. It is not a guarantee. The math of the FIRE number is one division. The judgment is everything else. Learn how the 25x rule is derived (annual expenses / 0.04 = annual expenses x 25), what the four FIRE variants actually mean (Lean is 70% of expenses x 25 for the minimalist, Fat is 200% of expenses x 25 for the upgraded lifestyle, Coast is the portfolio you need today so compound growth alone gets you to FIRE by traditional retirement age, Barista is half the FIRE number plus part-time income), why the safe withdrawal rate is the variable that matters most (3% is safer but takes 33x expenses, 4% is the Trinity default at 25x, 5% is aggressive at 20x), why the return rate should be real not nominal (a 30-year retirement has three decades of inflation; a 7% nominal return with 3% inflation is a 4% real return, and if you use the 7% you will overestimate your portfolio by a factor of two), why Coast FIRE is a present-value calculation (the portfolio you need today so that, with no further contributions, it compounds to the FIRE number by your retirement age — formula is FIRE / (1+r)^(years to retirement)), why Barista FIRE is not actually modeled by most calculators (the part-time income is a label, not a computation — the calculator gives you half the FIRE number and stops), why Lean and Fat FIRE often ignore the SWR you set (they hard-code the 25x multiplier, so if you set SWR to 3.5% the headline number rises but Lean and Fat do not), why the years-to-FIRE calculation assumes constant contributions (no salary growth, no inflation escalation, no career-stage income changes — it is a closed-form annuity formula, not a simulation), and what a FIRE calculator cannot do (model sequence-of-returns risk, taxes, Social Security, salary growth, asset allocation glide paths, or the 30-year withdrawal phase itself).

YouTube pays creators 55 percent of ad revenue — but the amount per 1,000 views varies by a factor of 7.5 depending on niche. Finance channels earn $12-15 CPM. Gaming channels earn $2-3. Same views, same audience size, different income. Learn what CPM (cost per mille) and RPM (revenue per mille) actually measure, why advertisers pay more for finance audiences than gaming audiences (purchasing power and intent), why only 60-70 percent of views are monetized (ad blockers, non-monetized regions, limited-ads content), how the monetization pipeline works (views to monetized views to gross revenue to creator share), why the 45/55 split means a $10 CPM nets the creator $5.50, and why ad revenue is only one of five income streams for established creators (memberships, Super Chat, merch, sponsorships, affiliate links).

Validate your hreflang tags before Google does — check for missing x-default, non-reciprocal links, wrong language codes, and relative URLs, with a free browser checker.

Audio file size is sample rate times bit depth times channels times duration. A 3-minute stereo CD-quality track at 44,100 Hz, 16-bit, 2 channels is 30 megabytes — 44,100 x 16 x 2 x 180 / 8. Reduce any of those four numbers and the file shrinks proportionally. Cut the sample rate to 22,050 Hz and the file halves. Cut to 8,000 Hz (telephone quality) and it drops to 18 percent of the original. Convert stereo to mono and it halves again. Drop bit depth from 16-bit to 8-bit and it halves once more. A 3-minute 8 kHz mono 8-bit file is 1.4 megabytes — 4.7 percent of the CD original, a 95 percent reduction. Learn what the Nyquist theorem says about sample rate (it must be at least twice the highest frequency you want to capture, so 44.1 kHz captures up to 22 kHz, 8 kHz captures up to 4 kHz which is why telephone audio sounds muffled), why bit depth controls dynamic range (6 dB per bit, so 16-bit gives 96 dB and 8-bit gives 48 dB), why stereo matters for music but not for voice, why the tool outputs WAV PCM rather than MP3 (browser-based MP3 encoding requires a library, and WAV is uncompressed but the size reduction comes from fewer samples not from codec compression), how peak normalization to 0 dBFS maximizes loudness without clipping, and why codec-based compression (MP3, AAC, Opus) achieves much smaller files than PCM parameter reduction at similar perceived quality.

Turn a CSV export into a clean, aligned GitHub-flavored Markdown table in seconds — plus the escaping, alignment, and big-table gotchas that trip people up.

Hexadecimal is base 16, using digits 0-9 and A-F. Learn positional notation (value = sum of digit times base^position), the conversion algorithm for both directions, why hex exists as a compact shorthand for binary (each hex digit maps to exactly 4 bits), where hex actually appears in the wild (colors, memory addresses, byte values), and why BigInt matters for large hex numbers.

The standard conversion is hourly times 40 times 52 equals annual salary, using 2,080 hours. Learn why the real number of paid hours is usually 1,920 to 2,000 (holidays, PTO, sick leave), the difference between bi-weekly (26 paychecks) and semi-monthly (24 paychecks), how to convert a salary back to an hourly rate for freelance pricing, and why gross salary and take-home pay differ by 25 to 35 percent.

Turn a JSON array into ready-to-run SQL INSERT statements — with the dialect quoting, NULL handling, and type gotchas that decide whether the insert actually runs.

Writing numbers as words is a naming convention, not a mathematical operation. The number 1,234,567 reads as 'one million two hundred thirty-four thousand five hundred sixty-seven' because of a system that groups digits by thousands and names each group. But the group names are not universal. In the US and modern UK, a billion is 10^9 (one thousand million). In the older UK long scale and most of continental Europe, a billion was 10^12 (one million million) and a milliard was 10^9. The same number written differently across cultures. Learn how the short scale names large numbers (million 10^6, billion 10^9, trillion 10^12, quadrillion 10^15, quintillion 10^18), why each step multiplies by 1,000 in short scale but by 1,000,000 in long scale, how the Latin roots give the names (bi- = 2, tri- = 3, quadri- = 4), why the US and UK say 'one hundred twenty' but older British English says 'one hundred and twenty', how decimals are read digit by digit (3.14 = 'three point one four', not 'three and fourteen hundredths'), why ordinals have irregular forms (one becomes first, two becomes second, three becomes third, five becomes fifth, twelve becomes twelfth, twenty becomes twentieth), why JavaScript's number type loses precision above 2^53 (about 9 quadrillion), and why the Indian numbering system (lakhs and crores) does not fit the thousand-grouping model.

A PDF page is a fixed-size canvas — usually A4 or US Letter at 72 points per inch. An e-reader screen is 6 inches diagonal at 167 PPI. Shrinking a full PDF page to fit makes text unreadably small. EPUB solves this by making text reflowable. Learn the EPUB file structure (it is a ZIP with mimetype, META-INF/container.xml, OEBPS/content.opf manifest+spine, OEBPS/toc.ncx navigation, and XHTML chapters), why the mimetype file must be uncompressed and first in the ZIP, how PDF.js extracts text using Y-coordinate line detection, why each PDF page becomes a chapter instead of detecting real chapter boundaries, what EPUB 2.0 vs 3.0 means for compatibility, and why images, tables, and multi-column layouts do not survive the conversion.

Converting a PDF to Markdown is not a format conversion, it is a text extraction with structure guessing layered on top. A PDF has no paragraphs, no headings, no lists — it has positioned text runs. The PDF format draws letters at exact x/y coordinates on a page, and the concept of a paragraph or a heading is reconstructed from the positions. Markdown, by contrast, is structural — it has paragraphs separated by blank lines, headings marked with number signs, lists marked with dashes. The converter has to read the PDF's positioned text runs, guess which runs form a line (by y-coordinate), guess which lines form a paragraph (by blank space), guess which lines are headings (by font size, all-caps, or short standalone lines), and guess which lines are list items (by bullet characters). Each guess is wrong sometimes, and the wrong guesses compound. Learn how a PDF-to-markdown converter actually works (pdf.js extracts text runs with their positions; the converter groups runs into lines by y-coordinate, sorts lines top to bottom, then applies heuristics to mark up the lines), why text-layer PDFs convert cleanly and scanned PDFs produce empty output (scanned PDFs are images with no text runs; the converter has nothing to extract — you need OCR, which is a different tool), why multi-column layouts produce garbled text (the converter does not detect columns; text from both columns at the same y-coordinate is merged into one line), why tables become a flattened list of cell contents (no table detection; the row and column structure is lost), why bold and italic are lost (pdf.js's text extraction does not expose font weight or style; the converter has nothing to read), why the 60-character heading heuristic misclassifies short paragraphs and dialogue as headings (any standalone line under 60 characters becomes a subheading), why the converter runs entirely in your browser (pdf.js is a JavaScript library; no server upload), and what to use when the converter is not enough (pandoc for structured academic PDFs, Marker or docling for layout-aware extraction, Tesseract or Adobe's OCR for scanned PDFs).

PDF is a fixed-layout format that stores text as positioned characters, not paragraphs. PowerPoint is a reflowable format with slides, text boxes, and editable elements. Converting between them is inherently lossy because positions do not map to structure. Learn how PDF.js extracts text from the content stream, why the first line becomes the slide title and the rest becomes the body, why line breaks are approximated by Y-coordinate proximity, why scanned PDFs produce empty slides, and when this conversion actually works versus when it produces garbage.

Power is a rate, not an amount. The watt is one joule per second — energy divided by time. A 100-watt light bulb uses 100 joules every second. A 1,000-watt microwave uses 1,000. A kilowatt-hour is not a unit of power; it is a unit of energy — 1,000 watts sustained for one hour, or 3.6 million joules. Power units multiply by factors (metric: W, kW, MW, GW, each 1,000x), but horsepower has variants that are not the same. Mechanical horsepower (used in the US and UK) is 745.7 watts. Metric horsepower (used in most of the rest of the world) is 735.5 watts — about 1.4 percent less. A 100-hp engine in the US produces 74.57 kW; the same 100 hp in Germany produces 73.55 kW. Learn why James Watt defined horsepower as 33,000 foot-pounds per minute (he was selling steam engines and needed a comparison to draft horses), why metric horsepower is defined as 75 kilograms lifted one meter per second (75 x 9.81 x 1 = 735.5 W), why BTU per hour is still the unit for HVAC (1 BTU/hr = 0.293 W, and a 10,000 BTU/hr air conditioner is about 2.93 kW), the difference between real power (watts) and apparent power (volt-amperes) in AC circuits, and why the tool does not include electrical horsepower (746 W exactly), boiler horsepower (9,809 W), or refrigeration tons.

Converting steps to calories is not a measurement, it is a chain of three estimates. The step count is the only thing you measured. Everything else — the stride length, the speed, the duration, the energy per unit time — is inferred. The formula is calories = MET x weight(kg) x time(hours), where MET (Metabolic Equivalent of Task) is a population-average intensity factor: 1 MET is resting, 3.5 is walking at 5 km/h, 8.0 is running at 9 km/h. Time is not measured; it is derived from steps x stride / assumed speed. Stride is not measured; it is estimated as 0.413 x height (a pedometer approximation from the 1990s). Speed is not measured; it is assumed at 5 km/h for walking and 9 km/h for running, regardless of your actual pace. Each of these estimates has a real error band, and the errors compound. The result is a number that is useful for tracking relative change (did you burn more this week than last) but unreliable for absolute truth (you did not burn exactly 347 kcal). Learn what MET actually is (oxygen consumption at rest, 1 MET = 3.5 mL O2/kg/min = about 1 kcal/kg/hr, so a 70 kg person burns about 70 kcal/hr doing nothing), why the formula multiplies MET by weight and time (a heavier person moves more mass, so burns more for the same activity), how stride length is estimated from height (0.413 x height for walking, 0.54 x height for running — a rough average that varies 10-15 percent between individuals), why the tool collects age and gender but does not use them (a known limit worth knowing), the difference between gross and net calories (gross includes the resting baseline you would burn anyway; net subtracts it; MET values are gross), why walking and running have different METs even at the same speed (running is less efficient — more vertical oscillation, more ground-contact force), and why heart-rate-based estimates from a fitness watch are usually more accurate than step-based estimates (heart rate tracks effort, which is what drives calorie burn, while step count tracks only cadence).

SVG scales infinitely. PNG does not. Learn how rasterization works (vector to pixel grid via Canvas), why viewBox determines your output size, when to use scale factors vs custom dimensions for retina, which format to pick (PNG vs JPEG vs WebP vs BMP), and the SVG features that silently fail during conversion.

Most unit conversions are just multiplication — inches to centimeters is x 2.54, pounds to kilograms is x 0.453592. Temperature is different. Converting Celsius to Fahrenheit requires multiplying by 9/5 AND adding 32, because the two scales have different zero points. Celsius puts zero at the freezing point of water. Fahrenheit put zero at a brine solution in 1724. Learn why the offset exists, why Kelvin has no degree symbol and never goes negative (absolute zero at 0 K = -273.15 C), why Rankine is Fahrenheit-based Kelvin, what Gas Mark means in UK ovens, why the historical scales (Delisle, Newton, Reaumur, Romer) died out, how wind chill is calculated (temperature + wind speed, NWS 2001 formula), and how the heat index combines temperature and humidity into apparent temperature.

Text to binary is not a cipher. It is character encoding — mapping each character to a number, then writing that number in base 2. The letter A is 65 in decimal, 0x41 in hex, 01000001 in binary. That is the whole thing for ASCII. But ASCII only has 128 characters — no accent marks, no Chinese, no emoji. UTF-8 fixes this with variable-length encoding: characters 0-127 are one byte (identical to ASCII), characters 128-2047 are two bytes, 2048-65535 are three bytes, and anything above that is four bytes. The Euro sign is three bytes. The party emoji is four. Learn how the byte values map to binary (8 bits, positions 2^7 through 2^0, divide-by-2 algorithm for conversion), why hex (base 16) and octal (base 8) are also shown alongside binary (programmers read hex faster than binary, octal shows up in Unix file permissions), how UTF-16 differs from UTF-8 (fixed 2-byte vs variable 1-4 byte), what bitwise operations do (AND/OR/XOR/NOT/shift on binary values), and why decoding requires knowing the encoding — the same byte sequence means different things in ASCII vs UTF-8 vs UTF-16.

GIF is limited to 256 colors and has no inter-frame compression, which is why your 2 MB video becomes an 8 MB GIF that looks worse. Learn the format's constraints, the frame-rate sweet spot, and when to use something else.

Weight conversion is multiplication by a factor, but the factors are not all decimal. The metric system is clean — 1 kilogram is 1,000 grams, 1 gram is 1,000 milligrams, every step is a power of 1,000. The imperial system is not. 1 pound is 16 ounces. 1 stone is 14 pounds. 1 US ton is 2,000 pounds but 1 UK long ton is 2,240. And precious metals use a different system entirely — a troy ounce (31.1 grams) is heavier than an avoirdupois ounce (28.3 grams), a troy pound has 12 ounces not 16, and a gold bar is 400 troy ounces or about 12.4 kilograms, not the 16 ounces per pound you expect. Learn how mass differs from weight (mass is intrinsic, weight is the force of gravity on that mass, measured in newtons not kilograms), why the metric system uses powers of 1,000 with the kilogram as the base unit (not the gram), why cooking conversions depend on density (1 cup of water is 236.6 grams but 1 cup of flour is 120 grams and 1 cup of sugar is 200 grams), how scientific mass units span 57 orders of magnitude (atomic mass unit at 1.66e-27 kg to solar mass at 1.989e30 kg), and why the intermediary-base-unit approach (convert to kilograms, then from kilograms) avoids an N-squared conversion table.

An XLSX file is not a spreadsheet. It is a ZIP archive containing a folder of XML files, and converting it to CSV is an exercise in unpacking the archive, reading the XML, and reconstructing the two-dimensional grid of cells that the spreadsheet application rendered on screen. The format is called Office Open XML, and it was designed for Microsoft Excel, not for data interchange. Every piece of information a spreadsheet needs — the cell values, the shared strings, the styles, the number formats, the formulas, the sheet names, the charts, the images — is stored in its own XML file inside the ZIP. A converter that wants to produce CSV has to open the ZIP, find the right XML files, parse them, and walk the cell references to build a grid. The hard parts are not the conversion itself. The hard parts are the shared strings table, the formula cache, the date detection, and the multi-sheet problem. Learn how an XLSX file is structured (the ZIP contains xl/sharedStrings.xml for strings, xl/styles.xml for number formats, xl/worksheets/sheet1.xml for the first sheet's cells, and xl/workbook.xml for the sheet list), why shared strings exist (Excel deduplicates repeated strings to keep file size down — the cell stores an index into a shared table, not the string itself), why a converter that does not read the shared strings table produces a column of integers instead of the actual text, why formulas are not computed by the converter (the XML stores the cached value, not the formula's result, and a freshly inserted formula that was never opened in Excel has no cached value), why the 1900 leap year bug means a date serial of 61 is March 1, 1900 not March 2 (Excel inherited the Lotus 1-2-3 bug that treats 1900 as a leap year; converters must subtract a day for serials above 60), why the date format ID is the only reliable way to detect dates (a numeric cell with a date number format is a date; a numeric cell without one is a number), why the time component is usually lost (most converters output date-only YYYY-MM-DD and discard the fractional part of the serial), why only the first sheet is converted by default (the other sheets are in sheet2.xml, sheet3.xml, and the converter has to be told to look at them), and what a converter cannot do (read .xls binary files, extract charts or images, preserve formatting, compute formulas, handle multi-sheet workbooks without explicit selection).

Markdown tables are pipe-delimited text — pipe characters separate columns, hyphens separate the header row from data, and colons in the separator row control alignment. Learn why `:---` means left, `---:` means right, `:---:` means center, why column padding in the source does not change the rendered output, how to put bold, italic, code, and links inside cells (inline formatting works, block formatting does not), why GitHub-Flavored Markdown extended the original Markdown spec to add tables (John Gruber's 2004 Markdown had no table syntax at all), how CSV import maps to table rows, what happens when cells contain pipe characters (escape them with backslash), and when to export to RST, AsciiDoc, or LaTeX instead of Markdown.

Extracting email addresses from a block of text is a regex problem. The pattern `[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+.[a-zA-Z]{2,}` matches most email addresses — but it also matches invalid ones, misses obfuscated ones, and cannot tell you whether an address actually accepts mail. Learn what the email regex components actually match (local part character class, @ symbol, domain labels, TLD minimum length), why obfuscated emails like user [at] domain [dot] com slip past the regex, how deobfuscation preprocessing converts bracketed and word-form addresses before extraction, why HTML input needs stripping (mailto: links, entity decoding, script/style removal), why CSV input needs delimiter handling, how email validation differs from extraction (RFC 5322 compliance vs pattern matching), and why deduplication with occurrence counting tells you more than a unique list.

Extracting frames from a video is a seek-and-capture operation, and the part nobody tells you is that browser-based extractors are not frame-accurate. The mechanism is the limit: the tool loads the video into a hidden video element, seeks to a timestamp, waits for the seeked event, and draws the current frame onto a canvas. The seek lands on the nearest keyframe, not the exact frame you asked for. Browsers do not expose frame-accurate seeking through the video element — they seek to the closest keyframe and decode from there. For a video with keyframes every 2 seconds, a request for the frame at 3.1 seconds lands somewhere between 2 and 4 seconds, and the frame you get is whatever the decoder produced. This is inherent to the canvas-capture approach, not a bug in any specific tool. Learn how the three extraction strategies work and when each is right (interval mode grabs every N seconds for a time-lapse summary; timestamps mode grabs specific moments you care about; nth-frame mode grabs every Nth frame for a stop-motion or analysis), why the 30fps assumption is baked into most nth-frame extractors and why it is wrong for 24, 25, 60, or 120 fps video (a frame number divided by 30 is only the right timestamp if the video is actually 30fps — for 60fps video you get half the frames you asked for), why PNG beats JPEG for frames with text or sharp edges (PNG is lossless; JPEG introduces block artifacts around text and lines at any quality setting), why JPEG beats PNG for frames with gradients or photographs (JPEG is 5 to 10 times smaller at a quality the eye cannot distinguish from the source), why the 50-frame cap exists in browser tools (each frame is held in memory as both a data URL and a blob; 50 frames at 1080p is tens of megabytes, and the browser tab will get sluggish past that), and what to use when the browser tool is not enough (ffmpeg for frame-accurate extraction at any scale, WebCodecs for in-browser frame-accurate work, mpv or VLC for one-off manual grabs).

A YouTube channel ID is the 24-character string starting with UC that is the channel's permanent identifier. Every YouTube channel has one, and only one. The @handle, the legacy /user/ username, and the /c/ custom URL are all aliases layered on top of the channel ID — they are display names, not identifiers, and YouTube can change or remove them without touching the channel ID. The channel ID is what the YouTube Data API expects, what third-party analytics tools require, and what you need if you are embedding a channel feed, building a subscription link with a return parameter, or doing any work that needs to point at a channel unambiguously. The problem with finding it is that the channel ID is only literally present in one of the four URL forms YouTube uses: the /channel/UCxxxxxxxxxxxxxxxxxxxxxx URL. The other three forms — @handle, /user/Name, /c/Name — do not contain the channel ID at all. To get the channel ID from a handle, you have to call the YouTube Data API (channels.list with forHandle=@handle), which requires an API key. There is no way to resolve a handle to a channel ID without an API call, because YouTube does not expose the mapping publicly outside its API. Learn the four YouTube identifier types (UC channel ID, @handle, legacy /user/ username, /c/ custom URL) and what each is for, why only the /channel/ URL contains the channel ID directly, why handles and usernames cannot be resolved to channel IDs without the YouTube Data API, how a pure URL parser finds the channel ID when it is in the /channel/ form and admits defeat when it is not (a known limit worth knowing), how to resolve a handle yourself with the YouTube Data API v3 channels.list endpoint, how to find your own channel ID through YouTube Studio without any tool, and what the common URL forms look like so you can recognize them on sight.

JSON is a strict subset of JavaScript, not the same thing. Learn the six syntax rules that make valid JS fail JSON validation, when to format vs minify, the JSON5 escape hatch, and how to generate TypeScript interfaces from an API response.

Formatting text for social media is not a styling operation. It is a Unicode substitution. When you paste text into a 'bold' or 'italic' generator and copy the output into an Instagram bio or a Twitter post, you have not made the text bold or italic. You have swapped each letter for a Unicode character in the Mathematical Alphanumeric Symbols block that happens to look like a bold or italic version of the original. The platform stores and displays that Unicode character. If the platform's font has a glyph for it, the character renders as bold-looking text. If it does not, the character renders as an empty box, called tofu. This is why bold text works on iOS and most modern Android but sometimes shows as boxes on older Windows or older Android. The text is not actually bold; it is a different character, and the platform's font decides what to do with it. The same mechanism is how circled text (U+2460 Enclosed Alphanumerics), squared text (U+1F130 Enclosed Alphanumeric Supplement), fullwidth text (U+FF01 Halfwidth and Fullwidth Forms), strikethrough text (U+0336 combining long stroke overlay), and the cursed Zalgo text (stacks of combining diacritical marks) all work. None of these are formatting. All are character substitution. Learn the four mechanisms a Unicode text formatter uses (lookup-table replacement, arithmetic code-point shift, combining-mark insertion, character reversal), why digits do not work in most styles (the Unicode blocks for italic, script, fraktur, and small caps do not define digit variants), why the combining-mark styles like strikethrough, underline, and bubble text render inconsistently across platforms (the marks are hints, not instructions, and each platform's text renderer decides how to stack them), why Zalgo text is non-deterministic and regenerates differently each time, why the platform character counter in these tools lies (it counts your original input, not the transformed output, and the transformed output is often 2 to 3 times longer in UTF-16 code units), why screen readers either ignore the styling or read every character as 'mathematical bold capital A' making the text incomprehensible, why Unicode-styled text is not searchable as the original on any platform, and when to use these styles and when to stop (sparingly, for emphasis — never for body text, never for bios you want people to find by name, never for anything a screen reader will read aloud).

Well-formed XML means parseable: single root, properly nested tags, quoted attributes, escaped ampersands. Valid XML means it conforms to a DTD or schema. Learn how DOMParser builds a tree and reports parsererror, the difference between formatting (re-serializing from the parsed tree) and minifying (regex-based whitespace and comment removal), how XML-to-JSON conversion works (attributes prefixed with @, text under #text, repeated children become arrays), XPath path expressions with predicates and functions, and why namespaces break XPath queries unless you declare them.

Formatting YAML is not the same as formatting JSON or XML, because YAML has comments, and almost every formatter drops them. The mechanism is the problem: most YAML formatters work by parsing the document into an in-memory tree and re-dumping it from the tree. The tree has no comments, because the parser threw them away during the parse. When the dumper writes the tree back out, there are no comments left to write. This is true of js-yaml, the parser behind most browser-based YAML formatters, and it is true of PyYAML in Python. The comments are gone the moment you parse, and no amount of dump options will bring them back. Learn how a YAML formatter actually works (parse the document with js-yaml into a JavaScript object, then dump the object back to a YAML string with your chosen indent, quote style, line width, and flow level), why comments are always lost (the parser discards them during the parse; the dumper has nothing to re-emit), what your options are when you need to keep comments (use the eemeli/yaml library, which preserves comments in its AST, or use prettier with the yaml plugin, which does the same — or edit by hand), how the indent, quote-style, line-width, and flow-level options affect the output (indent sets the spaces per level, quote style forces single or double quotes on all strings, line width wraps long scalars, flow level switches from block style to flow style with braces and brackets), why multi-document YAML files (with --- separators) need special handling (each document is parsed and dumped separately, then rejoined), how anchors and aliases work (an anchor &name marks a value, an alias *name references it, a merge key <<: *name pulls in the anchored mapping — js-yaml resolves these during parse, and the dump option noRefs controls whether they reappear as anchors or get inlined), why the 'Tab indentation' option in some formatters is a lie (js-yaml does not support tab characters for indentation in its dump; the button sets the indent to 2 spaces regardless), and when to use a formatter at all (when you inherited an inconsistently indented file, when you want to normalize quote style, when you want to convert between YAML and JSON).

Generate a scannable barcode by picking the right format, computing the check digit, and keeping the quiet zone. Covers EAN-13, UPC-A, Code 128, ITF-14, Codabar, and Pharmacode.

A MAC address is 48 bits. The first 24 bits are an OUI the IEEE assigns to a vendor. The last 24 bits are a device identifier the vendor assigns. Two bits in the first octet are reserved for meaning, not identity: bit 0 says unicast or multicast, bit 1 says locally administered or universally unique. A MAC generator that ignores those bits produces addresses that look valid but break on a real network. A MAC generator that sets them correctly produces addresses that work as ephemeral interface identifiers, as virtual machine MACs, as Docker bridge addresses, as privacy MACs for mobile devices, and as test fixtures. The generator's job is small but precise: pick 6 random bytes, set or clear the two reserved bits in the first byte according to the user's choice, optionally pin the first 3 bytes to a vendor OUI, format the result. The choice of randomness source matters more than it looks: the device portion is 24 bits, which is 16 million possible values, and a generator using Math.random with a 56-bit internal state can collide within a few thousand outputs. A generator using crypto.getRandomValues cannot, in any practical sense, collide. The four output formats are cosmetic — colon-separated (AA:BB:CC:DD:EE:FF), hyphen-separated, no separator, and Cisco dotted (AABB.CCDD.EEFF) — and which one you use depends on which tool expects which input. The vendor OUI database is a small static list of about two dozen vendors, not the full IEEE registry of 30,000-plus, and selecting a vendor does not preserve the vendor's original U/L bit, because the generator always overwrites bits 0 and 1 of the first byte to match the user's selection. Learn the 48-bit structure (OUI 24 + NIC 24), the two reserved bits in the first octet (unicast/multicast at bit 0, locally/universally administered at bit 1), why locally administered is the right choice for generated MACs (the OUI belongs to a vendor you are not, so claiming universal administration is wrong), why crypto.getRandomValues matters for the device portion (24 bits is small enough that Math.random collides within thousands of outputs), how vendor OUI prefixes interact with the bit override (selecting Apple and locally administered turns 00:1A:2B into 02:1A:2B), why the Cisco dotted format exists (routers and switches use it in ARP tables and interface configs), how privacy MACs in iOS and Android use the locally-administered bit, why virtualization platforms use specific OUI prefixes (VMware 00:50:56 and 00:0C:29, Hyper-V 00:15:5D, VirtualBox 08:00:27, KVM 52:54:00), why Docker bridge addresses start with 02:42 (locally-administered bit set, then 42 as the Docker identifier), and what a MAC generator cannot do (validate that an OUI is actually assigned, produce EUI-64 addresses, lowercase output, or download results despite what the FAQ claims).

Random string generation has two meanings. For a UI test placeholder, Math.random is fine — speed matters, unpredictability does not. For a password, API key, session token, or nonce, Math.random is broken. JavaScript's Math.random uses a PRNG (pseudo-random number generator) initialized from a predictable seed and observable state. Anyone who can run code in the same process can predict the next output. The cryptographic alternative is crypto.getRandomValues, which pulls entropy from the operating system and is unpredictable even to an attacker running in the same browser. Learn how entropy is calculated (log2 of charset size times length — 16 characters from a 62-character alphabet gives 95 bits, 20 characters gives 119 bits), why 128 bits is the security threshold (brute-force at 10^18 operations per second takes years to exhaust), why adding symbols helps less than adding length (an 8-character alphanumeric string has 47 bits; adding 20 symbols gets it to 52 bits; doubling the length gets it to 95 bits), how ambiguous characters (0 and O, l and 1, I and l) make tokens unreadable for humans, how pronounceable strings trade entropy for memorability (vowel-consonant alternation), why no-repeat mode uses permutations not independent picks (entropy = log2(n!) not log2(charset^n)), and why the modulo bias in many CSPRNG wrappers is a negligible but real source of non-uniformity.

A UUID is a 128-bit identifier with 2^122 random bits in version 4, making collisions practically impossible. Learn the UUID structure (version nibble at position 12, variant nibble at position 16), how v4 uses random numbers, v1 uses a 60-bit timestamp from the Gregorian epoch of October 1582, v7 uses a Unix millisecond timestamp for sortability, v3 and v5 hash a namespace and name with MD5 or SHA-1 for deterministic output, and how ULID and NanoID compare for shorter or sortable identifiers.

Placeholder images fill layout slots before real assets exist. Learn why SVG placeholders are infinitely scalable and under 500 bytes while PNG equivalents are 10-100x larger, why JPEG compression produces visible artifacts on solid-color placeholders (blocky banding from DCT quantization), why WebP is the modern replacement for both, how the Canvas 2D API renders raster placeholders (fillRect for backgrounds, createLinearGradient for gradients, stroke loops for patterns), how SVG placeholders are generated as text strings (rect + text elements, no rendering engine needed), why social media platforms require specific dimensions (Instagram 1080x1080, Twitter 1200x675, YouTube 1280x720), and why blueprint mode with dimension annotations is better for technical mockups than plain colored rectangles.

Naming a brand is a known hard problem, and the reason is structural. Every dictionary word in English is registered as a .com. Every common compound (RedHouse, BlueBird, FastFox) is registered. Every common suffix (-ify, -ly, -io, -hub) has been tried thousands of times. The namespace is exhausted at the obvious layer, so usable brand names live one layer down — in portmanteaus (Pinterest = pin + interest), in foreign roots (Velox is Latin for swift), in empty-vessel coinages (Google, Spotify, Zynga) that mean nothing until the brand fills them with meaning, and in deliberate misspellings (Lyft, Flickr, Tumblr). The job of a brand name generator is to produce candidates at that layer, not the exhausted one. Learn the two big naming strategies (descriptive names like General Motors that tell you what the company does, vs empty-vessel names like Apple that mean nothing and let the brand define them — descriptive is easier to launch, empty-vessel is easier to trademark and scale), why the .com is almost always taken and the four real ways to deal with that (buy it, use a modifier like getname.com, use a different TLD like .io/.co/.ai, or pick a name nobody owns), the seven naming patterns generators use (compound like Facebook, portmanteau like Microsoft, suffix mashup like Shopify, foreign root like Volvo, metaphor like Apple, acronym like IBM, invented coinage like Kodak), the radio test (can you spell the name over the phone without confusion — Lyft passes, Lfyt fails), why trademark classes matter (a name can be trademarked in one class and free in another; you must search USPTO before falling in love), why the industry input in this tool is collected but unused (a known limit worth knowing), and why 'AI' in the tool's name is marketing, not mechanism (the generator is a seeded combinatorial picker, not a language model).

A Reddit username is a 3-to-20-character string that is yours forever. Reddit does not let you change it. When you create an account, the name you type is the name you have for the life of the account, and if you want a different one you have to start a new account and lose your karma, your post history, your subreddit memberships, and your saved posts. So the choice matters more than on most platforms, and the choosing is harder than on most platforms, because Reddit has been around since 2005 and has tens of millions of accounts. The obvious names are taken. The short names are taken. The dictionary words are taken. The reasonable combinations of two short words are mostly taken. What is left is either long, awkward, or includes numbers. A username generator does the easy part of this problem — it produces 20 candidates that match Reddit's format rules — and leaves the hard part to you, which is checking whether any of them are actually available. The format rules are simple: 3 to 20 characters, only letters, digits, underscores, and hyphens, cannot start with a digit, case-insensitive on the backend but with display casing preserved. A generator can validate all of these in the browser without any network call. The availability check is the part the generator cannot do, because checking availability requires asking Reddit's servers whether a name is taken, and Reddit does not expose a public API for that. The only way to check is to type the name into the Reddit signup page and see if Reddit accepts it. A generator that claimed to check availability would either be lying, or would be scraping the signup page, or would be using a private API that could break at any time. So the honest generator stops at format validation and tells you to check availability yourself. Learn the Reddit username rules (3-20 chars, charset, no leading digit, case-insensitive storage), why a generator cannot check availability (no public API, scraping is brittle, the privacy tradeoff of not sending your name ideas to a server), how the six vibe presets actually work (Serious, Playful, Nerdy, Edgy, Professional, Mysterious, Random — each selects a different adjective word bank, but the nouns, verbs, and colors are shared across all vibes), how variants are constructed (a word from the vibe's adjective bank plus a word from a shared noun bank, concatenated in PascalCase, with optional numbers, underscores, or mixed-case), why the MixedCase style is partly defeated by the case-insensitive dedup (the generator drops duplicates case-insensitively, so two differently-cased versions of the same base name cannot coexist in one batch), why long adjective-noun combinations get truncated to mid-word garbage (the generator builds the full string first, then truncates from the right to 20 characters, so AlgorithmicCryptographic becomes AlgorithmicCryptograph), why the hyphen is valid but never produced (the word banks do not contain hyphens, and keywords with hyphens are filtered out before use), and the actual workflow for getting a name that is available on Reddit (generate, scan for ones that fit your vibe, paste each into reddit.com/signup, take the first one Reddit accepts).

Dividend returns depend on DRIP (reinvesting after-tax dividends into new shares), dividend growth rate, and price growth rate. Learn how yield on cost climbs when dividends grow, why a 3 percent yielder with 8 percent growth beats a 5 percent yielder with no growth over 20 years, how tax interacts with DRIP, and why the model assumes constant growth that real companies never deliver.

Resizing an image for social media is not one operation. It is two. The first is scaling the image to the platform's required dimensions. The second is cropping the image to the platform's required aspect ratio. The two are different, and the second is the one that ruins photos. The dimensions are published numbers — Instagram square post is 1080 by 1080, portrait is 1080 by 1350, story is 1080 by 1920, Twitter post is 1200 by 675, Facebook link preview is 1200 by 630, LinkedIn post is 1200 by 627, YouTube thumbnail is 1280 by 720. The aspect ratios follow from these dimensions — 1:1, 4:5, 9:16, 16:9, 1.91:1. The numbers are the easy part. The crop is the hard part. Your photo is rarely the right aspect ratio to begin with, and the crop takes things out of the frame. A landscape photo cropped to Instagram's 4:5 portrait cuts off the sides. A portrait photo cropped to Twitter's 16:9 landscape cuts off the top and bottom. A photo with a face near the top cropped to a Facebook cover cuts off the face. The crop is where photos die, and the crop is the decision the resizer makes for you when you do not tell it otherwise. Learn the seven platforms and their preset dimensions (Instagram, Twitter/X, Facebook, LinkedIn, YouTube, TikTok, Pinterest — 29 presets in total across the major placements), why the dimensions are what they are (they are display-native multiples — Instagram displays at 1080 pixels wide on a phone, so 1080 is the width that avoids a resample on the way to the screen), why cover-crop is the only mode that works for social media (the platform fills the frame; an image with letterboxing looks broken), why the focal point matters more than the dimensions (the focal point tells the resizer which part of the image to keep when the crop takes the rest), why JPEG beats PNG for photos and PNG beats JPEG for screenshots and graphics with text, why the transparency in your source image becomes solid white in the output (the resizer paints a white background under the image before drawing, so any transparent regions in the source PNG become white, even when the output is PNG), why EXIF orientation can produce a rotated result (mobile phones shoot in landscape and tag the photo with an orientation flag; a resizer that does not read the flag draws the photo in landscape, then you see it rotated on the platform), and what a social image resizer cannot do (handle safe zones for text overlays, enforce platform file size limits, generate multiple sizes at once, preserve transparency).

The Black-Scholes model prices a European option by computing the probability-weighted present value of its payoff, given five inputs: stock price, strike, time to expiry, risk-free rate, and volatility. A sixth input, dividend yield, extends it to the Merton version. Four of those inputs are observable. The stock price is on the screen. The strike and expiry are in the contract. The risk-free rate is published. The dividend is announced. Volatility is the one you cannot read off anything. You have to estimate it from historical price data or back it out of other option prices, and the price the model gives you is extremely sensitive to which number you pick. Learn what d1 and d2 actually represent (d1 is the risk-adjusted distance to the strike in standard deviations; N(d2) is the risk-neutral probability the option expires in the money), why the call formula has two terms (the present value of receiving the stock weighted by N(d1), minus the present value of paying the strike weighted by N(d2)), why put-call parity must hold (C - P = S*e^(-qT) - K*e^(-rT), and if it doesn't, there is an arbitrage), what the five Greeks measure (Delta is the hedge ratio, Gamma is the convexity, Theta is the time decay per day, Vega is the sensitivity to a 1 percent volatility move, Rho is the rate sensitivity), why Theta is divided by 365 and Vega by 100 (trading conventions, not the textbook annualized figures), what the volatility smile is evidence of (the constant-volatility assumption is wrong; options at different strikes trade at different implied volatilities), and why this tool is European-only (American options with early exercise need a different model).

Diff checkers use the Longest Common Subsequence algorithm, which has no modify operation — only equal, add, and remove. Learn how LCS works (dynamic programming, O(m times n), greedy fallback for large inputs), why what the UI calls a modified line is actually a removed line paired with an added line by Levenshtein similarity, when to use line vs word vs character granularity, and how ignore options normalize before comparing.

Matrix addition is element-wise, but matrix multiplication is a dot-product operation that requires the inner dimensions to match. Learn the dimension rule (cols of A must equal rows of B), how each cell of the product is computed, why AB is not BA, what the determinant measures (volume scaling, zero means singular), how Gauss-Jordan elimination produces the inverse, and what RREF and rank tell you about linear independence.

A random word generator picks from a list using Math.random, which is pseudorandom, not cryptographic. Learn how word list size determines passphrase entropy (bits = wordCount times log2 of list size), why filtering by letter or length destroys entropy, the difference between sampling with and without replacement, and when PRNG is fine and when it is not.

The arithmetic mean is not always the right average. Learn when to use the geometric mean (growth rates, returns) and harmonic mean (speeds, rates), why median plus IQR beats mean plus SD for skewed data, the 1.5xIQR outlier rule, and what skewness and kurtosis actually tell you.

Most unit conversions are multiply-by-a-ratio. Temperature, fuel economy, and data storage are not. Learn the three conversion types, the KB-vs-KiB trap, and why energy and power are different categories.

A Unix timestamp counts seconds since January 1, 1970 UTC. Learn why the 32-bit signed integer limit (2147483647) means millions of systems break on January 19, 2038 at 03:14:07 UTC, how auto-detection distinguishes seconds from milliseconds (10-digit vs 13-digit heuristic), why timestamps are timezone-independent (they count UTC seconds, display is local), how date arithmetic with timestamps differs from calendar arithmetic, and how a world clock shows the same instant across timezones.

An AI Instagram caption generator does not write your caption. It assembles four fixed structures — short and punchy, long-form story, question-based, educational — from your topic and drops in a tone-specific emoji, a call to action, and a handful of hashtags. The output is scaffolding, not a finished post. The four styles are not decorative; each maps to a different reader behavior and a different content goal. Short and punchy works for feeds where nobody taps 'more'; long-form story works when the photo is the hook and the caption is the payoff; question-based works when comments are the metric you are optimizing for; educational works when the post is a carousel or reel and the caption is the takeaway summary. Learn what each of the four styles is actually for (and when each fails), why the tone selector only changes the emoji and the call to action but leaves the four body templates untouched (a 'promotional' tone still produces a mindset-story narrative — a known limit worth knowing), why the 'AI' in the tool's name is marketing rather than mechanism (the generator is a deterministic template engine seeded by a sine-based pseudo-random number generator, not a language model — same inputs always produce identical output, and the 'Regenerate' button is a no-op), why your description past the first 80 characters is ignored by every template, why the niche field is cosmetic (it appends one hashtag and perturbs the seed; it does not customize the hashtag pool to your niche), why 5 to 15 hashtags outperforms the 30-tag maximum, and why the 2,200 character limit is a ceiling, not a target.

Physics formulas are relationships between quantities, not equations to memorize. Learn the five formula families, when to use each kinematic equation, the unit-consistency rule that causes most wrong answers, and which constants aren't actually constant.

A social media bio is a 30-to-220-character string that explains who you are, what you do, and why someone should follow you. The hard part is not the writing. The hard part is the compression. A bio is shorter than a tweet on every platform that matters — Instagram caps at 150, Twitter at 160, TikTok at 80, LinkedIn at 220, YouTube at 1000. You have to fit your role, your niche, your location, your call to action, and some signal of personality into a space that holds about two sentences. Every word costs you, and the costs compound. A bio generator does the easy part of this problem. It produces a list of template strings with your inputs substituted in — your role, your interest, your location, your industry, your goal, your audience — and shows you what the filled-in templates look like against the platform's character limit. The hard part, which is the choice of which template matches your actual voice and which inputs actually describe you, is left to you. The generator is a scaffolding tool, not a writing tool. It gives you eight candidates per click, with five tone presets (Professional, Creative, Minimal, Emoji-Rich, Humorous) and ten niche presets (General, Fitness, Tech, Beauty, Food, Travel, Business, Art, Music, Gaming). The candidates are deterministic — the same inputs and the same preset produce the same candidates, with only three random number placeholders (age, percent, percent) changing between clicks. The generator is honest about this in its design: it does not claim to be an LLM, it does not claim to know your voice, and it does not claim to produce a finished bio. It produces a draft that you edit. Learn the five platform character limits and what each one implies for structure (Instagram 150 — two sentences plus a CTA; Twitter 160 — two short fragments; TikTok 80 — one fragment, no CTA; LinkedIn 220 — three fragments, professional tone; YouTube 1000 — a real paragraph, not a bio), why the five tone presets only change the template phrasing and the emoji selection, not the underlying structure (Professional uses pipe-delimited fragments, Creative uses sentence form, Minimal uses periods, Emoji-Rich inserts emojis next to placeholders, Humorous uses self-deprecation and Ctrl+C jokes), why the ten niche presets matter less than you think (each niche has 2 to 3 templates per tone, and the templates overlap heavily across niches), why the same bio looks different on each platform (the character limit changes what fits, the platform culture changes what reads well, the audience expectation changes what works), why the LinkedIn limit is 220 not 2600 (220 is the headline field, not the About section — the bio generator targets the headline, which is the field that appears under your name on posts and comments), why the TikTok 80-character limit breaks most templates (many templates produce 100+ characters even with short inputs, and the tool shows the over-limit warning but does not truncate), why the company placeholder exists in the templates but has no input field (a known gap — templates reference {company} but the form never collects it, so it defaults to 'MyBrand'), and the actual workflow for turning a generator's draft into a finished bio (generate, pick the template that is structurally closest, edit every word, count the characters, paste, repeat).

Instagram truncates captions after roughly 125 characters in the feed. Learn the hook-context-CTA-hashtag structure, when to use each tone (casual, professional, funny, inspirational, promotional), category-specific caption patterns for food/travel/fitness/fashion/business/lifestyle/selfie, why 5-15 hashtags outperforms 30, and the 2,200 character hard limit.

YouTube tags used to be a primary lever for ranking. They are not anymore. YouTube's own Creator Academy now describes tags as a minor signal, useful mostly for misspellings and disambiguation, and says the title, description, and thumbnail matter far more. The 500-character tag field still exists and still gets filled, but the evidence that it moves a video up the search results is thin. What tags do well is help YouTube understand what a video is about when the title is vague, and surface it in related-video queues when a viewer's watch history is ambiguous. They are a hedge, not a strategy. Learn how YouTube actually uses tags (for misspellings, disambiguation, and related-video surfacing — not as a primary ranking factor), how the 500-character limit is counted (multi-word tags are wrapped in quotes and the whole field is comma-joined, so a 30-character tag with a space costs 32 characters), why long-tail tags beat broad tags (broad tags like 'react' compete with millions of videos; long-tail tags like 'react hooks useEffect cleanup tutorial' target a specific intent with far less competition), why the hierarchy is title >> description >> tags (the title is the single biggest on-page signal), how the tag generator produces tags by combinatorial suffix expansion (keyword + 'tutorial', + 'guide', + '2026', + 'for beginners', plus niche-specific suffixes — not keyword research), why year-tagged tags ('react hooks 2026') date your content and hurt long-term performance, why the tool's plural/gerund morphology is naive English (it appends 's' or 'ing' by rule, which fails on irregular verbs), and what to actually do if tags matter (front-load the most important tags, keep the field under 500 characters, and spend your real effort on the title and thumbnail).

Open an OpenAPI 3.x or Swagger 2.0 file, find the endpoints that matter, and read a schema fast — in the browser, with nothing to install. A practical walkthrough plus the parts of the spec worth knowing.

Generate a JSON Schema from an existing JSON payload in seconds, then tighten it by hand. Covers types, required fields, enums, formats, and the four things a generator can't infer.

A complete guide to free online calculators for finance, health, dates, and math — with the formulas behind each, so you understand the numbers, not just get them.

A complete 2026 guide to on-page SEO: search intent, title tags, meta descriptions, URLs, headings, keywords, content depth, internal links, image alt text, schema, and social previews.

Generate an XML sitemap for your website in minutes with a free, browser-based tool, plus tips on lastmod, priority, and submitting to Google.

A practical 2026 guide to free social media tools for creators and marketers: hashtags, captions, bios, link-in-bio, post timing, character counts, and more.

A complete 2026 guide to technical SEO: crawling, indexing, robots.txt, sitemaps, canonicals, redirects, HTTPS, Core Web Vitals, schema, and hreflang.

A practical guide to online text tools: count words, change case, clean whitespace, dedupe lines, compare texts, find-and-replace, sort, and more in your browser.

Create a robots.txt file in minutes with a free browser-based generator: pick a preset, set crawl rules, add your sitemap, test URLs, and download.

A complete, practical guide to image optimization for the web: formats, compression, sizing, responsive images, lazy loading, alt text, and a raw-to-shipped workflow.

A practical 2026 guide to the free online developer tools every web dev needs: JSON, regex, encoding, hashing, minifying, API debugging, and data conversion.

Learn how to create a QR code for free in your browser — link a URL, text, Wi-Fi, or contact, then download a print-ready PNG or SVG. No sign-up.

A practical 2026 guide to AI writing tools: how LLM-based tools work, the jobs they do well, how to prompt and edit them, real risks, and where they fit an SEO workflow.

Discover the 15 best free SEO tools in 2026 that require no signup. Boost rankings, analyze keywords, and optimize your site instantly online.

Learn how to minify CSS and JavaScript (plus HTML) in your browser to shrink file sizes, cut load times, and ship faster pages.

Learn to test a regular expression in your browser: paste a pattern and sample text, set flags, read live matches and capture groups, and debug.

Convert PNG to WebP free in your browser with The Toolbox image format converter. Step-by-step guide plus tips for JPG, BMP, and quality settings.

Learn how to create a favicon for your website from an image, text, or emoji, then export every size plus the HTML tags in one browser-based step.

Learn what meta tags are and how they impact SEO. This complete guide covers title tags, meta descriptions, and best practices for higher rankings.

Learn how to remove image background for free in your browser with a click-to-sample tool that exports a transparent PNG. No upload, no sign-up.

Run a WHOIS and DNS lookup for any domain in your browser: find registrar, expiry, name servers, and A/MX/TXT records with The Toolbox.

Resize an image online in seconds: set exact pixels or a percentage, lock the aspect ratio, preview the result, and download. No upload, no sign-up.

Convert HEIC to JPG free in your browser, no upload or sign-up. A step-by-step guide using The Toolbox HEIC to JPG converter, plus tips and FAQ.

Learn how to password-protect a PDF in your browser, set a strong password, choose AES encryption, and lock permissions with no upload or sign-up.

Learn how to test website speed with The Toolbox's free in-browser speed test, read the metrics, and fix what's slowing your pages down.

Use this web accessibility checklist to make your site WCAG compliant. Covers color contrast, alt text, keyboard navigation, and free testing tools.

Convert images to PDF in your browser: combine JPG, PNG, or WebP files into one PDF, reorder pages, and set page size, margins, and orientation.

Learn how to split a PDF into separate files for free in your browser, by page range, every N pages, or one file per page, with no upload.

Learn how to compress a PDF without losing quality in your browser: pick a compression level, fine-tune image quality, and download a smaller file.

Learn to check SSL certificate details—expiry, issuer, chain, and TLS settings—using a free in-browser SSL checker, plus how to read the live cert.

Learn how to merge PDF files online for free in your browser - no upload, no sign-up. Combine multiple PDFs into one in a few clicks.

Your complete unit conversion reference guide. Covers length, weight, temperature, volume, and digital units with formulas and free converter tools.

Learn how to decode a JWT in your browser: paste the token, read the header, payload, and claims, and check expiry safely.

Learn how to write an Instagram bio that converts: a clear formula, a step-by-step walkthrough with a free AI bio generator, plus tips and FAQs.

Learn how schema markup works and how to get rich results in Google. Step-by-step guide to structured data for higher click-through rates.

Check password strength in your browser: see entropy, estimated crack time, and a 0-100 score, then fix weak passwords. Free, no upload, no sign-up.

Learn how to generate hashtags for Instagram, TikTok, and more with a free browser tool, plus a strategy for mixing popular and niche tags.

Learn how to generate a strong password in your browser with a free password generator: length, character sets, passphrases, and entropy explained.

Explore the best free online PDF tools for merging, splitting, compressing, and converting PDFs. No signup needed, works in your browser instantly.

Learn how to summarize an article or long text fast: paste it into a free AI summarizer, set the length, and get a clean recap.

Learn how to convert units online for length, weight, and temperature with free in-browser converters, plus tips, rounding advice, and a quick FAQ.

Learn how to write a meta description that earns clicks: ideal length, what to include, and a fast AI-assisted workflow to draft and refine yours.

Learn how to create strong passwords that protect your accounts. Covers password best practices, common mistakes, and free generation tools.

Convert a Unix timestamp to a date in your browser: paste the epoch, pick a timezone, and read the human-readable date instantly.

Learn how to check grammar online for free with an AI grammar checker: paste text, review AI suggestions, and polish your writing in seconds.

Master JSON formatting with best practices for developers. Learn validation, structure, naming conventions, and tools to write cleaner JSON code.

Learn how to convert JSON to CSV in your browser: paste data, pick a delimiter, flatten nested objects, and download a clean spreadsheet file.

Learn how to paraphrase text fast with The Toolbox's free AI Paraphraser: pick a mode, set intensity, freeze key terms, and review every variation.

Learn how to rewrite an article without plagiarizing using an AI article rewriter, plus manual checks to keep your draft original and accurate.

Convert YAML to JSON in your browser: paste, pick indentation, copy clean JSON, and turn JSON back to YAML. No upload, no sign-up.

Learn how to compress images without losing quality. Step-by-step guide covering formats, tools, and techniques for faster websites and better SEO.

Learn how to count the days between two dates in seconds, plus the manual method, business days, and how to include the end date correctly.

Check readability score in seconds with The Toolbox: paste your text, read Flesch and grade-level numbers, and edit until your writing is clear.

Learn how to use a word counter to improve your writing. Discover tips for hitting word counts, tracking readability, and writing better content fast.

Learn how to calculate a discount and sale price fast: the percent-off formula, a free discount calculator, reverse pricing, coupon stacking, and tax.

Convert Markdown to HTML in your browser: paste, pick GFM/sanitize/full-document options, then copy or download clean HTML.

Learn how to calculate a tip fast: use a free tip calculator or do the percentage math by hand, split the bill, and handle tax and rounding.

Learn how to remove duplicate lines from any text in seconds with a free browser tool, including case, sorting, and whitespace options.

Learn how to calculate compound interest by hand and with a free online calculator, including the formula, contributions, and compounding frequency.

Learn how to compare two texts and spot every difference in seconds using a free browser-based diff tool, with views, ignore options, and merge.

Learn how to calculate loan payments fast with a free browser tool, plus the monthly payment formula explained step by step.

Learn how to change text case to uppercase, lowercase, title case, and more in your browser, fast and free with no sign-up.

Calculate your age down to the exact years, months, and days with a free online age calculator. Step-by-step guide plus the formula behind it.

Learn how to calculate your BMI in seconds with a free browser tool, plus the formula, categories, and what the number really means.

Learn how to calculate a percentage three ways by hand and instantly with a free online percentage calculator, with worked formulas and examples.

Learn how to write effective meta titles and descriptions that improve your search rankings and click-through rates.

Learn what schema markup is, why it matters for SEO, and how to implement it on your website to get rich snippets in Google.