Here's are some methods on changing colors for the UI in Vim.



## Color one-offs in .vimrc

Most of the colors you have will probably come from a theme. I've been using [Dracula](https://draculatheme.com/vim) lately, and it's great.

But if you want to make one-off color adjustments yourself, you can stick those in your `.vimrc` file.

## Highlight command

The `highlight` command, or `hi` for short, is the key to setting colors on things. You set highlights on groups, by `group-name`.

In `.vimrc`, you'd start with something like:

```
hi LineNr 
```

Where `LineNr` is the group name to target. But the command is incomplete.  There are no colors set yet. Let's set some foreground (fg) and background (bg) colors.

## Color codes depend on Terminal or App

You can run vim in a few different ways. The most basic categories are to run vim through your terminal app (eg, zsh from iTerm) or through a standalone app (eg, macvim). You have to set colors for both.

```
hi LineNr ctermfg= ctermbg= guifg= guibg=
```

Usually you make cterm (for terminal) match gui (for standalone app) so that the colors are the same no matter how you run. But when you define the colors, the coding for each is different. What a pain!

Terminal colors are specified in a 256 ANSI color scheme. GUI colors are specified in my modern hex colors.

To finally finish the `LineNr` coloring, let's do a:

```
hi LineNr ctermfg=59 ctermbg=222 guifg=#ffb86c guibg=#282a36
```

There are other options you can learn in the help file via `:h hi`.

## Reload using latest .vimrc

After you save, you can see the colors applied in the current editor without restarting vim, using:

```
:source ~/.vimrc
```

## See current colors and things to color

If you want to learn the other color group names or see all the current color scheme, you can use the command:

```
:hi
```

The great thing is that the group-names that are standard to vim *and* those that your plugins add are all available to see here. 

How else do you like to set colors in vim?

Set Colors in Vim

Macros are sequences of commands in Vim that can be recorded to build up more complex tasks and then run them again.



## Record a vim macro

This will put you in a mode where you'll be recording your commands as they run until later, when you say to stop recording.

`q` - start the recording.

`a-z` - store the macro in a register (ie, any letter a to z) for later recall.

## Add commands to macro

Then you start typing commands in a way that's repeatable.  These can be any normal commands! They might include:

`0` - start at the beginning of the line.

`fX` - move next instance of a certain character (eg, "X").

`r'` - replace some character with another (eg, "'").

`bp` - paste from a register (eg, "b").

`j` - go the next line.

`q` - stop the recording.

## Run a vim macro

After you've recorded a macro, you can use it as long as it stays recorded. (Be careful not to overwrite any you want to keep.)

`0-9` - (optional) the number of times you want to run the macro.

`@` - indicate you're going to run the macro.

`a-z` - the register in which you previously stored your macro.

## Run the last macro again

`@@` - whichever was run last will be run again

Convenient, eh!

## See what macros are in your registers

If you ever forget what you have recorded, you can list them.  The hard part is reading what you've recorded. :)

`:reg` - list contents of all registers

Any other tips on running macros in vim?

Record Vim Macros

Vim has a lot of great text editing features built in. But if you want to do anything else to customize it -- and you probably do -- you'll want some Vim plugins, of which there are many. What you may not want is a plugin manager. Neither do I. Here's how to take care of your plugins without a plugin manager.



## Vim Version 8+

You used to need a version manager. But if you have a vim of version 8 or later, you don't. There are additional capabilities baked in. Check your version. This is required for the rest to work.

To check your version, open vim and type `:version`.

## A Place for Plugins

There are many plugins to be found. Find one that suits some need you have.

Once you have a plugin in mind, you just need put it in a specific place.

A place like `~/.vim/pack/bundle/start` will work. What is special and specific about this path?

- `.vim/` is where you put all vim-related stuff
- `pack/` means packages
- `bundle/` the name of our package -- we can call this whatever we want (eg, `my-plugins`)
- `start/` loaded on vim startup

## Get the Plugin Code

Find your plugin online, probably on Github somewhere, and copy the git clone url. If I was going to install `vim-javascript`, I'd find the url: `https://github.com/pangloss/vim-javascript`.

If you're like me, you put your [dotfiles](https://github.com/jaketrent/dotfiles) in a git repo. Within my dotfiles clone, the vim subdirectory looks like:

```text
.
...
├── vim
│   └── pack
│       └── my-plugins
│           └── start
```

Now you want to record the fact that your vim config uses a plugin but keep that plugin source code elsewhere -- in its original repo. This is a great use case for [git submodules](https://git-scm.com/book/en/v2/Git-Tools-Submodules).

To make the connection in git, we type:

```bash
cd ~/dev/dotfiles
git submodule init
cd ~/dev/dotfiles/vim/pack/my-plugins/start
git submodule add https://github.com/pangloss/vim-javascript
git add .
git commit -m "add vim plugin for javascript"
```

Of course, please make adjustments for your own dotfiles repo paths. Also note that `git submodule init` only needs run once ever. Future plugins will only need the `git submodule add` command to be included.

## On Next Clone

Now you're set for your current install of vim. But what about that next wipe of your harddrive and a reinstall? To get all this back up and running, you'll need to clone your dotfiles:

```bash
git clone --recurse-submodules -j8 git@github.com:jaketrent/dotfiles.git
```

Note the special flag `--recurse-submodules`. If you forget this, you won't get that plugin code, and vim won't be responding to your plugins, because that code won't be downloaded.

Now vim is ready to be loaded with plugins and you don't need special plugin managers Pathogen, Vundle, or the others to do it.

Manage plugins in vim without a plugin manager.  Just use git.