Live100% Client-Side

Developer Variable Case Converter

Convert code identifiers between camelCase, PascalCase, snake_case, CONSTANT_CASE, and kebab-case.

Convert programming identifiers between camelCase, PascalCase, snake_case, CONSTANT_CASE, and kebab-case. Acronym-aware parser handles API and codebase keys.

Workbench

Use Developer Variable Case Converter

Ctrl/⌘ + Enter to convert
Canonical Tool

Looking for prose, headline, or general text casing (Title Case, Sentence case)?

Open Prose & Text Case Converter →
Quick format:
Input

Code Identifiers or Schema Keys

Output

Converted Result

Ready. Code identifiers transformed locally in browser memory.
Multi-Format Studio

Synchronized Programming Conventions

All primary code identifier formats computed simultaneously. Click Copy on any card for instant clipboard access.

camelCaseJavaScript • TypeScript • JSON
PascalCaseGo Exports • C# • React Types
snake_casePython PEP 8 • SQL Columns • Rust
CONSTANT_CASEEnv Vars • Enum Values • Macros
kebab-caseCSS Classes • HTML Attrs • URLs
dot.caseConfig Keys • Dot Notation • Metrics
What it does

Built for the task, not the page view

  • Acronym-aware boundary parsing for code variables (e.g., parseJSONPayload -> parse_json_payload)
  • Developer casing formats: camelCase, PascalCase, snake_case, CONSTANT_CASE, kebab-case, dot.case, and more
  • Synchronized multi-case studio cards with instant single-click copy per format
  • Per-line batch conversion preserving indentation for schema definitions and variable lists
  • Configurable number splitting and consecutive uppercase token preservation
Inputs & outputs
Accepts
Raw TextMulti-line Text
Produces
Converted Text
Reference

Use it correctly

Identifier tokenization & boundary detection

The engine parses programming identifiers into semantic word tokens using deterministic boundary rules: transitions between lowercase and uppercase letters (camelCase), separator delimiters (_, -, ., /), and optional numeric transitions. These tokens are then recombined into your chosen developer casing convention.

Acronym preservation & consecutive uppercase tokens

When "Preserve consecutive caps" is enabled, acronyms such as HTTP or JSON in identifiers like getHTTPResponseCode or parseJSONPayload are recognized as cohesive units rather than split into single letters. In snake_case, CONSTANT_CASE, and kebab-case, the acronym is transformed uniformly (get_http_response_code, GET_HTTP_RESPONSE_CODE).

Consecutive acronyms & number boundary caveats

When identifiers contain numbers (e.g. user1Id, v2Api, item100), the "Split on numbers" option separates digit sequences from surrounding alphabetic tokens (user_1_id vs user1_id). For technical terms where numbers belong directly to the token (e.g. utf8, sha256), unchecking number splitting preserves the number as part of the adjacent word.

Per-line batch conversion for schemas & codebases

In per-line batch mode, each line of text is processed independently while strictly preserving leading whitespace indentation (spaces or tabs) and line breaks. This enables bulk conversion of SQL schema definitions, GraphQL fields, TypeScript interface properties, and environment variable lists directly from clipboard.

Confidential codebase privacy guarantee

All tokenization and casing transformations execute entirely in local browser memory using native ECMAScript string operations. Proprietary variable names, database column schemas, internal API keys, and codebase identifiers are never submitted to an EveryTools transformation API or logged by any remote server.

Language Style Guide Standards & Conventions

Modern software development teams navigate disparate casing standards across languages and platforms. When translating database schemas into REST models, or mapping ORM fields into frontend state, maintaining idiom compliance avoids runtime bugs and lint violations.

Language / EcosystemPrimary Identifier FormatConstant / Type ConventionOfficial Style Guide
Pythonsnake_case (functions, variables, modules)CONSTANT_CASE (constants), PascalCase (classes)PEP 8 Style Guide
JavaScript / TypeScriptcamelCase (variables, methods, properties)PascalCase (classes, interfaces, types)Google JavaScript Style / Airbnb
Go (Golang)camelCase (unexported), PascalCase (exported)Acronyms keep casing (e.g. JSONPayload, HTTPURL)Effective Go & Go CodeReview
Rustsnake_case (functions, methods, variables)SCREAMING_SNAKE_CASE (constants), PascalCase (types, traits)Rust API Guidelines
SQL / Relational DBssnake_case (tables, columns, indexes)UPPERCASE (reserved keywords e.g. SELECT, WHERE)ANSI SQL / PostgreSQL Best Practices
CSS / Webkebab-case (class names, custom properties, IDs)kebab-case (BEM modifier syntax)W3C CSS Specifications

Consecutive Acronyms & Number Boundaries

Code identifiers frequently embed domain acronyms (e.g. XMLHttp, APIEndpoint, parseJSONPayload) and numeric indexes (e.g. user123AccountId). Naive string splitters dismantle these incorrectly.

Acronym Boundary Detection

When "Preserve consecutive caps" is active, regex tokenization scans for uppercase sequences followed by camel-case transitions: ([A-Z]+)([A-Z][a-z]). This ensures:

  • getHTTPResponseCode → get_http_response_code
  • parseJSONPayload → parse_json_payload
  • exportXMLElements → export_xml_elements

Alphanumeric Number Splitting

When "Split on numbers" is active, transitions between letters and digits trigger word boundaries: ([a-zA-Z])([0-9]) and ([0-9])([a-zA-Z]):

  • user1Id → user_1_id (split enabled)
  • sha256Hash → sha256_hash (split disabled)
  • item100Count → item_100_count (split enabled)

Programming Case Converter FAQ

How are acronyms like HTTP or API handled when converting case?

The tokenizer includes dedicated lookahead regex patterns that preserve consecutive uppercase runs. In snake_case and kebab-case, the acronym is downcased as a complete semantic word (get_http_response_code). In CONSTANT_CASE, all letters remain capitalized (GET_HTTP_RESPONSE_CODE).

Can I convert a list of database column names in bulk?

Yes. With Per-line mode active, paste an entire SQL schema or column list. Each line is converted independently while preserving indentation, comments, and empty lines. You can instantly map 500+ database columns to JavaScript camelCase object keys.

Why does dot.case / dot.notation matter for developers?

Dot notation is the ubiquitous convention for configuration hierarchies (e.g. server.database.connection_timeout in Spring or YAML), telemetry metric names (e.g. http.requests.latency.p99 in Prometheus/Datadog), and property access paths.

Is my code or database schema sent to any remote server?

No. All string decomposition, tokenization, and casing logic execute strictly in your local browser tab via client-side JavaScript. No variable names or identifiers are transmitted to an EveryTools server or third-party service.