An extension for VS Code which provides support for the Go language.

Go for Visual Studio Code

Join the chat at Build Status

Important Note: If you have recently upgraded to Go 1.7, you may need to run gocode close in your terminal to ensure Go completion lists continue to work correctly. See

Read the Release Notes to know what has changed over the last few versions of this extension

This extension adds rich language support for the Go language to VS Code, including:

  • Completion Lists (using gocode)
  • Signature Help (using gogetdoc or godef+godoc)
  • Snippets
  • Quick Info (using gogetdoc or godef+godoc)
  • Goto Definition (using gogetdoc or godef+godoc)
  • Find References (using guru)
  • File outline (using go-outline)
  • Workspace symbol search (using go-symbols)
  • Rename (using gorename. Note: For Undo after rename to work in Windows you need to have diff tool in your path)
  • Build-on-save (using go build and go test)
  • Lint-on-save (using golint or gometalinter)
  • Format (using goreturns or goimports or gofmt)
  • Generate unit tests skeleton (using gotests)
  • Add Imports (using gopkgs)
  • [partially implemented] Debugging (using delve)

IDE Features



First, you will need to install Visual Studio Code. Then, in the command palette (cmd-shift-p) select Install Extension and choose Go.

In a terminal window with the GOPATH environment variable set to the GOPATH you want to work on, launch code. Open your GOPATH folder or any subfolder you want to work on, then open a .go file to start editing. You should see Analysis Tools Missing in the bottom right, clicking this will offer to install all of the Go tooling needed for the extension to support its full feature set. See the Tools section below for more details.

Note: Users may want to consider turning Auto Save on in Visual Studio Code ("files.autoSave": "afterDelay") when using this extension. Many of the Go tools work only on saved files, and error reporting will be more interactive with Auto Save turned on. If you do turn Auto Save on, you may also want to turn format-on-save off ("go.formatOnSave": false), so that it is not triggered while typing.

Note 2: This extension uses gocode to provide completion lists as you type. To provide fresh results, including against not-yet-built dependencies, the extension uses gocode's autobuild=true setting. If you experience any performance issues with autocomplete, you should try setting "go.gocodeAutoBuild": false in your VS Code settings.


The following Visual Studio Code settings are available for the Go extension. These can be set in user preferences (cmd+,) or workspace settings (.vscode/settings.json).

    "go.buildOnSave": true,
    "go.lintOnSave": true,
    "go.vetOnSave": true,
    "go.buildTags": "",
    "go.buildFlags": [],
    "go.lintTool": "golint",
    "go.lintFlags": [],
    "go.vetFlags": [],
    "go.coverOnSave": false,
    "go.useCodeSnippetsOnFunctionSuggest": false,
    "go.formatOnSave": true, 
    "go.formatTool": "goreturns",
    "go.formatFlags": [],
    "go.goroot": "/usr/local/go",
    "go.gopath": "/Users/lukeh/go",
    "go.gocodeAutoBuild": false


A linter is a tool giving coding style feedback and suggestions. By default this extension uses the official golint as a linter.

You can change the default linter and use the more advanced Go Meta Linter. Note that you need to install the package manually: go get -u and edit your configuration (set the go.lintTool value to "gometalinter").

Go meta linter uses a collection of various linters and those linters also need to be installed manually. If one of the tools is available, it will be used by default (golint for instance is still run by default).

Some of the very useful linter tools:

  • errcheck checks for unchecked errors in your code.
  • varcheck finds unused global variables and constants.
  • deadcode finds unused code.

If you wish to install all the supported linter tools, gometalinter provides you with an installer: gometalinter --install

If you want to run only specific linters (some linters are slow), you can modify your configuration to specify them:

  "go.lintFlags": ["--disable-all", "--enable=errcheck"],

Finally, the result of those linters will show right in the code (locations with suggestions will be underlined), as well as in the output pane.


In addition to integrated editing features, the extension also provides several commands in the Command Palette for working with Go files:

  • Go: Add Import to add an import from the list of packages in your Go context
  • Go: Current GOPATH to see your currently configured GOPATH
  • Go: Run test at cursor to run a test at the current cursor position in the active document
  • Go: Run tests in current package to run all tests in the package containing the active document
  • Go: Run tests in current file to run all tests in the current active document
  • Go: Generates unit tests (package) Generates unit tests for the current package
  • Go: Generates unit tests (file) Generates unit tests for the current file
  • Go: Generates unit tests (function) Generates unit tests for the selected function in the current file

Optional: Debugging

To use the debugger, you must currently manually install delve. See the Installation Instructions for full details. On OS X it requires creating a self-signed cert to sign the dlv binary.

For more read Debugging Go Code Using VS Code

Remote Debugging

To remote debug using VS Code, read Remote Debugging

Building and Debugging the Extension

You can set up a development environment for debugging the extension during extension development.

First make sure you do not have the extension installed in ~/.vscode/extensions. Then clone the repo somewhere else on your machine, run npm install and open a development instance of Code.

rm -rf ~/.vscode/extensions/lukehoban.Go
cd ~
git clone
cd vscode-go
npm install
code .

You can now go to the Debug viewlet and select Launch Extension then hit run (F5).

In the [Extension Development Host] instance, open your GOPATH folder.

You can now hit breakpoints and step through the extension.

If you make edits in the extension .ts files, just reload (cmd-r) the [Extension Development Host] instance of Code to load in the new extension code. The debugging instance will automatically reattach.

To debug the debugger, see the debugAdapter readme.


The extension uses the following tools, installed in the current GOPATH. If any tools are missing, you will see an "Analysis Tools Missing" warning in the bottom right corner of the editor. Clicking it will offer to install the missing tools for you.

  • gocode: go get -u -v
  • godef: go get -u -v
  • gogetdoc: go get -u -v
  • golint: go get -u -v
  • go-outline: go get -u -v
  • goreturns: go get -u -v
  • gorename: go get -u -v
  • gopkgs: go get -u -v
  • go-symbols: go get -u -v
  • guru: go get -u -v
  • gotests: go get -u -v

If you wish to have the extension use a separate GOPATH for its tools, set the VSCODE_GOTOOLS environment variable to the desired path.

To install the tools manually in the current GOPATH, just paste and run:

go get -u -v
go get -u -v
go get -u -v
go get -u -v
go get -u -v
go get -u -v
go get -u -v
go get -u -v
go get -u -v
go get -u -v
go get -u -v

And for debugging: