Developer Toolkit

Text Case
Converter

Instantly convert any text between 12 different cases — UPPERCASE, lowercase, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, dot.case, path/case, and alternating case. Paste your text, click a case, copy the result.

Your Text
Choose a case format — click to convert
📝 Text & Writing
💻 Programming & Code
🔀 Other Transforms
Output — select a case above
📖 How to Use the Text Case Converter
1
Paste or type your text
Click the input box at the top and paste your text with Ctrl+V (or Cmd+V on Mac). You can also type directly, or use the Paste button to pull from your clipboard. Click Sample to load example text and explore how each case looks.
2
Click the case you want
Browse the case cards below the input. Each card shows a live example of what your text will look like. Click any card — the output updates instantly at the bottom. The selected case is highlighted in purple. You can switch between cases as many times as you like.
3
Copy the result
Click the Copy button in the output section header. The button turns green to confirm the copy was successful. You can then paste directly into your code editor, document, or any other app. The output box is also editable if you need to make small tweaks before copying.
4
Convert as many times as needed
There's no limit — convert different chunks of text, switch between cases, or run the same text through multiple formats. Use Clear to reset the input, or just highlight and replace your text with new content. The word and character counts update live as you type.
Pro tips: camelCase and PascalCase are used in code — avoid them for variable names that contain abbreviations (use userID not userId if your team prefers it). snake_case is standard in Python and SQL. kebab-case is used in CSS class names and URLs. CONSTANT_CASE is used for environment variables and constants across most languages.
Case Format Quick Reference
FormatExample OutputCommon UseLanguages / Context
UPPERCASEHELLO WORLDEmphasis, headings, constantsAll
lowercasehello worldURLs, tags, filenamesAll
Title CaseHello WorldHeadlines, book titles, namesEnglish writing
Sentence caseHello worldNormal prose, UI copyEnglish writing
camelCasehelloWorldVariables, function namesJavaScript, Java, Swift
PascalCaseHelloWorldClass names, componentsC#, Java, React, TypeScript
snake_casehello_worldVariables, functions, DB columnsPython, Ruby, SQL, Rust
kebab-casehello-worldCSS classes, HTML attributes, URLsCSS, HTML, REST APIs
CONSTANT_CASEHELLO_WORLDConstants, env variablesAll languages
dot.casehello.worldConfig keys, namespace pathsJava properties, i18n
path/casehello/worldFile paths, URL segmentsFile systems, REST APIs
aLtErNaTiNghElLo wOrLdMocking tone, sarcasm (internet)Social media

When to use Title Case vs Sentence case

Title Case capitalizes every major word — used for headlines, book titles, article headings, and proper nouns. Sentence case only capitalizes the first word and proper nouns — used for UI button labels, menu items, and most modern app copy (it feels more conversational). AP Style, Chicago Style, and APA all have different rules for which words to capitalize in Title Case; this tool uses a general rule capitalizing all words except short prepositions, articles, and conjunctions under 5 letters.

camelCase vs PascalCase in programming

Both join words without spaces, but they differ in the first letter. camelCase starts lowercase (userProfile, fetchData) and is the standard in JavaScript, Java, and Swift for variable and function names. PascalCase starts uppercase (UserProfile, FetchData) and is used for class names, React components, and TypeScript interfaces. Most style guides are consistent within a language — mixing them is a code smell that makes PRs harder to review.

Why snake_case is dominant in Python and SQL

Python's PEP 8 style guide explicitly recommends snake_case for all function and variable names (my_variable, calculate_total). SQL column names traditionally use snake_case because SQL is case-insensitive and underscores are easier to read than camelCase in query results. PostgreSQL, MySQL, and most ORMs follow this convention. The underscore was chosen over hyphens because hyphens are subtraction operators in code — a bareword like user-id is parsed as subtraction.

kebab-case in CSS and URLs

CSS class names use kebab-case (.nav-bar, .hero-title) because CSS identifiers can't contain underscores in older parsers, and uppercase letters are meaningless (CSS selectors are case-insensitive for class names in HTML). URLs use kebab-case for readability and SEO — Google treats hyphens as word separators but treats underscores as word joiners, meaning "hello_world" is indexed as one word while "hello-world" is indexed as two. Always prefer kebab-case in URLs and slugs.

Frequently Asked Questions
How do I convert text to Title Case?
Paste or type your text in the input box at the top of this page, then click the "Title Case" card in the Text & Writing section. Your text converts instantly. Title Case capitalizes the first letter of every major word — articles (a, an, the), conjunctions (and, but, or), and short prepositions (in, on, at, to) are kept lowercase unless they're the first or last word. Click the Copy button to copy the result to your clipboard.
What's the difference between camelCase and PascalCase?
Both formats join multiple words without spaces, but they differ in whether the first letter is upper or lowercase. camelCase: the first word is all lowercase, every subsequent word starts with uppercase — e.g., "hello world" becomes "helloWorld". PascalCase (also called UpperCamelCase): every word including the first starts with uppercase — "hello world" becomes "HelloWorld". Use camelCase for JavaScript variables and functions; use PascalCase for class names, React components, and TypeScript types.
Can I convert a whole paragraph or document?
Yes — there's no length limit on the input. Paste an entire paragraph, article, or code file. The converter processes all of it and preserves line breaks in most formats. Note that code-style formats like camelCase and snake_case work best on identifiers (single phrases or words), not full sentences — they'll strip punctuation and join all words, which transforms prose into one long identifier. For prose, use Title Case, Sentence case, UPPERCASE, or lowercase.
Does it work with special characters and numbers?
Yes. Numbers pass through unchanged in all formats. Special characters (punctuation, symbols) are preserved in text-style cases (UPPERCASE, Title Case, etc.) but removed in code-style cases (camelCase, snake_case, kebab-case) since identifiers can't contain most special characters. Accented letters (é, ü, ñ) are handled in text cases — for code cases, they're typically stripped since most programming languages restrict identifiers to ASCII. Always review the output when converting internationalized text.
How to Use the Text Case Converter

Convert text between camelCase, snake_case, UPPER_SNAKE, kebab-case, title case, and more.

01
Paste your text
Enter any text — a variable name, a heading, a list of words, or a paragraph. The converter works on any length.
02
Select the output format
Choose from: camelCase (firstName), PascalCase (FirstName), snake_case (first_name), UPPER_SNAKE (FIRST_NAME), kebab-case (first-name), Title Case, UPPERCASE, lowercase, or Sentence case.
03
Copy the result
The converted text appears immediately. Click the copy button to grab it.
04
Convert multiple formats at once
All format outputs are shown simultaneously — you can copy whichever format you need without switching modes.
05
Use for code variable naming
When renaming variables, paste the old name, pick the convention your codebase uses, and copy the correctly-formatted version.
💡
💡 JavaScript uses camelCase for variables (myVariable). Python uses snake_case (my_variable). Constants in both languages use UPPER_SNAKE (MAX_VALUE). CSS uses kebab-case (background-color). Switching between languages is where this tool earns its keep.