GoLand 2018.1 EAP 5: Dep Integration, Smarter Auto-Imports, Scratch Files, Faster Rename and Find Usages, and More

A fresh GoLand 2018.1 EAP build is here, and as always, it comes with lots of new features and bugfixes! Below is a quick overview of the changes.


The most important news about the update is the support for dep, the official experimental dependency management tool. The update is capable of importing existing dep projects and also provides a project wizard for creating new dep projects.

To create a new dep project, open the Project Wizard and switch to the Dep tab on the left-hand side of the dialog:

To create or work with a dep project, you have to fill the Dep location with the path to the dep binary.

If you import an existing dep project, the IDE will detect dep and will prompt you to enable the dep integration:

Now when you work with a dep project and open a file that has an unresolved import statement, the IDE will offer a quick-fix that runs dep ensure:

After you click it, the IDE will run the command and afterward automatically sync the changes in the vendor folder.

The path to the dep location can always be changed in Settings | Go | Dep:


The auto-import mechanism has been made smarter with this update and it now only applies it if the resulting code compiles with no errors (GO-1730). If the resulting code cannot apply without errors, the IDE prompts a quick-fix that adds the corresponding import statement – so you can call it manually.

Code completion

Code completion suggestions for boolean expressions now can be selected and negated by simply pressing “!” (GO-5411):

Scratch files

A scratch file, created from a Go code selection, now gets all proper import statements automatically. If you haven’t used Scratch Files yet, make sure to try them as they offer a “Go Playground”-like editing session with full IDE support.


The two other minor yet very important improvements are:

  • The global symbols now can be renamed and searched for usages much faster.
  • The inspection that reports type mismatch now respects type aliases (GO-5190 and GO-5408).

Additionally, if you are wondering about support for vgo, the new experimental tool for dependency management, please keep an eye on GO-5390. We will post updates there when we have them.

Last but not least, GoLand 2018.1 now offers a brand new plugin for Kubernetes.

To learn more about the plugin, read its announcement in IntelliJ IDEA’s blog.

That’s it for now. Now go ahead and try all these improvements for yourself! The update can be downloaded from the website, the Toolbox App, or from the IDE if you run the latest EAP build.

Happy developing!

Posted in EAP, New Features | Tagged , | Leave a comment

GoLand 2018.1 EAP 4 is Here: Partial Commits for Git, Attaching Debugger to Local Processes, and More

Following the train of EAPs of the IDEs based on the IntelliJ platform, GoLand is releasing its own. Welcome GoLand 2018.1 EAP 4. The update brings in the improvements from the platform, such as the long-awaited support for partial Git commits together with Go-related improvements and some new features. Below you’ll find more details. Anyone wanting to just get going with it is welcome to download the update through the website, the IDE, or the Toolbox App.

First, let’s get into the new Go-related features and improvements. The IDE is now able to attach the Debugger to locally running processes (GO-4867). The only thing you have to do is click Run in the main menu and choose Attach to Local Process:

The IDE will prompt you to select a process to debug:

Note, the IDE may also prompt you to install the gops package. When asked, please click to agree to do so in the popup. The IDE will do it automatically. After that, you’ll be able to attach the debugger to local processes.

Once the process is selected, it will open the Debugger tool window and be ready to stop at breakpoints:

Another area of improvement brought by the update is Postfix Completion.

All the templates can now be disabled or enabled. Earlier some of the templates were not present in the Settings (GO-5165):

Here in the list, you will also notice there is the new template “.if” (GO-4094). It’s very convenient to transform an entered bool expression into an if statement:

If a bool expression is a check for nil, make sure to use “.nn” or “.nil” templates instead because they are designed exactly for that.

When a template is applied to a function argument, the IDE sometimes used to apply the template to the function instead of the argument. The update fixes this issue (GO-5125).

Also, the IDE now does not run Example functions within go tests if those functions have no output values (GO-2029). The Gutter icon is also not shown for such functions.

The Go Scratch Files are now created from the predefined templates that can be customized in Settings | Editor | File and Code Templates:

Secondly, let’s now have a look at the platform-level improvements. Yes, you got it right from the intro to this post. This update supports partial Git commits (IDEA-63201).

Now you can choose which individual changes within a file to commit:

Also, now you can assign these individual changes within a file to different Changesets. To do this, click the change marker on the Gutter (the left-hand pane of the editor):

Last but not least, in case you have several repositories configured for the project, the VCS tool window will allow you to group the changes by the repositories. To do that, use the corresponding icon on the right-hand toolbar of the Local Changes tab.

That’s it for now. For the complete list of changes, please check out the release notes. Your feedback as always is welcome here in the comments or even better right in the issue tracker.

Happy developing!

Posted in EAP, New Features | Tagged , | 5 Comments

GoLand 2018.1 EAP 3: Move Refactoring, Better Test Runner, Go Build, QuickDoc, and More

Great news everyone! A fresh GoLand 2018.1 EAP build is here with lots of goodies inside. Read on to learn what’s in there or go ahead and download the EAP build to try it for yourself.

Thanks to the new -json option introduced in Go 1.10 for go test, the update is able to represent the results of the tests better. Now it supports the hierarchy of tests and correctly attributes the output and compilation errors to individual tests and packages:

With the updated Go Build run configuration now you can select and run multiple files (GO-555). You can either select the files in the run configuration dialog using the Plus button next to the Files field, or select the files in the Project tool window and then choose Run from the context menu:

The Quick Documentation action is now aware of example functions and includes them as part of the documentation (GO-2000):

The family of available refactorings for Go is extended with Move (GO-4088). This refactoring allows you to move any top-level member to another file:

The Undo action when used along with File Watchers, doesn’t offer to undo Reload from Disk anymore (GO-4726). Instead, it simply undoes the latest change, including the change made by File Watchers.

Last but not least, the Auto Import has been made smarter and prevents you from adding undesired import statements (GO-5118).

That’s it for now. For a complete list of changes, please refer to the release notes. Please give the new EAP build a try and share your feedback with us in our issue tracker.

If you’d like to make your life easier and automate managing updates, please consider installing Toolbox App.

Happy developing!

Posted in New Features | Tagged , | Leave a comment

GoLand 2018.1 EAP 2 is Here

Last week we announced the opening of GoLand 2018.1. Today we’re glad to present you with a fresh EAP build with a number of improvements. Read on to learn about them in more detail, or go ahead and install the update in whatever is your preferred way: download from the website, update from the IDE, or update from Toolbox App.

The editor is now able to remove import statements for unused packages on the fly as you type. This is convenient as you don’t have to remove those import statements by yourself anymore. The IDE does it for you:

This option is called Optimize imports on the fly. You can enable it in Settings | Go | Imports:

The Build run configuration earlier didn’t allow you to use -o in the Go tools arguments field. Now it does, and overrides the value set in the Output directory field:

When debugging, the IDE now distinguishes shadowed variables in the Watches and Variables tabs of the Debugger tool window:

The name suggestion algorithm is now aware of the context and avoids name collisions, e.g. when extracting variables.

Some of the inspections that correspond to go vet and which are supposed to run before go test in Go 1.10 were improved. A few examples are given below:

1) In the following case, the IDE doesn’t offer to simplify the second part of the boolean expression:

2) The IDE warns about type mismatches for the calls of fmt.Printf:

3) The IDE reports invalid build tags:

And last but not least, if you now click Enter when the caret is on a chain call or a string literal, the IDE auto-formats the resulting code:

That’s it for today. For a more complete list of changes in the build, refer to the release notes.

As always, your feedback along with bug reports and feature requests is very welcome in our issue tracker!

Happy developing!

Posted in EAP, New Features | Tagged , | 3 Comments

Welcome GoLand 2018.1 EAP: Better Inspections, Completion, Performance, and More

Following the opening of the EAPs for IntelliJ IDEA and WebStorm, the GoLand team is in a hurry to let you know that GoLand 2018.1 EAP is here with lots of goodies. Read below to learn what’s new or go ahead, download the EAP and give it a spin yourself. If you use Toolbox App, it already awaiting you there.

Go 1.10

Following the changes introduced with Go 1.10, the IDE now supports many of these changes.

First, for method expressions, the IDE now supports any type as a receiver:


Second, the support for Go templates now respects the new keywords such as break and continue:


The formatter has also been updated and now offers correct formatting to three-index slices and single-method interfaces.


Since go vet is now by default running as part of go test, the IDE added missing go vet inspections available on the fly.

For example, the inspection, that reports conditions that are always true (or false), now also spots unnecessary checks for functions on nil:


Also, the IDE reports direct assignments to atomic values:


Code completion

For return statements inside functions, code completion now suggest default values:



There’s a number of new intentions added to the update, e.g. Flip for binary expressions, and Negate and Negate recursively for boolean expressions:


In addition to Negate, for if statement, you now can use Invert:



Speaking of performance, the update makes it possible to limit indexing of the local project and avoid indexing an entire GOPATH. This new option makes sense when you vendor all your dependencies with dep or glide tools and don’t use libraries from global GOPATH.

The option is available in both File | Settings | Go | GOPATH | Index entire GOPATH and the Project Wizard.


The EAP also brings many non-Go related improvements:

  • The IDE now respects fractional scale factors when multiple HiDPI monitors are used
  • The Replace in Path popup now previews replacements even if a regular expression is used.
  • Now any folder in the Project tool window can be easily opened in the Terminal tool window. The action is called Open in Terminal.
  • VCS
    • The Git Branches popup now supports pasting text from the clipboard.
    • The Force Push action is enabled by default for all branches except the protected ones. The Allow force push checkbox has been removed from the Preferences | Version Control | Git.
  • Web
    • Better code completion for SVG properties and values
    • Navigation from HTML to both compiled CSS and its source
    • Pasting HTML to JSX now respects React-specific attributes (className, onClick, onChange, etc).

Major bug fixes

The update has tons of bug fixes including a few major ones, such as with focus issues. Here’s a list of some of the fixed cases:

  • The Search Everywhere popup didn’t receive focus.
  • The Project tool window didn’t receive focus from the Select In popup.
  • The VCS tool window didn’t receive focus from the Diff dialog.
  • The Find in Path dialog doesn’t disappear now if you click outside the dialog

For the complete list of changes in the EAP build, please refer to the release notes.

That’s it for now. To try out to all these (and some other improvements), go ahead and download the EAP build from the website or from the Toolbox App.

Note, the EAP is work in progress and thus may have bugs. If you find a bug, please make sure to report it to our issue tracker. This way you not only help us make the product better but will also keep informed on the progress, e.g. when this or that bug is going to be fixed.

Happy developing!

Posted in EAP, New Features | Tagged , | 5 Comments

GoLand 2017.3.1: Syntax Highlighting, Fill Structs, Debugger, and More

The GoLand team is recovering from the holidays, and we wish everyone who celebrates like us on Dec 31st/Jan 1st a very happy New Year!

Here’s some good news for you. Though with a bit of a slight delay, GoLand 2017.3.1 is finally here. This minor update fixes many of the bugs we were having, increases stability, and improves performance.  Here’s a short list of the most notable changes.

First, the Code Style settings in addition to function declaration now offer syntax highlighting options for function calls as well:

Second, the IDE now bundles the Monokai color scheme which can be chosen in the Code Style settings or on the first initial IDE setup:

The Fill struct intention action added earlier is now able to add missing keys even to the structs that are only partially initialized:

Also, the update fixes a very annoying bug related to the cross-platform compilation (GO-2683). The IDE gave a wrong name to the binary (e.g., added .exe while compiling on Windows for Linux).

The Debugger has been updated to the latest version of Delve and now supports
macOS as well as Go 1.10 better.

Last but by no means least, the update fixes many other issues related to both the Go functionality (QuickDoc, Inspections, Test Runner, and Refactorings) and the platform. For the complete list, please refer to the release notes.

Happy developing!

Posted in New Features, Releases | Tagged , | 7 Comments

GoLand 2017.3.1 Nightly Builds

The moment GoLand 2017.3 was released, our team started addressing the feedback you’ve been sharing with us. As we’re approaching GoLand 2017.3.1 (a minor update that brings lots of fixes), we’d like to remind you that its nightly builds are already available to try. Below is a quick introductory instruction on how to try GoLand nightly builds.

To switch the IDE to the “nightly” channel, go to Settings | Plugins, click Browse repositories, then click Manage repositories and make sure you’ve added “https://plugins.jetbrains.com/plugins/nightly/9568” to the list of plugin repository URLs:

This way the IDE will be updated via the nightly versions of the Go plugin.

Keep in mind that the quality of nightly builds is usually below our normal standards and you may encounter many issues. On the plus side though, by using the nightly builds, you help us identify those possible issues in advance so we can fix them before the build goes GA.

If you’re using a nightly build and see an issue, please report it immediately to our issue tracker. We’re grateful for your support!

The GoLand Team
The Drive to Develop

Posted in Uncategorized | Tagged | Leave a comment

The Way to Go: JetBrains GoLand IDE Hits the Market

It has always fascinated us to see how fast the developer industry is evolving. If you watch it long enough, you’ll see new products and technologies join a developer’s essential toolset every year. No matter how effective or efficient a programming language or framework is, an even better way of doing things is bound to be discovered or invented. With this diversity of technologies, it’s vital for us at JetBrains to keep improving the one thing that matters most: Developer Experience.

Last winter we announced we were building a new Go IDE on top of IntelliJ Platform which we codenamed Gogland. Today we’ve reached a special milestone and are happy to report that this IDE finally hits the market as GoLand and is available for download and purchase!

NOTE: If you use IntelliJ IDEA Ultimate, you can take advantage of GoLand’s functionality inside IntelliJ IDEA via this plugin. To learn about the availability of the Go plugin in other IntelliJ-based IDEs, please read this post.


GoLand is aimed at offering the same level of developer experience for Go as PyCharm does for Python or IntelliJ IDEA does for Java. GoLand provides clever completion, on-the-fly inspections and quick-fixes, navigation and automated refactorings – all packed together inside an ergonomic environment.

In addition to Go-specific in-editor coding assistance, the IDE offers a built-in test runner, test coverage, and a debugger. Other integrated tools include support for Git, Docker, databases, a terminal, and many more. Finally, GoLand fully supports front-end development with dedicated coding assistance for JavaScript, TypeScript, React, Vue.js, Angular, and other technologies.

In case you’ve heard the early announcement but haven’t followed the recent progress, take a look at the latest EAP news or check out GoLand’s website.

GoLand 2017.3 is officially released but this is only the beginning. We are going to keep improving every part of the IDE including its inspections, refactorings, the debugger, and everything else. If you have a feature request or a bug report, please make sure to file it into our issue tracker or simply tweet @GoLandIDE.

What is the licensing model?

GoLand uses the standard JetBrains licensing model: there are subscriptions available for corporate and individual customers, with monthly and yearly payment options. Using your subscription continuously helps you save up to 40% off the standard price for your third year and onwards. In addition to standalone licensing, GoLand is also part of the All Products pack along with other JetBrains IDEs and .NET tools.

To learn more about pricing, get a quote, or apply for a complimentary license, see GoLand’s Buy page. Or just try GoLand free for 30 days at any moment.

GoLand is available free for selected groups including students, teachers, and non-commercial Open Source projects.

How frequent are the updates?

Major updates for GoLand will be released 3 times per year, same as for our other IDEs: in Spring, Summer and Winter. Minor updates will be more frequent and will still be available should you ever decide to cancel your subscription.

Your JetBrains GoLand Team
The Way to Go

Posted in News, Releases | 19 Comments

GoLand EAP 20: Go Build Run Configuration and Other Improvements

Hurray! A fresh GoLand EAP is now out. One of the most notable changes in this update is a new type of run configuration: Go Build. This run configuration replaces the Go Application run configuration, and it basically runs the Go build command. You can configure this run configuration for a file, package or directory:

If the build command produces a binary, the IDE will run it. Otherwise, the IDE will simply show the build output. If you don’t want to run the binary, you can uncheck the corresponding option.

We hope with this addition your workflow and build process, in general, will now be even more straightforward.

Last but not least, the Status Bar now includes a widget (on the right-hand side) for quick access to the Go settings, UI theme, keymap, plugins, etc.

In addition to these improvements, the update has some bugfixes. Please give the update a thorough try and share your feedback with us in our issue tracker!

Happy developing!

Posted in EAP, New Features | 3 Comments

GoLand EAP 19: Docs in Param Info, Coverage for Multiple Packages, Build Tags and More

We’ve just published a fresh GoLand EAP build. Since we’re approaching the release date (roughly early December), we are now paying more attention to fixing important issues and the overall stability of the IDE. The published update comes with plenty of bugfixes. At the same time, the update includes several new features. Below are some details on some of them.

Now you can see the documentation on function parameters as a part of the Param Info popup:

It’s disabled by default. To enable it, go to Settings | Go, and check Show documentation in parameter info:

The Call Hierarchy introduced earlier now has a button that toggles the mode in which it additionally shows the calls on interfaces:

The upcoming Go 1.10 is going to support running tests with coverage from multiple packages. Now if you use Run with Coverage on a folder that has several packages, the IDE properly collects and displays the coverage data for all packages:

Note, to make it work, you have to use a Go distributive built from the sources.

Earlier we added Add directory to the current project to the context menu of the Project tool window so you could quickly add a content root to the project. Now the IDE also offers Remove directory from current project to quickly remove the content root from the project:

Running tests with build tags got easier. Now, if the tests you’re running have build tags that are not listed in Settings | Go | Vendoring & Build Tags, the IDE will automatically include the tags in the command line:

The Run Configuration dialog now has an option to automatically include the tags specified in Settings | Go | Vendoring & Build Tags into the command line:

For the complete list of changes in the build, please check out the release notes.

Once again, let us remind you that we’re getting close to the release date. It means we heavily need your feedback. Please help us test it more thoroughly to find and get fixed all the important issues before the release. When you notice anything, please be sure to submit it to our issue tracker. Thanks for your support and help!

Happy developing!

Posted in EAP, New Features | 7 Comments