Voice to Text for PyCharm
You're deep in a Python coding session in PyCharm. Your hands are on the keyboard, logic flowing. Then you need to write a docstring explaining that complex function, document your type hints, or add markdown to your Jupyter notebook. Switching from Python-brain to documentation-brain breaks your momentum. Blurt lets you speak your documentation directly into PyCharm. Hold a button, say what you need, release. Text appears at your cursor. Works everywhere in PyCharm — Python files, Jupyter notebooks, the terminal, commit messages, anywhere you can type. Your docstrings get written. Your notebooks get documented. Your flow stays intact.
The Typing Problem
Docstrings you know you should write but skip
That function does something clever with nested dictionaries and optional parameters. You know exactly how to explain it — you could describe it verbally in 20 seconds. But typing out a proper Google-style or NumPy-style docstring with Args, Returns, Raises, and Examples? That's 5 minutes of tedious formatting. So you skip it. The function ships undocumented. Future you will spend 10 minutes figuring out what past-you was thinking.
Type hints that need explanation
You're using Union types, TypeVars, and Protocol classes. The types are technically correct but not self-explanatory. A comment would help: why this particular type constraint, what the edge cases are, why Optional rather than a default value. But you're in the zone writing logic. Stopping to type explanatory comments means losing momentum. The type hints stay cryptic.
Jupyter notebook markdown cells you never fill in
Your notebook has code cells that work perfectly. But the markdown cells between them? Empty or bare-bones. You know the analysis needs explanation — what the data shows, why you chose this approach, what the caveats are. You could explain it to a colleague in two minutes. Typing it out while switching between code and markdown mode? You'll do it later. You never do it later.
Commit messages that explain nothing
You just refactored the data processing pipeline. There are breaking changes, new dependencies, performance implications. Git wants a commit message. You could explain all of it — you just finished thinking through every detail. But typing a comprehensive message means context switching. You write 'refactor pipeline' and push. The git history becomes archaeology.
README updates that stay on your TODO list
The API changed. The installation steps are different now. The README is lying to anyone who reads it. You know exactly what needs updating — you just did the work. But opening the file and typing it out while the deployment is waiting? The README can wait. It waits for months. New team members get confused. You explain it verbally every time someone asks.
How It Works
Blurt works everywhere in PyCharm — Python files, Jupyter notebooks, the integrated terminal, version control, settings, anywhere you can place a cursor.
Hold your hotkey
Press your chosen shortcut anywhere in PyCharm. A small indicator confirms Blurt is listening.
Speak naturally
Dictate your docstring, comment, or markdown. Blurt handles punctuation and capitalization automatically.
Release and continue
Text appears at your cursor in PyCharm. No confirmations, no extra steps. Keep coding.
Real Scenarios
Speaking docstrings while the function is fresh
You just finished a function that processes nested JSON into a pandas DataFrame with specific handling for missing keys and type coercion. Cursor inside the triple quotes, hold your hotkey: 'Transform nested JSON data into a flattened DataFrame. Args: data, a dictionary containing nested user records. Schema, optional mapping of field names to pandas dtypes. Strict, if True raises ValueError on schema mismatch, if False coerces silently. Returns a pandas DataFrame with one row per user. Raises KeyError if required fields are missing from data.' A proper docstring in 15 seconds, written while you still remember every detail.
Documenting type hints with inline comments
You've written a function signature with complex type hints: Callable[[DataFrame, Optional[Dict[str, Any]]], Tuple[DataFrame, List[str]]]. It's correct but opaque. Hold button after the type hint: 'Transformer function that takes a DataFrame and optional config, returns the transformed DataFrame plus a list of columns that were modified. We return the column list for downstream validation.' The type hint now makes sense to the next reader.
Filling Jupyter notebook markdown cells
You've run a correlation analysis and the heatmap is rendering. The markdown cell above is empty. Hold button: 'Correlation analysis between user engagement metrics. Note that session duration and pages viewed are highly correlated at 0.84, suggesting we can drop one without losing predictive power. The negative correlation between bounce rate and conversion is expected. Outlier in mobile sessions requires investigation, see cell 12 for filtering.' Your notebook tells a story instead of just showing code.
Explaining pandas operations inline
You've chained five pandas operations that transform the data in non-obvious ways. It works, but future you won't remember why. Hold button above the chain: 'This chain handles the quarterly rollup. First groupby aggregates daily data, then the pivot creates the quarter columns, the fillna handles new customers with no prior quarter, and finally we sort by total descending. The column rename at the end matches the BI tool's expected schema.' The pandas magic is now documented.
Writing comprehensive commit messages
You've restructured the ML feature pipeline. The commit dialog opens. Hold your hotkey: 'Refactor feature engineering pipeline to use sklearn Pipeline and ColumnTransformer. Enables consistent preprocessing between training and inference. Moves custom transformers to separate module for unit testing. Breaking change: FeatureEngine class is replaced by get feature pipeline function. Old pickled models are incompatible, see migration guide in docs.' Context preserved for future debugging sessions.
TODO comments with actual context
You've found an edge case in the data validation. It's not blocking, but it needs handling. Hold button: 'TODO: Handle timezone-naive datetime columns. Currently assumes UTC which causes incorrect joins with the events table for about 5 percent of records. Proposed fix is to add timezone parameter to the load data function. See Jira DATA dash 892.' A TODO that's actually useful when someone revisits it.
Code review comments in PyCharm
You're reviewing a colleague's data processing PR. There's a subtle issue with how they're handling NaN values. Hold button: 'This dropna happens before the groupby, which means groups with any missing values are completely excluded. If that's intentional, add a comment explaining why. If not, consider using fillna with the group median instead. I can help refactor if you want to preserve partial records.' Constructive feedback that teaches.
Why Python 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 |
| Python vocabulary | Handles DataFrame, NumPy, sklearn terms | Often mangles technical terms |
| Jupyter integration | Works in markdown cells and code comments | Inconsistent in notebook interface |
| 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