dot.case Converter: Package & Domain Name Generator
Transform any text into clean dot.case format instantly. Whether you're naming Java packages, creating domain names, or organizing hierarchical namespaces, our tool automatically converts your text into proper dot.case formatting while following programming and web conventions.
Converts any text to valid dot.case in real time — paste a package path, a config key, or a plain phrase and get a dot-separated, lowercase identifier ready for Java, Kotlin, or configuration files.
Preserves hierarchical structure: each word or segment becomes a dot-separated component, making namespace depth immediately visible in the output.
Strips characters illegal in Java package names and domain identifiers — slashes, hyphens, underscores — so the result is a clean namespace path without post-processing.
Handles input from multiple formats: space-separated phrases, camelCase, snake_case, and kebab-case all produce consistent dot.case output.
Produces lowercase-only output, matching the Java package naming convention which explicitly forbids uppercase letters to avoid ambiguity with class names.
Works for reverse-domain notation (com.company.project), property key hierarchies (app.server.port), and log category names — the same conversion logic applies across all three contexts.
How to Use
Enter your text or package name
Copy namespace-ready text
Java Development
- Package names
- Namespace organization
- Module identifiers
- Library paths
Web Development
- Domain names
- Reverse domains
- Email addresses
- Configuration keys
System Organization
- File paths
- Configuration keys
- Registry entries
- Object notation
| Original Text | Result |
|---|---|
com user profile | com.user.profile |
org-project-main | org.project.main |
web_app_config | web.app.config |
domain name system | domain.name.system |
Programming
- Java
- Android
- Kotlin
- Scala
Web Systems
- DNS
- Config Files
- Package Names
When creating a new Java or Kotlin project, establish the root package name (com.yourcompany.projectname) using this converter before writing any code — renaming a package after classes exist requires refactoring every import statement across every file.
For Spring Boot application.properties or application.yml files, configuration keys follow dot-separated hierarchies (spring.datasource.url, server.port) — convert your custom config key descriptions here to get properly formatted property names.
Log4j and SLF4J logger names are conventionally the fully-qualified class name in dot.case; when setting log levels per package in your logging config, use this tool to format the package path accurately.
Android package names follow the same reverse-domain dot.case convention as Java — convert your app identifier (com.yourname.appname) here to verify it's valid before setting it in build.gradle, since package names cannot be changed after publishing to the Play Store.
In JavaScript and Node.js, dot-notation is used for nested config keys in libraries like dotenv-expand, nconf, and convict — use this tool to format nested configuration key paths before writing your config schema.
Always start Java package names with your organization's reverse domain (com.yourcompany) rather than a generic prefix like 'app' or 'util' — generics collide across projects and make dependency resolution ambiguous in multi-module builds.
Keep each dot-separated segment as a single lowercase word without numbers at the start — Java compilers accept digits within segments but many build tools and IDE refactoring features behave unexpectedly with numeric-prefixed package names.
Avoid using Java reserved words (class, interface, package, import) as segment names — the JVM permits some of them in package identifiers but IDEs and linters flag them as confusing, and some build tools reject them outright.
For configuration key hierarchies, use consistent depth — mixing flat keys (database) with deep keys (app.server.database.pool.maxSize) in the same config file creates an inconsistent mental model that makes configuration audits harder.
When publishing an Android app, finalize the package name before your first Play Store release — unlike most other identifiers in a project, the Android package name is permanently associated with your app listing and cannot be changed without creating an entirely new store entry.
Frequently Asked Questions
Find answers to common questions about our tools and services.
Understanding dot.case
dot.case is the oldest of the common programming naming conventions still in active daily use. It appeared in early Lisp systems and Unix configuration files before being formalized as the mandatory package naming convention in Java 1.0 in 1996. The Java Language Specification requires that package names be lowercase dot-separated identifiers in reverse domain order — com.company.product — to guarantee global uniqueness across the entire ecosystem. That requirement pushed dot.case into mainstream developer culture in a way no other convention had, since every Java file begins with a package declaration.
The primary daily use case for this converter is Java and Kotlin development. When starting a new module, library, or Android app, you need a package identifier before you can create the first class. Product managers and designers hand off project names in plain English ('User Authentication Service', 'Payment Gateway Client'); this tool converts them to valid package path segments that you can prepend with your organization's reverse domain. The conversion is simple enough that developers often do it mentally, but manual conversion of multi-word names introduces inconsistencies — 'auth service' might become com.company.authservice, com.company.auth_service, or com.company.authService depending on who types it.
A second use case is Spring Boot and general JVM configuration. Spring's externalized configuration system uses dot-separated key hierarchies extensively: spring.datasource.url, spring.jpa.hibernate.ddl-auto, management.endpoints.web.exposure.include. When defining your own application-specific configuration properties, matching Spring's convention makes your keys feel native to the framework and ensures compatibility with Spring Boot's configuration binding and relaxed binding rules.
Outside the JVM world, dot.case appears in: JavaScript object property chains used as configuration keys (webpack resolve.alias, eslint rules.no-unused-vars), Python logging configuration (logging.getLogger('myapp.services.auth')), YAML configuration hierarchies that configuration libraries flatten using dots as separators, and DNS hostnames where each label is a dot-separated component. The converter is useful in all of these contexts even when Java packages are not involved.
The manual alternative is straightforward for short names but error-prone at scale: lowercase everything, strip non-alphanumeric characters, and join with dots. The edge cases that trip developers up are consecutive separators (multiple spaces or mixed underscores and hyphens creating double dots), leading digits in a segment (invalid in Java packages), and accidentally including the project's TLD as a segment rather than the full reverse domain. This tool normalizes all of those cases.