Usage

IDE Integration

Ultracite works best when integrated into your editor, so you get immediate feedback as you write code. It is designed to run automatically on save.

To test it out, open a project in your IDE. As you edit files, you should see formatting take effect on save. Try introducing a small code style mistake (like an extra semicolon or a wrongly indented line) and hit Save — Ultracite will instantly reformat the file.

If you introduce a lint issue (like an unused variable), you'll see a squiggly underline or a warning in the Problems panel. On save, Ultracite will attempt to fix it if it's auto-fixable (for example, removing an unused import) or otherwise leave a warning for you to address.

Instant formatting

Every time you save a file, your chosen linter formats the code. You don't need to run a separate formatter or worry about style — it's taken care of.

Thanks to the codeActionsOnSave settings, VS Code will also apply "fix all" actions on save. This means any lint rule with an auto-fix (like converting != to !==, adding missing parentheses, fixing import order, etc.) will be applied automatically.

We also enable formatOnPaste — so if you paste code from elsewhere, it will immediately be formatted to match your style.

The key advantage is instant feedback. You write code, and Ultracite continuously keeps it clean. Over time, you'll spend little to no time fixing lint errors — Ultracite either fixes them for you or points them out early.

Problems panel integration

Any issues that require your attention will show up in the Problems panel. For example, if Ultracite finds an error it can't fix (like a deprecated API or an unhandled Promise rejection), it will list it as an error or warning. Click it to jump to the location in code.

Quick fixes

In many cases, the VS Code extension for your linter provides quick fix suggestions. If you see a yellow lightbulb or a suggestion popup, you can apply fixes manually as well.

CLI Usage

Ultracite comes with a CLI that wraps your chosen linter. The commands work the same regardless of which toolchain you're using.

Checking Code

The check command runs the linter without modifying files:

npx ultracite check

Fixing Code

The fix command runs the linter and auto-fixes issues:

npx ultracite fix

You can also apply unsafe fixes (fixes that may change code behavior):

npx ultracite fix --unsafe

Type-Aware Linting (Oxlint)

When using Oxlint, you can enable type-aware linting rules that leverage TypeScript's type system.

To set up type-aware linting during initialization:

npx ultracite init --linter oxlint --type-aware

This installs the required oxlint-tsgolint dependency automatically.

Then use the flags when checking or fixing:

npx ultracite check --type-aware
npx ultracite fix --type-aware

This enables rules like no-floating-promises, no-misused-promises, and await-thenable that catch bugs by analyzing types.

You can also enable TypeScript compiler diagnostics (experimental):

npx ultracite check --type-check
npx ultracite fix --type-check

Both flags can be combined:

npx ultracite fix --type-aware --type-check

Validating Setup

The doctor command checks your setup for issues and provides recommendations. This is useful to run after installing Ultracite to ensure everything is configured correctly:

npx ultracite doctor