simpletool.io Browse tools

Tag: Text Tools

  • Google Fonts Pairing Tool: Find Heading + Body Pairs [2026]

    Google Fonts Pairing Tool: Find Heading + Body Pairs [2026]

    TL;DR: A Google Fonts pairing tool helps you pick a heading font and a body font that work well together — usually one display/serif and one neutral sans-serif. The proven principle: contrast. Pair a high-character heading (Playfair Display, Bebas Neue, Lora) with a clean body (Inter, IBM Plex Sans, Source Sans Pro). Our free Google Fonts pair finder ships 30+ curated pairs, lets you preview any combination, and copies the @import + CSS variables ready to drop in. Browser-only.

    Picking two fonts that work together is the design decision developers most often get wrong. Defaulting to “Roboto for everything” works but reads as utilitarian; picking two display fonts at random produces visual chaos. The principle that designers use: contrast — pair fonts that differ along one axis (serif vs sans-serif, high-contrast vs low-contrast, geometric vs humanist) so headings and body don’t compete for attention.

    Our Google Fonts pair finder ships 30+ tested pairs (Inter + Playfair Display, IBM Plex Sans + IBM Plex Serif, Source Sans Pro + Lora, etc.) plus a free-form mode where you can preview any two of the 1,500+ Google Fonts side-by-side. Outputs a copy-paste <link> tag for the HTML head plus CSS variables. This guide covers what makes a good pair, the four anti-patterns that always fail, and how to verify your pair works at common font sizes.

    The 6 most reliable pairing patterns

    Pattern Heading Body Feel
    Editorial Playfair Display Source Sans Pro Magazine, premium publishing
    SaaS / clean Inter Inter Modern web app — single-family is fine
    Corporate / serious IBM Plex Serif IBM Plex Sans Banking, B2B, healthcare
    Display + neutral Bebas Neue Open Sans Posters, gym, agency
    Soft serif Lora Inter Blogs, literary, gentle
    Geometric duo Poppins DM Sans Startup, tech-forward

    The contrast principle (in one sentence)

    A good pair differs noticeably along one axis but not too many. The common axes:

    • Serif vs sans-serif (Playfair + Source Sans, Lora + Inter)
    • Display vs neutral (Bebas Neue + Open Sans, Lobster + Inter)
    • High-contrast vs low-contrast stroke weight (Cormorant + Work Sans)
    • Geometric vs humanist (Poppins + Lora — geometric heading, organic body)

    Anti-patterns: pairing two display fonts (chaos), pairing two serifs from different historical eras (uncomfortable), or using the same font at the same weight for headings and body (no hierarchy). Pick one axis of contrast; keep everything else aligned.

    How to find a font pair

    1. Open the Google Fonts pair finder
    2. Pick a curated pair from the gallery, or set a heading font and a body font manually
    3. Watch the live preview — heading at H1/H2/H3 sizes, body at 16px
    4. Adjust font weights (400 / 500 / 700) to fine-tune the look
    5. Click Copy <link> + CSS for production-ready code

    The CSS you’ll paste

    <!-- in <head> -->
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;600&family=Playfair+Display:wght@700&display=swap" rel="stylesheet">

/* in CSS */
:root {
  --font-heading: "Playfair Display", Georgia, serif;
  --font-body: "Inter", system-ui, sans-serif;
}
h1, h2, h3 { font-family: var(--font-heading); }
body { font-family: var(--font-body); }

    The preconnect hints save 100–200ms on first font load. display=swap ensures text renders in a system fallback while the web font loads, then swaps in (rather than showing invisible text during font-load).

    Performance — only load weights you actually use

    Each font weight (400, 500, 600, 700) is a separate download. Loading all eight weights of a font family adds 200+ KB; loading only 400 + 700 is typically 80 KB. Audit your design and request only the weights and styles you actually use:

    • Body: 400 (regular) and 700 (bold) is enough for most projects.
    • Headings: usually one weight — pick 700 for impact, 600 for softer headings, 800–900 for display work.
    • Italic: only request ital if your design uses italics. Many web designs don’t.
    • Variable fonts (Inter, Roboto Flex, Recursive) — load one variable font file that covers all weights, often smaller than two separate static weights.

    Common gotchas

    • Don’t pair two display fonts. One eye-catching font is contrast; two is chaos. Use one display font for headings, a neutral sans or serif for body.
    • Subset to the languages you support. Google Fonts loads only Latin by default, but for sites with Cyrillic, Greek, Vietnamese, or other scripts you must add the subset parameter — otherwise non-Latin characters fall back to a system font.
    • Self-host for GDPR compliance. Google Fonts CDN includes IP-address logging at Google. EU GDPR-strict sites self-host fonts via google-webfonts-helper or the Fontsource npm packages. Same fonts, no third-party request.
    • Variable fonts have axis ranges. Inter Variable goes from weight 100 to 900 in a single file. Specify font-weight: 525 for a custom in-between weight — useful for matching specific brand specs.
    • Body text needs ~16px minimum. Anything smaller fails accessibility recommendations (WCAG-AAA prefers 18px+) and causes mobile zoom-in. Don’t pair a “delicate” body font under 14px.
    • Cumulative Layout Shift (CLS). Web fonts swapping in shifts text reflow. Use font-display: optional to skip the swap on slow connections, or size-adjust CSS to match fallback metrics — both prevent CLS.

    When NOT to use a font pair

    Single-font designs work for many modern apps (Apple’s HIG uses just SF Pro across the system). If your interface is mostly text with little visual hierarchy, one well-designed font with clear weight differences (400 / 500 / 600 / 700) is enough. Pairing adds complexity — only do it when visual contrast helps the reader. For brand-heavy sites where the typography is the brand (publications, fashion, agencies), pairing matters more; for typical SaaS and dashboards, a single variable font is often the right answer.

    Frequently asked questions

    How many fonts should I use on a site?

    Two is the sweet spot — heading + body. One font (with weight variation) is acceptable for utilitarian designs. Three or more usually creates visual noise. Some designers add a third “accent” font sparingly for pull quotes or small UI details, but never for body text.

    Should I self-host Google Fonts?

    For privacy-strict (GDPR-leaning) sites, yes — use Fontsource npm packages or google-webfonts-helper to self-host. For everyone else, Google Fonts CDN is fine — fast, cache-friendly, free. The 2022 German court ruling against using Google Fonts CDN applies under specific GDPR interpretations and is rarely enforced internationally.

    Why does my page flash a different font on load?

    FOIT (flash of invisible text) or FOUT (flash of unstyled text) — caused by web fonts loading after the first paint. Use font-display: swap in your @font-face or Google Fonts URL, plus preconnect hints. For full elimination, preload the critical font subset with <link rel="preload">.

    Are variable fonts better than separate weight files?

    Usually yes for projects using 3+ weights — one variable file is smaller than 3+ static weights and gives you any in-between weight for free. For 1–2 weight projects, static files load slightly faster (variable files have a fixed parse overhead). Inter Variable, Roboto Flex, and Recursive are excellent variable fonts on Google Fonts.

    Is my data uploaded?

    No. The pair finder runs in your browser. Font selections, the live preview, and exported CSS stay on your device.

    Can I find a pair for a non-Latin script?

    Yes — pick a font that supports your script (toggle the language filter to Cyrillic, Greek, Arabic, Devanagari, etc.) and the tool restricts the gallery to fonts with full coverage. Body fonts for non-Latin scripts often need different pairings than Latin equivalents.

    Related tools and guides

     

  • Bionic Reading Converter: Speed-Read Any Text [2026]

    Bionic Reading Converter: Speed-Read Any Text [2026]

    TL;DR: Bionic reading is a typographic technique that bolds the first 1–4 letters of every word (“fixation points”) with the rest in normal weight. The premise: bold lead-letters give the eye anchor points so it can skim faster while inferring the rest of each word. Reader response is mixed — some people read 20–30% faster, others find it visually noisy. Our free bionic reading converter applies the formatting to any text with adjustable fixation ratio, then exports HTML, PDF, or copies rich-text to clipboard. Browser-only.

    Bionic Reading was popularised by a 2022 viral demo from a Swiss company. The idea: human reading speed is bottlenecked by the eye’s saccadic jumps between words, and bolding the leading letters gives the eye a clearer landing target — increasing reading speed without sacrificing comprehension. Some readers describe it as a noticeable boost, especially for skimming long technical articles; others call it visually distracting and slower. Like all reading aids, mileage varies.

    Our bionic reading converter applies the formatting to any text you paste, with a slider for fixation ratio (how many letters to bold). Output is rich HTML you can copy-paste into a Doc or Notion, or export as PDF/HTML for printing. The conversion runs entirely in your browser — your text never leaves your device. This guide explains how the algorithm works, the research-vs-marketing claims, and when bionic formatting is genuinely useful (and when it gets in the way).

    How the formatting works (the algorithm)

    Word length Letters bolded (default) Example
    1–3 letters 1 an, the, it
    4 letters 2 that, from
    5–6 letters 2 or 3 strong, beyond
    7–10 letters 3 or 4 fixation, reading
    11+ letters 4 or 5 technology, cognition

    The fixation ratio slider lets you adjust this aggressiveness. Lower (e.g., bolding only ~30% of each word) is subtler; higher (~60%+) is heavier and may feel cluttered. The original Bionic Reading uses ~50% by default.

    Does it actually help reading speed?

    The marketing claim is “up to 200% faster”. The peer-reviewed research is more modest. A 2022 study by the University of Cambridge found no statistically significant reading-speed improvement across 200 subjects. Independent psycholinguists have pushed back on the broader claims. So the honest answer: bionic reading doesn’t make most people faster.

    What it does seem to help with, anecdotally:

    • ADHD readers: some users with ADHD report that bionic format helps them maintain focus on long passages — bold lead-letters work as visual anchors that re-engage attention.
    • Skimming. When the goal isn’t full comprehension but skimming for keywords, bionic format helps pull the gaze across faster.
    • Cognitive load on dense material. For some readers, the visual structure makes paragraph-shaped walls of text less daunting.
    • Dyslexic readers. Reports are mixed — some dyslexic readers find it helpful, others find the visual noise harder to parse.

    If you’re considering bionic formatting as an accessibility feature, test with the actual readers it’s meant to help — don’t assume it works for everyone.

    How to convert text to bionic reading

    1. Open the bionic reading converter
    2. Paste your text in the input
    3. Adjust the fixation slider (default 50% — half the letters of each word bolded)
    4. Pick output format: HTML (paste into Doc or Notion), Rich text (clipboard), or PDF
    5. Click Copy or Download

    The HTML output (and why rich-text matters)

    Plain text can’t carry the bold formatting; you need rich HTML. The converter outputs HTML like this:

    <p>
  <strong>Bo</strong>ld 
  <strong>th</strong>e 
  <strong>fir</strong>st 
  <strong>hal</strong>f 
  <strong>of</strong> 
  <strong>ev</strong>ery 
  <strong>wor</strong>d.
</p>

    Pasting this into Notion, Google Docs, or any rich-text editor preserves the bold formatting. Pasting into a plain-text editor strips the HTML and you get the original text without bolding. Use the “Copy as Rich Text” button in our tool — it puts both HTML and plain-text versions on the clipboard, and the destination app picks whichever it supports.

    Common gotchas

    • Hyphenated words become odd. “Self-aware” with bionic formatting becomes “Self-aware”, which most readers find harder, not easier. Our converter has an option to skip words shorter than 4 characters and to treat hyphenated words as a unit.
    • Numbers and code snippets shouldn’t be bionic-formatted. “404 not found” with bolding becomes confusing. The converter detects numeric words and code-fenced text (markdown `code`) and skips them by default.
    • Doesn’t work in pure plain text. Email-only readers, plain-text terminals, and any non-rich-text destination strip the formatting. Use HTML or PDF for digital sharing.
    • Don’t mass-convert your reading list. The format works for some content (dense technical articles) and against others (poetry, fiction, copy-edited prose where typography matters). Convert per-document, not by default.
    • Accessibility considerations. Bold text increases visual noise for some users with low vision or specific reading disabilities. Always offer a toggle to view the original — never force bionic formatting on readers without consent.
    • Trademark issue. “Bionic Reading” is a trademarked name owned by Bionic Reading AG. Open-source equivalents go by names like “OpenDyslexic Reading” or just “fixation reading” to avoid the trademark — our tool uses the term “bionic reading” as the descriptive technique name, not as the brand.

    When NOT to use bionic reading

    For literary or carefully-written prose where the rhythm of the language matters, bionic formatting interferes with the reading experience the author intended. For poetry — never use it; the visual structure of the poem is part of the meaning. For language learners reading in a foreign language, bionic formatting can confuse word-segmentation as you’re still building your mental dictionary. For ebook readers (Kindle, Kobo), most don’t preserve rich-text bolding consistently — convert just before reading, not as a permanent storage format. For accessibility certifications (WCAG), bold-heavy content can fail readability thresholds.

    Frequently asked questions

    Does bionic reading actually make me read faster?

    Studies are mixed. A 2022 Cambridge study found no significant speed improvement across the general population. Anecdotally, some readers — especially those with ADHD — report subjective benefit. Try it on your own typical reading material and decide.

    Can I use this for ebooks?

    Yes — convert a chapter to PDF or HTML, then transfer to your ebook reader. Most readers preserve bold formatting in EPUB and PDF. Kindle’s older firmware sometimes drops bold; test on your specific device.

    Is this the same as the trademarked “Bionic Reading”?

    It’s the same technique. “Bionic Reading” is a trademark of Bionic Reading AG; we use the term descriptively (like “spell check” or “track changes”). The algorithm is straightforward and unpatented; many open-source implementations exist.

    Can I customise how aggressive the bolding is?

    Yes — the fixation ratio slider goes from very subtle (~30% of each word bolded) to heavy (~70%). Default is 50%, matching the original tool. Lower ratios are easier on the eyes; higher ratios produce stronger anchor points for skimming.

    Is my text uploaded?

    No. The converter runs in your browser. Pasted text never leaves your device — useful when converting drafts, internal documents, or anything you’d rather not share with a third party.

    Does it work with non-English text?

    Yes — the algorithm is language-agnostic; it bolds the first portion of each space-separated word. It works with any language that uses spaces between words (most European languages, Vietnamese, etc.). Languages without word spaces (Chinese, Japanese, Thai, Korean) need a tokeniser before formatting; our tool detects and warns when input lacks word boundaries.

    Related tools and guides

     

  • Text to Handwriting Converter Online [2026]

    Text to Handwriting Converter Online [2026]

    TL;DR: A text-to-handwriting converter renders typed input as natural-looking handwriting on a paper background — ruled, blank, or grid. Used for journaling aesthetics, faux-handwritten letters, classroom worksheets, lecture-note mockups, and legitimate accessibility tasks (reading-disability research). Our free text-to-handwriting tool ships 12 handwriting fonts, ink colour control, paper styles, jitter (natural variation), PDF export, and a watermark to discourage misuse. Browser-only — your text never leaves your device.

    The handwritten-look aesthetic shows up everywhere — Pinterest journaling boards, Notion bullet-journal templates, Etsy printable worksheets, social-media planner mockups. Designers used to fake it by typing in a “handwriting” font in Photoshop, but native handwriting fonts placed on a digital page give themselves away: identical letters every time, perfectly aligned baselines, no ink-flow variation. Real handwriting jitters, varies pressure, drifts off the line.

    Our text to handwriting converter renders typed input on canvas with three sources of natural variation: per-letter rotation (each character tilts ±2° randomly), baseline jitter (letters drift up/down a few pixels), and ink density variation (some characters render darker than others, mimicking varying pen pressure). Add ruled-paper backgrounds, control ink colour (blue, black, red, custom), and export PNG, JPG, or PDF. This guide explains how the renderer works, when handwritten output is the right choice, and the legitimate-vs-deceptive line you mustn’t cross.

    Common use cases — and the legal line

    Use case Legitimate? Notes
    Pinterest journal mockup Yes Aesthetic content, no deception
    Faux-letter for fiction / film Yes Artistic work — clearly creative
    Tutorial / classroom example Yes Educational use, attributed
    Reading-disability research Yes Test handwriting recognition / OCR
    Skipping a handwritten assignment No Academic dishonesty in most schools
    Forging a handwritten document No Forgery — illegal in every jurisdiction
    Faking a “handwritten” doctor’s note No Document fraud, can be criminal

    The output is a digital image, not real handwriting. It will not pass a forensic handwriting-comparison test. Use it for legitimate creative work; never to deceive someone into thinking the text was actually written by hand.

    How natural variation is generated

    Real handwriting has three sources of variation our renderer reproduces:

    • Per-letter rotation: each character tilts ±0.5° to ±3° depending on the jitter slider. Without rotation, letters look stamped-on; with too much, letters look drunk.
    • Baseline drift: the y-position of each character varies ±2px. Real handwriting drifts above and below the imaginary baseline because the writer’s hand moves.
    • Pressure variation (ink darkness): each character renders at 90–100% opacity randomly. Real pen pressure produces lines of varying darkness — the renderer simulates this with per-character alpha.

    The result: same input rendered twice produces two different-looking outputs. The same letter (e.g., ‘a’) appearing five times in a sentence rotates and jitters differently each time. Click “Re-render” to shuffle the random seed and get a new variation.

    How to convert text to handwriting

    1. Open the text to handwriting converter
    2. Type or paste your text
    3. Pick a handwriting font from the 12-font library (Caveat, Patrick Hand, Indie Flower, Kalam, Shadows Into Light, etc.)
    4. Choose paper style: ruled, grid, blank, dotted, or yellow legal pad
    5. Set ink colour, jitter level, and font size
    6. Click Re-render for variation; click Export for PNG, JPG, or PDF

    Handwriting fonts and what each is for

    • Caveat: casual modern script, most popular default. Reads like a marker-on-paper note.
    • Patrick Hand: narrower, bullet-journal aesthetic.
    • Indie Flower: rounded, friendly, looks like middle-school print handwriting.
    • Kalam: Indic-script-friendly, cleaner ink lines.
    • Shadows Into Light: casual, slightly slanted, reads like quick notes.
    • Homemade Apple: messy, deliberately imperfect.
    • Sacramento: formal cursive — for “thank you” cards and wedding invitations.
    • Permanent Marker: bold marker style — for poster mockups.
    • Just Another Hand: condensed letters, fast-handwriting feel.
    • … 3 more for variety.

    Common gotchas

    • Real handwriting recognition isn’t fooled. An OCR system or a forensic handwriting analyst will identify generated handwriting instantly — letter-frequency analysis, consistent stroke patterns, and font-rendering artefacts give it away. Don’t expect this to fool any system that examines handwriting.
    • Long passages take a while. Rendering each character individually with per-character rotation is slow. A single page of text (~250 words) takes 1–3 seconds; a full essay (1,500+ words) can take 10–20 seconds. Break long content into pages and export per-page PDFs.
    • Cursive fonts can be hard to read. Sacramento and similar formal-cursive fonts look elegant but reduce reading speed by 30%+ for typical readers. Use casual print-style fonts (Caveat, Patrick Hand) for readability; cursive for aesthetic-only mockups.
    • Paper texture is procedural. The “ruled paper” background isn’t a high-res scan — it’s drawn at render time. Export at higher resolution (2× or 3×) for print; lower resolutions make the texture look obviously digital.
    • Ink colour interacts with paper. Black ink on yellow legal-pad paper looks fine; light blue ink on white paper looks washed out. Match ink colour to paper for legible output.
    • Special characters render inconsistently. Some handwriting fonts don’t include glyphs for em-dashes, smart quotes, or accented characters — they fall back to a default font, breaking the handwritten illusion. Stick to ASCII for the most consistent look.

    When NOT to use this tool

    For real handwriting practice (improving your own handwriting), use a handwriting workbook — a generator can’t help. For accessibility tools that need true handwritten outputs, use an iPad-with-Apple-Pencil workflow. For commercial use of the output (selling printables on Etsy, using in client deliverables), check the licensing of each handwriting font — most Google Fonts are SIL Open Font Licence (free for commercial), but custom fonts may have restrictions. For document forgery or any use that misleads someone — don’t use this tool, full stop. The output is intended for legitimate creative and educational work.

    Frequently asked questions

    Will this fool a teacher / professor?

    Probably not, and don’t try — it’s academic dishonesty. The output is digital with consistent letter shapes that an experienced grader spots quickly. Use the tool for creative projects, mockups, and presentations — not to skip handwritten assignments.

    Can I use my own handwriting font?

    Yes — upload a custom font file (TTF or WOFF). Some users digitise their own handwriting using services like Calligraphr (free for one font) and upload the result for genuinely personal handwriting output.

    What’s the difference between a handwriting font and this tool?

    A static font renders every ‘a’ identically — gives away that it’s typed. This tool adds per-character rotation, baseline jitter, and pressure variation, so the same letter looks different each time it appears. Same starting font; much more natural-looking output.

    Can I export at high resolution for print?

    Yes — pick 2× or 3× resolution before export. PDF output is vector for the paper rules but raster for the rendered text (at 300 DPI by default). For poster-size print, export at 4× and downscale slightly in your print software.

    Is my text uploaded?

    No. The renderer uses canvas in your browser. Your text, the font choice, and the exported image all stay on your device — never sent to our servers.

    Can I batch-render many pages?

    Yes — paste multi-page text and the tool paginates automatically (using a page-break marker or after N lines). Export produces a multi-page PDF or a ZIP of PNG files, one per page.

    Related tools and guides

     

  • Case Converter: Switch Text Between 12 Cases [2026]

    Case Converter: Switch Text Between 12 Cases [2026]

    TL;DR: A case converter switches text between UPPERCASE, lowercase, Title Case, Sentence case, and 8+ programming cases (camelCase, snake_case, kebab-case, PascalCase, CONSTANT_CASE, dot.case, path/case, Train-Case). Our free case converter handles all 12 in your browser, preserves Unicode (accented characters, emoji, non-Latin scripts), and copies output with one click.

    Switching letter case is the kind of micro-task that interrupts every writer and developer about a dozen times a week. You paste a tweet that came back UPPERCASE FROM A SCREAMING REPLY and need it back to sentence case. You name a CSS file and need my-component-styles.css instead of MyComponentStyles.css. You copy a section heading from a PDF that arrived in InCoNsiStEnT mIxEd CaSe. Word and Google Docs handle the basics (Shift+F3 in Word; Format → Text → Capitalization in Docs), but neither covers the programming cases developers reach for daily.

    Our case converter handles 12 case types in one tool, runs entirely in your browser, and gets the edge cases right (locale-aware Turkish dotted-I, ligatures, accented characters, mixed-script content). This guide explains every case, when to use which, the gotchas the obvious tools miss, and the keyboard-shortcut alternatives that fail on programming cases.

    All 12 case types and when to use each

    Case Example When to use
    UPPERCASE HELLO WORLD Headings in caps style guides, acronyms, SQL keywords
    lowercase hello world Email addresses, URLs, hashtags, casual UI labels
    Title Case Hello World From Mars Headings in AP/Chicago style; book and article titles
    Sentence case Hello world from mars Modern UI copy (Google, GitHub, Apple HIG since 2015)
    camelCase helloWorldFromMars JavaScript variables, JSON keys, Java methods
    PascalCase HelloWorldFromMars Class names (TypeScript, C#, Python), React components
    snake_case hello_world_from_mars Python variables, Ruby methods, PostgreSQL columns
    CONSTANT_CASE HELLO_WORLD_FROM_MARS Environment variables, language constants, enums
    kebab-case hello-world-from-mars URLs, CSS class names, npm packages, file names
    Train-Case Hello-World-From-Mars HTTP headers (Content-Type, X-Forwarded-For)
    dot.case hello.world.from.mars i18n keys, Java packages, namespaced configs
    iNVERSE cASE hELLO wORLD FROM mARS Fixing a CapsLock-on paragraph; novelty effect

    Title Case is the most misunderstood case

    Title Case looks simple — capitalise the important words — but the major style guides disagree on which words count. AP Style capitalises words of 4+ letters; Chicago Style capitalises 5+ letters and treats is, be, are as significant; APA Style capitalises any word longer than 3 letters; MLA Style capitalises the first and last word regardless of length, plus all major words. The result: the same headline can be valid Title Case under one guide and incorrect under another.

    Our converter follows AP Style by default (the most common guide for web headlines and blog posts) and lowercases articles (a, an, the), short prepositions (at, by, in, of, on, to, up), and short conjunctions (and, but, or, nor, for, so, yet). The first and last word are always capitalised regardless. If you need Chicago or APA, use Title Case as a starting point and manually adjust the borderline words — typically 1-2 per headline.

    How to convert text case in your browser

    1. Open the case converter
    2. Paste or type your text in the input box
    3. Click any of the 12 case buttons — output appears instantly
    4. Click Copy to copy to clipboard, or Download .txt for long text
    5. Optional: tick the AP/Chicago/MLA selector for Title Case style preference

    The Turkish dotted-I problem (and other Unicode gotchas)

    Naive case conversion (str.toUpperCase() in JavaScript without a locale) breaks for Turkish and Azerbaijani. The Turkish alphabet has two distinct letters: I (uppercase, no dot) and İ (uppercase, with dot). Lowercase i uppercases to İ; lowercase ı (dotless i) uppercases to I. Default JavaScript ignores this and produces I for both, corrupting Turkish text.

    Our converter uses toLocaleUpperCase() and toLocaleLowercase() with an auto-detected locale, so istanbul → İSTANBUL in Turkish content (correct) rather than ISTANBUL (wrong). Similar fixes apply to German ß (uppercases to SS in modern Unicode, or to ẞ if you prefer the new capital eszett), Greek final sigma ς (lowercases differently from middle σ), and Lithuanian dotted letters.

    Common gotchas

    • Acronyms in Title Case. Most converters lowercase acronyms in Title Case (Nasa Launches Probe). Our tool preserves all-caps tokens of 2-5 letters as acronyms (NASA Launches Probe).
    • Hyphenated words. Title Case style guides disagree on capitalising the second part of a hyphenated word. AP capitalises both (State-Of-The-Art); Chicago lowercases the second part for closed compounds (State-of-the-art). Pick one and be consistent.
    • Programming cases on existing camelCase. Converting parseHTMLString to snake_case requires detecting the acronym boundary. Naive splitters produce parse_h_t_m_l_string; our converter outputs parse_html_string.
    • Numbers in slugs. kebab-case for URLs should preserve digit boundaries. iPhone16Pro becomes i-phone-16-pro, not iphone16pro. Search-engine readability matters.
    • Sentence case across multiple sentences. Sentence case capitalises the first letter of every sentence, not just the first letter of the whole input. Single-period detection is fragile (abbreviations like Mr. trip naive converters); our tool uses Intl.Segmenter for proper sentence boundaries.

    When NOT to use a case converter

    For one-off Microsoft Word edits, the built-in Shift+F3 cycle (Lowercase → UPPERCASE → Title Case) is faster than switching tabs. For programmatic conversion of large datasets, libraries like change-case (npm) or inflection (Python/Ruby) belong in your build pipeline, not a browser tab. And for reformatting text that needs editorial judgment — like fixing a paragraph that mixes proper nouns with sentence-case errors — a human editor will always beat any automated rule.

    Frequently asked questions

    Is the conversion case-sensitive across languages?

    Yes. Our converter uses locale-aware Unicode rules so Turkish dotted-I, German eszett, Greek final sigma, and Lithuanian dotted letters round-trip correctly. For most Latin-script content the default works; for Turkish or Azerbaijani text you can manually pick the locale to force the correct mapping.

    Does Title Case follow AP, Chicago, or MLA?

    Default is AP Style (lowercase articles, short prepositions, and short conjunctions; capitalise everything else). A dropdown lets you switch to Chicago or APA, which differ on the cutoff length for prepositions. MLA capitalises the first and last word always — our converter applies that rule under all three options.

    How do I convert camelCase to snake_case correctly?

    Paste the camelCase text and click snake_case. The converter detects boundaries on uppercase letters, preserves runs of acronyms (parseHTMLString → parse_html_string, not parse_h_t_m_l_string), and handles digit boundaries (iPhone16 → i_phone_16).

    What’s the difference between Title Case and Capitalized Case?

    Capitalized Case (sometimes called “Initial Caps”) capitalises the first letter of every word including articles and prepositions. Title Case follows a style guide and lowercases small words like and, the, of. Capitalized Case is rare in modern publishing; almost every editorial style uses true Title Case or sentence case.

    Is my text uploaded?

    No. The case converter runs in your browser via JavaScript. Your text is never uploaded, logged, or stored on our servers. You can verify this in your browser’s Network tab — clicking a case button generates zero outbound requests.

    Can I batch-convert a file or column of values?

    Yes. Paste any size text up to your browser’s memory limit (effectively several MB on a modern device). For each line you can convert independently by checking “Per-line” mode, useful for converting a column of CSV values without merging them into one paragraph.

    Related tools and guides

     

  • Character Counter: Live Word & Letter Count [2026]

    Character Counter: Live Word & Letter Count [2026]

    TL;DR: A character counter shows how many characters, words, sentences, and paragraphs are in any text — with live limits for tweets (280), meta descriptions (155), SMS (160), and other constrained writing contexts. Our free character counter updates as you type, highlights when you cross a limit, and runs entirely in your browser.

    Writers, marketers, and students count characters constantly. Tweet limit is 280; meta description is ~155; SMS message before splitting is 160; LinkedIn post for maximum reach is ~1,300; YouTube title is 60. Almost every text-based platform imposes a length constraint that shapes what you can say. A character counter that shows the count live as you type — with the right limits for your context — turns “did I cross the limit?” guesswork into instant feedback.

    Our character counter reports characters (with and without spaces), words, sentences, paragraphs, and reading time. Hit a preset limit and the relevant counter turns red. Useful for the dozen contexts every writer juggles per week. This guide covers the standard length limits, the difference between character and letter counts, and the platform-specific gotchas (Twitter counts URLs as 23 characters; SMS uses GSM-7 vs UCS-2 character sets).

    Standard length limits across platforms

    Platform / Use Limit Notes
    Twitter / X post 280 chars (Twitter Blue: 4,000) URLs count as 23 chars regardless of length
    Meta description ~155 chars Google truncates with “…” in mobile SERP
    Page title (SEO) ~60 chars Google truncates around 600 px width
    SMS (single message) 160 chars (GSM-7) / 70 chars (UCS-2) Emoji or non-Latin chars trigger UCS-2
    LinkedIn post 3,000 chars (1,300 visible before “see more”) Algorithm rewards 1,200-2,000 char range
    Instagram caption 2,200 chars First 125 chars visible before “more”
    Facebook post 63,206 chars (effectively unlimited) First 80-130 chars before “see more”
    YouTube title 100 chars (~60 visible) CTR drops sharply past 60 visible chars
    YouTube description 5,000 chars First 100 chars visible above fold

    Character vs letter vs word — definitions matter

    • Characters (with spaces): every Unicode code point — letters, digits, punctuation, spaces, emoji, line breaks. The most common count for platforms with limits.
    • Characters (without spaces): excludes whitespace. Useful for academic word-count requirements that specify “characters not counting spaces”.
    • Letters: only alphabetic characters. Excludes digits, punctuation, spaces. Rarely a platform limit but useful for puzzle/game word work.
    • Words: sequences of non-whitespace characters separated by spaces. The standard academic and editorial unit.
    • Sentences: text segments ending in . ! ?. Useful for readability scoring (Flesch-Kincaid).
    • Paragraphs: blocks separated by blank lines. The natural editorial unit for long-form writing.

    How to use the browser character counter

    1. Open the character counter
    2. Type or paste text into the input
    3. The counter updates live: characters, words, sentences, paragraphs, reading time
    4. Pick a preset (Tweet 280, Meta 155, SMS 160) — the relevant counter shows progress and turns red when exceeded
    5. Optional: tick “Without spaces” for the alternate character count

    Reading time math

    Reading time is computed at 200-250 words per minute (the average adult reading rate for moderate-difficulty prose). Our counter uses 230 wpm. For technical writing, expect ~150 wpm; for fiction, ~280 wpm. Use the readability count as a planning tool, not a strict promise.

    Common gotchas

    • Twitter URL counting. Twitter counts every URL as 23 characters regardless of actual length. A 50-char URL costs only 23 toward your 280 limit.
    • SMS character set switching. Add one emoji to a 160-char SMS and the entire message switches from GSM-7 (160 chars / segment) to UCS-2 (70 chars / segment). The same text now requires multiple segments and costs more to send.
    • Emoji counted multiple ways. A simple smiley 😀 is 1 character in most counters but 2 UTF-16 code units. Some old systems count emoji as multiple characters.
    • Trailing whitespace. Many platforms trim trailing spaces but count them locally. Pasting “hello ” into Twitter shows as 6 chars but posts as 5.

    Frequently asked questions

    Does the counter count emoji as one or multiple characters?

    One. Modern counters (including ours) use Intl.Segmenter to count emoji as single grapheme clusters, matching how humans perceive them. Twitter, SMS, and Instagram count emoji similarly.

    Why do my Twitter character counts differ?

    Twitter counts URLs as 23 characters. Our counter reports raw character count. For a Twitter-aware count, manually subtract URL lengths and add 23 per URL.

    What’s the right meta description length for SEO?

    150-160 characters. Google truncates around 155 chars on mobile, 158 on desktop. Aim for 155 to leave a small safety buffer.

    How is reading time calculated?

    Word count divided by 230 (the standard average words-per-minute for adult readers). Technical writing reads slower (~150 wpm); fiction reads faster (~280 wpm). Use as a planning tool.

    Is my text uploaded?

    No. The counter runs in your browser via JavaScript. Text and counts stay on your device.

    Can I count characters in code or markdown?

    Yes — the counter treats all text identically regardless of format. For markdown, raw characters include the asterisks and hash marks; rendered word count would differ. The tool reports raw values.

    Related tools and guides

     

  • Remove Extra Spaces & Whitespace from Text [2026]

    Remove Extra Spaces & Whitespace from Text [2026]

    TL;DR: A whitespace remover collapses multiple spaces to one, strips leading and trailing spaces, removes blank lines, and (optionally) deletes invisible characters like non-breaking space (NBSP, U+00A0) and zero-width characters. Useful when copying text from PDFs, emails, or web pages that arrive with broken formatting. Our free whitespace remover handles all of these in your browser, with toggles for which kinds of whitespace to strip.

    Text copied from PDFs, emails, Word docs, and web pages almost never arrives clean. PDFs convert paragraph breaks to \r\n, embedded NBSPs, or even hard line breaks mid-sentence. Email signatures bring trailing spaces. Web copy-paste sneaks zero-width joiners and the invisible “Right-to-Left Mark” that breaks search-and-replace. Outlook substitutes regular spaces for non-breaking spaces inside paragraphs, so a string-equality check passes visually but fails programmatically.

    Our whitespace remover covers all of these with explicit toggles: collapse multiple spaces, trim every line, remove blank lines, normalise line endings (CRLF → LF), strip NBSP, strip zero-width characters, optionally remove all line breaks for one-paragraph output. Every option is a separate checkbox so you can apply only what you want. This guide explains which problem each toggle solves and the gotchas that catch most regex-based whitespace fixes.

    Whitespace categories — what each toggle does

    Toggle Removes Common source
    Collapse multiple spaces "a b" → "a b" PDF copy, double-space-after-period habit
    Trim each line Leading/trailing spaces per line Email signatures, manual indent
    Remove blank lines Empty or whitespace-only lines PDF page breaks, double Enter habit
    Normalise line endings CRLF/CR → LF Windows files, mixed editors
    Strip NBSP U+00A0 → regular space Word, Outlook, Pages, web HTML
    Strip zero-width U+200B, U+200C, U+200D, U+FEFF YouTube descriptions, Slack pastes
    Strip BiDi marks U+200E, U+200F, U+202A–U+202E Right-to-left text, accidental keyboard
    Tabs to spaces \t → 2 or 4 spaces Code, tabular text from spreadsheet

    The invisible character problem

    Visible whitespace is the easy part. The harder problem is invisible characters that look like nothing but break string equality, sort order, and search. The four most common culprits in pasted text:

    • Non-breaking space (NBSP, U+00A0) — looks like a regular space but doesn’t break across lines. Word and Outlook generate these freely. Your "hello world".indexOf("hello world") returns -1 if either side has an NBSP.
    • Zero-width joiner / non-joiner (U+200C / U+200D) — invisible. Used legitimately in Arabic and Indic scripts; appears as garbage in copy-paste from rich-text editors.
    • Byte-order mark (BOM, U+FEFF) — invisible. Often the first character of a UTF-8 file saved by Windows tools. Breaks JSON parsing, CSV import, and shell scripts.
    • Right-to-left mark (RLM, U+200F) — invisible. Flips display direction of subsequent text. Single accidental keystroke can mangle a whole paragraph.

    Our remover strips all of these by default. Toggle off if you’re working with intentional Arabic / Hindi / Hebrew content where these characters carry meaning.

    How to clean up text in your browser

    1. Open the whitespace remover
    2. Paste your text in the input
    3. Pick a preset (Light cleanup, Standard cleanup, Aggressive) or toggle individual options
    4. Output appears live as you type or paste
    5. Click Copy or Download .txt

    Common gotchas

    • Inside-string spaces matter in some contexts. If you’re cleaning code, “Aggressive” mode will collapse spaces inside string literals, breaking "foo bar". Use Light or Standard for code; aggressive for prose only.
    • Markdown is sensitive to trailing spaces. Two trailing spaces at the end of a markdown line is a hard line break. “Trim each line” destroys that. Disable trim if you’re cleaning markdown source.
    • YAML and Python are indent-sensitive. Don’t run “tabs to spaces” or “trim leading whitespace” on indented config — you’ll change the meaning. Use this tool on prose; use a code formatter on code.
    • NBSP in Word documents is intentional sometimes. Editorial styles use NBSP to keep “Mr. Smith” or “Page 5” together across line wraps. Aggressive NBSP-strip removes that protection.
    • BOM at the start of a file is invisible to your eye. Open a “broken” CSV in a hex editor — if the first three bytes are EF BB BF, that’s the BOM. Our tool strips it; many command-line tools don’t.
    • Tab width matters. Replacing tabs with spaces requires a width — 2 (modern web), 4 (Python / older code), or 8 (terminal default). Pick the same width your destination uses.

    When NOT to use this tool

    For programmatic cleanup inside a script, use the language-native tools — String.prototype.normalize('NFC').replace(/\s+/g, ' ').trim() in JavaScript, or " ".join(s.split()) in Python. For source code, use a code formatter (Prettier for JS, Black for Python). For Markdown source, use a Markdown linter that knows the format. Use this browser tool for prose, copy-pasted text from PDFs, email cleanup, and one-off formatting jobs where you don’t want to write a regex.

    Frequently asked questions

    Why does my “hello world” string fail comparison even though it looks right?

    Almost always an NBSP (U+00A0) where you expect a regular space (U+0020). Word, Outlook, and many web editors substitute NBSP automatically. Run “Strip NBSP” or use str.replace(/ /g, ' ') in code.

    Will this remove blank lines from my code?

    Yes if you toggle “Remove blank lines”. Don’t run that on code — blank lines often separate logical blocks. Use a code formatter instead. For prose, removing blank lines collapses paragraphs into one big block; for converting paragraphs to a single paragraph use the “Remove all line breaks” toggle instead.

    What’s the difference between trim, collapse, and strip blank lines?

    Trim removes leading and trailing whitespace per line. Collapse merges consecutive spaces inside a line into one. Strip blank lines deletes lines that contain only whitespace. They’re independent — you can run any combination.

    Does this fix line endings between Windows and macOS / Linux?

    Yes — toggle “Normalise line endings” to convert all CRLF and CR to LF (or pick the reverse). Useful when sharing CSV or text files across operating systems where one tool expects Unix-style and another expects Windows-style line endings.

    Is my text uploaded?

    No. The whitespace remover runs in your browser via JavaScript. Pasted content never reaches our servers — useful when cleaning up sensitive material (drafts, contracts, internal notes).

    Can I keep paragraph breaks but collapse internal whitespace?

    Yes — that’s the most common preset. Enable “Collapse multiple spaces” + “Trim each line” + “Strip NBSP” and leave “Remove blank lines” off. Result: clean paragraphs with no internal extra spaces, original paragraph structure preserved.

    Related tools and guides

     

  • Lorem Ipsum Generator: Placeholder Text in Seconds [2026]

    Lorem Ipsum Generator: Placeholder Text in Seconds [2026]

    TL;DR: A lorem ipsum generator produces placeholder text — sentences and paragraphs of fake-Latin filler — for design mockups, layout prototyping, and content-shaped void filling. Our free lorem ipsum generator outputs by paragraphs, sentences, or word count, with optional HTML markup (<p> wrappers) for direct paste into a CMS, and the canonical “lorem ipsum dolor sit amet” opening or randomised text.

    Lorem ipsum has been the design industry’s placeholder text since the 1500s, when an unknown printer adapted a 45 BC philosophy treatise by Cicero — De finibus bonorum et malorum — into nonsense Latin to demonstrate typesetting fonts without distracting readers with real content. Five centuries later, every CMS, design tool, and front-end mockup still leans on it. The reason it stuck: real content distracts. When you’re showing a client a layout, you want them looking at the layout, not reading the words.

    Our lorem ipsum generator outputs by paragraph count, sentence count, or word count, with options for HTML wrapping, randomised vs. canonical opening, and instant copy. This guide explains the right and wrong uses of placeholder text, the alternatives worth considering, and the gotchas that lead to “lorem ipsum” accidentally shipping to production (it has happened — embarrassingly — at multiple Fortune 500 companies).

    What lorem ipsum actually says (and why it doesn’t matter)

    The canonical first sentence — “Lorem ipsum dolor sit amet, consectetur adipiscing elit” — is a corruption of Cicero’s “Neque porro quisquam est qui dolorem ipsum quia dolor sit amet, consectetur, adipisci velit”. The original translates roughly to “There is no one who loves pain itself, who seeks after it and wants to have it, simply because it is pain”. The placeholder version is gibberish — words have been chopped, jumbled, and elongated into nonsense.

    That nonsense is the point. Lorem ipsum’s job is to occupy visual space without drawing reader attention. Real content immediately triggers comprehension instincts; the reader starts thinking about the message. Pseudo-Latin defeats that instinct — your brain registers “text-shaped” without engaging with meaning. Designers can evaluate typography, hierarchy, line-length, and rhythm without the user (or the client) getting distracted by what the text says.

    Five legitimate uses of lorem ipsum

    • Wireframes and mockups. Before content is written, designers fill body areas with lorem ipsum to show structure. The whole point of a wireframe is to communicate layout independently of content.
    • Stress-testing typography. Real content rarely fills the worst-case scenarios — extra-long paragraphs, missing line breaks, weird character combinations. Lorem ipsum stretches across the layout reliably for QA.
    • CMS template development. Building a WordPress theme or design system component? Lorem ipsum demonstrates how the template handles arbitrary text without exposing real client data during development.
    • Print-design proofing. Magazine layouts, brochures, and editorial designs test column flow with lorem ipsum before final copy lands.
    • Email template testing. Email clients render unpredictably; testing with lorem ipsum across Gmail/Outlook/Apple Mail catches breakage before real campaigns send.

    How to use the browser lorem ipsum generator

    1. Open the lorem ipsum generator
    2. Choose unit: paragraphs, sentences, or words
    3. Set quantity (1-50 paragraphs, 1-100 sentences, 1-1000 words)
    4. Toggle “Start with Lorem ipsum dolor sit amet…” for the canonical opening, or leave off for randomised
    5. Toggle “Wrap in HTML” to get <p> tags around each paragraph (paste-ready for CMS visual editors that don’t auto-wrap)
    6. Click Copy to grab the generated text, or Generate again for a fresh sample

    The output is generated client-side by selecting from a curated word list and assembling sentences with realistic Latin-like punctuation distribution. Nothing transmits to a server.

    Lorem ipsum alternatives — when filler text needs personality

    Alternative Vibe When to use
    Bacon Ipsum Meat-themed (bacon, prosciutto, t-bone) Restaurant menus, food brands
    Hipster Ipsum Brooklyn-flavour adjective stew Trendy startup mockups
    Corporate Ipsum Synergize-leverage-ROI buzzwords B2B SaaS pitch decks
    Cupcake Ipsum Sugar/dessert words Bakery, candy, kid-targeted designs
    Real content Actual draft copy Anything past initial wireframe — content shapes design

    Themed alternatives are fun for early-stage mocks but should never be left in production. They draw attention to themselves the way real lorem ipsum doesn’t, and clients tend to comment on them rather than the design.

    The “lorem ipsum shipped to production” hall of fame

    Lorem ipsum makes it to production websites surprisingly often. Search “lorem ipsum site:nytimes.com” or any major brand domain on Google and you’ll find archived examples. Common scenarios:

    • Form-field placeholders — the “Enter your email” placeholder in a signup form gets replaced with “Lorem ipsum” and ships.
    • Image alt text — accessibility audits surface lorem ipsum alt attributes on production marketing images.
    • Empty CMS fields — a category page renders lorem ipsum because the editor never wrote real introductory text.
    • Email signatures — corporate email templates with placeholder paragraphs still in them, sending to real customers.
    • Mobile app onboarding screens — the third onboarding step’s body text never got written, lorem ipsum ships in the app.

    Every team that has shipped lorem ipsum to production swears they have a “before-launch checklist” now. Search-and-replace for “lorem ipsum” across your codebase before deploys.

    Generating lorem ipsum in code

    Node.js (lorem-ipsum npm package):

    import { LoremIpsum } from "lorem-ipsum";

const lorem = new LoremIpsum({
  sentencesPerParagraph: { max: 8, min: 4 },
  wordsPerSentence: { max: 16, min: 4 },
});

console.log(lorem.generateParagraphs(3));

    Python (lorem package):

    import lorem
print(lorem.paragraph())   # one paragraph
print(lorem.text())         # multiple paragraphs

    VS Code shortcut (Emmet):

    // In any HTML file, type "lorem" + Tab → 30 words of lorem ipsum
// Or specify count: "lorem50" → 50 words

// Wrap in elements:
// p*3>lorem  → 3 paragraphs each containing lorem ipsum

    Common mistakes with lorem ipsum

    • Using it past wireframe stage. Once visual design is approved, lorem ipsum should be replaced with real content. Designs that look great with placeholder text often break with real content (longer headlines, shorter body copy, missing data).
    • Forgetting it in CSS comments or hidden fields. “Lorem ipsum” sometimes lurks in CSS comments or HTML attributes that don’t render but show up in search results or developer-tool inspections.
    • Letting it indicate quality. A product page with three perfectly-typeset paragraphs of lorem ipsum looks like a finished product to your eye. Real content of the same length might be three short bullet points and an FAQ. Test designs against realistic content shapes, not idealised paragraphs.
    • Using English-language lorem ipsum. Some “lorem ipsum” alternatives are actually English nonsense words. They’re harder to ignore — your brain auto-parses them — defeating the purpose. Stick with Latin-style for layout work.

    When NOT to use lorem ipsum

    • For final-stage user testing. Test with realistic content. Users react differently to “Lorem ipsum dolor” than to “Track your medication, set reminders, share with your doctor”.
    • For accessibility testing. Lorem ipsum’s punctuation and word-length distribution doesn’t match real screen-reader experience. Test with real content for accessibility.
    • For SEO content audits. Lorem ipsum has zero topical relevance and zero search potential. Don’t analyse search performance against placeholder text.
    • For client previews on a launched site. Lorem ipsum on a live URL looks unprofessional. Use a staging environment.

    Frequently asked questions

    Does lorem ipsum text mean anything?

    The canonical lorem ipsum is a corruption of Cicero’s De finibus bonorum et malorum from 45 BC, scrambled in the 1500s by an anonymous printer. Words were chopped, reordered, and altered into pronounceable nonsense. There’s no meaningful translation — that’s intentional. The text exists to occupy visual space without engaging the reader’s comprehension.

    How much lorem ipsum should I generate for a typical mockup?

    For body content, 50-100 words per paragraph and 2-4 paragraphs per section. For headlines, 5-12 words. For meta descriptions, ~25 words (matches Google’s snippet length). The goal is matching realistic content shape, not maximum filler.

    Will Google penalise pages containing lorem ipsum?

    Not directly — Google doesn’t single out lorem ipsum for penalty. But pages with lorem ipsum almost universally have other quality issues (thin content, no real value, draft state) that Google’s algorithm penalises. Lorem ipsum is a symptom, not a cause. Search Console may surface “lorem ipsum dolor” as a query you’re ranking for, which is embarrassing but not dangerous.

    Can I use lorem ipsum commercially?

    Yes. Lorem ipsum is in the public domain — Cicero died over 2000 years ago, and the modern corruption has been used continuously since the 1500s. No copyright applies. Use it freely in any commercial design work or product.

    What’s the best length for lorem ipsum in a wireframe?

    Match real content. If your real article will be 800 words, generate 800 words. If your hero subhead will be 8-12 words, generate 8-12. Designs that look balanced with the wrong filler length break when real content arrives. Always test against realistic content shape.

    Is the lorem ipsum generator generated locally?

    Yes. The text is assembled in your browser using a curated word list. No requests are made to any server. Verify in DevTools Network tab — there are no API calls when you click Generate.

    Related tools and guides