diff --git a/autoload/vundle.vim b/autoload/vundle.vim
index 6a3df33..f186236 100644
--- a/autoload/vundle.vim
+++ b/autoload/vundle.vim
@@ -21,7 +21,7 @@ com! -nargs=? -bang   PluginClean
 \ call vundle#installer#clean('!' == '<bang>')
 
 com! -nargs=0         PluginDocs
-\ call vundle#installer#helptags(g:bundles)
+\ call vundle#installer#helptags(g:vundle#bundles)
 
 " Aliases
 com! -nargs=* -complete=custom,vundle#scripts#complete PluginUpdate PluginInstall! <args>
@@ -61,22 +61,22 @@ endif
 " :Plugin command in the vimrc.  It is not possible to do this automatically
 " because when loading the vimrc file no plugins where loaded yet.
 func! vundle#rc(...) abort
-  let g:bundle_dir = len(a:000) > 0 ? expand(a:1, 1) : expand('$HOME/.vim/bundle', 1)
-  let g:updated_bundles = []
-  let g:vundle_log = []
+  let g:vundle#bundle_dir = len(a:000) > 0 ? expand(a:1, 1) : expand('$HOME/.vim/bundle', 1)
+  let g:vundle#updated_bundles = []
+  let g:vundle#log = []
   call vundle#config#init()
 endf
 
 " Alternative to vundle#rc, offers speed up by modifying rtp only when end()
 " called later.
 func! vundle#begin(...) abort
-  let g:vundle_lazy_load = 1
+  let g:vundle#lazy_load = 1
   call call('vundle#rc', a:000)
 endf
 
 " Finishes putting plugins on the rtp.
 func! vundle#end(...) abort
-  unlet g:vundle_lazy_load
+  unlet g:vundle#lazy_load
   call vundle#config#activate_bundles()
 endf
 
diff --git a/autoload/vundle/config.vim b/autoload/vundle/config.vim
index a17eeb1..8467b9f 100644
--- a/autoload/vundle/config.vim
+++ b/autoload/vundle/config.vim
@@ -10,11 +10,11 @@ func! vundle#config#bundle(arg, ...)
   if !s:check_bundle_name(bundle)
     return
   endif
-  if exists('g:vundle_lazy_load') && g:vundle_lazy_load
-    call add(g:bundles, bundle)
+  if exists('g:vundle#lazy_load') && g:vundle#lazy_load
+    call add(g:vundle#bundles, bundle)
   else
     call s:rtp_rm_a()
-    call add(g:bundles, bundle)
+    call add(g:vundle#bundles, bundle)
     call s:rtp_add_a()
     call s:rtp_add_defaults()
   endif
@@ -40,9 +40,9 @@ endf
 " once.
 " ---------------------------------------------------------------------------
 func! vundle#config#init()
-  if !exists('g:bundles') | let g:bundles = [] | endif
+  if !exists('g:vundle#bundles') | let g:vundle#bundles = [] | endif
   call s:rtp_rm_a()
-  let g:bundles = []
+  let g:vundle#bundles = []
   let s:bundle_names = {}
 endf
 
@@ -55,11 +55,11 @@ endf
 func! vundle#config#require(bundles) abort
   for b in a:bundles
     call s:rtp_add(b.rtpath)
-    call s:rtp_add(g:bundle_dir)
+    call s:rtp_add(g:vundle#bundle_dir)
     " TODO: it has to be relative rtpath, not bundle.name
     exec 'runtime! '.b.name.'/plugin/*.vim'
     exec 'runtime! '.b.name.'/after/*.vim'
-    call s:rtp_rm(g:bundle_dir)
+    call s:rtp_rm(g:vundle#bundle_dir)
   endfor
   call s:rtp_add_defaults()
 endf
@@ -180,7 +180,7 @@ endf
 " runtimepath.
 " ---------------------------------------------------------------------------
 func! s:rtp_rm_a()
-  let paths = map(copy(g:bundles), 'v:val.rtpath')
+  let paths = map(copy(g:vundle#bundles), 'v:val.rtpath')
   let prepends = join(paths, ',')
   let appends = join(paths, '/after,').'/after'
   exec 'set rtp-='.fnameescape(prepends)
@@ -193,7 +193,7 @@ endf
 " runtimepath.
 " ---------------------------------------------------------------------------
 func! s:rtp_add_a()
-  let paths = map(copy(g:bundles), 'v:val.rtpath')
+  let paths = map(copy(g:vundle#bundles), 'v:val.rtpath')
   let prepends = join(paths, ',')
   let appends = join(paths, '/after,').'/after'
   exec 'set rtp^='.fnameescape(prepends)
@@ -262,7 +262,7 @@ let s:bundle = {}
 " return -- the target location to clone this bundle to
 " ---------------------------------------------------------------------------
 func! s:bundle.path()
-  return s:expand_path(g:bundle_dir.'/'.self.name)
+  return s:expand_path(g:vundle#bundle_dir.'/'.self.name)
 endf
 
 
diff --git a/autoload/vundle/installer.vim b/autoload/vundle/installer.vim
index ffc44ba..472271a 100644
--- a/autoload/vundle/installer.vim
+++ b/autoload/vundle/installer.vim
@@ -1,6 +1,7 @@
 " ---------------------------------------------------------------------------
-" Try to clone all new bundles given (or all bundles in g:bundles by default)
-" to g:bundle_dir.  If a:bang is 1 it will also update all plugins (git pull).
+" Try to clone all new bundles given (or all bundles in g:vundle#bundles by
+" default) to g:vundle#bundle_dir.  If a:bang is 1 it will also update all
+" plugins (git pull).
 "
 " bang   -- 1 or 0
 " ...    -- any number of bundle specifications (separate arguments)
@@ -8,10 +9,10 @@
 func! vundle#installer#new(bang, ...) abort
   " No specific plugins are specified. Operate on all plugins.
   if a:0 == 0
-    let bundles = g:bundles
+    let bundles = g:vundle#bundles
   " Specific plugins are specified for update. Update them.
   elseif (a:bang)
-    let bundles = filter(copy(g:bundles), 'index(a:000, v:val.name) > -1')
+    let bundles = filter(copy(g:vundle#bundles), 'index(a:000, v:val.name) > -1')
   " Specific plugins are specified for installation. Install them.
   else
     let bundles = map(copy(a:000), 'vundle#config#bundle(v:val, {})')
@@ -23,7 +24,7 @@ func! vundle#installer#new(bang, ...) abort
   endif
 
   let names = vundle#scripts#bundle_names(map(copy(bundles), 'v:val.name_spec'))
-  call vundle#scripts#view('Installer',['" Installing plugins to '.expand(g:bundle_dir, 1)], names +  ['Helptags'])
+  call vundle#scripts#view('Installer',['" Installing plugins to '.expand(g:vundle#bundle_dir, 1)], names +  ['Helptags'])
 
   " This calls 'add' as a normal mode command. This is a buffer local mapping
   " defined in vundle#scripts#view(). The mapping will call a buffer local
@@ -163,10 +164,10 @@ endf
 " return -- the return value from s:sync()
 " ---------------------------------------------------------------------------
 func! vundle#installer#install(bang, name) abort
-  if !isdirectory(g:bundle_dir) | call mkdir(g:bundle_dir, 'p') | endif
+  if !isdirectory(g:vundle#bundle_dir) | call mkdir(g:vundle#bundle_dir, 'p') | endif
 
   let n = substitute(a:name,"['".'"]\+','','g')
-  let matched = filter(copy(g:bundles), 'v:val.name_spec == n')
+  let matched = filter(copy(g:vundle#bundles), 'v:val.name_spec == n')
 
   if len(matched) > 0
     let b = matched[0]
@@ -179,12 +180,12 @@ endf
 
 
 " ---------------------------------------------------------------------------
-" Call :helptags for all bundles in g:bundles.
+" Call :helptags for all bundles in g:vundle#bundles.
 "
 " return -- 'error' if an error occurred, else return 'helptags'
 " ---------------------------------------------------------------------------
 func! vundle#installer#docs() abort
-  let error_count = vundle#installer#helptags(g:bundles)
+  let error_count = vundle#installer#helptags(g:vundle#bundles)
   if error_count > 0
       return 'error'
   endif
@@ -222,10 +223,10 @@ endf
 " bang   -- not used
 " ---------------------------------------------------------------------------
 func! vundle#installer#list(bang) abort
-  let bundles = vundle#scripts#bundle_names(map(copy(g:bundles), 'v:val.name_spec'))
+  let bundles = vundle#scripts#bundle_names(map(copy(g:vundle#bundles), 'v:val.name_spec'))
   call vundle#scripts#view('list', ['" My Plugins'], bundles)
   redraw
-  echo len(g:bundles).' plugins configured'
+  echo len(g:vundle#bundles).' plugins configured'
 endf
 
 
@@ -237,10 +238,10 @@ endf
 "           should be removed unconditionally
 " ---------------------------------------------------------------------------
 func! vundle#installer#clean(bang) abort
-  let bundle_dirs = map(copy(g:bundles), 'v:val.path()')
+  let bundle_dirs = map(copy(g:vundle#bundles), 'v:val.path()')
   let all_dirs = (v:version > 702 || (v:version == 702 && has("patch51")))
-  \   ? split(globpath(g:bundle_dir, '*', 1), "\n")
-  \   : split(globpath(g:bundle_dir, '*'), "\n")
+  \   ? split(globpath(g:vundle#bundle_dir, '*', 1), "\n")
+  \   : split(globpath(g:vundle#bundle_dir, '*'), "\n")
   let x_dirs = filter(all_dirs, '0 > index(bundle_dirs, v:val)')
 
   if empty(x_dirs)
@@ -465,7 +466,7 @@ func! s:sync(bang, bundle) abort
     return 'todate'
   endif
 
-  call add(g:updated_bundles, [initial_sha, updated_sha, a:bundle])
+  call add(g:vundle#updated_bundles, [initial_sha, updated_sha, a:bundle])
   return 'updated'
 endf
 
@@ -527,7 +528,7 @@ func! s:log(str, ...) abort
   let lines = split(a:str, '\n', 1)
   let time = strftime(fmt)
   for line in lines
-      call add(g:vundle_log, '['. time .'] '. prefix . line)
+      call add(g:vundle#log, '['. time .'] '. prefix . line)
   endfor
   return a:str
 endf
diff --git a/autoload/vundle/scripts.vim b/autoload/vundle/scripts.vim
index 8f17632..5d56476 100644
--- a/autoload/vundle/scripts.vim
+++ b/autoload/vundle/scripts.vim
@@ -42,7 +42,7 @@ endf
 func! vundle#scripts#complete(a,c,d)
   if match(a:c, '\v^%(Plugin|Vundle)%(Install!|Update)') == 0
     " Only installed plugins if updating
-    return join(map(copy(g:bundles), 'v:val.name'), "\n")
+    return join(map(copy(g:vundle#bundles), 'v:val.name'), "\n")
   else
     " Or all known plugins otherwise
     return join(s:load_scripts(0),"\n")
@@ -61,7 +61,7 @@ func! s:view_log()
   if bufloaded(s:log_file)
     execute 'silent bdelete' s:log_file
   endif
-  call writefile(g:vundle_log, s:log_file)
+  call writefile(g:vundle#log, s:log_file)
   execute 'silent pedit ' . s:log_file
 
   wincmd P | wincmd H
@@ -74,7 +74,7 @@ endf
 " ---------------------------------------------------------------------------
 func! s:create_changelog() abort
   let changelog = ['Updated Plugins:']
-  for bundle_data in g:updated_bundles
+  for bundle_data in g:vundle#updated_bundles
     let initial_sha = bundle_data[0]
     let updated_sha = bundle_data[1]
     let bundle      = bundle_data[2]
@@ -258,7 +258,7 @@ endf
 "           specifications) of all plugins from vim-scripts.org
 " ---------------------------------------------------------------------------
 func! s:load_scripts(bang)
-  let f = expand(g:bundle_dir.'/.vundle/script-names.vim-scripts.org.json', 1)
+  let f = expand(g:vundle#bundle_dir.'/.vundle/script-names.vim-scripts.org.json', 1)
   if a:bang || !filereadable(f)
     if 0 != s:fetch_scripts(f)
       return []