Convert text between lowercase, UPPERCASE, Title Case, sentence case, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, dot.case, path/case.
Last updated
Text formatting
Case converter
Convert text between lowercase, UPPERCASE, Title Case, sentence case, camelCase, PascalCase, snake_case,
kebab-case, CONSTANT_CASE, dot.case, path/case, Train-Case, COBOL-CASE, flatcase, and inverse case.
It also splits acronym and digit boundaries so code-like text such as XMLHttpRequest2 can be rebuilt cleanly.
Examples
Detected input style
Title Case (medium confidence)
What it detects
Spaces, hyphens, underscores, dots, slashes, camelCase transitions, acronyms, and digit boundaries are split before each format is rebuilt.
Result
Converted text formats
Transform 3 words, 19 characters,
and 1 line into writing, programming, file-name, and route-friendly case styles.
Word count
3
Character count
19
Line mode
Single block
Parsing
Likely source: Title Case.
Standard
lowercase
hello world example
Quickly normalize pasted copy to all lowercase.
UPPERCASE
HELLO WORLD EXAMPLE
Format short labels, codes, and emphasis text.
Title Case
Hello World Example
Headings, card titles, and editorial labels.
Sentence case
Hello world example
Interface copy, descriptions, and natural prose.
Programming
camelCase
helloWorldExample
JavaScript, Java, JSON keys, and frontend variables.
PascalCase
HelloWorldExample
Classes, React/Svelte components, and type names.
snake_case
hello_world_example
Python, Ruby, SQL columns, and data fields.
kebab-case
hello-world-example
URLs, CSS classes, filenames, and CLI flags.
CONSTANT_CASE
HELLO_WORLD_EXAMPLE
Constants, environment variables, and config keys.
dot.case
hello.world.example
Namespaced settings and translation keys.
path/case
hello/world/example
Route segments and structured path fragments.
Special
Train-Case
Hello-World-Example
HTTP-style headers and hyphenated display labels.
COBOL-CASE
HELLO-WORLD-EXAMPLE
Legacy all-caps hyphenated identifiers.
flatcase
helloworldexample
Compact package names and simple identifiers.
iNVERSE cASE
hELLO wORLD eXAMPLE
Flip existing letter case for cleanup checks.
How it reads your text
The converter splits words across spaces, hyphens, underscores, dots, slashes, camelCase boundaries, acronym transitions, and digit boundaries before rebuilding
each output format. With line-by-line mode on, each pasted row is converted independently so lists of field names keep their row structure.
Case converter: lowercase, UPPERCASE, Title Case, sentence case, camelCase, snake_case
A case converter rewrites the same words into the naming style your document, CMS, codebase, spreadsheet, or route map expects. This page also explains the main assumptions behind the case converter result, highlights the supporting figures shown by the calculator, and helps the reader use the estimate without overstating what a quick online tool can prove.
What a case converter actually changes
The converter changes formatting, not meaning. It takes one input string, splits it into word-like chunks, and rebuilds those chunks in several common output styles. That makes it faster to move the same phrase between editorial and technical contexts without retyping it repeatedly.
Lowercase, UPPERCASE, Title Case, and sentence case are usually used for writing and interface copy. camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, dot.case, path/case, Train-Case, COBOL-CASE, and flatcase are more common in code, file names, keys, CSS classes, URLs, route fragments, and configuration values.
How the converter finds words
A good case converter has to detect word boundaries before it can rebuild them. Spaces are the easiest boundary, but they are not the only one. Hyphens, underscores, dots, slashes, and camelCase transitions can also signal where one word ends and the next begins.
That means an input such as "launchReadyFormat" can still become "launch_ready_format" or "Launch Ready Format" because the converter first separates the embedded words, then applies the requested style to the clean word list.
Spaces keep words separate for sentence-style output.
Hyphens, underscores, dots, and slashes are stripped before rebuilding new formats.
camelCase and PascalCase boundaries are split so code-style input can become readable copy.
All outputs are rebuilt from the same parsed word sequence for consistency.
Case styles in practice
Lowercase and UPPERCASE are the simplest styles for general text and quick formatting changes. Title Case and sentence case are usually the two writing styles people reach for first: Title Case works well for headings, while sentence case is common in interface text and body copy.
camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, dot.case, path/case, Train-Case, COBOL-CASE, and flatcase are more common in code, file names, CSS classes, environment variables, route fragments, translation keys, and configuration values. A case converter online is useful because it lets you move between editorial copy and developer naming conventions without retyping the phrase each time.
Acronyms, digits, and tricky inputs
Real-world text often includes acronyms and numbers. A good case converter should split names like XMLHttpRequest2 into a word sequence before rebuilding the selected style. That is why acronyms, digits, and camelCase transitions matter just as much as spaces and underscores.
Punctuation is handled differently depending on the formatting goal. This page is designed for practical case conversion, not for full punctuation cleanup or slug creation. If you need a stricter URL slug, a dedicated slug converter or slugify tool is usually a better fit.
Acronyms should still read cleanly after conversion.
Digits should stay visible rather than disappearing into the surrounding word.
The same input can be rebuilt into multiple naming conventions.
Not every punctuation mark belongs in every output style.
Worked example: one phrase across writing and code
Suppose the source text is "Calcipedia Converter Tools". A content editor may want sentence case or Title Case for interface copy, while a developer may need "calcipediaConverterTools", "CalcipediaConverterTools", or "calcipedia_converter_tools" for implementation details.
Using one converter pass helps keep those variations aligned. It reduces accidental mismatches where a label, a slug, a CSS token, and a documentation heading all drift into slightly different wording or separators.
Batch conversion and copy workflows
Batch output is useful when you are naming the same phrase for a CMS field, API key, CSS class, and documentation heading. It is even more useful when you paste a list of variable names, spreadsheet headers, API fields, or file names and need every row converted in the same pass.
Line-by-line mode keeps each row independent, so an input list such as api_response_id, userProfileURL, and checkout-total can become camelCase, snake_case, kebab-case, or path/case without the rows merging into one long identifier. That workflow reduces mistakes when you are preparing a migration map or cleaning a column list before a refactor.
The copy buttons, copy-all action, download option, source-case detection, and quick examples make the page more than a bare uppercase lowercase converter. They help you check the input, choose the target convention, and move the result into the next tool with less manual cleanup.
Developer formats beyond camelCase and snake_case
The common search intent is not only "convert to uppercase". Developers often need a camel case converter, snake case converter, title case converter, kebab-case converter, CONSTANT_CASE converter, or dot.case converter depending on the system they are touching.
This page therefore includes route- and configuration-oriented outputs such as path/case and dot.case alongside writing formats. Those extra outputs matter when one source label has to become a JavaScript property, a Python field, a CSS class, a translation key, and a route segment.
camelCase and PascalCase for JavaScript, Java, TypeScript, components, and class names.
snake_case for Python, Ruby, SQL fields, and backend data models.
kebab-case for URLs, CSS classes, filenames, and command-line flags.
CONSTANT_CASE for constants, environment variables, and build configuration.
dot.case and path/case for namespaced settings, translation keys, and route fragments.
Privacy, client-side conversion, and sensitive text
Text case conversion often happens on real work material: unpublished headings, customer-field names, code identifiers, configuration keys, or internal spreadsheet columns. For that reason, a useful online case converter should be fast, transparent, and safe to use for text that should not be pasted into an opaque server-side tool.
The calculator runs in the browser as part of the page interaction. It is still sensible to avoid pasting secrets, passwords, API keys, or confidential documents into any web page, but the conversion itself does not need a remote lookup or account-specific data source.
Where this converter improves on common alternatives
Competitor pages commonly offer instant uppercase, lowercase, Title Case, sentence case, camelCase, PascalCase, snake_case, and kebab-case output. Stronger tools add more programming formats, line statistics, batch mode, source-case hints, and explanations of where each naming style belongs.
This page closes those gaps by combining row-preserving batch conversion, source-case detection, acronym and digit splitting, copy-all and download workflows, and a broader set of developer formats in one compact calculator. The practical advantage is fewer manual passes when you are standardising field names across code, content, and configuration.
When not to use it
A case converter is great for style changes, but it is not a full slug editor or punctuation normaliser. If you need hyphens removed, special characters stripped, or a URL-safe string created from scratch, use a dedicated slug tool instead.
It is also not intended to rewrite meaning or grammar. The words stay the same; only the casing and separators change.
Frequently asked questions
What is the difference between Title Case and sentence case?
Title Case capitalises the main words in a heading, while sentence case capitalises only the opening word and any proper nouns. Title Case is common for headings and cards, while sentence case is often preferred for body copy and many product interfaces.
When should I use camelCase instead of snake_case?
camelCase is common in JavaScript variables, JSON properties, and many frontend codebases. snake_case is common in databases, environment variables, and some backend or scripting contexts. The right choice depends on the naming convention used by the system you are working in.
What is the difference between a case converter and a text case converter?
They are the same idea. Both convert the same words into different text styles such as lowercase, uppercase, Title Case, sentence case, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, dot.case, path/case, and related formats.
Does the converter handle acronyms and numbers?
Yes. The converter splits acronym boundaries and digit boundaries before rebuilding the text, so inputs like XMLHttpRequest2 can be converted into cleaner developer-friendly formats.
Will the converter keep punctuation exactly the same?
It is designed for phrase and identifier conversion, so it focuses on rebuilding word boundaries cleanly. If punctuation is part of the string, review the output before using it in production copy or code-sensitive contexts.
Why does converting from camelCase still work?
The converter detects transitions from lowercase to uppercase letters and treats those changes as word boundaries. That lets it turn camelCase or PascalCase text back into readable multi-word output before rebuilding the other formats.
Can I copy all formats at once?
Yes. The page shows all supported formats together, and the copy buttons let you copy one style or the full batch of converted text.
Can I convert multiple lines at once?
Yes. Turn on line-by-line mode when you paste several field names, headings, or identifiers. Each row is converted independently, so a list keeps its structure instead of becoming one combined phrase.
What are dot.case and path/case used for?
dot.case is common for namespaced settings, translation keys, and configuration paths. path/case is useful when the same words need to become route segments or structured folder-like fragments.
Which case should I use for file names and URLs?
kebab-case is common for URLs and file names because hyphens are easy to read and search engines treat them as separators. snake_case is also common in some systems, especially code and configuration.
Is sentence case the same as lowercase?
No. Sentence case capitalises the first word and keeps the rest in lowercase, while lowercase keeps every word in lowercase.
Can this help with headings and product labels?
Yes. The writing styles are useful for headings, product labels, buttons, and other UI text, while the programming styles are useful for code and structured data.
Is it safe to paste sensitive text into a case converter?
Avoid pasting passwords, API keys, private customer data, or confidential documents into any web page. For ordinary headings, labels, and identifiers, the calculator is designed as a client-side text transformation and does not need a remote lookup to perform the conversion.
