Free Case Converter

Convert text between 10 different letter cases instantly — UPPER CASE, lower case, Title Case, camelCase, PascalCase, snake_case, kebab-case, and more.

Enter your details
Result
Enter your details on the left, then press Calculate.

What is this calculator for?

You wrote a 500-word draft in all caps by mistake. Or you need to convert a list of names from "JOHN SMITH" to "John Smith" for a database. Or you're applying snake_case to a JavaScript codebase. The case converter transforms text between UPPERCASE, lowercase, Title Case, Sentence case, camelCase, snake_case, kebab-case, and other common conventions.

Case conventions in computing and writing. UPPERCASE: typically used for shouting in informal writing, headings in older styles, environment variables, constants in some languages. lowercase: most prose, URL slugs, file names in Unix. Title Case (also called Headline Case): capitalize each major word; used for titles, headings. Sentence case: capitalize first word and proper nouns only; most prose. camelCase: combinedWordsLikeThis; common in JavaScript and Java identifiers. PascalCase: SimilarToCamelCaseButFirstLetterCapitalized; class names. snake_case: words_with_underscores; common in Python and Ruby. kebab-case: words-with-hyphens; common in CSS and URL slugs. CONSTANT_CASE: uppercase with underscores; programming constants and environment variables.

This converter handles all transformations. Useful for text editing, programming, database cleaning, and writing.

How to use this calculator

Paste text into the input field. Pick the target case: UPPERCASE, lowercase, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE. The converter transforms the text and outputs the result.

For mixed-case input: the converter handles arbitrary input ("hELLO wORLD" → "Hello World" for Title Case).

For programming identifier conversion: convert variables across languages. JavaScript "userFirstName" → Python "user_first_name" → CSS "user-first-name" → constant "USER_FIRST_NAME". Useful when porting code or generating identifiers consistently.

Understanding your results

The converter outputs your text in the target case. Common conversion behaviors:

UPPERCASE: every letter becomes capital. "hello world" → "HELLO WORLD".

lowercase: every letter becomes lowercase. "HELLO WORLD" → "hello world".

Title Case: first letter of each major word capitalized; articles and short prepositions typically lowercase ("and", "or", "the", "in"). "the great gatsby" → "The Great Gatsby". Some style guides differ on specifics — Chicago Manual of Style vs AP differ slightly.

Sentence case: capitalize first letter of sentence and proper nouns. "the quick brown fox" → "The quick brown fox". The most common case for prose.

camelCase: combinedWordsWithoutSpaces with first letter lowercase. "user first name" → "userFirstName".

PascalCase: SameAsCamelButFirstLetterCapitalized. "user first name" → "UserFirstName".

snake_case: words_separated_by_underscores in lowercase. "user first name" → "user_first_name".

kebab-case: words-separated-by-hyphens in lowercase. "user first name" → "user-first-name".

Title case style differences. Chicago Manual: capitalize first and last word, all major words including prepositions of 4+ letters. AP Style: capitalize prepositions of 4+ letters; lowercase most others. APA: simpler — capitalize first word and all words of 4+ letters in titles. The differences are minor but matter in formal publishing. For most writing, Sentence case or simple Title Case (capitalize all words) is fine.

Programming identifier conventions. JavaScript: camelCase for variables and functions, PascalCase for classes. Python: snake_case for variables and functions, PascalCase for classes. Java: camelCase for variables/methods, PascalCase for classes. CSS: kebab-case for classes and IDs. SQL: typically lowercase with underscores for column names, though varies. URL slugs: kebab-case (search-engine-friendly). Mixing conventions within a project is the cardinal sin of code style; pick one and stick with it.

A worked example

Lin is migrating a Python codebase to JavaScript. She needs to convert hundreds of snake_case identifiers to camelCase.

Sample Python: get_user_profile, parse_request_body, handle_form_submission. Target JavaScript: getUserProfile, parseRequestBody, handleFormSubmission.

She pastes the snake_case list into the case converter, selects camelCase output. The tool transforms all identifiers consistently. She copies the results into a search-and-replace operation in her IDE.

For 200+ identifiers, this saves about 30-40 minutes of manual case conversion. The mechanical transformation is exact and error-free — no risk of typos that would create subtle bugs.

Variation: Maria is editing a list of book titles for a website. The data came as: THE GREAT GATSBY, to kill a mockingbird, One Hundred Years of Solitude — inconsistent casing. She wants all in Title Case.

She pastes all 50 titles, selects Title Case output. The converter normalizes everything: The Great Gatsby, To Kill a Mockingbird, One Hundred Years of Solitude. Caveat: it doesn't perfectly handle all style nuances (e.g., "of" in "One Hundred Years of Solitude" — the converter may leave it lowercase per AP style or capitalize it per Chicago style). She reviews the output for the few titles where her preference differs from the converter's default, manually adjusts. Final result: 95% automated, 5% manual touch-up. Total time for 50 titles: 10 minutes vs 40+ minutes manual.

Related resources

For text length analysis, see Word Counter and Character Counter. For other text transformation tools, the Lorem Ipsum Generator and Regex Tester. For URL-specific case considerations (slugs use kebab-case), the URL Encoder. Major style guides (Chicago Manual, AP Stylebook, APA) publish detailed rules on title case conventions; their actual reference works are authoritative for formal publishing.

Related calculators

word countercharacter counterlorem ipsum

Frequently asked questions

When do I use each letter case?

UPPER CASE: acronyms, labels, emphasis. lower case: informal writing, usernames. Title Case: book titles, headings, proper nouns. Sentence case: standard prose. camelCase: JavaScript/TypeScript variables and functions. PascalCase: class names, React components. snake_case: Python variables, SQL columns, file names. kebab-case: HTML attributes, URL slugs, CSS class names. CONSTANT_CASE: environment variables, constants. dot.case: package names (npm, Java).

What is the difference between camelCase and PascalCase?

Both combine multiple words without spaces, but camelCase starts lowercase (myVariableName) while PascalCase starts uppercase (MyClassName). In most languages: camelCase is for variables and functions; PascalCase is for classes and types. React uses PascalCase for components because JSX treats lowercase tags as HTML elements and PascalCase tags as components.

How does Title Case differ from Sentence case?

Title Case capitalizes the first letter of every word (The Quick Brown Fox). Sentence case only capitalizes the first word and proper nouns (The quick brown fox). Title Case is conventional for English book titles and formal headings. Sentence case is preferred in modern UI text, buttons, and digital products — it is easier to scan and less formal.

What's the difference between camelCase and PascalCase?

First letter only. camelCase: first letter lowercase, subsequent word boundaries capitalized. Example: <code>userFirstName</code>, <code>getUserData</code>. PascalCase: first letter capitalized along with subsequent word boundaries. Example: <code>UserFirstName</code>, <code>GetUserData</code>. Programming convention: camelCase for variables and functions in many languages (Java, JavaScript, C#); PascalCase for class names and type names. Mixed within a single language: camelCase for everything except classes and types, which use PascalCase. The two are otherwise identical.

When should I use snake_case vs camelCase?

Language convention. snake_case (variables_like_this) is conventional in Python, Ruby, Rust, and C++. camelCase (variablesLikeThis) is conventional in JavaScript, Java, C#, Swift. SQL traditionally uses snake_case (or even lowercase with underscores or all caps). The choice within a language follows community norms; mixing within a project creates cognitive friction. For cross-language work (Python backend + JavaScript frontend): each language uses its native convention; API responses are typically formatted in the language of the consumer (camelCase for JS frontends consuming Python APIs).

What's the right title case for an article title?

Depends on style guide. Chicago Manual of Style: capitalize first and last word, all major words (nouns, verbs, adjectives, adverbs), and prepositions/conjunctions of 4+ letters. AP Style: capitalize words of 4+ letters; lowercase shorter prepositions and conjunctions. APA style: capitalize first word and major words; APA is more flexible. The simplest rule that works for most modern writing: capitalize the first word, the last word, and all major words (nouns, verbs, adjectives, adverbs, pronouns); lowercase articles (a, an, the), short conjunctions (and, but, or), and prepositions of 3 letters or fewer. 'A Tale of Two Cities' (correct). 'A Tale Of Two Cities' (every-word capitalization, less standard).

Is there a standard for URL slug case?

Kebab-case (words-separated-by-hyphens) is the universal standard for URL slugs. Reasons: Google explicitly recommends hyphens (not underscores) between words; URLs are case-sensitive on most servers, so lowercase eliminates case-related bugs; hyphens improve readability and visual word-separation. Bad: my_blog_post (Google reads as one word). Good: my-blog-post. Don't use camelCase (visually awkward and unconventional in URLs). Don't use spaces (illegal in URLs, get encoded as %20 which is ugly). Always lowercase: 'My-Blog-Post' (works but case-sensitive servers may treat differently than 'my-blog-post'). Stick with all-lowercase, hyphen-separated for any URL slug.

How do I convert text to small caps?

Small caps aren't a separate case from a character standpoint — they're a typographic effect. True small caps require either a font that has small caps glyphs (Times New Roman, Garamond, professional fonts often do) or specific Unicode characters (a special set of small caps letters in Unicode that look different on most fonts). For most computing purposes: small caps is achieved via CSS (font-variant: small-caps) or word processor styling, not by changing the actual characters. Pseudo-small-caps (using actual uppercase letters at smaller font size) doesn't look right. If you need small caps in plain text contexts (without rich formatting), there's no real equivalent — the visual effect requires typographic styling.