Text Case Converter — camelCase, snake_case & 20 Formats

Popular Text & Data tools

• JSON FormatterPrettify, minify, and validate JSON data instantly.
• JSON Repair ToolRepair and fix malformed JSON data from AI outputs, API responses, and copy-paste.
• jq Playground & Filter BuilderInteractive jq expression tester, filter builder, and JSON transformer powered by WebAssembly.
• Base64 Encode/DecodeEncode and decode Base64 strings, files, and data URIs instantly.
• Git Conflict ResolverVisually resolve Git merge conflicts by picking current, incoming, or both versions.

How to Text Case Converter Online

1. 1

   Paste or type your source text into the input area on the left — camelCase variables, snake_case identifiers, UPPER_SNAKE constants, or raw prose.

2. 2

   The engine tokenizes the string into constituent words, automatically splitting on uppercase character boundaries, numbers, underscores, hyphens, slashes, and dots.

3. 3

   All 20 case variations (camelCase, PascalCase, snake_case, kebab-case, Title Case, etc.) are computed simultaneously in real time.

4. 4

   Smart Case Detection automatically recognizes your source formatting pattern and highlights the matching format card with an active badge.

5. 5

   Click on any case card in the grid to select it as your active output, or use one-click copy to immediately place the converted text onto your clipboard.

6. 6

   Switch to Batch Mode (⌘⇧B) to transform multi-line lists of database columns, CSV headers, or API field definitions at once.

7. 7

   Click "Share" to generate a gzip-compressed URL that encodes your input string and target formatting settings without storing data on any server.

Text Case Converter Features

• ✓

  20 standard case formats: camelCase, PascalCase, snake_case, UPPER_SNAKE_CASE (CONSTANT_CASE), kebab-case, UPPER-KEBAB-CASE, dot.case, path/case, Title Case, Sentence case, lowercase, UPPERCASE, Capital Words, aLtErNaTiNg, iNVERSE, COBOL-CASE, Train-Case, flatcase, and SpOnGeBoB.

• ✓

  Intelligent heuristic tokenizer: preserves acronym boundaries (e.g., XMLParser → xml parser, getHTMLString → get html string) and numbers without token corruption.

• ✓

  Smart Case Detection: automatically identifies whether source input is snake_case, kebab-case, camelCase, PascalCase, CONSTANT_CASE, or prose.

• ✓

  Real-time live transformation with debounced rendering as you type, with an option to toggle manual execution mode.

• ✓

  Batch conversion mode (⌘⇧B): convert hundreds of identifiers or column names line-by-line in a single operation.

• ✓

  Transformation pipeline tools: chain Trim, Prefix, Suffix, and Case conversions for rapid database migration and refactoring scripts.

• ✓

  Real-time text metrics bar: displays character count, word count, line count, and byte size.

• ✓

  One-click clipboard copying with visual confirmation on every individual case preview card.

• ✓

  Lossless URL sharing: gzip-compresses the input payload into an idempotent URL hash for easy developer collaboration.

• ✓

  100% client-side execution: all string processing runs locally in browser memory with zero network latency or server data retention.

• ✓

  Full keyboard shortcut support: ⌘↵ Run, ⌘⇧B Batch, ⌘⇧C Copy Selected, ⌘⇧K Clear, ⌘⇧L Toggle Live Mode.

Supported Formats & Dialects

The Text Case Converter supports 8 syntax formats and dialects for accurate parsing and processing.

camelCase (lowerCamelCase)

Compound word notation where the first word is lowercase and every subsequent word is capitalized with no delimiter spaces. Standard for variables, methods, and properties in JavaScript, TypeScript, Java, C#, Swift, and Dart.

PascalCase (UpperCamelCase)

Capitalizes the initial letter of every constituent word with zero delimiter spaces. Universal convention for classes, React and Vue UI components, TypeScript interfaces and types, and C# namespaces.

snake_case & UPPER_SNAKE_CASE (CONSTANT_CASE)

Words separated by underscore (_) characters. Lowercase snake_case is standard in Python, Ruby, Rust, and SQL column names; UPPER_SNAKE_CASE (SCREAMING_SNAKE) is standard for environment variables, global constants, and C macros.

kebab-case & COBOL-CASE (UPPER-KEBAB)

Words separated by hyphen (-) characters. Lowercase kebab-case is standard for URL slugs, HTML attributes, CSS class names, npm packages, and Kubernetes labels; COBOL-CASE is used in mainframe data divisions and AS/400 schemas.

Train-Case (HTTP Header Case)

Capitalizes the first letter of each word and joins them with hyphens (e.g., Content-Type, Accept-Encoding). Specified by RFC 9110 for standard HTTP and MIME header fields.

Title Case (AP / Chicago Style) & Capital Words

Title Case capitalizes primary nouns, verbs, and adjectives while keeping minor articles and conjunctions lowercase per AP/Chicago rules; Capital Words capitalizes every single word regardless of grammar for UI buttons and table headers.

dot.case & path/case

Dot-delimited notation used for Java package namespaces, property configuration keys, and nested JSON object paths; slash-delimited notation used for filesystem paths, URL routing paths, and resource identifiers.

SpOnGeBoB & aLtErNaTiNg Case

Alternating uppercase and lowercase character sequences popularized by internet memes for satirical tone and widely utilized by QA engineers for fuzz-testing case-insensitive parser robustness.

Frequently Asked Questions

What is camelCase and why does it differ from PascalCase (UpperCamelCase)?

Both camelCase and PascalCase combine words without spaces, capitalizing the first letter of subsequent words. The key distinction is the first letter: camelCase (also called lowerCamelCase) starts with a lowercase letter (e.g., calculateTotalPrice), whereas PascalCase (UpperCamelCase) starts with an uppercase letter (e.g., CalculateTotalPrice). In languages like JavaScript, TypeScript, and Java, camelCase is reserved for functions, variables, and instance fields, while PascalCase is mandatory for classes, constructors, and React UI components.

How does the tokenizer handle consecutive uppercase acronyms like "getHTMLString" or "XMLParser"?

Standard naive regex splitting breaks acronyms into single-character fragments (e.g., "X M L Parser"). DevFlow uses a multi-stage regex lookahead tokenizer: it detects transitions between runs of uppercase letters followed by an uppercase letter with a lowercase trailing vowel (/([A-Z]+)([A-Z][a-z])/g) and transitions from lowercase or digits to uppercase (/([a-z\d])([A-Z])/g). This splits "getHTMLString" into ["get", "html", "string"] and "XMLParser" into ["xml", "parser"], producing correct outputs like "get_html_string" and "xml_parser".

What are the standard casing conventions across major programming languages?

Different programming language ecosystems enforce strict style guides: JavaScript and TypeScript use camelCase for variables/functions and PascalCase for types/classes; Python (PEP 8) and Rust use snake_case for functions/variables, PascalCase for classes/structs, and CONSTANT_CASE for module constants; Go uses camelCase for package-private identifiers and PascalCase (Capitalized) for exported public identifiers; C# uses PascalCase for methods, properties, and classes, and camelCase with an optional leading underscore for private fields.

How does Title Case distinguish between major words and short grammatical particles?

DevFlow Title Case implements Associated Press (AP) and Chicago Manual of Style heuristics. Major words (nouns, verbs, adjectives, adverbs) are always capitalized. Short function words containing three or fewer letters—such as articles ("a", "an", "the"), coordinating conjunctions ("and", "but", "or", "for", "nor"), and prepositions ("in", "on", "at", "to", "by", "of", "as", "is", "it")—remain lowercase unless they appear as the first or last word of the title.

When should CONSTANT_CASE (SCREAMING_SNAKE_CASE) be used over regular snake_case?

CONSTANT_CASE (or SCREAMING_SNAKE_CASE) uses all uppercase letters with underscore separators: MAX_RETRY_ATTEMPTS. It is standard across Python, C/C++, Java, JavaScript, and Go to represent immutable compile-time constants, global configuration flags, and system environment variables (such as DATABASE_URL or NODE_ENV). Regular snake_case is reserved for mutable variables, function names, and database column names.

How does Train-Case relate to HTTP header formatting specifications (RFC 9110)?

Train-Case capitalizes the first letter of each word and joins them with hyphens (e.g., Content-Type, X-Request-ID, Cache-Control). RFC 9110 and RFC 7230 specify that HTTP field names are case-insensitive, but Train-Case is the canonical human-readable convention adopted by web browsers, HTTP proxies, Postman, and API documentation.

How does the Smart Detect heuristic algorithm recognize source string formatting?

When text is entered, the detection engine tests the string against regular expression patterns in a prioritized hierarchy: first checking for specific delimiter signatures (underscore-separated uppercase for CONSTANT_CASE, hyphen-separated uppercase for COBOL-CASE, lowercase underscores for snake_case, lowercase hyphens for kebab-case), then testing casing structures (capitalized hyphenated tokens for Train-Case, mixed uppercase transitions for PascalCase and camelCase). If the input is ambiguous or contains only lowercase space-delimited text, it identifies standard prose.

How does batch conversion mode handle multi-line lists of database columns or API fields?

Batch mode (⌘⇧B) splits multi-line input by newline characters, trims boundary whitespace from each line independently, and passes each non-empty string through the selected casing transformation function while preserving line numbers and empty line breaks. This allows developers to paste entire SQL table schemas, ORM model definitions, or JSON keys and convert them between snake_case and camelCase in a single operation.

How are international Unicode characters and case mapping handled during conversion?

Conversions utilize ECMAScript String.prototype.toUpperCase() and toLowerCase(), which adhere to the Unicode Standard Default Case Conversion algorithms. For Latin accented characters (e.g., "café" → "CAFÉ"), casing transforms accurately. For specialized language requirements (such as Turkish dotted/dotless "i"), standard ECMAScript locale-neutral mapping is applied.

How does kebab-case improve SEO and accessibility for URL slugs and filenames?

Search engine web crawlers (including Google and Bing) treat hyphens in kebab-case URLs (e.g., "/tools/text-case-converter") as word separators, indexing each individual keyword correctly. In contrast, underscores in snake_case URLs are often interpreted as joining characters (treating "text_case" as a single token "textcase"), and camelCase URLs can create ambiguity in case-insensitive filesystems and web servers.

Related Developer Tools

• Lorem Ipsum GeneratorGenerate placeholder text in multiple formats and styles instantly.
• Text Diff CheckerCompare two text blocks and highlight exactly what changed.
• Regex TesterTest, debug, and explain regular expressions with real-time match highlighting.
• Regex ExplainerBreak down any regex into plain English, token by token.
• Markdown PreviewPreview and render Markdown with GFM, math, Mermaid diagrams, and export options.
• HTML Entities Encoder/DecoderEncode and decode HTML entities with named, numeric, and hex modes.
• Env File Parser & ConverterParse, validate, and convert .env files between JSON, YAML, Docker, and Kubernetes formats.
• URL Encoder/DecoderEncode, decode, and parse URLs and query strings instantly.