Input Text
Output -- Title Case
Output appears here...
What this tool does
Free text case converter -- convert text to camelCase, snake_case, Title Case, UPPER CASE, kebab-case, and 7 more formats instantly online
How this text case changer works, what each case format is used for, and how to batch-convert variable names, titles, and content
This free online text case converter transforms any text between 11 distinct capitalisation formats instantly in your browser. The tool works by first tokenising your input into individual words using a multi-pass algorithm: it splits on whitespace, underscores, hyphens, and dots (the common programmatic separators), and also detects embedded camelCase and PascalCase boundaries by identifying transitions from lowercase to uppercase letters and from sequences of uppercase letters into mixed case words. This means you can input text in any existing format -- sentence case prose, snake_case identifiers, camelCase variable names, UPPER CASE headlines -- and convert accurately to any of the 11 output formats without needing to pre-clean the input. The conversion logic runs entirely in your browser as a pure JavaScript function with no network requests, making it instantaneous regardless of text length.
The 11 supported case formats cover the full range of naming conventions used across writing, web development, and software engineering. UPPER CASE and lower case are the simplest transformations, converting all letters wholesale. Title Case applies the Chicago Manual of Style rules for capitalising headings: every word is capitalised except articles (a, an, the), coordinating conjunctions (and, but, or, nor, for, so, yet), and short prepositions (at, by, in, of, on, to, up, as) -- unless those words appear as the first or last word of the title. Sentence case capitalises only the first word of each line, matching standard prose writing. The programmer-oriented formats -- camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, dot.case, and Train-Case -- strip all spaces and separators and join words using the format-specific delimiter and capitalisation rules. Multi-line input is handled by processing each line independently, preserving blank lines, which makes batch conversion of identifier lists, column name schemas, and CSS class lists practical in a single operation.
The most common use cases for this text case converter fall into three categories. For developers, the tool is most useful for: converting database column names (snake_case) to JavaScript object keys (camelCase) when building API response mappers, generating environment variable names (CONSTANT_CASE) from human-readable config labels, converting design system component names between PascalCase (React) and kebab-case (CSS/HTML), and reformatting imported data from one naming convention to another when switching languages or frameworks. For writers and content creators, the key uses are: correcting improperly cased article titles to Chicago-style Title Case, converting ALL CAPS legacy document text to readable Sentence case, and generating consistent heading formats across long documents. For SEO and web work, converting page titles to Title Case and URL slugs to kebab-case are the most frequent tasks -- both of which this tool handles accurately in real time.
Formats and features
UPPER CASE
Converts all letters to uppercase -- used for acronyms, emphasis, and ALL CAPS style headlines.
lower case
Converts all letters to lowercase -- used for tags, metadata, and normalising mixed-case input.
Title Case
Capitalises each major word following Chicago Manual of Style rules for articles, conjunctions, and prepositions.
Sentence case
Capitalises only the first word of each line -- the standard format for prose, emails, and social media.
camelCase
No spaces, first word lowercase, subsequent words capitalised -- standard for JS, Java, and Swift variables.
PascalCase
No spaces, every word capitalised -- used for class names, TypeScript types, and React component names.
snake_case
Words joined by underscores, all lowercase -- the Python and Ruby standard for variables and database columns.
kebab-case
Words joined by hyphens, all lowercase -- used for URL slugs, CSS class names, and HTML attributes.
CONSTANT_CASE
Words joined by underscores, all uppercase -- the universal standard for environment variables and named constants.
dot.case
Words joined by dots, all lowercase -- used for config file keys and hierarchical identifiers.
Train-Case
Words joined by hyphens, each word capitalised -- used for HTTP header names and some CLI argument formats.
Multi-line batch
Each line is converted independently with blank lines preserved -- convert entire lists of identifiers in one step.
Examples
Text case conversion examples -- camelCase for APIs, Title Case for headlines, CONSTANT_CASE for env vars, and more
Five real-world scenarios showing how to use the text case converter for development, content writing, and document formatting
ExcellentBatch converting database columns to camelCase for a JavaScript API
Input (snake_case columns from SQL schema):
user_first_name
created_at
account_balance
is_email_verified
last_login_timestamp
Output (camelCase -- select camelCase mode):
userFirstName
createdAt
accountBalance
isEmailVerified
lastLoginTimestamp
A common developer task: converting a list of database column names to camelCase for use as JavaScript object property names or API response keys. Each line is converted independently, preserving the list structure. The converter correctly handles multi-word underscore-separated names and single-word names equally.
ExcellentConverting an article draft title to proper Title Case
Input (typed in sentence case):
the art of writing for the web and beyond
Output (Title Case -- Chicago Manual of Style rules):
The Art of Writing for the Web and Beyond
Articles/conjunctions kept lowercase: for, and, the (middle)
First and last words always capitalised: The, Beyond
Title Case conversion follows the Chicago Manual of Style rule set: articles (a, an, the), coordinating conjunctions (and, but, or), and short prepositions (for, of, in, at, by) are kept lowercase except when they are the first or last word. This is the correct format for book titles, article headings, and editorial content.
GoodConverting CSS class names from snake_case to kebab-case
Input (snake_case from a Python template):
nav_container
hero_section_title
btn_primary_large
footer_link_list
Output (kebab-case -- for CSS/HTML):
nav-container
hero-section-title
btn-primary-large
footer-link-list
When migrating from a Python-generated template (which uses snake_case) to standard CSS and HTML (which uses kebab-case), this batch conversion handles the entire class name list in one step. The converter simply replaces underscores with hyphens and ensures all characters are lowercase.
GoodGenerating environment variable names in CONSTANT_CASE
Input (human-readable config labels):
Database connection url
API rate limit per minute
JWT secret key
Max file upload size mb
Output (CONSTANT_CASE -- for .env files):
DATABASE_CONNECTION_URL
API_RATE_LIMIT_PER_MINUTE
JWT_SECRET_KEY
MAX_FILE_UPLOAD_SIZE_MB
Environment variable names in .env files and shell scripts are universally written in CONSTANT_CASE. Converting a list of human-readable configuration labels to CONSTANT_CASE in one step saves time when setting up new projects or documenting environment variable names for a README.
GoodFixing ALL CAPS marketing copy to readable sentence case
Input (pasted from a legacy document in ALL CAPS):
INTRODUCING OUR NEW PRODUCT LINE FOR SUMMER
FREE SHIPPING ON ALL ORDERS OVER FIFTY DOLLARS
LIMITED TIME OFFER ENDS SUNDAY
Output (Sentence case -- readable body text):
Introducing our new product line for summer
Free shipping on all orders over fifty dollars
Limited time offer ends sunday
All-caps text from legacy documents, PDFs, or copy-pasted spreadsheet data is immediately readable after sentence case conversion. Each line is treated as a separate sentence with only the first letter capitalised. Note that proper nouns (product names, place names) will need manual re-capitalisation after conversion, as the converter has no proper noun dictionary.
FAQ
Frequently asked questions about text case conversion, camelCase, snake_case, Title Case rules, and programming naming conventions
Common questions about when to use each case format, how the converter handles acronyms and multi-line text, and whether your text is stored
What is a text case converter and what does it do?
A text case converter is a tool that transforms text between different capitalisation formats without requiring manual retyping. This tool supports 11 distinct case types: UPPER CASE, lower case, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, CONSTANT_CASE, dot.case, and Train-Case. You paste your text into the input area, select the target case from the grid, and the converted output appears instantly in the preview panel with a one-click copy button. Every conversion processes line by line, preserving paragraph structure and blank lines, making it suitable for converting single identifiers, multi-line code variable lists, article headlines, and full document passages.
What is the difference between camelCase and PascalCase?
Both camelCase and PascalCase join multiple words together without spaces and capitalise the first letter of each word -- but they differ in how they treat the very first word. In camelCase (also called lower camel case), the first word is entirely lowercase and subsequent words each start with a capital letter: for example, 'hello world foo' becomes helloWorldFoo. In PascalCase (also called upper camel case or StudlyCase), every word including the first starts with a capital letter: 'hello world foo' becomes HelloWorldFoo. The practical difference is that camelCase is used for variable and function names in JavaScript, Java, Swift, Kotlin, and Dart, while PascalCase is used for class names, type names, React component names, and constructor functions in those same languages.
When should I use snake_case vs kebab-case?
The choice between snake_case and kebab-case is largely determined by the language or context you are working in. snake_case (words joined by underscores, all lowercase) is the standard naming convention for variables, functions, and module names in Python as defined in PEP 8, for method and variable names in Ruby, and for column names in SQL databases and ORM models. kebab-case (words joined by hyphens, all lowercase) is the standard for HTML element attributes, CSS class names and IDs, URL slugs and URL paths in web applications, and file names in many web development frameworks. The key reason kebab-case cannot be used as an identifier in most programming languages is that hyphens are interpreted as the subtraction operator, making hello-world ambiguous -- which is why kebab-case is confined to markup, styling, and URL contexts.
What is Title Case and which words should not be capitalised?
Title Case capitalises the first letter of each significant word in a title or heading. However, traditional English title case rules (as defined by the Chicago Manual of Style and AP Style Guide) specify that certain short words should remain lowercase unless they appear as the first or last word of the title. These lowercase words are called articles (a, an, the), coordinating conjunctions (and, but, or, nor, for, so, yet), and short prepositions (at, by, in, of, on, to, up, as). This tool implements these rules: articles, conjunctions, and short prepositions are kept lowercase in the middle of a title, but are always capitalised if they are the first or last word. For example: 'the art of the deal' becomes 'The Art of the Deal'.
What is CONSTANT_CASE and when is it used?
CONSTANT_CASE (also called SCREAMING_SNAKE_CASE or UPPER_SNAKE_CASE) formats text with all letters in uppercase and words joined by underscores. It is used almost exclusively for named constants and environment variables across many programming languages. In JavaScript and TypeScript, constants declared with const that represent configuration values are conventionally written in CONSTANT_CASE: for example, MAX_RETRY_COUNT, API_BASE_URL, DEFAULT_TIMEOUT_MS. In Python, module-level constants follow the same convention per PEP 8. In shell scripts and CI/CD configuration, environment variables are almost universally written in CONSTANT_CASE: DATABASE_URL, SECRET_KEY, NODE_ENV. The visual distinction from normal variable names makes constants immediately recognisable in source code.
How does the camelCase converter handle acronyms and abbreviations?
This text case converter treats each word as a separate unit after splitting on spaces, underscores, hyphens, dots, and camelCase boundaries. For acronyms embedded in text like 'HTML parser' or 'parse XML data', the converter splits on the camelCase boundary algorithm which detects transitions from uppercase sequences to mixed case. 'HTMLParser' is split to ['HTML', 'Parser'] before conversion. When converting to camelCase, the first segment is lowercased in full (html) and subsequent segments have their first letter capitalised (Parser), producing htmlParser. For snake_case output, the same input produces html_parser. This approach handles the most common acronym scenarios, though highly irregular capitalisation in the input may produce unexpected splits -- in those cases, pre-separating acronyms with spaces in the input before converting gives the most predictable output.
Can I convert multiple lines or a list of variable names at once?
Yes -- this text case converter processes each line independently. When you paste multi-line text, every line is converted to the selected case format while blank lines are preserved in their original positions. This makes it practical for batch-converting lists of variable names, database column names, API keys, or CSS class names. For example, if you paste a list of snake_case database columns (user_first_name, created_at, account_balance) and select camelCase, each line is converted independently to produce userFirstName, createdAt, accountBalance. The 'Use as Input' button allows you to chain conversions -- convert to one format, click Use as Input, then convert again to a second format.
What is dot.case and where is it used?
dot.case formats text by joining words with periods (dots) and making all letters lowercase. It is less common than snake_case or kebab-case but appears in specific contexts: configuration file keys in formats like TOML, HOCON, and some JSON configuration systems where hierarchical keys are flattened (for example, database.connection.timeout rather than a nested object), package names and module identifiers in languages like Erlang and Elixir, version namespace identifiers in some frameworks, and property access notation when representing object paths as strings. This tool's dot.case output strips spaces, hyphens, underscores, and other separators and joins all words with a single dot, making it useful for generating config keys from human-readable labels.
What is Train-Case and how is it different from kebab-case?
Train-Case (also called HTTP-Header-Case or Start-Case-With-Hyphens) formats words joined by hyphens with each word's first letter capitalised: 'hello world foo' becomes Hello-World-Foo. It differs from kebab-case (hello-world-foo) only in capitalisation -- Train-Case capitalises the first letter of each segment while kebab-case is all lowercase. Train-Case is most commonly seen in HTTP header names, where headers like Content-Type, Accept-Encoding, X-Request-ID, and Cache-Control follow this capitalisation pattern. Some command-line tools and configuration systems also use Train-Case for option names. For web development purposes, generating correctly capitalised HTTP header names from plain English descriptions is the primary use case for Train-Case conversion.
How does the sentence case converter work?
Sentence case capitalises only the first letter of the first word in each line, and lowercases all other letters. This mirrors the capitalisation style of normal written prose -- how you would write a sentence in an email, document, or social media post. In this tool, each line of input is treated as a separate sentence, meaning the first word of every line gets capitalised regardless of punctuation. This is appropriate for converting a list of sentences, email subject lines, or social media post text from ALL CAPS or Title Case back to normal readable prose. Note that proper nouns within the text will be lowercased by this conversion -- if your text contains names or trademarked terms that must retain their capitalisation, you will need to re-capitalise those manually after conversion.
Is this text case converter free and does it store my text?
This text case converter is completely free with no signup, no account required, and no usage limits. All conversion processing happens entirely within your browser using JavaScript -- your text is never transmitted to any server, never logged, and never stored. This makes it safe to use with sensitive content such as internal documentation, code containing API key patterns, or proprietary product names. The tool runs as a pure client-side React component: the input text stays in browser memory only and is discarded when you close or refresh the page. There are no analytics events fired on the text content, and no third-party services are involved in the conversion process.
Related Tools
Need a disposable email address?Stop giving your real email to sites you don't trust -- get a free instant throwaway with no signup and no trace.
Get Free Temp Mail ->