Paste your text and instantly switch between common writing and programming case styles with one click.
XConvert's text case converter transforms your text between nine different casing formats instantly. Whether you're formatting variable names for code, preparing titles for publication, or standardizing data for a database, this tool handles every common text transformation.
Step 1: Paste or Type Your Text. Enter the text you want to convert into the input field. You can paste anything from a single word to multiple paragraphs. The tool preserves your original line breaks and spacing structure.
Step 2: Choose Your Target Case Format. Select from nine available formats: UPPERCASE, lowercase, Title Case, Sentence case, camelCase, PascalCase, snake_case, kebab-case, or CONSTANT_CASE. Each format button shows a live preview so you can see the result before committing.
Step 3: Review the Converted Output. The converted text appears instantly in the output panel. Check that the transformation matches your expectations — especially for edge cases like acronyms, hyphenated words, or names with unusual capitalization.
Step 4: Copy to Clipboard. Click the copy button to grab the converted text. Paste it directly into your code editor, document, spreadsheet, or CMS. No formatting artifacts are added — you get clean, plain text every time.
A text case converter is a tool that changes the capitalization pattern of text according to specific rules. Different contexts demand different casing conventions — programming languages use camelCase and snake_case for variable names, publishers use Title Case for headlines, databases often store text in UPPERCASE or lowercase for consistency, and URLs use kebab-case for readability and SEO.
Manually reformatting text case is tedious and error-prone, especially with large blocks of text. A word processor's built-in case change is limited to basic uppercase and lowercase. Developers need specialized formats like camelCase (where each word after the first is capitalized with no separators) or snake_case (where words are joined by underscores). These formats follow strict rules that are easy to get wrong when typing manually, particularly with multi-word phrases or text containing numbers and special characters.
XConvert's text case converter applies precise transformation rules for all nine formats. It correctly handles edge cases like consecutive spaces, mixed-case input, numbers within words, and common acronyms. The tool runs entirely in your browser with no server processing, making it fast, private, and available offline. It pairs well with the Lorem Ipsum generator when you need placeholder text in a specific casing format for mockups and prototypes.
| Format | Example | Separator | Use Case | Common In |
|---|---|---|---|---|
| UPPERCASE | HELLO WORLD | Space | Constants, headers | SQL, env variables |
| lowercase | hello world | Space | Normalization, search | Databases, URLs |
| Title Case | Hello World | Space | Headlines, titles | Publishing, UI |
| Sentence case | Hello world | Space | Body text, descriptions | Content writing |
| camelCase | helloWorld | None (caps) | Variables, functions | JavaScript, Java |
| PascalCase | HelloWorld | None (caps) | Classes, types | C#, TypeScript |
| snake_case | hello_world | Underscore | Variables, columns | Python, Ruby, SQL |
| kebab-case | hello-world | Hyphen | URLs, CSS classes | HTML, CSS, URLs |
| CONSTANT_CASE | HELLO_WORLD | Underscore | Constants, enums | C, Java, Python |
Code Refactoring and Variable Naming. Developers frequently need to convert between naming conventions when moving code between languages or refactoring. A Python function name in snake_case (get_user_data) needs to become camelCase (getUserData) in JavaScript or PascalCase (GetUserData) in C#. This tool eliminates manual rewriting and reduces typos.
SEO-Friendly URL Slugs. Content managers need to convert article titles into URL-friendly kebab-case slugs. "How to Convert Text Case Online" becomes how-to-convert-text-case-online. Consistent URL formatting improves SEO and user experience. Use alongside the Markdown to HTML converter when preparing web content.
Database Field Standardization. When importing data from multiple sources, field names often arrive in inconsistent formats. Converting everything to a standard case (typically snake_case for SQL columns or camelCase for NoSQL document fields) ensures consistency and prevents bugs caused by case-sensitive lookups.
Content Formatting for Publishing. Writers and editors need Title Case for headlines, Sentence case for body text, and UPPERCASE for acronyms or emphasis. Batch-converting text saves significant time when formatting articles, newsletters, or marketing copy.
CSS Class and ID Naming. Front-end developers follow BEM or other naming conventions that require kebab-case for CSS classes. Converting component names from PascalCase (used in React/Vue) to kebab-case (used in CSS) ensures consistency between JavaScript and stylesheet files.
API Response Transformation. APIs from different services return data in different casing conventions. A REST API might use snake_case while a GraphQL API uses camelCase. Converting field names between formats is essential when integrating multiple data sources.
Naming conventions are not arbitrary — they carry semantic meaning within each programming ecosystem. Using the wrong convention makes code harder to read and can even cause bugs in case-sensitive languages.
JavaScript and TypeScript use camelCase for variables and functions (getUserName, isActive), PascalCase for classes and React components (UserProfile, DataTable), and CONSTANT_CASE for constants (MAX_RETRIES, API_BASE_URL). This convention is so deeply embedded that ESLint rules enforce it automatically.
Python follows PEP 8, which prescribes snake_case for variables, functions, and module names (get_user_name, is_active), PascalCase for class names (UserProfile), and CONSTANT_CASE for module-level constants (MAX_RETRIES). Mixing conventions in Python code is considered a style violation and triggers linter warnings.
Java and C# use camelCase for local variables and parameters, PascalCase for class names, method names (in C#), and interfaces. Java methods use camelCase (getUserName) while C# methods use PascalCase (GetUserName). Constants use CONSTANT_CASE in both languages.
Ruby follows snake_case for methods and variables, PascalCase for classes and modules, and CONSTANT_CASE for constants. Ruby's convention is similar to Python's, reflecting both languages' emphasis on readability.
CSS and HTML use kebab-case for class names, IDs, data attributes, and custom properties (user-profile, is-active, --primary-color). This convention exists because CSS is case-insensitive for property names but case-sensitive for class selectors, and hyphens are the traditional word separator in CSS.
SQL traditionally uses UPPERCASE for keywords (SELECT, FROM, WHERE) and snake_case for table and column names (user_profiles, created_at). While SQL itself is case-insensitive for keywords, this convention improves readability by visually separating SQL syntax from data identifiers.
Go uses PascalCase for exported (public) identifiers and camelCase for unexported (private) identifiers. This is unique because the casing itself determines visibility — GetUser is public while getUser is private. This makes correct casing functionally important, not just a style preference.
Understanding these conventions helps you use the text case converter effectively. When converting a phrase for use in code, choose the format that matches your target language's conventions.
Start with clean, properly spaced text. The converter uses spaces, underscores, hyphens, and capitalization changes as word boundaries. Text with inconsistent spacing or missing separators may not split correctly. Clean up your input for the best results.
Handle acronyms manually when needed. Most case converters treat acronyms as single words. "HTML parser" in camelCase becomes htmlParser, not HTMLParser. If you need specific acronym handling, adjust the output manually after conversion.
Use Sentence case for natural language. When converting text for UI labels, descriptions, or body copy, Sentence case (only the first word capitalized) reads more naturally than Title Case and is the modern standard for most interface text.
Combine with the Lorem Ipsum generator. When building UI prototypes, generate placeholder text with the Lorem Ipsum generator and then convert it to the casing format your design requires.
Test edge cases with numbers. Text containing numbers (like "version2update") may split differently than expected. Check the output when your input includes digits adjacent to letters.
Use CONSTANT_CASE for environment variables. When defining configuration values or environment variables, CONSTANT_CASE (DATABASE_URL, API_KEY) is the universal convention across operating systems and programming languages.
camelCase starts with a lowercase letter and capitalizes the first letter of each subsequent word (getUserName). PascalCase capitalizes the first letter of every word, including the first (GetUserName). In most languages, camelCase is used for variables and functions, while PascalCase is reserved for class names, type names, and constructors.
Use snake_case for programming contexts where underscores are valid in identifiers — Python variables, Ruby methods, SQL column names, and environment variables. Use kebab-case for contexts where hyphens are the convention — CSS class names, URL slugs, HTML attributes, and CLI flag names. Most programming languages don't allow hyphens in variable names, so kebab-case is limited to non-code contexts.
Title Case capitalizes the first letter of every major word ("How to Convert Text Case Online"), while Sentence case only capitalizes the first word and proper nouns ("How to convert text case online"). Title Case is used for headlines and book titles. Sentence case is used for UI labels, descriptions, and most modern web interfaces.
Yes. XConvert preserves special characters and handles numbers within text. Characters like @, #, &, and punctuation marks are maintained in the output. Numbers adjacent to letters are treated as part of the word in most formats, so "version2" stays together as one unit.
CONSTANT_CASE (also called SCREAMING_SNAKE_CASE) uses all uppercase letters with underscores between words (MAX_RETRY_COUNT). It's the universal convention for constants, environment variables, and enum values across nearly all programming languages. The all-caps format signals that the value should not be modified during program execution.
Paste the full list of variable names into XConvert, with each name on a separate line. Select your target format, and all names will be converted simultaneously. For bulk conversions in code files, consider using your IDE's find-and-replace with regex, or a dedicated refactoring tool, after using XConvert to determine the correct converted names.
Yes. XConvert processes each line independently, preserving your original line break structure. This is useful for converting lists of names, CSV headers, or multi-line code snippets. Empty lines are preserved as-is.
Standard camelCase conversion treats each word uniformly, so "HTML to PDF" becomes htmlToPdf rather than HTMLToPDF. This is actually the recommended convention in most style guides (Google's Java style guide, for example, prescribes htmlParser over HTMLParser). If you need a different acronym treatment, adjust the specific acronym manually after conversion.
Kebab-case uses lowercase letters with hyphens between words (my-component-name). It's named after the visual resemblance to words skewered on a kebab stick. It's the standard for CSS class names, URL paths, HTML custom element names, npm package names, and Git branch names. It's highly readable and URL-safe.
Yes. If you have JSON keys in one format and need them in another (e.g., converting snake_case API response keys to camelCase for JavaScript), paste the key names into XConvert and convert them. For full JSON structure conversion, use the JSON/YAML/XML converter to transform between data formats.