Case Converter

What Is a Case Converter?

A case converter is a small utility that rewrites text into a different naming style. Programmers use it constantly: switching a variable from camelCase to snake_case when porting code from JavaScript to Python, generating CONSTANT_CASE environment variable names from a feature description, or producing a kebab-case CSS class from a component name. Writers and editors reach for it too — to fix a heading that arrived in ALL CAPS, or to turn a raw phrase into Title Case. This tool covers every common style, from code conventions like camelCase and snake_case to writing styles like Title Case, UPPERCASE and lowercase, in one panel — paste your text, and you get every variant at once.

Common Case Styles

How to Convert Cases

1. Paste any text into the input area — a single identifier, a sentence, or many lines at once.
2. Press Ctrl+Enter or click the Convert button. The output panel shows every case variant.
3. Copy the line you need. The whole table copies with one click via the Copy button or Ctrl+Shift+C.
4. Type to convert in real time — the tool re-converts on every keystroke (debounced) so you can iterate quickly.

The conversion is fully bidirectional. You can paste helloWorldExample, hello_world_example, hello-world-example or Hello World Example — the tool detects the original style by scanning for word boundaries and re-emits the value in every other style.

How Word Boundaries Are Detected

A robust case converter has to recognize where words begin and end no matter how the input is formatted. This tool uses three rules:

• Separator characters — underscores (_), hyphens (-), spaces, dots (.), and slashes (/) split the input into words.
• Case transitions — a lowercase letter followed by an uppercase letter starts a new word (helloWorld → hello, World).
• Acronym handling — a sequence of uppercase letters followed by a lowercase letter splits before the last uppercase (XMLHttpRequest → XML, Http, Request). This matters when you convert acronym-heavy code.

Numbers stay attached to the surrounding word (getHTML5Player → getHtml5Player or get_html5_player), which is what most style guides prescribe.

camelCase vs snake_case

This is the most-Googled case-conversion question. The answer is mostly cultural, not technical:

• JavaScript, TypeScript, Java, Kotlin, Swift, C# — community style guides and language conventions favor camelCase for variables and methods. The standard library is camelCase. Frameworks like React lean on PascalCase for components and camelCase for props.
• Python and Ruby — PEP 8 (Python) and the Ruby community guide both prescribe snake_case for variables, functions and module names. PascalCase is reserved for classes; CONSTANT_CASE for constants.
• Rust and Go — Rust uses snake_case for items and PascalCase for types. Go uses MixedCaps (essentially PascalCase for exported, camelCase for unexported) and lints any deviation.
• C and C++ — historically snake_case in the standard library and many older codebases; many modern style guides allow either.
• SQL — most teams use snake_case for table and column names because identifiers are case-insensitive in many engines and quoting mixed-case is awkward.

When in doubt: read the existing code in the repo and match its style. Consistency inside one project beats any abstract preference for one style over another.

Convert snake_case to camelCase (and Back)

The two most-requested conversions are snake_case → camelCase and camelCase → snake_case, usually when moving data across a boundary — a Python or SQL backend that speaks snake_case talking to a JavaScript or TypeScript frontend that speaks camelCase. Both directions work the same way here:

1. Paste the identifier — user_first_name or userFirstName — into the input.
2. Read the matching line from the output: the camelCase row gives userFirstName, the snake_case row gives user_first_name.
3. Copy that single line, or click Copy All to grab the whole set.

Because the converter normalizes the input to a list of words before re-emitting it, the starting style never matters: user_first_name, userFirstName, UserFirstName and user-first-name all produce the exact same set of outputs. That means you can round-trip an identifier through any style and back without losing information — handy when you’re not sure which convention a snippet came from.

Text Case for Writing: Title Case, UPPERCASE and lowercase

Case conversion isn’t only for code. Writers, editors and marketers reshape prose case constantly, and this tool handles those styles too:

• Title Case — capitalizes the first letter of each word (Hello World Example). Used for headlines, article titles, button labels and UI headings. Strict style guides such as AP and Chicago lowercase short articles and prepositions like a, the, of and to; this tool applies the simpler “capitalize every word” rule, which is what most CMS and UI contexts actually expect.
• Sentence case — capitalizes only the first word (Hello world example). Modern UI guidelines (Google Material, Apple’s Human Interface Guidelines) increasingly prefer sentence case for buttons and headings because it reads as less shouty and more conversational.
• UPPERCASE — every letter capitalized (HELLO WORLD EXAMPLE). Useful for headings, emphasis, spreadsheet column labels and systems that store values in caps.
• lowercase — every letter lowercased (hello world example). Useful for tags, URL slugs, search normalization and de-shouting text that arrived in all caps.

Paste a heading that came in the wrong case and you get every writing style at once — no retyping required. Like everything else here, it runs entirely in your browser, so you can safely convert unpublished copy or internal document titles.

Common Mistakes When Converting Case

• Losing acronym capitalization — naive conversion turns parseHTML into parsehtml instead of parse_html. Use a converter that recognizes acronym runs.
• Concatenating numbers into separate words — mp3Player should become mp3_player, not mp_3_player. Most style guides keep digits glued to the preceding word.
• Mangling Unicode letters — accented characters like é and ñ should keep their case-folding behavior. This tool uses JavaScript’s toLowerCase() and toUpperCase(), which respect Unicode rules.
• Trimming meaningful separators — converting a file path like src/components/Button.tsx should preserve the path structure, not flatten it. If you’re working with paths, use the dedicated path/case output.

When to Use This Tool

• Porting code between languages — translate a Python API to TypeScript, or the other way around, and rename every identifier.
• Generating environment variable names — turn a feature description like “stripe webhook secret” into STRIPE_WEBHOOK_SECRET.
• Building CSS class names from component names — UserProfileCard → user-profile-card.
• Cleaning up a CSV header row — First Name, Last Name, Email Address → first_name, last_name, email_address for SQL ingestion.
• Renaming a batch of identifiers — paste an entire list, get the converted output, paste it back.

Everything runs locally in your browser. No data leaves your machine, which means you can safely paste internal identifiers, API endpoints or proprietary feature names without worrying about a third-party server logging them.