I write code, draft documents, and prepare content every day, and one of the most surprisingly frequent tasks is changing text case. Whether it is converting a paragraph of yelling emails to proper sentence case, renaming a variable from my_variable_name to myVariableName, or formatting a heading in Title Case, the need to switch between letter cases comes up more often than you would think.
A case converter does exactly what it sounds like — it takes your text and transforms it from one capitalization format to another. Sounds simple, right? It is. But the real value is in understanding which case to use when, and having a tool that does it instantly without you needing to manually retype everything. In this guide, I will walk you through every letter case format, explain where each one is used, and show you how to get the most out of a free online case converter.
What Is a Case Converter
A case converter is a tool that changes the capitalization pattern of your text. It takes input in any format and outputs it in the case you choose.
Every piece of text has a case pattern. The sentences you read in a novel use sentence case. The titles of articles use Title Case. The variable names in your JavaScript code use camelCase. The file names on a Linux server use snake_case or kebab-case. A case converter lets you switch between all of these formats with a single click.
The core idea is simple: you paste your text, pick the case you want, and the tool transforms every character accordingly. No manual retyping, no missed letters, no inconsistency. The AFFLIGO case converter supports 12 different letter case formats, handles any text length, runs entirely in your browser (your text never leaves your device), and shows real-time character, word, and line counts as you type.
All 12 Case Types Explained
Here is every case format the tool supports, with examples and when to use each one.
| Case Type | Example | Primary Use |
|---|---|---|
| UPPERCASE | HELLO WORLD | Emphasis, headers, warnings |
| lowercase | hello world | Casual text, URLs, emails |
| Title Case | Hello World | Headings, titles, book names |
| Sentence case | Hello world | Paragraphs, UI labels, normal writing |
| aLtErNaTiNg | HeLlO WoRlD | Decorative, meme text |
| iNVERTED | hELLO wORLD | Decorative, meme text |
| Capitalize Words | Hello World | Titles, headings, formal names |
| camelCase | helloWorld | JavaScript, Java, method names |
| PascalCase | HelloWorld | Class names, React components |
| snake_case | hello_world | Python, Ruby, database columns |
| kebab-case | hello-world | URLs, CSS classes, file names |
| SCREAMING_CASE | HELLO_WORLD | Constants, environment variables |
UPPERCASE
Converts every letter to its uppercase form. Used for emphasis in writing ("DO NOT ENTER"), warning labels, acronyms (NASA, FBI), and headings that need to stand out. In code, SCREAMING_CASE (uppercase with underscores) is the convention for constants.
lowercase
Converts every letter to its lowercase form. The most common case for body text in informal writing, URLs, email addresses, and file paths. Many style guides recommend lowercase for headings in certain contexts (e.g., Wikipedia article titles).
Title Case
Capitalizes the first letter of every word. Used for book titles, article headlines, movie names, and formal headings. The Chicago Manual of Style and APA both have specific Title Case rules (e.g., small words like "the" and "a" are lowercase unless they start the title).
Sentence case
Capitalizes only the first letter of each sentence. This is the standard case for body text, paragraphs, descriptions, and most written content. It is the most natural reading format and is recommended by most style guides for general prose.
aLtErNaTiNg CaSe
Alternates between uppercase and lowercase for each character. Primarily used for decorative purposes, social media posts, and meme text. Has no practical use in formal writing or programming.
iNVERTED CaSe
Flips each character — uppercase becomes lowercase and vice versa. Similar to alternating case, this is used for decorative and humorous text. No practical application in formal contexts.
Capitalize Words
Capitalizes the first letter of every word but keeps the rest lowercase. Similar to Title Case but always applies to every word regardless of word length. Useful for formal names, menu items, and button labels.
camelCase
The first word is lowercase, and each subsequent word starts with a capital letter. The naming convention for variables, functions, and methods in JavaScript, Java, C#, and TypeScript. Example: userName, getData(), isActive.
PascalCase
Like camelCase but the first character is also capitalized. Used for class names, constructor functions, React component names, and type definitions. Example: MyComponent, UserProfile, HttpRequest.
snake_case
Words are lowercase, separated by underscores. The standard naming convention in Python, Ruby, C, and for database column names. Also used in file names on Unix/Linux systems. Example: user_name, get_data.
kebab-case
Words are lowercase, separated by hyphens. The standard for URL slugs, CSS class names, HTML attributes, and file names in web development. Example: user-name, get-data, my-component.
SCREAMING_CASE
All uppercase with underscores between words. The convention for constants, environment variables, and configuration keys in most programming languages. Example: MAX_BUFFER_SIZE, API_KEY, DEBUG_MODE.
When to Use Each Case
Choosing the right case matters. Here is a practical guide to picking the correct format for every situation.
Writing and Publishing
- Book titles, article headlines: Title Case — "The Art of Learning"
- Body text, paragraphs: Sentence case — "The quick brown fox jumps over the lazy dog."
- Warning signs, emphasis: UPPERCASE — "CAUTION: WET FLOOR"
- Casual messages: lowercase — "hey, are you coming tonight?"
Web Development
- URL slugs: kebab-case —
/blog/case-converter-guide - CSS class names: kebab-case —
.nav-link - HTML IDs: kebab-case —
main-header - JavaScript variables: camelCase —
userName - React components: PascalCase —
UserProfile - Environment variables: SCREAMING_CASE —
API_KEY
Programming Languages
- Python: snake_case for variables and functions, PascalCase for classes
- JavaScript: camelCase for variables and functions, PascalCase for classes and components
- Java: camelCase for methods and variables, PascalCase for classes, SCREAMING_CASE for constants
- Ruby: snake_case for methods and variables, SCREAMING_CASE for constants
- C/C++: snake_case or camelCase for functions, SCREAMING_CASE for macros and constants
Database and File Management
- Database table names: snake_case —
user_profiles - Database column names: snake_case —
created_at - File names: kebab-case or snake_case —
user-data.csv - Image file names: kebab-case —
hero-banner.png
How the Case Converter Works
Step-by-step walkthrough of using the tool, plus what happens under the hood.
Paste or Type Your Text
Open the case converter and enter your text in the input box. You can type directly or paste from anywhere — emails, documents, code editors, websites. The tool accepts any length of text and automatically expands the input area as you type.
Click a Case Button
Choose from 12 case buttons: UPPERCASE, lowercase, Title Case, Sentence case, aLtErNaTiNg, iNVERTED, Capitalize Words, camelCase, PascalCase, snake_case, kebab-case, and SCREAMING_CASE. The first button (UPPERCASE) is selected by default. Click any button to switch.
Copy or Download
The converted text appears instantly in the output box. Click Copy to copy it to your clipboard, or click Download .txt to save it as a plain text file. Your original text stays in the input box — you can switch between cases without re-entering anything.
The tool updates the output in real time as you type (with a tiny 80ms debounce for performance). You do not need to click a "Convert" button — just start typing and the result appears immediately. This makes it easy to experiment with different cases and see results instantly.
Real-World Use Cases
Who uses case converters and why. These are the most common scenarios.
Content Writers and Bloggers
Writers frequently need to convert between sentence case and Title Case for headings, subheadings, and meta descriptions. SEO specialists use case converters to standardize title tags (most search engines display Title Case). Email marketers convert between cases for subject line A/B testing.
Software Developers
Developers rename variables between camelCase, snake_case, PascalCase, and kebab-case when porting code between languages. Converting a Python variable (user_name) to JavaScript (userName) or a CSS class (nav-link) to a React prop (navLink) takes one click.
Students and Academics
Students formatting research papers convert between Title Case (for headings per APA/MLA guidelines) and sentence case (for references). Bibliography entries require specific case formats that are tedious to apply manually.
SEO Professionals
Title case for page titles, sentence case for meta descriptions, lowercase for URL slugs, SCREAMING_CASE for certain structured data values. SEOs need to apply different cases to different elements quickly and consistently.
Business and Marketing
Marketing teams convert brand names between cases for different contexts — UPPERCASE for logos, Title Case for formal references, lowercase for casual social media posts. Product teams use specific case conventions for feature names and UI labels.
Data Entry and Cleanup
When importing data from different sources, case inconsistency is common. A case converter standardizes names, addresses, and labels across a dataset. Converting a column of mixed-case names to proper case (first letter uppercase, rest lowercase) takes seconds.
Case Conventions in Programming
Different languages and frameworks have strict case conventions. Here is a quick reference for developers.
| Language | Variables | Functions | Classes | Constants |
|---|---|---|---|---|
| JavaScript | camelCase | camelCase | PascalCase | SCREAMING_CASE |
| TypeScript | camelCase | camelCase | PascalCase | SCREAMING_CASE |
| Python | snake_case | snake_case | PascalCase | SCREAMING_CASE |
| Java | camelCase | camelCase | PascalCase | SCREAMING_CASE |
| Ruby | snake_case | snake_case | PascalCase | SCREAMING_CASE |
| C# | camelCase/PascalCase | PascalCase | PascalCase | SCREAMING_CASE |
| Go | camelCase | PascalCase | PascalCase | SCREAMING_CASE |
| Rust | snake_case | snake_case | PascalCase | SCREAMING_CASE |
| CSS | kebab-case (class names, IDs, properties) | |||
| HTML | kebab-case (attributes, IDs), lower-case (tag names) | |||
| SQL | snake_case or PascalCase (varies by database) | |||
// From Python snake_case to JavaScript camelCase:
const userName = getName();
const isActive = checkStatus();
// From JavaScript camelCase to Python snake_case:
user_name = get_name()
is_active = check_status()
Best Practices
Tips for choosing and using the right case format consistently.
Be Consistent Within a Project
Pick one case convention for each context and stick with it. If your JavaScript uses camelCase for variables, do not mix in snake_case. If your URLs use kebab-case, do not suddenly use underscores. Consistency makes code readable and URLs predictable.
Follow Language Conventions
Every language has established case conventions. Python uses snake_case; JavaScript uses camelCase. Violating these conventions makes your code harder to read for other developers and breaks compatibility with linters and formatters. Use the case converter when porting code between languages.
Use Title Case for Headings
Title Case is the standard for headings, titles, and navigation items. It improves readability and gives a professional appearance. Most style guides (Chicago, APA, AP) have specific Title Case rules — when in doubt, capitalize words with 4 or more letters.
Keep URLs Lowercase
URLs are case-sensitive on some servers. Always use lowercase or kebab-case for URLs to avoid broken links. A URL like /Blog/Case-Converter is different from /blog/case-converter on case-sensitive servers. Use kebab-case for the cleanest, most readable URLs.
When in doubt about which case to use, ask yourself: "Where will this text appear?" Headings get Title Case. Body text gets Sentence case. Code variables follow the language convention. URLs use kebab-case. Constants use SCREAMING_CASE. If you can answer that question, the right case choice becomes obvious.
Frequently Asked Questions
The most common questions about case conversion, answered.
What is a case converter?
A case converter is a tool that changes the capitalization pattern of text. It can convert lowercase to UPPERCASE, UPPERCASE to lowercase, apply Title Case, Sentence case, camelCase, snake_case, and many other letter case formats. The AFFLIGO case converter supports 12 different formats.
How do I convert text to uppercase?
Paste or type your text into the case converter, then click the UPPERCASE button. Every letter will instantly convert to its uppercase form. You can then copy or download the result.
What is the difference between Title Case and Sentence case?
Title Case capitalizes the first letter of every word (e.g., "The Quick Brown Fox"). Sentence case capitalizes only the first letter of each sentence (e.g., "The quick brown fox"). Title Case is used for headings; Sentence case is used for normal paragraphs.
What is camelCase used for?
camelCase is a naming convention where the first word is lowercase and each subsequent word starts with a capital letter (e.g., "myVariableName"). It is widely used in JavaScript, programming variable names, and function names.
What is snake_case used for?
snake_case uses underscores to separate words, all in lowercase (e.g., "my_variable_name"). It is commonly used in Python, Ruby, database column names, and URL slugs.
Is the case converter free?
Yes, the AFFLIGO case converter is completely free with no usage limits. You can convert as much text as you want without signing up.
Is my text private when using the converter?
Yes. All conversion happens in your browser. Your text is never sent to any server, so it remains completely private.
Can I download the converted text?
Yes. Click the Download .txt button to save the converted text as a plain text file on your device.
Quick Reference Card
Bookmark this section. All case formats and their primary uses in one place.
Basic Cases
UPPERCASE: ALL LETTERS CAPITAL
lowercase: all letters small
Title Case: First Letter Of Each Word
Sentence case: First letter of sentence
Decorative Cases
aLtErNaTiNg: AlTeRnAtInG CaSe
iNVERTED: InVeRsE cAsE
Capitalize Words: First Letter Of Every Word
Developer Cases
camelCase: myVariableName
PascalCase: MyClassName
snake_case: my_variable_name
kebab-case: my-variable-name
SCREAMING_CASE: MY_CONSTANT
When to Use
Headings: Title Case
Body text: Sentence case
URLs: kebab-case
JS variables: camelCase
Python variables: snake_case
Constants: SCREAMING_CASE