You've just copied a block of text from a PDF, and everything is in SCREAMING UPPERCASE. Or maybe you're refactoring a JavaScript codebase and need to convert a bunch of snake_case database column names into camelCase for your API layer. Text case conversion sounds trivial until you're staring at 200 lines that all need changing.
Let's walk through every common case style, when you'd actually use each one, and how to convert between them without losing your mind.
Uppercase and Lowercase
The simplest conversions, and the ones you'll use most often.
UPPERCASE converts every letter to its capital form. You'll see it in constants (MAX_RETRIES), SQL keywords (SELECT * FROM), and those emails from people who haven't discovered the Caps Lock key.
lowercase does the opposite. It's the starting point for most other transformations — if you need to normalize text for comparison or search, lowercasing is usually step one.
Here's a practical example. Say you're building a search feature and need case-insensitive matching:
User input: "JavaScript Tutorial"
Normalized: "javascript tutorial"
Convert text to uppercase or lowercase instantly with our browser-based tools — no data leaves your machine.
Title Case
Title Case Capitalizes The First Letter Of Each Word. It's what you'd use for headings, book titles, and article names.
But here's where it gets interesting: proper title case actually has rules. Most style guides (AP, Chicago, APA) say you should leave short words like "the", "and", "of", and "in" lowercase unless they start the sentence. The difference:
Simple title case: "The Lord Of The Rings"
AP style: "The Lord of the Rings"
Our Title Case converter handles common articles and prepositions, so you get properly formatted titles without memorizing style guides.
Sentence Case
Sentence case capitalizes only the first word and proper nouns, just like a normal sentence. It's become the preferred style for UI labels, button text, and subheadings in modern web design.
Title Case: "Create New Account"
Sentence case: "Create new account"
Google's Material Design, Apple's Human Interface Guidelines, and most modern design systems recommend sentence case for interface text. It reads more naturally and feels less like you're being shouted at.
camelCase
camelCase starts lowercase and capitalizes the first letter of each subsequent word, with no separators. It's the dominant convention in JavaScript, TypeScript, Java, and C# for variable and function names.
user first name → userFirstName
get all items → getAllItems
is valid email → isValidEmail
The name comes from the humps — the capital letters in the middle look like a camel's back. Some people call PascalCase (where the first letter is also capitalized) "upper camel case," but in practice they're treated as separate conventions.
When to use camelCase:
- JavaScript/TypeScript variables and functions
- Java methods and local variables
- JSON property names (by convention, not requirement)
- CSS-in-JS property names
Convert any text to camelCase with a single paste.
snake_case
snake_case uses underscores between words, all lowercase. It's the standard in Python, Ruby, Rust, and most database schemas.
userFirstName → user_first_name
getAllItems → get_all_items
isValidEmail → is_valid_email
Python's PEP 8 style guide explicitly mandates snake_case for function names, method names, and variable names. If you're moving data between a Python backend and a JavaScript frontend, you'll be converting between snake_case and camelCase constantly.
There's also SCREAMING_SNAKE_CASE (uppercase with underscores), used for constants in almost every language:
MAX_RETRY_COUNT
DATABASE_URL
API_BASE_PATH
Our snake_case converter handles the transformation cleanly, even with acronyms and numbers.
When Different Cases Collide
The real headache starts when you're working across systems that use different conventions. A typical web application might have:
| Layer | Convention | Example |
|-------|-----------|---------|
| Database columns | snake_case | first_name |
| API response (Python) | snake_case | first_name |
| API response (Node.js) | camelCase | firstName |
| React component props | camelCase | firstName |
| CSS classes | kebab-case | first-name |
| Environment variables | SCREAMING_SNAKE | FIRST_NAME |
That's six different representations of the same concept. Automated conversion tools save you from manually rewriting these, especially when you're mapping between layers.
Alternating Case
aLtErNaTiNg CaSe (or "spongebob case" if you're a meme connoisseur) toggles between lowercase and uppercase for each letter. It's not exactly a professional formatting choice, but it has its uses in creative text, social media, and testing how your application handles mixed-case input.
"serious business" → "sErIoUs BuSiNeSs"
The alternating case tool is there for when you need it. We don't judge.
Practical Tips for Case Conversion
A few things to keep in mind when converting between cases:
Acronyms are tricky. Converting HTMLParser to snake_case could give you h_t_m_l_parser or html_parser depending on the algorithm. Good converters treat known acronyms as single words.
Numbers matter. item2count to snake_case: is it item_2_count or item2_count? Both are valid depending on context.
Roundtrips aren't always perfect. Converting myXMLParser to snake_case gives my_xml_parser, but converting back gives myXmlParser — the original casing of "XML" is lost. If you need lossless conversion, you'll need to handle acronyms specially.
Locale matters for uppercase/lowercase. The Turkish "I" problem is famous: in Turkish, uppercase "i" is "İ" (dotted), not "I". If you're working with non-English text, make sure your tools handle Unicode correctly.
Try It Yourself
Stop manually retyping text in different cases. Paste your text into any of our case conversion tools and get instant results:
- UPPERCASE — for constants, SQL, emphasis
- lowercase — for normalization, search, URLs
- Title Case — for headings and titles
- Sentence case — for UI labels and modern copy
- camelCase — for JavaScript, TypeScript, Java
- snake_case — for Python, Ruby, databases
All processing happens in your browser. Your text never touches a server.