I share your experience, but it should only be a matter of time until the vim LSP clients[1] mature.
One notable exception is Go with its [vim-go](https://github.com/fatih/vim-go) plugin, which feels very mature to me as someone new to the language.
[1]: https://langserver.org/
In I Still Use Vimfatih
vim-go
Vim Script2014–2020
fatih / vim-go
vim-go
Go development plugin for Vim
29Distinct people
35Mentions
0Explicit recommenders
16.2KGitHub stars
What to know before exploring
What it is
Go development plugin for Vim
GitHub
Where it is used
No documented product use was verified in the last source check.
What people are saying
No recommendation phrase was found in the indexed comments.
No classified warning is attached to this page. Read the discussions before treating silence as approval.
Also in these discussions
No other repository is repeatedly linked in the same discussions.
This week on Hacker News
Nov 7–Nov 14 UTC · Direct repository links and separately labeled related project stories. Indexed through 11/14/2026, 3:03:16 PM UTC.
No direct repository links were found in the indexed HN discussions over the past seven days. Older discussions are available below.
Mentions over time
HN mentions by year35 dated mentions
Observed mentions: 2014-03-29 18:43:02 UTC to 2020-11-12 21:30:50 UTC.
Counts come from the repository’s dated source evidence. Index cutoff: 2026-11-02 08:16:59 UTC.
View mention counts and date ranges
| Period | Start (UTC) | End (exclusive, UTC) | Mentions | Submissions | Comments |
|---|---|---|---|---|---|
| 2014 | 2014-01-01 00:00:00 UTC | 2015-01-01 00:00:00 UTC | 5 | 1 | 4 |
| 2015 | 2015-01-01 00:00:00 UTC | 2016-01-01 00:00:00 UTC | 11 | 4 | 7 |
| 2016 | 2016-01-01 00:00:00 UTC | 2017-01-01 00:00:00 UTC | 7 | 3 | 4 |
| 2017 | 2017-01-01 00:00:00 UTC | 2018-01-01 00:00:00 UTC | 4 | 1 | 3 |
| 2018 | 2018-01-01 00:00:00 UTC | 2019-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2019 | 2019-01-01 00:00:00 UTC | 2020-01-01 00:00:00 UTC | 2 | 0 | 2 |
| 2020 | 2020-01-01 00:00:00 UTC | 2021-01-01 00:00:00 UTC | 4 | 0 | 4 |
From the project README
An excerpt from the repository, fetched Nov 13, 2026.
Read the project’s introduction
vim-go
Features
This plugin adds Go language support for Vim, with the following main features:
Compile your package with :GoBuild, install it with :GoInstall or test it
with :GoTest. Run a single test with :GoTestFunc).
Quickly execute your current file(s) with :GoRun.
Improved syntax highlighting and folding.
Debug programs with integrated delve support with :GoDebugStart.
Completion and many other features support via gopls.
formatting on save keeps the cursor position and undo history.
Go to symbol/declaration with :GoDef.
Look up documentation with :GoDoc or :GoDocBrowser.
Easily import packages via :GoImport, remove them via :GoDrop.
Precise type-safe renaming of identifiers with :GoRename.
See which code is covered by tests with :GoCoverage.
Add or remove tags on struct fields with :GoAddTags and :GoRemoveTags.
Lint your code with :GoLint or :GoMetaLinter, run your code through :GoVet to catch static errors, or make sure errors are checked with :GoErrCheck.
Advanced source analysis utilizing gopls, such as :GoImplements, :GoCallees, and :GoReferrers.
... and many more! Please see doc/vim-go.txt for more information.
Integration with gopls.
The gopls instance can be shared with other Vim plugins.
Vim-go's use of gopls can be disabled and alternative tools can be used when desired.
Integration with Tagbar via gotags.
Integration with Ultisnips and other snippet engines.
Install
vim-go requires at least Vim 8.2.5072 or Neovim 0.4.0.
The latest stable release is the
recommended version to use. If you choose to use the master branch instead,
please do so with caution; it is a development branch.
vim-go follows the standard runtime path structure. Below are some helper lines
for popular package managers:
Vim 8 packages
git clone https://github.com/fatih/vim-go.git ~/.vim/pack/plugins/start/vim-go
Neovim packages
git clone https://github.com/fatih/vim-go.git ~/.local/share/nvim/site/pack/plugins/start/vim-go
Pathogen
git clone https://github.com/fatih/vim-go.git ~/.vim/bundle/vim-go
vim-plug
Plug 'fatih/vim-go', { 'do': ':GoUpdateBinaries' }
Vundle
Plugin 'fatih/vim-go'
You will also need to install all the necessary binaries. vim-go makes it easy
to install all of them by providing a command, :GoInstallBinaries, which will
go install all the required binaries.
Check out the Install section in the documentation for more
detailed instructions (:help go-install).
Usage
The full documentation can be found at doc/vim-go.txt. You can
display it from within Vim with :help vim-go.
Depending on your installation method, you may have to generate the plugin's
help tags
manually (e.g. :helptags ALL).
We also have a tutorial in the official vim-go wiki.
FAQ and troubleshooting
The FAQ and troubleshooting tips are in the documentation and can be quickly
accessed using :help go-troubleshooting. If you believe you've found a bug or
shortcoming in vim-go that is neither addressed by help nor in existing
issues, please open an issue with
clear reproduction steps. :GoReportGitHubIssue can be used pre-populate a lot
of the information needed when creating a new issue.
Contributing
All PRs are welcome. If you are planning to contribute a large patch or to
integrate a new tool, please create an issue first to get any upfront questions
or design decisions out of the way first.
You can run the tests locally by running make. It will lint the VimL for you,
lint the documentation, and run the tests against the minimum required version
of Vim, other versions of Vim that may be critical to support, and Neovim.
License
The BSD 3-Clause License - see LICENSE for more details
Read the full README on GitHubWhat Hacker News says
35 sourcesFor a big project GoLand is the way to go. For small or quick edits I like to use vim with the vim-go plugin[1].
[1]https://github.com/fatih/vim-go
In Ask HN: Best Go Integration with an Editor?To an extent, yes, but I would say that the Vim philosophy involves utilizing external tools much more than in Emacs. Vim packages like the one for Go (https://github.com/fatih/vim-go) feel better-integrated into Vim than the equivalents do into Emacs. This is mostly subjective, so I can see where you're coming from.
In Making Emacs Popular AgainCongrats on 1.0! Feedback:
- Most needed feature: project-level fuzzy file opener. Hotkeys open a textbox that let me type letters in, which brings up files which match (ideally applying a Must-Recently-Used algo). (See Ctrl+P for VIM) ((Bonus: The fuzzy finder considers non-project imported files as well.))
- Debugger integration. (My preference is Delve.)
- Syntax error highlighting.
- Consider using https://github.com/fatih/vim-go/ as a list of nice features to add to your short(long)-list of ideas.
LMK, if I can elaborate on anything. I'll be watching. Thanks for your hard work!
In Chime, a Go Editor for macOS – v1.0 Now AvailableIt completely changed the way I write Go. This is editor specific though.
I use Vim for programming Go and have a few custom scripts built on top of https://github.com/fatih/vim-go.
In Yaegi – Yet Another Go InterpreterThere's been a bit of a backlash against exceptions in new languages (and attempts to "ban" them in old) and I actually kind of get it, especially having been a C++ developer. You'll see stuff like the Google C++ standard saying "don't use exceptions" but then if you want to apply RAII (and you really do), you have a constructor and the only way to indicate an error is via exceptions.
Also, how about this wonderful syntax:
class OrangeSite
{
Someobject m_object;
public:
OrangeSite(Someobject o) : m_object(o) {
try {
// construct object
} catch (std::exception& e) {
// exceptions for anything in the body above
}
} catch (std::exception& e) {
// exception handler for anything that failed in the initializer lists
}
Read the rest
};
I mean, kill it with fire. That is the only way to catch exceptions that occur in initializer lists and yes you have multiple catches. C# et al haven't reinvented all the same mistakes, but still, there's still two ways to control flow: return values and exceptions.
What is really needed is the ability to do the same sort of filtering on error types. You could actually do it in golang with a type assertion, but it would require implementing a type that implements the error interface and type assertions. It's ugly.
Regarding your errors/exceptions, I've heard this before and I agree with it. There are error conditions, from which the program can and is expected to recover, and exception conditions, from which the program cannot recover. Out of memory is a perfect exception condition.
However, this semantic distinction is entirely lost - a lot of error conditions are reported as exceptions. In my above example you have absolutely no choice in the matter; having no error type, languages like Java/C# etc heavily encourage, even if they don't mean to, return by exception.
The golang and rust mapping for these concepts is panic and... panic! respectively. You can catch and recover from panics if need be in golang; in Rust panic handling is bounded by thread and if a panic occurs on the main thread, the runtime triggers an exit. As far as I'm aware, the only way to recover from a panic is like this:
fn unrecoverable_error() -> thread::Result<()> {
return panic::catch_unwind(|| {
panicking_function()
});
}
with panic="unwind" set in cargo.toml. If the thread::Result seems bizarre. it's because panic::catch_unwind basically spins up a thread to isolate that panic.
Thus panics in Rust really are for things that should absolutely crash the program there and then. Everything else is a result type and you can shove any type you like into the error field. Golang is a bit more forgiving in that panics can be caught, but the language still encourages the use of errors rather than panics.
At the end of the day, at some point there's going to need to be a translation between some of the internal errors and what the end user sees and this process is going to end up in some boilerplate, be it lots of classes implementing some exception superclass, type or interface, or a bunch of if statements to handle exceptions. I don't think this is avoidable and one line magic code makes me uneasy - I have some experience now managing developers who like magic and want to avoid, at all, costs, translating errors to have friendly user output.
Lastly, there are workaround to this sort of boilerplate. Here's a simplified snippet I use to write this stuff whenever I write go:
snippet errif "Call function then check error" w
${1:var}, err ${2::}= ${3:func}(${4:args})
if err != nil {
fmt.Println("$5 %v", err)
return err
}
$0
endsnippet
It's 2019, so, most editors support this kind of thing. I'm using vim, but VS Code supports it too if you feel the need for a whole browser rendering engine just to edit some text ;) the placeholders allow me to fill in the template. Every time I find myself writing boilerpolate code, I write one of these and automate the task as much as possible. vim-go has a bunch of them: https://github.com/fatih/vim-go/blob/master/gosnippets/UltiS... and I'm not sure how I've programmed all these years without this kind of thing. I have snippets for everything.
I think the closet Go equivalent of 'byebug' would be delve[0].
It's got more of a learning curve than a REPL, but very powerful. Editor plugins for Go also tend to have good convenience support for delve, making using it less painful. For example, vim-go[1].
[0]: https://github.com/derekparker/delve/blob/master/Documentati...
[1]: https://github.com/fatih/vim-go/blob/master/doc/vim-go.txt#L...
In Go 2, here we comeA tonne of them, all managed by pathogen. I actually have a chunk of my bashrc that automatically reinfects my vimdir. Below are the ones I can easily grab. I also have a tonne of homebrew over the years, and a love/hate relationship with Jedi, YouCompleteMe and friends.
https://github.com/noahfrederick/vim-skeleton vim-skeleton
https://github.com/majutsushi/tagbar tagbar
https://github.com/tmhedberg/SimpylFold SimpylFold
https://github.com/nvie/vim-flake8 vim-flake8
https://github.com/kien/ctrlp.vim.git ctrlp.vim
https://github.com/hashivim/vim-terraform.git vim-terraform
https://github.com/hashivim/vim-packer.git vim-packer
https://github.com/hashivim/vim-vagrant.git vim-vagrant
git://github.com/rodjek/vim-puppet.git vim-puppet
https://github.com/fatih/vim-go.git vim-go
git://github.com/chase/vim-ansible-yaml.git
https://github.com/vim
Read the rest
-airline/vim-airline vim-airline
https://github.com/vim-airline/vim-airline-themes vim-airline-themes
git://github.com/ekalinin/Dockerfile.vim.git Dockerfile.vim
For Go-users wanting a quick way to get a basic Vim setup with Fatih's awesome vim-go plugin [1], you might want to checkout https://github.com/samuell/devbox-golang (Just updated to Go 1.9).
It is a little different from some other vagrant boxes in that it uses Ansible for provisioning. This means you can reasonable easy re-use the ansible roles (perhaps with some minor modifications) elsewhere too, like locally, or on some cloud image.
[1] https://github.com/fatih/vim-go
In Vagrant 2.0All editors support go really well, that's because go has official tools that integrate with editors (guru, for example).
At the top of the read me is the feature list for the vscode-go:
https://github.com/Microsoft/vscode-go
This is the feature list for vim-go:
https://github.com/fatih/vim-go
looks a little longer, but if you notice they both use the same back end tools. I see that VSC has partial delve integration, but vim running inside tmux makes delve (and every other CLI tool) feel like it's already integrated. I don't use debugging that much with Go though.
In Visual Studio Code 1.9For the record both vim and emacs have excellent "ide like" experiences for golang with just a few minutes of effort.
https://github.com/fatih/vim-go
https://github.com/dominikh/go-mode.el
It's not at all the case these days, especially in languages outside of java, that an "ide" is the better experience.
In Gogland – Capable and Ergonomic Go IDEShowing the 15 most recent of 35 sources. Enable JavaScript to search and browse every indexed mention.