Case Converter: dot.case

The Dot Case Converter transforms any text into dot.case format — a naming convention where every word is written in lowercase and separated by a period instead of a space. Also known as dot notation or dot-separated lowercase format, this style is widely used across software development and configuration management for creating clean, structured identifiers. Whether you're writing Spring Boot property keys, defining metric names in monitoring systems like Prometheus or StatsD, or building i18n translation key paths for internationalization libraries, dot.case keeps your identifiers consistent and readable. Unlike camelCase or PascalCase, dot.case avoids capitalization entirely, making it particularly well-suited for case-insensitive systems where uppercase letters could cause unpredictable behavior. The format also mirrors the structure of domain names and package namespaces, which is why it's the standard for Java package naming and property path hierarchies. This free online tool handles the conversion instantly — paste in a phrase, sentence, or list of words, and receive properly formatted dot.case output you can copy and use right away. No registration required, no software to install. It's ideal for developers, DevOps engineers, and technical writers who need a reliable way to standardize identifiers without manually editing every word.

Input
Output (dot.case)

Related Tools

Case Converter: snake_case

Convert text to snake_case. Example: Hello World → hello_world

Text

Case Converter: camelCase

Convert text to camelCase. Example: hello world → helloWorld

Text

Case Converter: kebab-case

Convert text to kebab-case. Example: Hello World → hello-world

Text

Case Converter: Header-Case

Convert text to Header-Case. Example: hello world → Hello-World

Text

What It Does

The Dot Case Converter transforms any text into dot.case format — a naming convention where every word is written in lowercase and separated by a period instead of a space. Also known as dot notation or dot-separated lowercase format, this style is widely used across software development and configuration management for creating clean, structured identifiers. Whether you're writing Spring Boot property keys, defining metric names in monitoring systems like Prometheus or StatsD, or building i18n translation key paths for internationalization libraries, dot.case keeps your identifiers consistent and readable. Unlike camelCase or PascalCase, dot.case avoids capitalization entirely, making it particularly well-suited for case-insensitive systems where uppercase letters could cause unpredictable behavior. The format also mirrors the structure of domain names and package namespaces, which is why it's the standard for Java package naming and property path hierarchies. This free online tool handles the conversion instantly — paste in a phrase, sentence, or list of words, and receive properly formatted dot.case output you can copy and use right away. No registration required, no software to install. It's ideal for developers, DevOps engineers, and technical writers who need a reliable way to standardize identifiers without manually editing every word.

How It Works

Case Converter: dot.case changes the representation of the input so the same information can be used in a different format or workflow. The key question is what structure the destination can preserve and what it has to flatten, rename, or serialize.

Conversion tools are constrained by the destination format. If the source can express nesting, comments, repeated keys, or mixed data types more richly than the target, the output may need to flatten or reinterpret part of the structure.

All processing happens in your browser, so your input stays on your device during the transformation.

Common Use Cases

  • Generating Spring Boot and application.properties configuration keys such as server.port or spring.datasource.url for consistent property file formatting.
  • Defining metric and event names in monitoring and observability platforms like StatsD, Prometheus, or Datadog that expect dot-separated metric paths.
  • Creating i18n and l10n translation keys in frameworks like i18next, Vue I18n, or Angular's TranslateService where nested keys are expressed as dot-separated strings.
  • Formatting Java package names and namespace identifiers that follow the reverse domain convention, such as com.company.module.service.
  • Building hierarchical configuration paths in tools like Consul, etcd, or custom YAML/TOML parsers where dotted keys represent nested structure.
  • Standardizing log event category names and structured logging fields to maintain consistency across distributed systems and log aggregation pipelines.
  • Converting human-readable feature flag names or A/B test identifiers into dot.case slugs compatible with feature flag platforms like LaunchDarkly or Unleash.

How to Use

  1. Paste or type your source text into the input field — this can be a phrase with spaces, a title, a sentence, or even an underscore-separated or camelCase string you want to reformat.
  2. Click the Convert button (or watch the live preview update automatically) to instantly transform your input into properly formatted dot.case output.
  3. Review the result in the output field to confirm that all spaces have been replaced by periods, all letters are lowercase, and any special characters have been handled cleanly.
  4. Use the Copy button to copy the dot.case result directly to your clipboard so you can paste it into your code editor, configuration file, or documentation without extra steps.
  5. If you're converting multiple identifiers, process them one at a time or paste a batch of lines and convert each to build a consistent set of keys for your project.

Features

  • Automatic period insertion that replaces all whitespace characters — including tabs and multiple consecutive spaces — with a single dot for clean, consistent output.
  • Full lowercase normalization that converts uppercase letters, mixed-case titles, and even ALL-CAPS input into uniform lowercase dot.case identifiers.
  • Smart handling of existing separators: underscores, hyphens, and slashes in the input are recognized as word boundaries and converted to dots rather than left as-is.
  • Instant one-click copy-to-clipboard functionality so you can move the converted result directly into your code, config file, or documentation without manual selection.
  • Clean stripping of punctuation and special characters that are not valid in dot.case identifiers, preventing malformed keys that could break parsers or configuration loaders.
  • Live preview conversion that updates the output as you type, giving you immediate feedback without needing to click a button after every edit.
  • No-install, browser-based operation — works entirely client-side with no data sent to a server, keeping your code and configuration details private.

Examples

Below is a representative input and output so you can see the transformation clearly.

Input
User profile settings
Output
user.profile.settings

Edge Cases

  • Very large inputs can still stress the browser, especially when the tool is working across many text. Split huge jobs into smaller batches if the page becomes sluggish.
  • Source values that look similar can map differently in the target format when data types are inferred, flattened, or serialized.
  • If the output looks wrong, compare the exact input and option values first, because Case Converter: dot.case should be repeatable with the same settings.

Troubleshooting

  • Unexpected output often means the input is being split or interpreted at the wrong unit. For Case Converter: dot.case, that unit is usually text.
  • If a previous run looked different, check for hidden whitespace, changed separators, or a setting that was toggled accidentally.
  • If nothing changes, confirm that the input actually contains the pattern or structure this tool operates on.
  • If the page feels slow, reduce the input size and test a smaller sample first.

Tips

When working with deeply nested configuration hierarchies, build your dot.case keys from the most general namespace to the most specific, such as app.database.connection.timeout rather than timeout.connection.database.app — this mirrors how most configuration parsers traverse the key hierarchy. If you're migrating a codebase from snake_case or kebab-case identifiers to dot.case, run your existing keys through the converter to catch any inconsistencies rather than converting manually. Be aware that some systems (particularly JavaScript object notation) treat the dot as a property accessor, so dot.case keys may need to be quoted when used as object property names. Always verify that your target platform supports dot.case natively — while it's standard in Java and .NET property files, some systems expect snake_case or kebab-case instead.

Dot.case is one of several programmatic naming conventions used in software development to create identifiers that are both machine-readable and human-legible. The convention is straightforward: all letters are lowercase, and words are separated by a single period (dot) rather than a space, hyphen, or underscore. What makes dot.case distinct from other delimiter-based cases is the period's dual identity in programming — it serves as both a word separator in dot.case strings and as a property accessor operator in most programming languages. This creates a useful visual metaphor: a dot.case key like app.server.port immediately communicates a hierarchy — the port setting, within the server namespace, within the app domain. The format has deep roots in Java, where the package naming convention mandates reverse-domain dot notation (e.g., com.google.guava). This practice spread naturally into Java-centric ecosystems, and today Spring Boot — one of the most widely used Java frameworks in enterprise development — relies entirely on dot.case for its application.properties and application.yml key equivalents. Keys like spring.jpa.hibernate.ddl-auto and management.endpoints.web.exposure.include are canonical examples you'll encounter in virtually every Spring Boot project. Beyond Java, dot.case has become the de facto standard for metric naming in observability and monitoring systems. StatsD, the open-source network daemon popularized by Etsy, expects metrics in dot-separated format like api.requests.success or db.query.latency. Prometheus, while it uses underscores natively, sees dot.case frequently in exporters and bridging layers. Datadog custom metrics, Graphite time-series data, and InfluxDB measurements all leverage dot-separated naming to enable hierarchical aggregation and filtering. Internationalization (i18n) is another domain where dot.case dominates. Libraries like i18next (JavaScript), vue-i18n, and React Intl support nested translation objects, and dot.case notation is the standard way to reference nested keys as flat strings — for example, errors.validation.required or navigation.menu.settings. This approach keeps translation files organized by feature or section while still allowing flat key lookups in templates. Comparing dot.case to its siblings helps clarify when to use it. Snake_case (underscores as separators) is preferred in Python, Ruby, SQL, and many database column names. Kebab-case (hyphens as separators) is standard for CSS class names, HTML attributes, and URL slugs. CamelCase and PascalCase are the norm for JavaScript/TypeScript variable and class names. Dot.case occupies a specific niche: hierarchical identifiers in configuration, metrics, and namespaced systems where the dot carries semantic meaning about parent-child relationships. One practical consideration when using dot.case is quoting. In JavaScript, an object key containing a dot must be accessed with bracket notation (obj['app.name']) rather than the dot accessor (obj.app.name), since the latter would attempt to resolve a nested property path. Configuration parsers like those used in Spring or .NET handle this transparently, but if you're storing dot.case keys in a JavaScript object or JSON structure, keep this in mind. Some libraries provide utility functions specifically for deep-setting or deep-getting nested values using dot.case path strings, which can make working with hierarchical data structures significantly cleaner.

Frequently Asked Questions

What is dot.case and when should I use it?

Dot.case is a text formatting convention where all letters are lowercase and words are separated by periods instead of spaces. It's used primarily in software development for configuration property keys, metric names, package identifiers, and i18n translation keys. You should use it when your target system expects dot-separated lowercase identifiers, such as Spring Boot property files, StatsD metrics, or i18next translation paths. It's particularly valuable in hierarchical naming systems where the dots visually communicate parent-child relationships between namespaces.

How is dot.case different from snake_case and kebab-case?

All three are delimiter-based naming conventions that replace spaces with a separator character and use lowercase letters, but they differ in which character they use. Snake_case uses underscores (my_variable_name) and is common in Python, Ruby, and SQL. Kebab-case uses hyphens (my-variable-name) and is standard for CSS classes, HTML attributes, and URL slugs. Dot.case uses periods (my.variable.name) and is most common in configuration files, Java package names, and metric systems. The choice between them is typically dictated by the conventions of the language or platform you're working with.

Can dot.case be used in JavaScript or JSON?

Dot.case strings are valid in JavaScript and JSON as property key values, but they require careful handling. Because JavaScript uses the dot operator for property access, a key like 'app.name' cannot be accessed via obj.app.name — you must use bracket notation: obj['app.name']. In JSON, dot.case keys are perfectly valid as long as they're quoted strings. Many configuration and utility libraries provide special handling for dot.case path strings, allowing you to set or get deeply nested values using a single dot-separated key.

Does dot.case preserve numbers and special characters?

Numbers within the text are typically preserved as-is in dot.case conversion — a phrase like 'version 2 release' would become 'version.2.release'. Special characters like hyphens, underscores, slashes, and punctuation are generally stripped or converted to dots depending on the converter's implementation, since they are not valid components of a standard dot.case identifier. It's good practice to review the output when converting text that contains numbers, acronyms, or special characters to ensure the result is valid for your target system.

Is dot.case the same as dot notation in programming?

They're related but not identical. Dot notation in programming refers to the syntax used to access properties or methods of an object (e.g., object.property.method()), while dot.case is a naming convention for identifiers. However, dot.case deliberately borrows the visual structure of dot notation to convey hierarchy within identifier strings. This is why configuration keys like server.connection.timeout feel intuitive — the dot-separated structure mirrors how you'd navigate an object hierarchy in code.

Why do Spring Boot and Java frameworks use dot.case for configuration?

Spring Boot uses dot.case for its application.properties keys because it aligns with Java's long-standing package naming convention (com.company.module) and provides a clean, human-readable way to represent hierarchical configuration structures without requiring actual nested objects. The framework automatically maps these dot-separated keys to nested configuration classes using its @ConfigurationProperties binding mechanism. This makes configuration files easy to read and write while still supporting deep nesting through a simple flat key format.

Can I use this tool to convert camelCase or PascalCase to dot.case?

Yes — a good dot.case converter will recognize camelCase and PascalCase input and split on capital letter boundaries before converting to dot.case. For example, 'serverConnectionTimeout' or 'ServerConnectionTimeout' would both produce 'server.connection.timeout'. This is especially useful when migrating code between ecosystems — for instance, translating JavaScript camelCase variable names into Spring Boot property key equivalents. Check your converter's behavior with a quick test using a known camelCase input to confirm it handles word boundary detection correctly.

Are there any platforms where I should avoid using dot.case?

Yes, dot.case is a poor choice in contexts where the period has reserved meaning. In CSS, dots denote class selectors, so a dot.case class name would break your stylesheet. In file systems, dots in filenames can conflict with file extension conventions. In DNS and URLs, dots are domain-level separators, so using dot.case for path segments would create confusion or parsing errors. In Python dictionaries and most dynamic languages, dot.case keys require bracket notation rather than attribute access. Always verify that your target system treats the dot as a neutral separator rather than a reserved operator.