Case Converter
Convert text to 12 case formats simultaneously — camelCase, PascalCase, snake_case, kebab-case, SCREAMING_SNAKE_CASE, dot.case, path/case and more. Real-time output, copy each with one click. Unique bulk mode for converting entire lists at once.
Case Converter Tool
12 formats simultaneously — including dot.case and path/case that most tools miss
Most case converters show one output at a time. This tool shows all 12 case formats at once, with a one-click copy button on every card. The bulk mode is unique — paste a list of identifiers or a CSV header row and convert every line simultaneously.
How to convert text case
How this case converter compares
| Feature | LazyTools ✦ | convertcase.net | textconverter.net | camelcasify.com |
|---|---|---|---|---|
| Number of case formats | ✔ 12 formats | 8 formats | 6 formats | 4 formats |
| All formats shown simultaneously | ✔ All at once | One at a time | One at a time | ✔ Yes |
| dot.case | ✔ Yes | ✘ No | ✘ No | ✘ No |
| path/case | ✔ Yes | ✘ No | ✘ No | ✘ No |
| Bulk multi-line conversion | ✔ Yes | ✘ No | ✘ No | ✘ No |
| Smart input parsing (any format in) | ✔ Yes | ✔ Partial | Words only | ✔ Yes |
| Copy each format button | ✔ Per format | ✔ Yes | ✔ Yes | ✔ Yes |
| Character and word count | ✔ Both | ✔ Yes | ✔ Some | ✘ No |
| Live output (no button press) | ✔ Real-time | ✔ Yes | Button | ✔ Yes |
| No ads blocking the tool | ✔ Clean | Ads | Heavy ads | Ads |
Case format quick reference — "hello world" in all 12 formats
| Format name | Output | Common usage |
|---|---|---|
| camelCase | helloWorld | JavaScript variables, Java variables and methods |
| PascalCase | HelloWorld | Classes, types, React components, C# methods |
| snake_case | hello_world | Python variables and functions, SQL column names, Ruby |
| SCREAMING_SNAKE_CASE | HELLO_WORLD | Constants in Python, Java, C, environment variables |
| kebab-case | hello-world | HTML attributes, CSS classes, URL slugs, YAML keys |
| dot.case | hello.world | i18n translation keys, logging namespaces, config keys |
| path/case | hello/world | File paths, URL routing patterns, module paths |
| Constant Case | HELLO WORLD | Formal headings, button labels, UI constants |
| Title Case | Hello World | Article titles, headings, proper nouns, UI labels |
| Sentence case | Hello world | Sentences, descriptions, UI copy, blog post text |
| UPPER CASE | HELLO WORLD | Emphasis, acronyms, headers, alert messages |
| lower case | hello world | Email addresses, URLs, normalised text for storage |
Case Conventions in Programming — A Complete Guide to camelCase, PascalCase, snake_case and More
Naming conventions — the rules that determine how variables, functions, classes, files and configuration keys are named — are one of the most frequently debated topics in software development. Every language, framework and organisation has its own conventions, and violating them creates code that is harder to read, search and maintain. Understanding the full landscape of case styles and when each is used makes you a faster, more consistent developer. This guide covers all 12 major case formats — from the widely known camelCase and snake_case to the less commonly discussed dot.case and path/case — with specific guidance on which language or context each format belongs to.
camelCase — the JavaScript default
camelCase starts with a lowercase letter and capitalises the first letter of each subsequent word: helloWorld, getUserById, isAuthenticated. It is the standard for JavaScript and TypeScript variable names, function names and object properties. Java uses it for variables and method names. Swift, Kotlin and Dart also use camelCase for variables and functions. The name comes from the visual appearance of the uppercase letters creating humps along the word, resembling a camel's silhouette.
PascalCase — for types and classes
PascalCase (also called UpperCamelCase) capitalises the first letter of every word including the first: HelloWorld, UserProfile, OrderLineItem. It is used universally for class names across Java, C#, TypeScript, Python and most other languages. In React, component names must be PascalCase — MyButton versus myButton — because JSX uses this to distinguish between custom components and native HTML elements. C# uses PascalCase for all public members including properties and methods, which is unusual compared to most other languages.
snake_case — Python and databases
Snake_case joins words with underscores and uses all lowercase: hello_world, user_first_name, get_order_by_id. It is the official Python style (PEP 8) for all variable names, function names and module names. Database column names in PostgreSQL, MySQL and SQLite conventionally use snake_case. Ruby also uses snake_case for variables and method names. REST API response fields are frequently snake_case, particularly those designed for Python or Ruby consumers. The underscore makes snake_case highly readable for multi-word identifiers, especially in longer names where camelCase humps become hard to parse.
SCREAMING_SNAKE_CASE — for constants
SCREAMING_SNAKE_CASE (all uppercase with underscores) is the universal convention for constant values: MAX_RETRY_COUNT, API_BASE_URL, DATABASE_CONNECTION_TIMEOUT. Python uses it for module-level constants (PEP 8). Java and C use it for static final constants. Most Linux and Unix environment variables use SCREAMING_SNAKE_CASE (PATH, HOME, DATABASE_URL). The uppercase signals to readers that this value does not change at runtime.
kebab-case — HTML, CSS and URLs
Kebab-case joins words with hyphens and uses all lowercase: hello-world, user-profile, background-color. It is the standard for HTML attributes, CSS class names and property names, URL slugs and YAML configuration keys. Kebab-case cannot be used as a variable name in most programming languages because the hyphen is the subtraction operator — user-name would be parsed as user minus name. In Vue.js, component props defined in camelCase are accessed as kebab-case attributes in HTML templates. URL slug generators typically produce kebab-case output.
dot.case and path/case — the formats most tools miss
Dot.case joins words with periods: application.server.port, user.first.name. It is used for i18n (internationalisation) translation keys in libraries like i18next and react-i18next, for Java property files, for logging namespace identifiers (com.myapp.services.auth), and for some configuration management systems. Path/case joins words with forward slashes: user/profile/settings. It is used in URL routing definitions, file system paths expressed as strings, and some module import systems. Both formats are absent from most free case converter tools, which is why developers building with these formats often end up writing conversion code manually.
Title Case vs Sentence case — for human-readable text
Title Case capitalises the first letter of every word: Hello World, The Quick Brown Fox. It is used for article headlines, book titles, UI headings, product names and navigation labels. Strict title case has additional rules — articles (a, an, the), short prepositions (in, on, at) and coordinating conjunctions (and, but, or) are not capitalised unless they are the first or last word — but this tool applies a simple capitalise-every-word rule which covers the vast majority of use cases. Sentence case only capitalises the first word and any proper nouns: Hello world. It is used for body text, descriptions, tooltip labels and conversational UI copy.
Case conventions by language — a quick reference
Different programming languages have different official conventions enforced by community style guides and linters. JavaScript and TypeScript: camelCase for variables and functions, PascalCase for classes and React components, SCREAMING_SNAKE_CASE for constants, kebab-case for HTML and CSS. Python: snake_case for variables and functions (PEP 8), PascalCase for classes, SCREAMING_SNAKE_CASE for constants, kebab-case for package names in some contexts. Java: camelCase for variables and methods, PascalCase for classes and interfaces, SCREAMING_SNAKE_CASE for constants (static final fields). Go: camelCase for unexported identifiers, PascalCase for exported identifiers (the capitalisation itself controls visibility). Rust: snake_case for variables, functions and modules, PascalCase for types and enums, SCREAMING_SNAKE_CASE for constants and statics. Ruby: snake_case for variables and methods, PascalCase for classes and modules, SCREAMING_SNAKE_CASE for constants.
Automatic case conversion in frameworks and tools
Many modern frameworks handle case conversion automatically between different layers of a system. GraphQL clients like Apollo automatically convert snake_case field names from a REST API to camelCase JavaScript properties. Django REST Framework can be configured to convert snake_case Python attributes to camelCase JSON responses. Axios and Fetch interceptors in JavaScript are commonly configured to run camelCase ↔ snake_case conversion on request and response bodies, keeping both the Python backend and the JavaScript frontend in their preferred conventions without manual renaming. Database ORM libraries like SQLAlchemy, Prisma and ActiveRecord map between snake_case column names in SQL and camelCase or PascalCase property names in the application layer. Understanding the case conventions at each layer of your stack — and where the conversions happen — is essential knowledge for full-stack developers building across language and platform boundaries.
When case conventions matter most
Case conventions become critical in three specific situations. First, in APIs and data exchange: if a REST API returns snake_case JSON and a JavaScript client expects camelCase properties, every field mapping will either fail silently or require explicit conversion. Documenting the case convention used at each API boundary prevents this class of bug entirely. Second, in database migrations: renaming columns in a production database from camelCase (a common mistake when database design is done in JavaScript) to snake_case (the SQL convention) requires careful coordination and usually involves multiple deployment steps. Starting with the correct convention avoids this entirely. Third, in version control and code review: inconsistent naming conventions generate unnecessary noise in diffs and make code review harder. A team agreement on which conventions to use in which context — enforced by a linter — keeps codebases cleaner and reviews faster. This case converter is particularly useful when joining a new project and needing to quickly convert a list of identifiers from one convention to another during a migration or refactor. The bulk multi-line mode is specifically designed for this workflow — paste the complete list, switch modes with one click, and copy the converted identifiers ready to use.