Easy Typing makes an Obsidian note format itself while you type in Chinese

Auto-spacing between Chinese, English and digits is the reason to install it

Easy Typing is an Obsidian enhancement plugin written in TypeScript, and the description of it is blunt: a plugin for users writing in an easy way. The problem behind it is typography in mixed-script notes.

When Chinese and English meet in a sentence, most editors leave it to you to insert a space. Forget one and the text looks wrong. The same applies to a Chinese character followed by a number, and to punctuation, where a full-width comma is expected after a CJK character but a half-width one is what a keyboard produces by default. Easy Typing inserts the space, switches the punctuation, and pairs CJK brackets and quotes so that typing an opening bracket produces its partner.

These behaviours are on as soon as the plugin is installed and enabled. The documentation describes them as working out of the box with no configuration. A smaller convenience sits alongside them: typing two middle dots produces inline code, so you do not have to leave your Chinese input method to reach for backticks.

The auto-formatting actions are individually undoable, which matters more than it first appears. Every transformation can be reverted with the standard undo shortcut, so a mistaken space insertion is one keystroke to fix rather than something to hunt for in the text.

The rule engine splits triggers into input, delete and selection

Custom behaviour runs through one rule engine with three trigger types, and the split is the design decision that makes the plugin extensible without turning into a script collection.

An Input rule fires when you type a matching pattern, and the built-in use is the two-middle-dot shortcut that becomes inline code. A Delete rule fires on backspace, where deleting the opening dollar sign of a formula removes the whole pair. A SelectKey rule fires when you type after selecting text, so selecting a phrase and pressing the full-width yen sign wraps it as inline math.

Rules are matched with regular expressions, and the replacement can reference capture groups through a bracketed syntax, with the README distinguishing a numbered group reference from a relative one. Regex flags for case-insensitive, multiline and Unicode matching are supported. The replacement can also contain tabstop placeholders, including a default value form, which are navigated with the Tab key, so a rule can leave a selected placeholder ready for you to type over.

Two scoping mechanisms keep rules from firing where they should not. A rule can be restricted to text, formula or code contexts, and code scope matches can be narrowed further to a language such as python. The replacement field can hold JavaScript logic rather than a fixed string, which is the escape hatch for transformations that regular expressions cannot express.

Tab, Backspace and Mod+A all behave differently from stock Obsidian

The editing features are where a typing plugin either earns its place or gets in the way, and Easy Typing takes a firm position on each one.

Tabout is the signature behaviour: pressing Tab inside paired symbols such as full-width brackets, angle marks, quotes or inline code jumps out of the pair instead of inserting a tab character. Better Backspace removes an empty list item or an empty quote line with a single keystroke. Enhanced Mod+A expands the selection progressively, from the current line to the current block to the whole document, which makes it usable for a quick section selection without reaching for the mouse.

Smarter behaviour also covers the operations that usually annoy. Smart Paste adds indentation and list or quote prefixes when you paste inside a list or a quote. Strict Line Break makes Enter produce a double line break, which is a Markdown paragraph break. Collapsed Heading Enter adds a sibling heading when you press Enter on a collapsed heading instead of expanding it first.

Inside code blocks, Better Code Edit improves selection, indentation, deletion and paste, and the Toggle Comment command supports code block languages, so the comment syntax follows the language of the block rather than the file. The command list also includes Format Article to apply auto-formatting to the whole document and Format Selection/Line for a smaller scope, which are the escape valves when automatic formatting has made a mess.

Commands cover whole-document formatting, and the hotkeys are fixed defaults

A handful of built-in commands handle the operations that are awkward to do by hand. Format Article runs auto-formatting over the entire document, Format Selection/Line applies it to the selected text or the current line, and Delete Blank Lines removes extra blank lines. New Line After Current creates a line below and moves the cursor into it, Insert Code Block converts the selection into a code block, and Select Block expands the selection to the current block.

Two of these are worth noting for how they affect the rest of the plugin. Toggle Auto-format is bound to Ctrl+Tab and switches the auto-formatting behaviour on and off, which is the fastest way to get raw typing back when a document needs a different kind of editing. Toggle Comment is bound to Mod+/ and works with the language of a code block.

The settings area holds the rest: inline element spacing for code, formulas and links can be set to none, soft or strict, and a prefix dictionary suppresses premature space insertion while a word is still being typed, which is the setting that decides whether auto-spacing feels helpful or twitchy. There are also compatibility options for Chinese IME behaviour, the macOS context menu and MS IME, and a file exclusion option that removes specific files from auto-formatting by path pattern.

Building from source means esbuild plus a version bump script

End users install the plugin through Obsidian itself and never touch the source tree, but the repository layout makes a developer build straightforward. The root holds manifest.json and versions.json, the two files Obsidian reads for plugin metadata, and the package entry point is main.js as declared in package.json. The TypeScript sources live in src, the build is configured in esbuild.config.mjs, and separate documentation for auto-formatting, edit enhancements and custom rules sits in the Doc directory.

The build scripts are declared in package.json, and the production build type checks before bundling:

	"scripts": {
		"dev": "node esbuild.config.mjs",
		"build": "tsc -noEmit -skipLibCheck && node esbuild.config.mjs production",
		"version": "node version-bump.mjs && git add manifest.json versions.json"
	},

Two details in there matter for a fork. The version script runs version-bump.mjs and stages manifest.json and versions.json, so a release touches both files and the two must stay in sync. The build script runs tsc with noEmit first, so type errors stop the bundle rather than producing a broken main.js. The dev script starts the esbuild config directly, which is the watch mode for iterating on a rule.

The dependency list is small on the runtime side, with sprintf-js as the only production dependency. The rest are development tools pinned in devDependencies, including the Obsidian typings, CodeMirror packages and esbuild 0.14.47, with TypeScript at 4.7.4.

The alternative rules approach differs in trigger, not in effect

Most typing helpers in this category work by watching the document and rewriting text after the fact. Easy Typing instead works at the input layer, where a rule is bound to a trigger and a replacement, and where the timing of the insertion is decided by the plugin rather than by a background pass over the file.

That difference is visible in the built-in behaviours. A background rewriting approach cannot know that a backspace on a dollar sign should take the whole inline math with it, because by the time it sees the change the pairing is already broken. A trigger-based rule can.

The project documentation credits three sources, obsidian-latex-suite, typing-transformer-obsidian and the Obsidian plugin documentation, and it does not describe how their behaviour compares with its own, so treat that list as provenance rather than a comparison. What you can check against the documentation here is the rule engine itself: three trigger types, scope-aware execution, tabstop placeholders, priority ordering with drag-and-drop reordering, and JSON import and export for user rules. Priority ordering and the import and export format are the two features worth comparing first if you are moving from another plugin.

The limits are equally clear. Auto-spacing, capitalisation and punctuation rewriting are active from the moment the plugin is enabled, which is convenient for someone who wants them and irritating for someone who does not, and the escape routes are the per-feature settings, the prefix dictionary, the file exclusion pattern and the Ctrl+Tab toggle. Auto-capitalise of the first letter of sentences, for instance, is listed among the auto-formatting behaviours, and there is no per-language switch documented for it.

Maintenance, licensing and what the version numbers show

The plugin is released under the MIT licence, which is a permissive choice with no obligations beyond keeping the notice. The last push to the repository was on 2026-07-12, and the repository is not archived, so the code is still receiving changes.

The release numbering has moved quickly. Version 6.0.9 was published on 2026-07-12, 6.0.8 on 2026-05-18 and 6.0.7 on 2026-03-31, and the manifest records the same version as the package.json entry. A project on a 6.x line with three releases inside four months is a young, actively changing plugin, which is a factor worth weighing against the feature list because settings and behaviour can shift between minor versions. The changelog is kept in changelog.md at the repository root, and the version-bump script keeps manifest.json and versions.json aligned with the package version.

The documentation for the three main areas, auto-formatting, edit enhancements and custom rules, is in the Doc directory of the repository, and the Chinese version of the README is maintained alongside the English one, which is a useful signal for a plugin whose primary audience writes in Chinese.

Editorial conclusion

Easy Typing fits a writer who constantly mixes Chinese, English and numbers in Obsidian notes and wants spacing and punctuation handled without thinking, and it is the wrong tool if you would rather type raw text and format later with a command. Verify first that the auto-spacing and capitalisation behave the way you want, since they are active as soon as the plugin is enabled, and set the file exclusion pattern for any note where automatic changes are unwelcome.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. Releases
5. Yaozhuwa/easy-typing-obsidian on GitHub