dot.case Converter — Convert Any Text to dot.case Format
This dot case converter turns any plain-English phrase into a dot-separated, all-lowercase key: "database connection url" becomes "database.connection.url" in one click. Dot case is the required format for Spring Boot's application.properties files, Logback logging configurations, and several other Java and Node.js framework config systems. Paste your description and get a ready-to-use property key. No signup, no character limit.
What Is dot.case Converter?
A dot.case converter transforms your text into lowercase words separated by dots: "hello world example" becomes "hello.world.example". Dot case is used in programming languages and frameworks that treat dot-separated identifiers as hierarchical property paths — Lua, Erlang, some Java package naming conventions, and certain logging frameworks. It also appears in configuration files (Spring Boot's application.properties uses "spring.datasource.url"), and version identifiers where the dot signals a namespace hierarchy.
Dot case is less common than snake_case or kebab-case in everyday development, but when a framework or system requires it, generating the correct format manually from a plain-English description is tedious. This converter handles the space-stripping, lowercasing, and dot-insertion in one step. It is similar to snake_case (lowercase, word-separated) and kebab-case (lowercase, separator-based), but uses a dot instead of underscore or hyphen.
Hello World→hello.worldBefore & After: dot.case Converter Examples
Real input → output pairs showing exactly what this tool does to your text.
| Input | dot.case Converter Output |
|---|---|
database connection url | database.connection.url |
server port number | server.port.number |
Hello World | hello.world |
API base URL | api.base.url |
version 2 settings | version.2.settings |
Key Features
Converts every word to lowercase and replaces spaces with dots simultaneously — the exact format required by Spring Boot's @ConfigurationProperties binding and Java logging frameworks like Logback and log4j.
Punctuation, slashes, and other non-word characters are removed during conversion. "API / base URL" becomes "api.base.url" without any manual cleanup — matching the character constraints of Spring Boot property key parsing.
Numeric tokens stay in place: "version 2 settings" → "version.2.settings". Useful for generating Spring Boot property keys that include version or port numbers (e.g. "server.port.8080").
Zero server round-trip. Paste a plain-English description and copy the dot.case key immediately — no IDE, no scripting, no library required. Useful during configuration design sessions when you need a key name quickly.
When to Use dot.case Converter
Use for file extensions, domain-style naming conventions, and some CSS framework class formats.
All special characters and spaces become dots. CamelCase is split at uppercase boundaries before conversion.
Who Should Use This Tool?
Generate Spring Boot application.properties key names in dot.case from readable descriptions — the format required by Spring's property binding system.
Convert module and identifier names to dot.case as required by Lua module paths and Erlang application configuration conventions.
Create dot-separated configuration property names for logging frameworks, monitoring tools, and property-file-based configuration systems.
Key Use Cases
- →Generate Spring Boot application.properties keys like "spring.datasource.url" from plain English descriptions.
- →Convert Lua module paths from human-readable descriptions to the dot-separated require() format.
- →Create hierarchical logging category names in dot.case for log4j, logback, and structured logging configurations.
- →Generate dot-separated property names for frameworks that use dots to express object hierarchy in flat configuration files.
- →Produce version-style identifiers and namespaced property paths for SDK configuration keys.
dot.case Converter vs Other Formats
How this tool compares to related approaches and methods
| Method / Format | Best For |
|---|---|
| THISdot.case (this tool) | Config property keys in Spring Boot, Java logging frameworks, Lua modules |
| snake_case | Python variables, Ruby methods, C identifiers, SQL column names |
| kebab-case | CSS class names, HTML attributes, URL slugs, CLI flag names |
| camelCase | JavaScript variables, Java fields, JSON keys, TypeScript properties |
dot.case Converter Rules: How It Works
- →All letters converted to lowercase
- →Spaces replaced with dots: "hello world" → "hello.world"
- →Punctuation and symbols stripped
- →Numbers preserved: "version 2 config" → "version.2.config"
- ×Spring Boot application.properties keys (spring.datasource.url)
- ×Lua module paths and Erlang application config
- ×Logging framework hierarchy names (com.example.service)
- ×NOT for JavaScript/CSS — use camelCase or kebab-case there
How to Use dot.case Converter
- Paste or type your text into the Input Text box.
- The result appears instantly on the right.
- Click Copy to copy the output to your clipboard.
- Click Clear to reset and process new text.
This Converter vs Manual Methods
Why use this tool instead of doing it by hand?
| Method | Limitation |
|---|---|
| Manual: type dots between words by hand | Error-prone for longer keys; easy to forget lowercase or miss a space |
| Python: text.lower().replace(" ", ".") | Doesn't handle multi-word phrases with symbols or punctuation without extra regex |
| VS Code multi-cursor editing | Requires manual cursor placement; can't batch-convert new descriptions |
| IDE live template / snippet | Only works for patterns already defined in the template; no dynamic conversion |
| ✓ BESTThis converter | None |
Common Mistakes & Pro Tips
- !Using dot.case for JavaScript identifiers — dots are property accessors in JavaScript, so "my.variable" means "property variable of object my". Use camelCase for JS identifiers, not dot.case.
- !Confusing dot.case with file extensions — "report.final" looks like a filename with an extension. In identifiers, dot.case signals hierarchy, not file type. Document clearly that a dot-case value is an identifier, not a filename.
- !Forgetting to check framework-specific key constraints — Spring Boot property keys support dot.case but also require valid characters (no spaces, some symbols disallowed). YAML property files may interpret certain dot-case keys differently from application.properties. Always verify that generated keys match the exact format the target framework expects before wiring them to configuration binding.
Frequently Asked Questions
Everything you need to know about dot.case Converter
What is the difference between dot.case and snake_case?
+
Both are lowercase with words separated by a single character. Dot.case uses a period: "my.property.name". Snake_case uses an underscore: "my_property_name". The choice is determined by the framework or system: Spring Boot uses dot.case for properties, Python uses snake_case for identifiers. Dots have special meaning as property accessors in many languages, making dot.case unsuitable for use in code identifiers where snake_case or camelCase would be used instead.
Which frameworks or languages use dot.case?
+
Spring Boot (application.properties keys), Lua (module paths via require("module.submodule")), Erlang (application environment keys), log4j and logback (logger hierarchy names like "com.example.service"), some Maven and Gradle property files, and certain YAML/TOML configuration conventions. It is not widely used for programming identifiers in mainstream languages — those prefer snake_case or camelCase.
Is dot.case the same as DNS notation?
+
Visually similar but different in purpose. DNS hostnames use dots to separate labels (api.example.com), but they have additional constraints (max 63 chars per label, case-insensitive, valid hostname characters only). Dot.case identifiers have no such constraints — they can contain any characters that are valid in the surrounding system. They share the dot-as-separator convention, but serve different purposes in different contexts.
Can I convert from snake_case or camelCase to dot.case?
+
This converter splits on spaces and punctuation. For camelCase or snake_case input, you'll need to first convert to space-separated words before using this tool. For example: "myPropertyName" → manually add spaces → "my property name" → dot.case → "my.property.name". Or use your IDE's regex find-and-replace to split camelCase boundaries before pasting here.
Is dot.case the same as package naming in Java?
+
Java package names use a reversed domain convention (com.example.project) which is visually dot.case, but the convention comes from DNS domain reversal, not dot.case as a naming style. Java method and field names use camelCase; class names use PascalCase. The package naming pattern happens to look like dot.case but it's specifically a reversed-domain hierarchy, not a general identifier style.
How does Spring Boot bind application.properties keys to Java fields?
+
Spring Boot's @ConfigurationProperties uses "relaxed binding" — it maps property keys to Java field names by stripping dots, hyphens, and underscores and matching case-insensitively. So "server.port.number", "server_port_number", "SERVER_PORT_NUMBER", and "serverPortNumber" all bind to the same field serverPortNumber. This means dot.case, snake_case, and SCREAMING_SNAKE_CASE all work for Spring Boot properties — but dot.case is the official convention documented in the Spring Boot reference.
How do I convert text to dot.case in Python and JavaScript?
+
Python: import re; ".".join(re.sub(r"[^\w\s]", "", text).lower().split()). JavaScript: text.toLowerCase().replace(/[^\w\s]/g, "").replace(/\s+/g, "."). Both patterns lowercase, strip non-word characters, and join on dot. For camelCase input, add a split on camelCase boundaries first: Python re.sub(r"([A-Z])", r" \1", text) before lowercasing; JavaScript text.replace(/([A-Z])/g, " $1") before the rest of the pipeline.