Convert text instantly between UPPERCASE, lowercase, Title Case, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, dot.case and more. Perfect for developers, writers, SEO, and content formatting.
camelCase starts words with lowercase, then uppercase for each following word, like helloWorld. It's used for JavaScript variables, function names, and Python method names.
PascalCase capitalizes every word including the first, like HelloWorld. It's used for classes, React components, and TypeScript types. camelCase (helloWorld) is used for variables and functions.
snake_case (hello_world) is common in Python variables, database columns, and Ruby. kebab-case (hello-world) is common in CSS classes, HTML data attributes, and URL slugs.
Title Case capitalizes every major word (Hello World). Sentence case capitalizes only the first word (Hello world). Title Case suits headlines; Sentence case suits body text.
Yes. Convert between camelCase, snake_case, kebab-case, and PascalCase instantly — useful when refactoring naming conventions across languages or frameworks.
The Logrith Text Case Converter transforms text between more than a dozen popular formats instantly: UPPERCASE, lowercase, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, dot.case, AlTeRnAtE, and InVeRsE CaSe. It's built for developers refactoring code, writers formatting content, SEO specialists optimizing slugs, and anyone who regularly deals with text in more than one naming convention.
Naming conventions matter more than most people realize until they run into a project with inconsistent formatting. A single codebase might expect camelCase for JavaScript variables, snake_case for Python scripts, kebab-case for CSS class names, and PascalCase for component names — all within the same feature. Manually retyping a phrase into four different formats is slow and error-prone, especially for multi-word names. This tool removes that friction entirely: type or paste your text once, then click through each format to get an instant, correctly-formatted result ready to copy.
Different case formats exist because different programming languages, style guides, and platforms adopted different conventions over time, and each format still serves a specific, well-established purpose today:
Developers convert between camelCase (JavaScript variables), PascalCase (React components), snake_case (Python or Django models), and kebab-case (CSS classes) without manually retyping names — especially valuable when porting code between languages that follow different naming conventions, or when standardizing a codebase that has drifted into inconsistent styles over time.
Content creators and writers switch between Title Case for headlines and Sentence case for body text, ensuring consistent formatting across articles, product descriptions, and marketing copy without manually adjusting capitalization word by word.
SEO specialists generate clean, hyphen-separated kebab-case URL slugs from article titles, which is the format search engines and most CMS platforms expect for readable, crawlable URLs.
To convert between these formats, the tool first needs to identify the individual "words" inside your input, regardless of what format it started in. It does this by detecting boundaries between lowercase and uppercase letters (to split camelCase and PascalCase input back into words) and by splitting on underscores, hyphens, and periods (to split snake_case, kebab-case, and dot.case input). Once the text is broken into a clean list of words, each case format simply applies its own capitalization and separator rules to reassemble those words — capitalizing the first letter of each word for Title Case, joining with underscores for snake_case, and so on.
Beyond the core case conversion, the tool tracks word count, character count, and line count for your input in real time, which is useful for quickly gauging the size of a block of text you're about to convert or format. The swap button lets you move the converted output back into the input field, letting you chain multiple format changes without retyping. Everything updates instantly as you type or click, with a one-click copy button to grab the final result the moment it looks right.
All text conversion in this tool happens directly in your browser using JavaScript string operations. Your text is never sent to a server, logged, or stored — the moment you close or refresh the page, everything you typed is gone. This makes the tool safe to use even with proprietary code, unpublished content, or other text you'd rather not send to a third-party server.
Real-world text is rarely as clean as a simple two-word example, so it's worth understanding how the converter handles trickier input. Numbers embedded in a phrase, like "Page 2 Section A," are treated as their own word boundary and pass through unchanged in most formats, so converting to snake_case produces something like "page_2_section_a." Acronyms in Title Case or existing camelCase input (like "APIResponse" or "HTMLParser") are split at each transition from lowercase to uppercase, which means a string of consecutive capital letters can sometimes be split more aggressively than a human might expect — for example, "XMLHttpRequest" becomes "x_m_l_http_request" in snake_case rather than "xml_http_request," since the algorithm can't reliably guess where one acronym ends and the next word begins without additional context. For most everyday variable and phrase conversions this isn't an issue, but it's useful to know if you're converting existing camelCase code that already contains acronyms.
Multi-paragraph input is also supported — the tool preserves line breaks as word boundaries where relevant, so pasting in a whole paragraph of text works the same way as converting a single short phrase, just at a larger scale. This makes it practical to reformat entire blocks of copy, not just single titles or variable names, in one pass.
Before tools like this existed, developers and writers would often use a text editor's find-and-replace feature, or a short script, to handle case conversions — replacing spaces with underscores, then manually fixing capitalization, for example. This approach works for very short strings but becomes unreliable and slow as soon as more than one transformation rule is needed at once (like converting spaces to underscores AND lowercasing everything AND handling existing punctuation). A dedicated case converter handles all of these rules together in a single, tested pass, which removes the risk of a partially-applied find-and-replace leaving text in an inconsistent, half-converted state.
If you're starting a new project and want to pick sensible naming conventions from the outset, a common and widely-accepted pattern looks like this: camelCase for JavaScript/TypeScript variables and functions, PascalCase for classes and component names, snake_case for Python code and most SQL database columns, kebab-case for CSS classes, HTML attributes, and URL paths, and CONSTANT_CASE for environment variables and true constants across nearly any language. Sticking to these established conventions, rather than inventing your own, makes a codebase far easier for other developers (or your future self) to read and maintain, since these patterns carry an implicit signal about what kind of thing a given identifier represents.
A few pairs of case formats look superficially similar but are used in very different contexts, and mixing them up is a common source of small bugs or style-guide violations: