Outside using Deno with your favorite IDE, this section also documents and environment variables.

    There is broad support for Deno in editors/IDEs. The following sections provide information about how to use Deno with editors. Most editors integrate directly into Deno using the Language Server Protocol and the language server that is integrated into the Deno CLI.

    If you are trying to write or support a community integration to the Deno language server, there is some located in the Deno CLI code repository, but also feel free to join the Discord community in the channel.

    Visual Studio Code

    There is an official extension for Visual Studio Code called . When installed, it will connect to the language server built into the Deno CLI.

    Because most people work in mixed environments, the extension does not enable a workspace as Deno enabled by default, and it requires that the "deno.enable" flag to be set. You can change the settings yourself, or you can choose Deno: Initialize Workspace Configuration from the command palette to enable your project.

    More information can be found in the Using Visual Studio Code section of the manual.

    JetBrains’ IntelliJ IDEA and WebStorm

    Currently support for JetBrains IDEs is available through .

    Once installed, replace the content of External Libraries > Deno Library > lib > lib.deno.d.ts with the output of deno types. This will ensure the typings for the extension match the current version. You will have to do this every time you update the version of Deno. For more information on how to set-up your JetBrains IDE for Deno, read this comment on YouTrack.

    JetBrain’s is considering migrating to the Deno language server (see: ). If you are a user of JetBrains and Deno, voicing your support can continue help JetBrains prioritize support.

    vim/Neovim

    Deno is well supported on both and Neovim via and ALE. coc.nvim offers plugins to integrate to the Deno language server while ALE supports it out of the box. The in Neovim also supports Deno. The built-in language server protocol in Neovim also supports Deno.

    Neovim 0.6+ and nvim-lspconfig

    Neovim has supported Deno’s language server since version 0.5, but recent changes to Deno mean that now Neovim 0.6 or newer is needed. Until the release of 0.6 stable you must .

    To use the Deno language server install nvim-lspconfig and follow the instructions to enable the .

    Deno’s linting is not supported out of the box, but assuming you are using the on_attach helper function from the basic setup example, the default of lint = false can be overridden as follows:

    1. nvim_lsp.denols.setup {
    2.   on_attach = on_attach,
    3.   root_dir = nvim_lsp.util.root_pattern("deno.json"),
    4.   init_options = {
    5.     lint = true,
    6.   },
    7. }
    9. nvim_lsp.tsserver.setup {
    10.   on_attach = on_attach,
    11.   root_dir = nvim_lsp.util.root_pattern("package.json"),
    12.   init_options = {
    13.     lint = true,
    14.   },
    15. }

    Also note here that for a Deno project, the example above assumes that there exists a deno.json file at the root of the project.

    coc.nvim

    Once you have coc.nvim installed installed, you need to install the required plugin via :CocInstall coc-deno.

    Once the plugin is installed and you want to enable Deno for a workspace, run the command :CocCommand deno.initializeWorkspace and you should be able to utilize commands like gd (goto definition) and gr (go/find references).

    ALE

    ALE supports Deno via the Deno language server out of the box and in many uses cases doesn’t require additional configuration. Once you have ALE installed you can perform the command to get information on the configuration options available.

    For more information on how to setup ALE (like key bindings) refer to the official documentation.

    Emacs

    lsp-mode

    Emacs supports Deno via the Deno language server using . Once lsp-mode is installed it should support Deno, which can be to support various settings.

    eglot

    You can also use built-in Deno language server by using .

    An example configuration for Deno via eglot:

    1. (add-to-list 'eglot-server-programs '((js-mode typescript-mode) . (eglot-deno "deno" "lsp")))
    3.   (defclass eglot-deno (eglot-lsp-server) ()
    4.     :documentation "A custom class for deno lsp.")
    6.   (cl-defmethod eglot-initialization-options ((server eglot-deno))
    7.     (list :enable t
    8.     :lint t))

    Atom

    The supports integrating with the Deno language server via the atom-ide-deno package. atom-ide-deno requires that the Deno CLI be installed and the package to be installed as well.

    Sublime Text

    supports connecting to the Deno language server via the LSP package. You may also want to install the to get full syntax highlighting.

    Once you have the LSP package installed, you will want to add configuration to your .sublime-project configuration like the below:

    1. {
    2.   "settings": {
    3.     "LSP": {
    4.       "deno": {
    6.           "deno",
    7.           "lsp"
    8.         ],
    9.         "initializationOptions": {
    10.           // "config": "", // Sets the path for the config file in your project
    11.           "enable": true,
    12.           // "importMap": "", // Sets the path for the import-map in your project
    13.           "lint": true,
    14.           "unstable": false
    15.         },
    16.         "enabled": true,
    17.         "languages": [
    18.           {
    19.             "languageId": "javascript",
    20.             "scopes": ["source.js"],
    21.             "syntaxes": [
    22.               "Packages/Babel/JavaScript (Babel).sublime-syntax",
    23.               "Packages/JavaScript/JavaScript.sublime-syntax"
    24.             ]
    25.           },
    26.           {
    27.             "languageId": "javascriptreact",
    28.             "scopes": ["source.jsx"],
    29.             "syntaxes": [
    30.               "Packages/Babel/JavaScript (Babel).sublime-syntax",
    31.               "Packages/JavaScript/JavaScript.sublime-syntax"
    32.             ]
    33.           },
    34.           {
    35.             "languageId": "typescript",
    36.             "scopes": ["source.ts"],
    37.             "syntaxes": [
    38.               "Packages/TypeScript-TmLanguage/TypeScript.tmLanguage",
    39.               "Packages/TypeScript Syntax/TypeScript.tmLanguage"
    40.             ]
    41.           },
    42.             "languageId": "typescriptreact",
    43.             "scopes": ["source.tsx"],
    44.             "syntaxes": [
    45.               "Packages/TypeScript-TmLanguage/TypeScriptReact.tmLanguage",
    46.               "Packages/TypeScript Syntax/TypeScriptReact.tmLanguage"
    47.             ]
    48.           }
    49.         ]
    50.       }
    51.     }
    52.   }
    53. }

    Nova

    The can integrate the Deno language server via the Deno extension.

    GitHub Codespaces

    GitHub Codespaces allows you develop fully online or remotely on your local machine without needing to configure or install Deno. It is currently in early access.

    Once selected, you will need to rebuild your container so that the Deno CLI is added to the container. After the container is rebuilt, the code space will support Deno.

    Kakoune

    Kakoune supports connecting to the Deno language server via the client. Once kak-lsp is installed an example of configuring it up to connect to the Deno language server is by adding the following to your kak-lsp.toml:

    Built into the Deno CLI is support to generate shell completion information for the CLI itself. By using deno completions <shell>, the Deno CLI will output to stdout the completions. Current shells that are supported:

    • bash
    • elvish
    • fish
    • powershell
    • zsh

    bash example

    Output the completions and add them to the environment:

    1. > deno completions bash > /usr/local/etc/bash_completion.d/deno.bash
    2. > source /usr/local/etc/bash_completion.d/deno.bash

    PowerShell example

    Output the completions:

    1. > deno completions powershell >> $profile
    2. > .$profile

    This will be create a Powershell profile at $HOME\Documents\WindowsPowerShell\Microsoft.PowerShell_profile.ps1, and it will be run whenever you launch the PowerShell.

    zsh example

    You should have a directory where the completions can be saved:

    1. > mkdir ~/.zsh

    Then output the completions:

    And ensure the completions get loaded in your ~/.zshrc:

    1. fpath=(~/.zsh $fpath)
    2. autoload -Uz compinit
    3. compinit -u

    If after reloading your shell and completions are still not loading, you may need to remove ~/.zcompdump/ to remove previously generated completions and then compinit to generate them again.

    zsh example with ohmyzsh and antigen

    is a configuration framework for zsh and can make it easier to manage your shell configuration. antigen is a plugin manager for zsh.

    Create the directory to store the completions and output the completions:

    1. > mkdir ~/.oh-my-zsh/custom/plugins/deno
    2. > deno completions zsh > ~/.oh-my-zsh/custom/plugins/deno/_deno

    Then your .zshrc might look something like this:

    1. source /path-to-antigen/antigen.zsh
    3. # Load the oh-my-zsh's library.
    4. antigen use oh-my-zsh
    6. antigen bundle deno

    fish example

    There are a couple environment variables which can impact the behavior of Deno:

    • DENO_AUTH_TOKENS - a list of authorization tokens which can be used to allow Deno to access remote private code. See the Private modules and repositories section for more details.
    • DENO_TLS_CA_STORE - a list of certificate stores which will be used when establishing TLS connections. The available stores are mozilla and system. You can specify one, both or none. The order you specify the store determines the order in which certificate chains will be attempted to resolved. The default value is mozilla. The mozilla store will use the bundled mozilla certs provided by . The system store will use your platforms native certificate store. The exact set of mozilla certs will depend the version of Deno you are using. If you specify no certificate stores, then no trust will be given to any TLS connection without also specifying DENO_CERT or --cert or specifying a specific certificate per TLS connection.
    • DENO_CERT - load a certificate authority from a PEM encoded file. This “overrides” the --cert option. See the section for more information.
    • DENO_DIR - this will set the directory where cached information from the CLI is stored. This includes items like cached remote modules, cached transpiled modules, language server cache information and persisted data from local storage. This defaults to the operating systems default cache location and then under the deno path.
    • DENO_INSTALL_ROOT - When using deno install where the installed scripts are stored. This defaults to $HOME/.deno/bin.
    • DENO_WEBGPU_TRACE - The directory to use for WebGPU traces.
    • HTTP_PROXY - The proxy address to use for HTTP requests. See the Proxies section for more information.
    • HTTPS_PROXY - The proxy address to use for HTTPS requests. See the section for more information.
    • NO_COLOR - If set, this will cause the Deno CLI to not send ANSI color codes when writing to stdout and stderr. See the website https://no-color.org/ for more information on this de facto standard. The value of this flag can be accessed at runtime without permission to read the environment variables by checking the value of Deno.noColor.
    • - Indicates hosts which should bypass the proxy set in the other environment variables. See the section for more information.