Need help with WSL-config?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

158 Stars 20 Forks 7 Commits 1 Opened issues


CS 4400 - Step by step guide for using WSL and Vim as a development environment

Services available


Need anything else?

Contributors list

# 288,089
5 commits

WSL as a Development Environment

This is guide is intended for CS 4400 students at the UofU

The following is a series of steps for setting up a fresh installation of Windows Subsystem for Linux as a development environment for Python, Python 3, Node, Ruby, C, C++, Objective-C, Objective-C++, Javascript etc.

The bread and butter of this step are Zsh and Vim respectively. In fact the real power of development comes from versatility of vim in conjunction with other tools such as tmux and different plugins. The purpose of this tutorial is to help you utilize Vim as an IDE.

For the Zsh setup, I will be using oh-my-zsh and antigen as my bundle manager.

We will be removing the default Vim package and compile our own from source to harness the power of plugins such as YouCompleteMe and Command-T.

This guide assumes that you have just completed a fresh installation of WSL and continues where the linked guide left off.

This repository provides starting

config files. Everything is commented for clarity. Please research each plugin to see its functionality and use.

First thing first make sure you have

on your WSL install and clone this repository in your
git clone

Rename the folder to make it hidden:

mv ./WSL-config ./.wslconfig 

Now update and upgrade everything to make sure all of our installed packages are up-to-date.

sudo apt-get update
sudo apt-get upgrade

Console Info:

By the end of Zsh Installation section your terminal should look like this:

enter image description here

In this screenshot I'm using cmder with wsltty using

color scheme.

If you decide to use the same console setup, you can copy

folder to
to have access to the themes. I have also included my
config file if you decide to use it.

For correct encoding of special characters, you need to install patched fonts for Powerline. Make sure to install these fonts as you would normally on Windows. Even though

is provided there is no point in running this script as the GUI is provided through the Windows OS.

Zsh Installation:

By the end of this section we will have installed zsh, oh-my-zsh and antigen as well as creating a symbolic link for our

file. Install Zsh first:
sudo apt-get install zsh

Installing oh-my-zsh:

oh-my-zsh is an open source, community-driven framework for managing your Zsh configuration. Let's install oh-my-zsh using

sh -c "$(curl -fsSL"

Installing antigen:

antigen is a small set of functions that help you easily manage your Zsh plugins, called bundles. The concept is pretty much the same as bundles in a typical vim setup. Antigen is to zsh, what Vundle is to vim.

Let's install antigen using

curl -L > antigen.zsh
mv antigen.zsh ./.antigen/

Create Symbolic .zshrc:

If you want to use the provided

file in the repository create a symbolic link in your
ln -s ~/.wslconfig/.zshrc  ~/.zshrc

Make sure to read up on the installed bundles for Zsh in this

file. There are some interesting features e.g fuzzy command history mapped to

Set Zsh as Default Shell:

In order to set Zsh as our default shell add the following snippet to you

file located in
# Launch Zsh
if [ -t 1 ]; then
exec zsh

Finally restart your terminal and wait for antigen to install all plugins.

Vim Installation:

By the end of this section we will have compiled and installed Vim from source, installed all of our development dependencies, as well as our Vim plugins. enter image description here

Installing Build Essentials & Cmake:

The build-essentials is a reference for all the packages needed to compile a debian package. It generally includes the

compilers an libraries and some other utils.

CMake is an extensible, open-source system that manages the build process in an operating system and in a compiler-independent manner.

sudo apt-get install build-essential cmake

Installing Python & Python 3:

Python is a widely used high-level programming language for general-purpose programming.

sudo apt-get install python-dev python3-dev

Installing Node, NPM & Typescript:

Node.js is a JavaScript runtime built on Chrome's V8 JavaScript engine. Node.js uses an event-driven, non-blocking I/O model that makes it lightweight and efficient. Node.js' package ecosystem, npm, is the largest ecosystem of open source libraries in the world.

curl -sL | sudo -E bash -
sudo apt-get install -y nodejs

TypeScript is a free and open-source programming language developed and maintained by Microsoft. It is a strict superset of JavaScript, and adds optional static typing and class-based object-oriented programming to the language.

npm install -g typescript

Remove Vim:

Remove Vim from your WSL setup:

sudo apt-get remove vim vim-runtime gvim

Just to be safe remove these packages as well:

sudo apt-get remove vim-tiny vim-common vim-gui-common vim-nox

Installing Dependencies for Vim & Ruby:

Compiling Vim from source is actually not that difficult. Install all the prerequisite libraries:

sudo apt-get install libncurses5-dev libgnome2-dev libgnomeui-dev libgtk2.0-dev libatk1.0-dev libbonoboui2-dev libcairo2-dev libx11-dev libxpm-dev libxt-dev ruby-dev lua5.1 liblua5.1-dev libperl-dev openssl libreadline6 libreadline6-dev curl git-core zlib1g zlib1g-dev libssl-dev libyaml-dev libsqlite3-dev sqlite3 libxml2-dev libxslt-dev autoconf libc6-dev ncurses-dev automake libtool bison subversion

Installing RVM and Ruby:

Ruby is a dynamic, open source programming language with a focus on simplicity and productivity. It is required for the


You can check if you have Ruby installed by doing

ruby -v
rvm -v
. If you get a message saying The program 'ruby' can be found in the following packages, you need to install Ruby and rvm.
curl -L | bash -s stable --ruby
rvm reinstall VERSION -C --enable-shared

Set .bashrc for rvm scripting:

source "$HOME/.rvm/scripts/rvm"

Installing Clang:

Clang is an open-source compiler that can compile C/C++/Objective-C/Objective-C++. The

library it provides is used to power the YCM semantic completion engine for those languages.
sudo apt-add-repository "deb llvm-toolchain-xenial-VERSION  main"
sudo apt-get update
sudo apt-get install clang-VERSION  lldb-VERSION 

Installing Checkinstall:

checkinstall is a simple program which monitors the installation of files, and creates a Debian package from them. There are two primary benefits to using checkinstall instead of running make install: You can easily remove the package with one step. You can install the resulting package upon multiple machines.

If you want to be able to easily uninstall vim use

sudo apt-get install checkinstall

Compiling Vim:

Once everything is installed, getting the source is easy. Note: If you are using Python, your config directory might have a machine-specific name (e.g. config-3.5m-x86_64-linux-gnu). Check in

to find yours, and change the
arguments accordingly.
cd ~
git clone
cd vim
./configure --with-features=huge \
            --enable-multibyte \
            --enable-rubyinterp=yes \
            --enable-pythoninterp=yes \
            --with-python-config-dir=/usr/lib/python2.7/config-x86_64-linux-gnu \
            --enable-perlinterp=yes \
            --enable-luainterp=yes \
            --enable-gui=gtk2 --enable-cscope --prefix=/usr

Make Vim

make VIMRUNTIMEDIR=/usr/share/vim/vim80

And install:

cd ~/vim
sudo checkinstall

Setup Vundle:

Vundle is a plugin manager for Vim. Clone the repository into the appropriate

bundle folder.
git clone ~/.vim/bundle/Vundle.vim

Vanilla .vimrc:

Put this at the top of your

to use Vundle. Remove plugins you don't need, they are for illustration purposes.
set nocompatible              " be iMproved, required
filetype off                  " required

" set the runtime path to include Vundle and initialize set rtp+=~/.vim/bundle/Vundle.vim call vundle#begin()

" let Vundle manage Vundle, required Plugin 'VundleVim/Vundle.vim'

" The following are examples of different formats supported. " Keep Plugin commands between vundle#begin/end. " plugin on GitHub repo " Plugin 'tpope/vim-fugitive' " plugin from " Plugin 'L9' " Git plugin not hosted on GitHub " Plugin 'git://' " git repos on your local machine (i.e. when working on your own plugin) " Plugin 'file:///home/gmarik/path/to/plugin' " The sparkup vim script is in a subdirectory of this repo called vim. " Pass the path to set the runtimepath properly. " Plugin 'rstacruz/sparkup', {'rtp': 'vim/'} " Install L9 and avoid a Naming conflict if you've already installed a " different version somewhere else. " Plugin 'ascenator/L9', {'name': 'newL9'}

" All of your Plugins must be added before the following line call vundle#end() " required filetype plugin indent on " required " To ignore plugin indent changes, instead use: "filetype plugin on " " Brief help " :PluginList - lists configured plugins " :PluginInstall - installs plugins; append ! to update or just :PluginUpdate " :PluginSearch foo - searches for foo; append ! to refresh local cache " :PluginClean - confirms removal of unused plugins; append ! to auto-approve removal " " see :h vundle for more details or wiki for FAQ " Put your non-Plugin stuff after this line

Launch Vim and run

To install from command line:
vim +PluginInstall +qall

Installing YouCompleteMe:

YouCompleteMe is a fast, as-you-type, fuzzy-search code completion engine for Vim. It has several completion engines:

  • an identifier-based engine that works with every programming language,
  • a Clang-based engine that provides native semantic code completion for C/C++/Objective-C/Objective-C++ (from now on referred to as "the C-family languages"),
  • a Jedi-based completion engine for Python 2 and 3 (using the JediHTTP wrapper),
  • an OmniSharp-based completion engine for C#,
  • a combination of Gocode and Godef semantic engines for Go,
  • a TSServer-based completion engine for TypeScript,
  • a Tern-based completion engine for JavaScript,
  • a racer-based completion engine for Rust,
  • and an omnifunc-based completer that uses data from Vim's omnicomplete system to provide semantic completions for many other languages (Ruby, PHP etc.).

Add the following line to your

Plugin 'Valloric/YouCompleteMe'

Launch Vim and run

To install from command line:
vim +PluginInstall +qall
is the quickest way to install YouCompleteMe.
  • C# support: install Mono and add
    when calling
  • Go support: install Go and add
    when calling
  • TypeScript support: install Node.js and npm then install the TypeScript SDK with
    npm install -g typescript
  • JavaScript support: install Node.js and npm and add
    when calling
  • Rust support: install Rust and add
    when calling

Finally configure YCM:

cd ~/.vim/bundle/YouCompleteMe 
./ --clang-completer --tern-completer

Installing Command-T:

Command-T is a Vim plug-in that provides an extremely fast "fuzzy" mechanism for: Opening files and buffers, Jumping to tags and help Running commands, or previous searches and commands with a minimal number of keystrokes.

Add the following line to your

Plugin 'wincent/command-t'

Launch Vim and run

To install from command line:
vim +PluginInstall +qall

Navigate to your Command-T bundle directory

cd ~/.vim/bundle/command-t

Now that you are in your Command-T bundle directory. Do the following:

rake make

That should recompile Command-T.

Easy Debugging with Conque GDB:

Conque GDB turns Vim buffers into terminal emulators, which enables you to run CLI programs from inside Vim windows.

Although you can run any CLI program with Conque GDB. The main reason for this plugin is to offer a nice and complete GDB command line interface inside of Vim. See demonstration video.

Add the following line to your

Plugin 'vim-scripts/Conque-GDB'

Launch Vim and run

To install from command line:
vim +PluginInstall +qall

Check the documentation for Conque GDB to see how you can easily toggle breakpoints and debug you apps with Vim's text editor.

Installing Vim Plugins:

Every time you add a plugin(s) to your

file you need to install the plugins(s) (duh). Launch Vim and run
To install from command line:
vim +PluginInstall +qall

Setting Vim as Default Editor:

Set Vim as your default editor with

sudo update-alternatives --install /usr/bin/editor editor /usr/bin/vim 1
sudo update-alternatives --set editor /usr/bin/vim
sudo update-alternatives --install /usr/bin/vi vi /usr/bin/vim 1
sudo update-alternatives --set vi /usr/bin/vim

Create Symbolic .vimrc:

If you want to use the provided

file in the repository create a symbolic link in your
ln -s ~/.wslconfig/.vimrc ~/.vimrc

Launch Vim and run

To install from command line:
vim +PluginInstall +qall

Make sure to read up on the installed bundles for Vim in this



Below is a list of original resources used to compile the steps above.

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.