Vim Doge

(Do)cumentation (Ge)nerator for nearly 20 languages 📚 Generate proper code documentation with a single keypress. ⚡️🔥
Alternatives To Vim Doge
Project NameStarsDownloadsRepos Using ThisPackages Using ThisMost Recent CommitTotal ReleasesLatest ReleaseOpen IssuesLicenseLanguage
2 days ago293mitLua
Find, Filter, Preview, Pick. All lua, all the time.
2 days ago20mitTeX
VimTeX: A modern Vim and neovim filetype plugin for LaTeX files.
a month ago469mitJavaScript
Map your keys for web surfing, expand your browser with javascript and keyboard.
Vim Tmux Navigator4,519
7 days ago56mitVim Script
Seamless navigation between tmux panes and vim splits
Vim Unimpaired2,968
a year ago48Vim Script
unimpaired.vim: Pairs of handy bracket mappings
Nvim Autopairs2,478
3 days ago20mitLua
autopairs for neovim written by lua
Jupyter Vim Binding2,094
3 months ago47JavaScript
Jupyter meets Vim. Vimmer will fall in love.
Vim Table Mode1,967
a month ago27Vim Script
VIM Table Mode for instant table creation.
Vim Which Key1,874
3 months ago30mitVim Script
:tulip: Vim plugin that shows keybindings in popup
Git Messenger.vim1,161
a year ago12mitVim Script
Vim and Neovim plugin to reveal the commit messages under the cursor
Alternatives To Vim Doge
Select To Compare

Alternative Project Comparisons


tests status Minimum supported Vim version Minimum supported NeoVim version Latest version License

Any fool can write code that a computer can understand. Good programmers write code that humans can understand. -- Martin Fowler, 1999

We all love documentation because it makes our codebases easier to understand, yet no one has time to write it in a good and proper way.

Vim-doge is a (Do)cumentation (Ge)nerator which will generate a proper documentation skeleton based on certain expressions (mainly functions). Simply put your cursor on a function, press <Leader>d, jump quickly through TODO items using <Tab> and <S-Tab> to quickly add descriptions and go on coding!

Visit demo page button

Table of Contents

Supported languages and doc standards

Every language that has a documentation standard should be supported by vim-doge.

Is your favorite language not supported? Suggest a new language 🎉
Is your favorite doc standard not supported? Suggest a new doc standard 🎉

Language Doc standards
Python reST, Numpy, Google, Sphinx, Doxygen
PHP phpdoc
JavaScript (Vanilla, ES6, FlowJS, NodeJS, Svelte, Vue) JSDoc
TypeScript JSDoc
HTML (through inline <script> tags) JSDoc
Lua LDoc
Java JavaDoc
Groovy JavaDoc
C++ Doxygen
C Doxygen, KernelDoc
Bash Google
Rust RustDoc
R Roxygen2
Scala ScalaDoc

Getting started

Using plug:

  • Plug 'kkoomen/vim-doge', { 'do': { -> doge#install() } }

Using vim-pack:

  • git clone --recursive --depth 1 ~/.vim/pack/*/start/vim-doge
  • Open Vim and run :call doge#install()

Using Pathogen:

  • git clone --recursive --depth 1 ~/.vim/bundle/vim-doge
  • Open Vim and run :call doge#install()

Using Vundle:

  • Plugin 'kkoomen/vim-doge'
  • Open Vim and run :call doge#install()

Using packer.nvim:

use {
  run = ':call doge#install()'


Run :help doge to get the full help page.

Choosing a different doc standard

Vim-doge supports multiple doc standard and you can overwrite them per filetype in your vimrc. Is your favorite doc standard not supported? Suggest a new doc standard 🎉


let g:doge_doc_standard_python = 'numpy'

If you want to change the doc standard specifically for a buffer, then you can do:

" Inside
:let b:doge_doc_standard = 'numpy'

If you want to generate a docblock using a different doc standard just for a specific expression, then you can use the DogeGenerate command:

" Inside, cursor is at a function expression (cursor = `|`):
"   |def foo(p1, p2):
"       pass
:DogeGenerate numpy

Here is the full list of available doc standards per filetype:

⚠️ For C and C++, see C Family Doc Standard Examples.

Variable Default Supported
g:doge_doc_standard_python 'reST' 'reST', 'numpy', 'google', 'sphinx', 'doxygen'
g:doge_doc_standard_php 'phpdoc' 'phpdoc'
g:doge_doc_standard_javascript 'jsdoc' 'jsdoc'
g:doge_doc_standard_html 'jsdoc' 'jsdoc'
g:doge_doc_standard_lua 'ldoc' 'ldoc'
g:doge_doc_standard_java 'javadoc' 'javadoc'
g:doge_doc_standard_groovy 'javadoc' 'javadoc'
g:doge_doc_standard_ruby 'YARD' 'YARD'
g:doge_doc_standard_cpp 'doxygen_javadoc' 'doxygen_javadoc', 'doxygen_javadoc_no_asterisk', 'doxygen_javadoc_banner', 'doxygen_qt', 'doxygen_qt_no_asterisk', 'doxygen_cpp_comment_slash', 'doxygen_cpp_comment_exclamation', 'doxygen_cpp_comment_slash_banner'
g:doge_doc_standard_c 'doxygen_javadoc' 'kernel_doc', 'doxygen_javadoc', 'doxygen_javadoc_no_asterisk', 'doxygen_javadoc_banner', 'doxygen_qt', 'doxygen_qt_no_asterisk', 'doxygen_cpp_comment_slash', 'doxygen_cpp_comment_exclamation', 'doxygen_cpp_comment_slash_banner'
g:doge_doc_standard_sh 'google' 'google'
g:doge_doc_standard_rs 'rustdoc' 'rustdoc'
g:doge_doc_standard_cs 'xmldoc' 'xmldoc'
g:doge_doc_standard_r 'roxygen2' 'roxygen2'
g:doge_doc_standard_scala 'scaladoc' 'scaladoc'



Default: 1

Whether to enable built-in mappings. If you decide to disable this, then you can copy the mappings below and change them to your needs:

" Generate comment for current line.
nmap <silent> <Leader>d <Plug>(doge-generate)

" Interactive mode comment todo-jumping.
nmap <silent> <TAB> <Plug>(doge-comment-jump-forward)
nmap <silent> <S-TAB> <Plug>(doge-comment-jump-backward)
imap <silent> <TAB> <Plug>(doge-comment-jump-forward)
imap <silent> <S-TAB> <Plug>(doge-comment-jump-backward)
smap <silent> <TAB> <Plug>(doge-comment-jump-forward)
smap <silent> <S-TAB> <Plug>(doge-comment-jump-backward)


Default: '<Leader>d'

The mapping to trigger vim-doge. The mapping accepts a count, to select a specific doc standard, if more than one is defined.



  'javascript': [
  'html': ['svelte', 'vue'],
  'java': ['groovy'],

Set filetypes as an alias for other filetypes. The key should be the filetype that is defined in ftplugin/<filetype>.vim. The value must be a list of 1 or more filetypes that will be aliases.


let g:doge_filetype_aliases = {
\  'javascript': ['typescript']

If you use the above settings and you open myfile.ts then it will behave like you're opening a JavaScript filetype.


Default: 1

Mappings to jump forward/backward are applied as buffer mappings when interactive mode starts and removed when it ends.


Default: '<Tab>'

The mapping to jump forward to the next TODO item in a comment. Requires g:doge_comment_interactive to be enabled.


Default: '<S-Tab>'

The mapping to jump backward to the previous TODO item in a comment. Requires g:doge_comment_interactive to be enabled.


Default: 1

Jumps interactively through all TODO items in the generated comment.


Default: 1

Continue to cycle among placeholders when reaching the start or end.


Default: ['n', 'i', 's']

Defines the modes in which doge will jump forward and backward when interactive mode is active. For example: removing i would allow you to use <Tab> for autocompletion in insert mode.


:DogeGenerate {doc_standard}

Command to generate documentation. The {doc_standard} accepts a count or a string as argument, and it can complete the available doc standards for the current buffer.

The numeric value should point to an index key from the b:doge_supported_doc_standards variable.

The string value should point to a doc standard name listed in the b:doge_supported_doc_standards variable.

Language-specific configuration

Below is a list of language-specific configuration and their default values.


JavaScript settings automatically apply for all the default filetypes that are being aliased, see g:doge_filetype_aliases.

let g:doge_javascript_settings = {
\  'destructuring_props': 1,
\  'omit_redundant_param_types': 0,
  • destructuring_props: Whether to generate @param tags for the destructured properties in a function expression.

  • omit_redundant_param_types: Whether to omit the {type} part of parameters and return types when the type is known (i.e. typescript).


let g:doge_php_settings = {
\  'resolve_fqn': 1
  • resolve_fqn: Whether to resolve the FQN based on the use statements in the current buffer. The FQN will be resolved for type hints in parameters and the return type.


let g:doge_python_settings = {
\  'single_quotes': 0,
\  'omit_redundant_param_types': 1
  • single_quotes: Whether to use single quotes for the multiline comments delimiters.

  • omit_redundant_param_types: Whether to omit the {type} part of parameters and return types when the type is specified in the function itself.


let g:doge_doxygen_settings = {
\  'char': '@'
  • char: Character to use for docblock tags. Use '@' for @param or '\' for \param.

Headless mode

If you're running your vim commands inside a docker, CI or similar environments with commands such as vim +PlugInstall +qall > /dev/null then you probably want to use headless mode. This will not spawn any terminals or progress bars and will simply run any process by vim-doge in the background.

This feature can be enabled by passing in { 'headless': 1 } into the doge#install() like so: doge#install({ 'headless': 1 }).

Example using vim-plug:

Plug 'kkoomen/vim-doge', {'do': { -> doge#install({ 'headless': 1 }) }}


To open all the help pages, run :help doge.


Help or feedback is always appreciated. If you find any bugs, feel free to submit a bug report. If you think vim-doge can be improved, feel free to submit a feature request or a pull request if you have time to help out.

Read the Contribution Guidelines and Code of Conduct when doing contributions.

Tree sitter

If you want a new language to be supported but tree-sitter doesn't support it yet, then feel free to create a custom tree-sitter language parser for that language and then we'll integrate it into vim-doge.


Environment setup

Make sure you install Rust and Cargo and you're good to go.


Vim-doge uses a custom command-line interface called vim-doge-helper, all made in Rust, that is responsible for parsing code and generating docblocks. Go have a look at the helper directory if you want to contribute to the parsers.

Testing locally

If you want to run the tests locally, you should install vader at the same directory level that vim-doge is, so your structure should look like this (using vim-plug example):

├── vader.vim
└── vim-doge

After that, you can do the following:

  • cd /path/to/vim-doge
  • vim -u test/vimrc
  • Inside vim you can now run: Vader test/**/**/*.vader to run all tests

💡 If you're working on specific tests, you can run that specific test only: Vader test/filetypes/<filetype>/functions.<ext>.

For more information, see Contribution Guidelines.


I created vim-doge mainly because I couldn't find a plugin that could generate proper comments for a big collection of languages that I would use on a daily basis in a quick and easy way.

Rather than scraping off the internet to find all sorts of vim plugins for every language I was coding in, I was more or less looking for a single plugin that supports every language I was working in.

Another big motivation for me is that I've noticed people tend to skip the documentation part because writing just the skeleton of the comment takes already too much time and I am one of those people. Having the skeleton generated and an interactive mode to quickly add descriptions is a big time saver.

Supporting vim-doge

Do you enjoy using vim-doge? Give it a star on GitHub and submit your vote on

Alternative projects

Vim-doge generates docblocks, but perhaps you want to take it a step further and generate it into HTML. Dooku.nvim is another plugin that can suit these needs.


Vim-doge is licensed under the GPL-3.0 license.

Popular Vim Projects
Popular Mapping Projects
Popular Text Editors Categories
Related Searches

Get A Weekly Email With Trending Projects For These Categories
No Spam. Unsubscribe easily at any time.