What's the difference between camelCase and PascalCase?

camelCase starts with a lowercase letter; every subsequent word is capitalized. PascalCase capitalizes the first letter too. JavaScript convention is camelCase for variables/functions and PascalCase for classes and React components.

Does the tokenizer respect existing case humps?

Yes. Input like 'getHTTPResponseCode' is split as get, HTTP, Response, Code — and rejoined per the target convention. snake_case output: get_http_response_code; camelCase: getHttpResponseCode (preserving common JavaScript convention).

Are acronyms handled specially?

Convertitive treats consecutive uppercase letters as a single token (HTTP, URL, JSON) — splitting only when the next character is lowercase. In camelCase / PascalCase, these become Title-cased (Http, Url, Json) which matches the most common style guide.

Will the tool ever modify content other than case?

It always lower-cases the input first to normalize it, then re-cases per target. Punctuation between words is dropped and replaced by the case's separator (or removed for camel/Pascal). Whitespace at the edges is trimmed.

Is dot.case really a thing?

Yes — Java package names, MIME-type-style identifiers, and many event-bus naming schemes use it. It's also useful for hierarchical configuration keys.

Can I convert non-Latin scripts?

The case mapping uses JavaScript's built-in String.prototype.toLowerCase / toUpperCase, which is Unicode-aware. Languages with no case (Arabic, Hebrew, Chinese, Japanese) pass through unchanged. Languages with locale-sensitive casing (Turkish dotted i ↔ undotted I) follow the runtime's default locale.

Case Converter

Ten case conventions, side by side, copy-ready.

Every programming language and config format has opinions about how identifiers should be capitalized. Convertitive’s case converter takes any input — even something already in a programming case like getHTTPResponseCode — and shows all ten common renderings at once. Paste, scan, copy the one you need. The tokenizer splits on whitespace, punctuation, and case humps, so mixed-case input is handled cleanly.

Input — any case, punctuation tolerated

UPPER CASE
THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG
lower case
the quick brown fox jumps over the lazy dog
Title Case
The Quick Brown Fox Jumps Over The Lazy Dog
Sentence case
The quick brown fox jumps over the lazy dog
camelCase
theQuickBrownFoxJumpsOverTheLazyDog
PascalCase
TheQuickBrownFoxJumpsOverTheLazyDog
snake_case
the_quick_brown_fox_jumps_over_the_lazy_dog
CONSTANT_CASE
THE_QUICK_BROWN_FOX_JUMPS_OVER_THE_LAZY_DOG
kebab-case
the-quick-brown-fox-jumps-over-the-lazy-dog
dot.case
the.quick.brown.fox.jumps.over.the.lazy.dog

How to use

Paste anything
The input can be a sentence, an identifier, or a half-renamed mess. Punctuation is treated as a separator.
Scan the ten outputs
Each row shows the same value re-rendered in one case convention. Use the row's copy button to grab just that variant.
Edit and watch it update
Every output recomputes as you type. The tool keeps the original tokenization stable, so adding or removing a word doesn't shuffle the case for the others.

Where each case shows up

Case	Typical usage
camelCase	JavaScript / TypeScript variables, JSON keys, Java methods
PascalCase	Class names, React components, .NET types
snake_case	Python identifiers, Ruby symbols, SQL columns
CONSTANT_CASE	Environment variables, language constants, enum values
kebab-case	CSS classes, URL slugs, npm package names
dot.case	Java packages, file extensions, namespaced events

Frequently asked questions

What's the difference between camelCase and PascalCase?: camelCase starts with a lowercase letter; every subsequent word is capitalized. PascalCase capitalizes the first letter too. JavaScript convention is camelCase for variables/functions and PascalCase for classes and React components.
Does the tokenizer respect existing case humps?: Yes. Input like 'getHTTPResponseCode' is split as get, HTTP, Response, Code — and rejoined per the target convention. snake_case output: get_http_response_code; camelCase: getHttpResponseCode (preserving common JavaScript convention).
Are acronyms handled specially?: Convertitive treats consecutive uppercase letters as a single token (HTTP, URL, JSON) — splitting only when the next character is lowercase. In camelCase / PascalCase, these become Title-cased (Http, Url, Json) which matches the most common style guide.
Will the tool ever modify content other than case?: It always lower-cases the input first to normalize it, then re-cases per target. Punctuation between words is dropped and replaced by the case's separator (or removed for camel/Pascal). Whitespace at the edges is trimmed.
Is dot.case really a thing?: Yes — Java package names, MIME-type-style identifiers, and many event-bus naming schemes use it. It's also useful for hierarchical configuration keys.
Can I convert non-Latin scripts?: The case mapping uses JavaScript's built-in String.prototype.toLowerCase / toUpperCase, which is Unicode-aware. Languages with no case (Arabic, Hebrew, Chinese, Japanese) pass through unchanged. Languages with locale-sensitive casing (Turkish dotted i ↔ undotted I) follow the runtime's default locale.

About

Tokenization, in detail

The input is normalized by replacing any non-alphanumeric character with a space, then inserting a space at every transition from a lowercase letter (or digit) to an uppercase letter, and at every transition between consecutive uppercase letters that's followed by a lowercase letter. The resulting tokens are lower-cased and joined per target convention.

Why so many cases exist

Each style is a historical accident of one community's typing conventions, paired with a desire to make identifiers visually distinct. Programming styles tend to be sticky once chosen, which is why a multi-language project usually ends up needing all of them at once — a function in JavaScript, a column in PostgreSQL, an env-var on the server, and a CSS class on the front-end can all describe the same conceptual thing in four different cases.