Voice to Text for IntelliJ IDEA
You are deep in Java or Kotlin code, building out a complex service layer. Your hands know the keyboard shortcuts, the refactoring tools, the code completion triggers. Then you need to write Javadoc for that public method. Or document why this Kotlin extension function exists. Or compose a meaningful commit message. Typing prose feels like a different language than typing code. Blurt lets you speak your documentation directly into IntelliJ IDEA. Hold a button, explain the method in plain English, release. Text appears at your cursor with proper formatting. Your hands stay on the keyboard. Your IDE stays in focus. Works everywhere in IntelliJ — code files, commit dialogs, code review comments, anywhere you can type.
The Typing Problem
Javadoc you know you should write but skip
That public API method needs documentation. You know the parameters, the return type, the exceptions it throws. You could explain it verbally in 20 seconds. But typing out @param and @return tags, formatting the descriptions, adding @throws annotations — that is 10 minutes of tedious work. IntelliJ warns you about missing Javadoc. You ignore the warning. The API ships without documentation. Future developers will guess at the method's behavior.
Kotlin documentation that never gets written
You created a beautiful Kotlin extension function that simplifies a common pattern across your codebase. Other developers will love it — if they know it exists. KDoc would make it discoverable. You could explain the use cases in 30 seconds out loud. But typing the documentation means breaking your flow. So you move on. The function stays hidden. Developers write redundant code because they never found yours.
Commit messages that explain nothing
You just refactored the authentication module to use dependency injection. Git wants a commit message. You could explain the architectural decision, the benefits, the migration path. Instead, you type 'refactor auth' because switching from code mode to writing mode takes too much mental energy. Six months later, someone asks why this change was made. Nobody remembers. The commit history is useless.
Code review comments that teach nothing
You are reviewing a pull request and spot a subtle threading issue. You could explain the race condition, suggest a fix, share context from past incidents. That explanation would take 30 seconds to speak. Typing it means a five-minute detour. You leave a terse 'not thread safe' and move on. The author learns nothing. The same mistake appears next sprint.
Inline comments you never write
You just implemented a workaround for a JVM bug that affects certain GC configurations. The code looks wrong but is intentional. Future maintainers will try to fix your workaround and break production. A comment would save hours of debugging. But typing that explanation means context-switching from code to prose. The comment never gets written. The tribal knowledge lives only in your head.
How It Works
Blurt works everywhere in IntelliJ IDEA — Java files, Kotlin files, commit dialogs, code review comments, search boxes, and any text field where you can place a cursor.
Hold your hotkey
Press your chosen shortcut anywhere in IntelliJ IDEA. A small indicator shows Blurt is listening.
Speak naturally
Dictate your Javadoc, code comment, or commit message. Blurt handles punctuation and capitalization automatically.
Release and done
Text appears at your cursor in IntelliJ IDEA. No extra steps, no dialogs. Keep coding.
Real Scenarios
Dictating comprehensive Javadoc for public methods
You finished implementing a critical service method in your Spring application. Position your cursor above the method signature, hold your hotkey: 'Processes a batch of user notifications asynchronously. Takes a list of notification requests containing user ID, message content, and priority level. Returns a CompletableFuture with a BatchResult containing success count and individual failure details. Throws IllegalArgumentException if the batch exceeds 1000 items. Thread-safe and suitable for concurrent invocation.' Complete Javadoc in 15 seconds instead of 5 minutes of typing tags.
Documenting Kotlin extension functions
You created a Kotlin extension that makes working with nullable types cleaner across your codebase. Hold button above the function: 'Extension function that safely transforms a nullable value, returning null if the receiver is null. Unlike the standard let function, this provides a more readable chain syntax for null-safe operations. Useful when multiple nullable values need sequential transformation without nested let calls.' KDoc written before you forget why this function exists.
Speaking detailed commit messages
You spent three hours migrating from Gradle to Gradle Kotlin DSL. The commit dialog opens. Hold hotkey: 'Migrate build configuration from Groovy to Kotlin DSL. Converts all build.gradle files to build.gradle.kts with type-safe accessors. Updates plugin declarations to use the plugins block. Removes deprecated configurations. Breaking change: Custom tasks now require explicit type annotations. See migration guide in docs slash gradle-migration dot md.' A commit message worth reading in 20 seconds.
Explaining complex algorithms inline
You implemented a custom comparator with specific business logic for sorting. Position cursor above the class, hold button: 'Custom comparator for priority queue ordering. High-priority items sort first, but within the same priority level, older items take precedence. This prevents priority inversion where new high-priority items starve older medium-priority ones. Based on fair queuing algorithm described in the architecture decision record ADR dash 047.' Future maintainers will understand the why, not just the what.
Code review feedback with context
You are reviewing a PR that introduces a new caching strategy. There is a subtle issue. Hold button on the problematic line: 'This cache invalidation approach will cause stale data during deployments. The TTL-based approach works for single-instance, but in our Kubernetes environment, cache entries can become inconsistent across pods. Consider using the distributed cache invalidation pattern we implemented in the payment service. I can pair on this if helpful.' Teaching feedback, not just criticism.
TODO comments with actionable context
You found an edge case that needs handling but is not blocking the current feature. Hold button: 'TODO: Add retry logic for transient database connection failures. Currently the service fails fast, but during rolling deployments we see brief connection drops. Proposed solution is exponential backoff with jitter, max three retries. See Jira ticket CORE dash 1847 for requirements. Estimated effort: two hours.' A TODO that is actually useful when revisited.
Documenting Spring annotations and configurations
You added custom Spring configuration with specific initialization order requirements. Hold button above the class: 'Configuration class that sets up the event processing pipeline. Must load after DataSourceConfig to ensure connection pool is available. The @DependsOn annotation is intentional, do not remove. Event listeners registered here receive all domain events and route to appropriate handlers based on event type.' Configuration that explains itself.
Why IntelliJ IDEA developers choose Blurt over built-in dictation
| Blurt | macOS Dictation | |
|---|---|---|
| Activation | Single customizable hotkey | Double-tap Fn key |
| Speed | Text appears in under 500ms | 2-3 second delay typical |
| Java terminology | Handles programming terms accurately | Struggles with camelCase and annotations |
| IDE integration | Works in all IntelliJ contexts | Inconsistent in dialogs and tool windows |
| Price | $10/month or $99/year | Free (included with macOS) |
| Free tier | First 1,000 words free | Unlimited but unreliable |
Frequently Asked Questions
Start Typing Faster Today
Free to try — no credit card required
Download Blurt