- Code Spell Checker
- Languages and Dictionaries
- Reporting and Display
- Files, Folders, and Workspaces
- Performance
- CSpell
- Advanced
- Experimental
- Legacy
| Setting | Scope | Description |
|---|---|---|
cSpell.enabled |
resource | Enable / Disable the spell checker. |
Name
: cSpell.enabled
Type : boolean
Scope : resource
Description : Enable / Disable the spell checker.
Default
: true
| Setting | Scope | Description |
|---|---|---|
cSpell.caseSensitive |
resource | Determines if words must match case and accent rules. |
cSpell.customDictionaries |
resource | Custom Dictionaries |
cSpell.dictionaries |
resource | Optional list of dictionaries to use. |
cSpell.dictionaryDefinitions |
resource | Define additional available dictionaries. |
cSpell.flagWords |
resource | List of words to always be considered incorrect. |
cSpell.ignoreWords |
resource | A list of words to be ignored by the spell checker. |
cSpell.language |
resource | Current active spelling language. |
cSpell.languageSettings |
resource | Additional settings for individual programming languages and locales. |
cSpell.noSuggestDictionaries |
resource | Optional list of dictionaries that will not be used for suggestions. Words in these dictionaries… |
cSpell.userWords |
resource | Words to add to global dictionary -- should only be in the user config file. |
cSpell.words |
resource | List of words to be always considered correct. |
Name
: cSpell.caseSensitive
Type : boolean
Scope : resource
Description : Determines if words must match case and accent rules.
- `false` - Case is ignored and accents can be missing on the entire word.
Incorrect accents or partially missing accents will be marked as incorrect.
Note: Some languages like Portuguese have case sensitivity turned on by default.
You must use `#cSpell.languageSettings#` to turn it off.
- `true` - Case and accents are enforced by default.
Default : - none -
Name
: cSpell.customDictionaries -- Custom Dictionaries
Type : object
Scope : resource
Description
: Define custom dictionaries to be included by default.
If addWords is true words will be added to this dictionary.
**Example:**
```js
"cSpell.customDictionaries": {
"project-words": {
"name": "project-words",
"path": "${workspaceRoot}/project-words.txt",
"description": "Words used in this project",
"addWords": true
},
"custom": true, // Enable the `custom` dictionary
"internal-terms": false // Disable the `internal-terms` dictionary
}
```
Default : - none -
Name
: cSpell.dictionaries
Type : string[]
Scope : resource
Description
: Optional list of dictionaries to use.
Each entry should match the name of the dictionary.
To remove a dictionary from the list add ! before the name.
i.e. !typescript will turn off the dictionary with the name typescript.
Default : - none -
Name
: cSpell.dictionaryDefinitions
Type : []
Scope : resource
Description : Define additional available dictionaries.
Default : - none -
Name
: cSpell.flagWords
Type : string[]
Scope : resource
Description : List of words to always be considered incorrect.
Default : - none -
Name
: cSpell.ignoreWords
Type : string[]
Scope : resource
Description : A list of words to be ignored by the spell checker.
Default : - none -
Name
: cSpell.language
Type : string
Scope : resource
Description : Current active spelling language. Example: "en-GB" for British English Example: "en,nl" to enable both English and Dutch
Default
: "en"
Name
: cSpell.languageSettings
Type : object[]
Scope : resource
Description : Additional settings for individual programming languages and locales.
Default : - none -
Name
: cSpell.noSuggestDictionaries
Type : string[]
Scope : resource
Description : Optional list of dictionaries that will not be used for suggestions. Words in these dictionaries are considered correct, but will not be used when making spell correction suggestions.
Note: if a word is suggested by another dictionary, but found in one of these dictionaries, it will be removed from the set of possible suggestions.
Default : - none -
Name
: cSpell.userWords
Type : string[]
Scope : resource
Description : Words to add to global dictionary -- should only be in the user config file.
Default : - none -
Name
: cSpell.words
Type : string[]
Scope : resource
Description : List of words to be always considered correct.
Default : - none -
| Setting | Scope | Description |
|---|---|---|
cSpell.diagnosticLevel |
resource | Set Diagnostic Reporting Level |
cSpell.maxDuplicateProblems |
resource | The maximum number of times the same word can be flagged as an error in a file. |
cSpell.maxNumberOfProblems |
resource | Controls the maximum number of spelling errors per document. |
cSpell.minWordLength |
resource | The minimum length of a word before checking it against a dictionary. |
cSpell.numSuggestions |
resource | Controls the number of suggestions shown. |
cSpell.showAutocompleteSuggestions |
language-overridable | Show CSpell in-document directives as you type. |
cSpell.showCommandsInEditorContextMenu |
application | Show Spell Checker actions in Editor Context Menu |
cSpell.showStatus |
application | Display the spell checker status on the status bar. |
cSpell.showStatusAlignment |
application | The side of the status bar to display the spell checker status. |
cSpell.suggestionMenuType |
resource | The type of menu used to display spelling suggestions. |
cSpell.suggestionNumChanges |
resource | The maximum number of changes allowed on a word to be considered a suggestions. |
Name
: cSpell.diagnosticLevel -- Set Diagnostic Reporting Level
Type
: ( "Error" | "Warning" | "Information" | "Hint" )
| `Error` | Report Spelling Issues as Errors |
| `Warning` | Report Spelling Issues as Warnings |
| `Information` | Report Spelling Issues as Information |
| `Hint` | Report Spelling Issues as Hints, will not show up in Problems |
Scope : resource
Description : Issues found by the spell checker are marked with a Diagnostic Severity Level. This affects the color of the squiggle.
Default
: "Information"
Name
: cSpell.maxDuplicateProblems
Type : number
Scope : resource
Description : The maximum number of times the same word can be flagged as an error in a file.
Default
: 5
Name
: cSpell.maxNumberOfProblems
Type : number
Scope : resource
Description : Controls the maximum number of spelling errors per document.
Default
: 100
Name
: cSpell.minWordLength
Type : number
Scope : resource
Description : The minimum length of a word before checking it against a dictionary.
Default
: 4
Name
: cSpell.numSuggestions
Type : number
Scope : resource
Description : Controls the number of suggestions shown.
Default
: 8
Name
: cSpell.showAutocompleteSuggestions
Type : boolean
Scope : language-overridable
Description : Show CSpell in-document directives as you type.
**Note:** VS Code must be restarted for this setting to take effect.
Default
: false
Name
: cSpell.showCommandsInEditorContextMenu
Type : boolean
Scope : application
Description : Show Spell Checker actions in Editor Context Menu
Default
: true
Name
: cSpell.showStatus
Type : boolean
Scope : application
Description : Display the spell checker status on the status bar.
Default
: true
Name
: cSpell.showStatusAlignment
Type
: ( "Left" | "Right" )
| `Left` | Left Side of Statusbar |
| `Right` | Right Side of Statusbar |
Scope : application
Description : The side of the status bar to display the spell checker status.
Default
: "Right"
Name
: cSpell.suggestionMenuType
Type
: ( "quickPick" | "quickFix" )
| `quickPick` | Suggestions will appear as a drop down at the top of the IDE. (Best choice for Vim Key Bindings) |
| `quickFix` | Suggestions will appear inline near the word, inside the text editor. |
Scope : resource
Description : The type of menu used to display spelling suggestions.
Default
: "quickPick"
Name
: cSpell.suggestionNumChanges
Type : number
Scope : resource
Description : The maximum number of changes allowed on a word to be considered a suggestions.
For example, appending an `s` onto `example` -> `examples` is considered 1 change.
Range: between 1 and 5.
Default
: 3
| Setting | Scope | Description |
|---|---|---|
cSpell.allowedSchemas |
window | Define Allowed Schemas |
cSpell.checkOnlyEnabledFileTypes |
resource | Check Only Enabled File Types |
cSpell.enableFiletypes |
resource | File Types to Check |
cSpell.files |
resource | Glob patterns of files to be checked. |
cSpell.globRoot |
resource | The root to use for glop patterns found in this configuration. |
cSpell.ignorePaths |
resource | Glob patterns of files to be ignored |
cSpell.import |
resource | Allows this configuration to inherit configuration for one or more other files. |
cSpell.noConfigSearch |
resource | Prevents searching for local configuration when checking individual documents. |
cSpell.spellCheckOnlyWorkspaceFiles |
window | Spell Check Only Workspace Files |
cSpell.useGitignore |
window | Tells the spell checker to load .gitignore files and skip files that match the globs in the… |
cSpell.usePnP |
resource | Packages managers like Yarn 2 use a .pnp.cjs file to assist in loading packages stored in… |
cSpell.workspaceRootPath |
resource | Workspace Root Folder Path |
Name
: cSpell.allowedSchemas -- Define Allowed Schemas
Type : string[]
Scope : window
Description : Control which file schemas will be checked for spelling (VS Code must be restarted for this setting to take effect).
Some schemas have special meaning like:
- `untitled` - Used for new documents that have not yet been saved
- `vscode-notebook-cell` - Used for validating segments of a Notebook.
- `vscode-userdata` - Needed to spell check `.code-snippets`
Default
: [ "file", "gist", "sftp", "untitled", "vscode", "vscode-notebook-cell", "vscode-userdata" ]
Name
: cSpell.checkOnlyEnabledFileTypes -- Check Only Enabled File Types
Type : boolean
Scope : resource
Description
: By default, the spell checker checks only enabled file types. Use #cSpell.enableFiletypes#
to turn on / off various file types.
When this setting is `false`, all file types are checked except for the ones disabled by `#cSpell.enableFiletypes#`.
See `#cSpell.enableFiletypes#` on how to disable a file type.
Default
: true
Name
: cSpell.enableFiletypes -- File Types to Check
Type : string[]
Scope : resource
Description : Enable / Disable checking file types (languageIds).
These are in additional to the file types specified by `#cSpell.enabledLanguageIds#`.
To disable a language, prefix with `!` as in `!json`,
**Example: individual file types**
```
jsonc // enable checking for jsonc
!json // disable checking for json
kotlin // enable checking for kotlin
```
**Example: enable all file types**
```
* // enable checking for all file types
!json // except for json
```
Default : - none -
Name
: cSpell.files
Type : string[]
Scope : resource
Description
: Glob patterns of files to be checked.
Glob patterns are relative to the #cSpell.globRoot# of the configuration file that defines them.
Default : - none -
Name
: cSpell.globRoot
Type : string
Scope : resource
Description
: The root to use for glop patterns found in this configuration.
Default: The current workspace folder.
Use globRoot to define a different location. globRoot can be relative to the location of this configuration file.
Defining globRoot, does not impact imported configurations.
Special Values:
- `${workspaceFolder}` - Default - globs will be relative to the current workspace folder\n
- `${workspaceFolder:<name>}` - Where `<name>` is the name of the workspace folder.
Default : - none -
Name
: cSpell.ignorePaths -- Glob patterns of files to be ignored
Type : string[]
Scope : resource
Description
: Glob patterns of files to be ignored. The patterns are relative to the #cSpell.globRoot# of the configuration file that defines them.
Default
: [ "package-lock.json", "node_modules", "vscode-extension", ".git/objects", ".vscode", ".vscode-insiders" ]
Name
: cSpell.import
Type : string[]
Scope : resource
Description : Allows this configuration to inherit configuration for one or more other files.
See [Importing / Extending Configuration](https://cspell.org/configuration/imports/) for more details.
Default : - none -
Name
: cSpell.noConfigSearch
Type : boolean
Scope : resource
Description : Prevents searching for local configuration when checking individual documents.
Default : - none -
Name
: cSpell.spellCheckOnlyWorkspaceFiles -- Spell Check Only Workspace Files
Type : boolean
Scope : window
Description
: Only spell check files that are in the currently open workspace.
This same effect can be achieved using the #cSpell.files# setting.
```js
"cSpell.files": ["**"]
```
Default
: false
Name
: cSpell.useGitignore
Type : boolean
Scope : window
Description
: Tells the spell checker to load .gitignore files and skip files that match the globs in the .gitignore files found.
Default
: true
Name
: cSpell.usePnP
Type : boolean
Scope : resource
Description
: Packages managers like Yarn 2 use a .pnp.cjs file to assist in loading packages stored in the repository.
When true, the spell checker will search up the directory structure for the existence of a PnP file and load it.
Default : - none -
Name
: cSpell.workspaceRootPath -- Workspace Root Folder Path
Type : string
Scope : resource
Description : Define the path to the workspace root folder in a multi-root workspace. By default it is the first folder.
This is used to find the `cspell.json` file for the workspace.
**Example: use the `client` folder**
```
${workspaceFolder:client}
```
Default : - none -
| Setting | Scope | Description |
|---|---|---|
cSpell.blockCheckingWhenAverageChunkSiz… |
language-overridable | The maximum average length of chunks of text without word breaks. |
cSpell.blockCheckingWhenLineLengthGreat… |
language-overridable | The maximum line length. |
cSpell.blockCheckingWhenTextChunkSizeGr… |
language-overridable | The maximum length of a chunk of text without word breaks. |
cSpell.checkLimit |
resource | The limit in K-Characters to be checked in a file. |
cSpell.spellCheckDelayMs |
application | Delay in ms after a document has changed before checking it for spelling errors. |
cSpell.suggestionsTimeout |
resource | The maximum amount of time in milliseconds to generate suggestions for a word. |
Name
: cSpell.blockCheckingWhenAverageChunkSizeGreaterThan
Type : number
Scope : language-overridable
Description : The maximum average length of chunks of text without word breaks.
A chunk is the characters between absolute word breaks.
Absolute word breaks match: `/[\s,{}[\]]/`
**Error Message:** _Average Word Size is Too High._
If you are seeing this message, it means that the file contains mostly long lines
without many word breaks.
Default
: 80
Name
: cSpell.blockCheckingWhenLineLengthGreaterThan
Type : number
Scope : language-overridable
Description : The maximum line length.
Block spell checking if lines are longer than the value given.
This is used to prevent spell checking generated files.
**Error Message:** _Lines are too long._
Default
: 10000
Name
: cSpell.blockCheckingWhenTextChunkSizeGreaterThan
Type : number
Scope : language-overridable
Description : The maximum length of a chunk of text without word breaks.
It is used to prevent spell checking of generated files.
A chunk is the characters between absolute word breaks.
Absolute word breaks match: `/[\s,{}[\]]/`, i.e. spaces or braces.
**Error Message:** _Maximum Word Length is Too High._
If you are seeing this message, it means that the file contains a very long line
without many word breaks.
Default
: 500
Name
: cSpell.checkLimit
Type : number
Scope : resource
Description : The limit in K-Characters to be checked in a file.
Default
: 500
Name
: cSpell.spellCheckDelayMs
Type : number
Scope : application
Description : Delay in ms after a document has changed before checking it for spelling errors.
Default
: 50
Name
: cSpell.suggestionsTimeout
Type : number
Scope : resource
Description : The maximum amount of time in milliseconds to generate suggestions for a word.
Default
: 400
| Setting | Scope | Description |
|---|---|---|
cSpell.ignoreRegExpList |
resource | List of regular expressions or Pattern names (defined in #cSpell.patterns#) to exclude from… |
cSpell.includeRegExpList |
resource | List of regular expression patterns or defined pattern names to match for spell checking. |
cSpell.overrides |
resource | Overrides are used to apply settings for specific files in your project. |
cSpell.patterns |
resource | Defines a list of patterns that can be used with the #cSpell.ignoreRegExpList# and |
Name
: cSpell.ignoreRegExpList
Type : string[]
Scope : resource
Description
: List of regular expressions or Pattern names (defined in #cSpell.patterns#) to exclude from spell checking.
- When using the VS Code Preferences UI, it is not necessary to escape the `\`, VS Code takes care of that.
- When editing the VS Code `settings.json` file,
it is necessary to escape `\`.
Each `\` becomes `\\`.
The default regular expression flags are `gi`. Add `u` (`gui`), to enable Unicode.
| VS Code UI | JSON | Description |
| :------------------ | :-------------------- | :------------------------------------------- |
| `/\\[a-z]+/gi` | `/\\\\[a-z]+/gi` | Exclude LaTeX command like `\mapsto` |
| `/\b[A-Z]{3,5}\b/g` | `/\\b[A-Z]{3,5}\\b/g` | Exclude full-caps acronyms of 3-5 length. |
| `CStyleComment` | `CStyleComment` | A built in pattern |
Default : - none -
Name
: cSpell.includeRegExpList
Type : string[]
Scope : resource
Description : List of regular expression patterns or defined pattern names to match for spell checking.
If this property is defined, only text matching the included patterns will be checked.
Default : - none -
Name
: cSpell.overrides
Type : object[]
Scope : resource
Description : Overrides are used to apply settings for specific files in your project.
**Example:**
```jsonc
"cSpell.overrides": [
// Force `*.hrr` and `*.crr` files to be treated as `cpp` files:
{
"filename": "**/{*.hrr,*.crr}",
"languageId": "cpp"
},
// Force `dutch/**/*.txt` to be treated as Dutch (dictionary needs to be installed separately):
{
"filename": "**/dutch/**/*.txt",
"language": "nl"
}
]
```
Default : - none -
Name
: cSpell.patterns
Type : object[]
Scope : resource
Description
: Defines a list of patterns that can be used with the #cSpell.ignoreRegExpList# and
#cSpell.includeRegExpList# options.
**Example:**
```jsonc
"cSpell.patterns": [
{
"name": "comment-single-line",
"pattern": "/#.*/g"
},
{
"name": "comment-multi-line",
"pattern": "/(?:\\/\\*[\\s\\S]*?\\*\\/)/g"
}
]
```
Default : - none -
| Setting | Scope | Description |
|---|---|---|
cSpell.advanced.feature.useReferencePro… |
language-overridable | Remove Matching Characters Before Rename |
cSpell.advanced.feature.useReferencePro… |
language-overridable | Use Reference Provider During Rename |
cSpell.fixSpellingWithRenameProvider |
language-overridable | Use Rename Provider when fixing spelling issues. |
cSpell.logFile |
window | Write Logs to a File |
cSpell.logLevel |
window | Set Logging Level |
Name
: cSpell.advanced.feature.useReferenceProviderRemove -- Remove Matching Characters Before Rename
Type : string
Scope : language-overridable
Description : Used to work around bugs in Reference Providers and Rename Providers. Anything matching the provided Regular Expression will be removed from the text before sending it to the Rename Provider.
See: [Markdown: Fixing spelling issues in Header sections changes the entire line · Issue #1987](https://github.com/streetsidesoftware/vscode-spell-checker/issues/1987)
It is unlikely that you would need to edit this setting. If you need to, please open an issue at
[Spell Checker Issues](https://github.com/streetsidesoftware/vscode-spell-checker/issues)
This feature is used in connection with `#cSpell.advanced.feature.useReferenceProviderWithRename#`
Default : - none -
Name
: cSpell.advanced.feature.useReferenceProviderWithRename -- Use Reference Provider During Rename
Type : boolean
Scope : language-overridable
Description
: Use the Reference Provider when fixing spelling issues with the Rename Provider.
This feature is used in connection with #cSpell.fixSpellingWithRenameProvider#
Default
: false
Name
: cSpell.fixSpellingWithRenameProvider
Type : boolean
Scope : language-overridable
Description : Use Rename Provider when fixing spelling issues.
Default
: true
Name
: cSpell.logFile -- Write Logs to a File
Type : string
Scope : window
Description : Have the logs written to a file instead of to VS Code.
Default : - none -
Name
: cSpell.logLevel -- Set Logging Level
Type
: ( "None" | "Error" | "Warning" | "Information" | "Debug" )
| `None` | Do not log |
| `Error` | Log only errors |
| `Warning` | Log errors and warnings |
| `Information` | Log errors, warnings, and info |
| `Debug` | Log everything (noisy) |
Scope : window
Description : Set the Debug Level for logging messages.
Default
: "Error"
| Setting | Scope | Description |
|---|---|---|
cSpell.experimental.enableRegexpView |
application | Show Regular Expression Explorer |
Name
: cSpell.experimental.enableRegexpView
Type : boolean
Scope : application
Description : Show Regular Expression Explorer
Default
: false
| Setting | Scope | Description |
|---|---|---|
cSpell.allowCompoundWords |
resource | Enable / Disable allowing word compounds. |
cSpell.enabledLanguageIds |
resource | Enabled Language Ids |
Name
: cSpell.allowCompoundWords
Type : boolean
Scope : resource
Description
: Enable / Disable allowing word compounds. - true means arraylength would be ok - false means it would not pass.
Note: this can also cause many misspelled words to seem correct.
Default
: false
Name
: cSpell.customFolderDictionaries
Type : []
Scope : resource
Description
: Define custom dictionaries to be included by default for the folder.
If addWords is true words will be added to this dictionary.
Deprecation Message
: - Use #cSpell.customDictionaries# instead.
Default : - none -
Name
: cSpell.customUserDictionaries
Type : []
Scope : application
Description
: Define custom dictionaries to be included by default for the user.
If addWords is true words will be added to this dictionary.
Deprecation Message
: - Use #cSpell.customDictionaries# instead.
Default : - none -
Name
: cSpell.customWorkspaceDictionaries
Type : []
Scope : resource
Description
: Define custom dictionaries to be included by default for the workspace.
If addWords is true words will be added to this dictionary.
Deprecation Message
: - Use #cSpell.customDictionaries# instead.
Default : - none -
Name
: cSpell.enabledLanguageIds -- Enabled Language Ids
Type : string[]
Scope : resource
Description
: Specify a list of file types to spell check. It is better to use #cSpell.enableFiletypes# to Enable / Disable checking files types.
Default
: [ "asciidoc", "c", "cpp", "csharp", "css", "elixir", "git-commit", "go", "graphql", "handlebars", "haskell", "html", "jade", "java", "javascript", "javascriptreact", "json", "jsonc", "jupyter", "latex", "less", "markdown", "php", "plaintext", "python", "pug", "restructuredtext", "rust", "scala", "scminput", "scss", "swift", "text", "typescript", "typescriptreact", "vue", "yaml", "yml" ]