Paste any text and instantly see it converted to 10 different case formats. Click any card to copy. Perfect for developers switching between naming conventions, writers fixing capitalization, or anyone who needs a quick text transformation.
Pro tip: Most programming languages have strict conventions: JavaScript uses camelCase for variables and PascalCase for classes, Python uses snake_case, and URLs use kebab-case. Mixing conventions is one of the fastest ways to confuse your future self (and your teammates).
How to Use the Case Converter
Type or paste any text into the input field. All 10 case formats update instantly as you type. Click any output card (or its clipboard icon) to copy that version to your clipboard. The tool automatically detects word boundaries from spaces, hyphens, underscores, dots, and camelCase transitions, so you can paste text in any format and convert it to any other.
When to Use Each Case Format
camelCase is the standard for JavaScript variables, function names, and JSON keys. PascalCase (also called UpperCamelCase) is used for class names in JavaScript, TypeScript, C#, and Java. snake_case is the convention in Python, Ruby, Rust, and SQL. kebab-case dominates URLs, CSS class names, and HTML attributes. CONSTANT_CASE (screaming snake case) is universally used for constants and environment variables. dot.case appears in Java package names, configuration keys, and some template engines.
Title Case vs. Sentence Case
Title Case capitalizes the first letter of every word and is standard for headlines, book titles, and formal headings. Style guides differ on whether to capitalize short words like “the,” “a,” and “of” — this tool capitalizes every word for consistency, matching AP style for simplicity. Sentence case capitalizes only the first letter of the first word (plus proper nouns, though automatic detection of proper nouns isn’t possible). Use sentence case for body text, UI labels, and casual headings.
Why Naming Conventions Matter in Code
Inconsistent naming is the number-one source of trivial bugs and code-review friction.
When a variable is called userName in one file and user_name
in another, developers waste time second-guessing which is correct. Most languages
enforce conventions through linters: ESLint enforces camelCase in JavaScript, PEP 8
enforces snake_case in Python, and RuboCop enforces snake_case in Ruby. Following
conventions isn’t about personal preference — it’s about making your
code readable to every other developer who will ever touch it.
How the Conversion Algorithm Works
The first step is word splitting: the tool breaks your input into individual words by detecting boundaries at spaces, underscores, hyphens, dots, and camelCase transitions (where a lowercase letter meets an uppercase letter). Once you have an array of clean lowercase words, each output format simply joins them differently: snake_case joins with underscores, kebab-case with hyphens, camelCase capitalizes all but the first, and PascalCase capitalizes all. The challenge is in the splitting — handling edge cases like acronyms (HTMLParser → html, parser), numbers (item2count → item2count), and mixed inputs.
Common Mistakes When Converting Cases
Losing acronyms: converting “parseHTMLDocument” to snake_case should ideally produce “parse_html_document,” not “parse_h_t_m_l_document.” This tool handles that by treating consecutive uppercase letters as a single word boundary. Forgetting URL encoding: kebab-case is URL-safe, but spaces and underscores can cause issues in URLs without proper encoding. Mixing conventions mid-project: if your codebase uses camelCase, don’t introduce snake_case in a new module — convert first, then be consistent.
Looking for related tools? Try our Word & Character Counter to analyze your text length and readability, or explore all Writing & Content tools.