Case Converter

Title Case vs Sentence case: the rule most people mix up

These two formats get confused more than any others, and the fix is simple once you see them side by side.

• Title Case capitalizes the major words of every phrase: “the quick brown fox” becomes “The Quick Brown Fox”. Use it for headlines, page titles, book titles and section headings.
• Sentence case capitalizes only the first word and any proper nouns: “The quick brown fox”. Use it for body text, UI labels, button text and most modern product copy.

The trend in software and web writing has been steadily toward sentence case, because it is easier to read and easier to keep consistent, you rarely have to decide whether a word is “important” enough to capitalize. Title Case still dominates traditional print media, many academic styles and most US newspaper headlines.

One practical warning: do not mix the two inside a single document unless you have a reason. A page with Title Case headings and Sentence case subheadings can look deliberate, but the same page with Title Case in one section and Sentence case in the next just looks careless. Pick one for each level of your document and apply it everywhere.

Which words stay lowercase in Title Case

The convention most style guides follow is to leave short function words lowercase, unless they are the first or last word of the title, or follow a colon.

• Articles: a, an, the
• Coordinating conjunctions: and, but, or, nor, for, yet, so
• Short prepositions: of, in, on, at, to, by, for, with, from

The exact cutoff varies by guide. This converter leaves a word lowercase when it appears in its small-word list and is four letters or shorter; anything longer than four letters is capitalized, and the first and last words are always capitalized. Here is how that plays out:

If your house style differs, some guides capitalize every preposition, others lowercase all of them, you can always fix the handful of exceptions by hand after converting.

camelCase, PascalCase and where each one is used

The developer formats strip the spaces out entirely and signal word boundaries with capitalization or a separator. The two that use capitalization are camelCase and PascalCase.

• camelCase joins the words and capitalizes each one after the first: myVariableName. The leading lowercase letter is the camel's “hump” lying down.
• PascalCase is the same idea but capitalizes the first word too: MyClassName. It is sometimes called UpperCamelCase.

Each language has a strong convention, and following it makes your code look native. The Google JavaScript Style Guide, PEP 8 for Python and Microsoft .NET naming guidelines all agree on the split below:

*In Go the first letter also controls visibility: thing is unexported, Thing is exported to other packages.

snake_case, kebab-case and CONSTANT_CASE

The three separator-based formats all replace spaces with a punctuation character and lowercase the words. Which separator you use is dictated by the language or the file type.

• snake_case uses underscores: user_profile_image. It is the standard in Python, Ruby, SQL column names and most config files.
• kebab-case uses hyphens: user-profile-image. It is the convention for URLs, HTML attributes, CSS class names and file names.
• CONSTANT_CASE (also called SCREAMING_SNAKE_CASE) uses underscores and capitalizes everything: MAX_RETRY_COUNT. It marks values that should never change at runtime.

The reason kebab-case wins for URLs and CSS is practical, not aesthetic. Hyphens are already valid in a URL and in a CSS selector, while underscores are awkward to type on a phone keyboard and can be hidden by the underline of a hyperlink. When a URL is underlined, user_profile can be misread as user profile or userprofile, but user-profile stays readable. That is why Google's own URL guidance and most style guides recommend hyphens over underscores in web addresses.

Worked example: one phrase converted eight ways

Take a messy, realistic input and watch what each format does to it. The phrase is:

User Login Form 2.0 (Draft)

This converter first splits on anything that is not a letter or a digit, so the period, the space, the parentheses and the version number all become boundaries. Then it applies the chosen rule:

Notice that the plain formats (UPPERCASE, lowercase, Title Case, Sentence case) keep the punctuation exactly as you typed it, while the developer formats drop it, because a variable name cannot contain a space, a period or a bracket.

How numbers, apostrophes and punctuation are handled

The two families of formats treat punctuation differently, and that trips people up.

Plain formats keep everything. UPPERCASE, lowercase, Title Case and Sentence case change only the case of letters. Every comma, apostrophe, period and bracket stays exactly where you put it. “Don't stop.” becomes “DON'T STOP.” in UPPERCASE and “Don't stop.” in Sentence case, apostrophes and periods untouched.

Developer formats remove punctuation. camelCase, PascalCase, snake_case, kebab-case and CONSTANT_CASE split the text on any character that is not a letter or a digit, then rejoin the pieces. That means periods, commas, apostrophes, brackets and slashes are all treated as word boundaries and disappear from the output. “Don't stop.” becomes dontStop, not don'tStop, because an apostrophe is not a valid character in an identifier.

Numbers survive either way. They are letters-and-digits as far as the splitter is concerned, so “Form 2” keeps its 2 in every format, it just loses the space around it in the developer styles.

Why URLs, CSS and file names prefer kebab-case

Three separate conventions converge on hyphens, and it is worth knowing why so you can apply the same logic to new situations.

• URLs. Search engines treat hyphens as word separators, so best-coffee-shops reads as four words while bestcoffeeshops reads as one. Hyphens are also the only separator that is never percent-encoded in a URL.
• CSS. Class and ID names are case-sensitive and conventionally lowercase, and hyphens avoid the confusion of underscores. The popular BEM methodology (block__element--modifier) leans on the same idea.
• File names. Hyphens are safe on every operating system, whereas some tools treat spaces and uppercase letters inconsistently. Lowercase kebab-case file names avoid case-sensitivity bugs when a file moves between Windows, macOS and Linux.

snake_case is not wrong, it is just used in different places, Python packages, SQL schemas and environment variables, where the surrounding ecosystem already uses underscores. Follow the language, not your personal taste, and your names will match everything around them.