To capitalize each word in a block of text means to raise the first letter of every word to uppercase while leaving the remaining letters alone, producing the familiar "Hello World" form that headlines, book titles, and UI labels use. The transformation is usually called Title Case, and it is the most common interpretation of the search query "capitalize each word." A modern case converter can produce Title Case and nine other case styles from one paste: UPPERCASE, lowercase, Sentence case, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, and an alternating aLtErNaTiNg style, so you do not need a separate tool for headlines versus variable names. That single-paste, multi-output workflow matters because capitalizing each word by hand in a long paragraph is tedious and error-prone, and reformatting a snake_case variable into camelCase by hand is even worse: a single missed boundary breaks the code. By typing once and reading ten variants, you skip both the manual work and the inconsistency.
What "Capitalize Each Word" Actually Means
The phrase sounds simple but covers three distinct intents, and which one you have determines which output style to copy. The first intent is the literal one: capitalize the first letter of every word and lower the rest, so "the quick brown fox" becomes "The Quick Brown Fox." This is Title Case and is the right choice for headlines, article titles, song names, book chapters, and product cards where every significant word is capitalized.
The second intent is Sentence case, where only the first letter of each sentence is capitalized. "the quick brown fox. the lazy dog." becomes "The quick brown fox. The lazy dog." Sentence case is the correct convention for body copy, blog paragraphs, UI labels, email messages, and any prose the reader scans from start to finish. Capitalizing every word in running prose looks heavy and can hurt readability, which is why most style guides reserve Title Case for headlines and Sentence case for everything else.
The third intent is the programming one: capitalize each word inside a variable, function, or class name using the casing rule of your language. "the quick brown fox" might become theQuickBrownFox in JavaScript, TheQuickBrownFox as a class name, the_quick_brown_fox in Python, the-quick-brown-fox as a CSS class or URL slug, or THE_QUICK_BROWN_FOX as an environment constant. The transformation is the same idea of splitting into words and capitalizing each one, but the join character changes the meaning.
Title Case vs. Sentence Case: Picking the Right One
Choosing between Title Case and Sentence case is the single most common capitalization decision for writers, and the rule is simpler than most style guides make it sound. Title Case belongs in titles, headings, and short labels: blog post titles, navigation items, button text, and slide titles. Sentence case belongs in running prose: paragraphs, captions, list items, error messages, and product descriptions. Most style guides keep articles, conjunctions, and short prepositions lowercase in Title Case ("The Lord of the Rings," not "The Lord Of The Rings"), but for everyday online use the simple "capitalize each word" form is widely accepted.
If you are unsure which one you need, paste your text into a case converter and read both versions side by side. Headlines feel right when every word is capitalized; paragraphs feel right when only the sentence starter is. The same input can look wrong in one style and correct in the other, and seeing them together removes the guesswork.
| Writing style | Example output | Best for |
|---|---|---|
| UPPERCASE | HELLO WORLD | Emphasis, signage, warning labels |
| lowercase | hello world | Calm tone, resetting caps-lock mishaps |
| Title Case | Hello World | Headlines, article titles, short labels |
| Sentence case | Hello world | Body copy, paragraphs, UI strings |
| aLtErNaTiNg | HeLlO WoRlD | Decorative or playful text |
Naming Conventions: Capitalize Each Word the Way Your Language Wants
In programming, capitalizing each word is not cosmetic; it is part of the syntax. Most languages reject a name like useraccountid because there is no way to read the boundaries, and they will happily compile userAccountId because camelCase makes the three words obvious. The five conventions you will run into most often are camelCase for JavaScript and Java variables, PascalCase for class names and React components, snake_case for Python variables and SQL column names, kebab-case for URLs and CSS classes, and CONSTANT_CASE for environment variables and other compile-time constants.
Mixing them up by hand is the most common source of small bugs. A snake_case name accidentally pasted as camelCase compiles but reads as one long word; a CONSTANT_CASE constant accidentally typed in camelCase becomes a different variable entirely; a kebab-case URL slug that picks up an underscore no longer matches the route. A reliable way to avoid those mistakes is to paste the original name into a case converter and copy the variant your codebase expects, every single time.
| Naming style | Example output | Typical use |
|---|---|---|
| camelCase | helloWorld | JavaScript and Java variables and functions |
| PascalCase | HelloWorld | Class names, React components, type names |
| snake_case | hello_world | Python variables, SQL column names |
| kebab-case | hello-world | URL slugs, CSS classes, file names |
| CONSTANT_CASE | HELLO_WORLD | Environment variables, compile-time constants |
Common Tasks That Start With "Capitalize Each Word"
Almost every text-reformatting task reduces to "capitalize each word" in some form. Fixing a headline that arrived in lowercase after a copy-paste from a PDF. Renaming a column of CSV headers from Title Case into the snake_case the database expects. Turning a blog title into a URL slug in kebab-case. Converting API field names from camelCase in JSON to snake_case for a SQL insert. Turning "welcome to the team" into a Title Case banner for a slide. Lowercasing shouting text that came from a caps-locked keyboard. Normalizing a list of product names so every one starts with a capital letter. Each task is a one-line job once you can see all ten styles from one paste.
A subtler use case is reformatting names of people, products, or brands that arrived in the wrong case. Pasting "ACME corporation" and reading both Title Case ("Acme Corporation") and Sentence case ("Acme corporation") tells you immediately which one matches the official branding. The same logic applies to converting environmental variables, normalizing commit messages, and preparing placeholder text for a wireframe where every heading must start with a capital letter.
How to Capitalize Each Word (and Nine Other Styles) at Once
- Open the Case Converter in your browser.
- Type or paste your text into the input box at the top of the page.
- Read the ten output variants generated instantly below the input: Title Case, UPPERCASE, lowercase, Sentence case, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, and the alternating style.
- Compare the variants side by side and pick the one that matches your context.
- Click the Copy button next to that result to put it on your clipboard, then paste it wherever you need it.
Because every conversion runs locally in your browser, the tool works offline, handles large pastes without a round trip to a server, and never uploads what you typed. That matters when you are reformatting internal variable names, draft contracts, or anything else you would rather not send to a third party.
Why Boundary Detection Matters for Mixed Inputs
The hard part of "capitalize each word" is not the casing; it is finding the word boundaries inside an input that mixes separators. A naive tool that swaps underscores for hyphens will turn snake_case into kebab-case cleanly, but will choke on something like fooBar_baz-qux because there is no space to split on. A reliable case converter re-tokenizes the input first: it splits on spaces, underscores, hyphens, and punctuation, and it also detects camelCase and PascalCase boundaries, so fooBar_baz-qux is correctly understood as four words (foo, Bar, baz, qux) regardless of which style it arrived in.
That re-tokenization also handles digits and acronyms. order66 is treated as one token, not split at the digits. HTMLParser is recognized as two words (HTML, Parser) at the acronym boundary, so it converts to html_parser in snake_case and htmlParser in camelCase rather than html_parser_r or h_t_m_l_parser. Acronym-heavy identifiers that arrive already shouting, like SNAKE_CASE_CONSTANT, normalize cleanly into camelCase because every word is reduced to a single canonical form before being re-cased.
The practical consequence is that the same input always produces the same output. If you are scripting a batch of variable names, reformatting a column of data, or generating a list of URL slugs from a column of titles, determinism is what keeps the result consistent from the first row to the last.
Related reading: How to Count Characters in Word and Check Limits Live.