New IDE for Go (Golang): A First Look at the Tool of the Future

Online Python Trainer for Beginners

Learn Python easily without overwhelming theory. Solve practical tasks with automatic checking, get hints in Russian, and write code directly in your browser — no installation required.

Start Course

Go in Focus: First Encounter with a New IDE for Golang

The Go (Golang) developer community continues to grow actively, and along with it, the need for high-quality development tools is increasing. A new integrated development environment (IDE) specifically designed for Go has recently appeared on the market. We decided to take a first look at it and share our initial impressions. The developers promise not just another code editor, but a full-fledged environment that takes into account all the language's features — from strict typing to goroutines.

So what does this tool offer, and is it worth paying attention to? Let's find out.

Key Features of the New IDE

From the first minutes of use, the well-thought-out interface stands out. The developers were clearly inspired by the best practices of JetBrains and Visual Studio Code, but added a number of unique features focused on working with Go projects.

Intelligent Autocomplete (IntelliSense): The environment not only suggests variable names but also takes into account the context of goroutines, channels, and package structure. Working with `context.Context` and `error` has become significantly more convenient.
Built-in Debugger with Goroutine Support: You can pause the execution of one goroutine without stopping the entire program. This is critically important for debugging concurrent code, which is ubiquitous in Go.
On-the-Fly Profiling: Basic `pprof` tools are built directly into the IDE. You can start CPU or memory profiling without leaving the editor and immediately see "bottlenecks" in the form of a flame graph.
Smart Refactorings: In addition to standard renames, the IDE can automatically extract common code fragments into functions, generate methods for structs, and even suggest replacing loops with more idiomatic Go constructs (e.g., `for range`).
Deep Integration with Modules (Go Modules): The environment automatically pulls in dependencies, highlights outdated package versions, and offers quick fixes for version incompatibilities.

First Impressions: What We Liked

On a medium-sized test project (a microservice in Go using gRPC and PostgreSQL), the IDE performed stably. We were especially pleased with the refactoring functionality: the "Extract Interface" feature worked perfectly, generating all the necessary methods and preserving the package structure. The built-in terminal also deserves praise — it is so tightly integrated that commands like `go test -race` display results directly as a test tree, rather than just as text.

Special mention should be made of template support. For beginners in Go, there are ready-made project templates (REST API, CLI utility, web server) that are created with one click and already contain the correct folder structure and `go.mod` files.

What Still Raises Questions

Like any new tool, the IDE has its drawbacks. At the time of the first release, there are issues with memory consumption — on large monorepos, the environment can be sluggish. Also, support for popular Go plugins, such as `golangci-lint`, is currently missing — it has to be run manually. The developers promise to fix this in upcoming updates.