0.12.0

0.11.2
Enhanced ranking algorithm
2025-08-11 02:02:01 -07:00 · 2016-04-16 14:45:16 +09:00 · 2016-04-16 14:37:16 +09:00 · 2016-04-16 14:33:38 +09:00 · 2016-04-15 12:57:38 +09:00 · 2016-04-15 09:15:12 +09:00
51 changed files with 4574 additions and 1528 deletions
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@@ -0,0 +1,29 @@
+<!-- Check all that apply [x] -->
+- Category
+    - [ ] fzf binary
+    - [ ] fzf-tmux script
+    - [ ] Key bindings
+    - [ ] Completion
+    - [ ] Vim
+    - [ ] Neovim
+    - [ ] Etc.
+- OS
+    - [ ] Linux
+    - [ ] Mac OS X
+    - [ ] Windows
+    - [ ] Etc.
+- Shell
+    - [ ] bash
+    - [ ] zsh
+    - [ ] fish
+
+<!--
+### Before submitting
+
+- Make sure that you have the latest version of fzf
+- If you use tmux, make sure $TERM is set to screen or screen-256color
+- For more Vim stuff, check out https://github.com/junegunn/fzf.vim
+
+Describe your problem or suggestion from here ...
+-->
+
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
 bin
-src/fzf/fzf_*
+src/fzf/fzf-*
+gopath
 pkg
 Gemfile.lock
 .DS_Store
--- a/.travis.yml
+++ b/.travis.yml
@@ -4,7 +4,7 @@ rvm:

 install:
 - sudo apt-get update
- sudo apt-get install -y libncurses-dev lib32ncurses5-dev
+- sudo apt-get install -y libncurses-dev lib32ncurses5-dev libgpm-dev
 - sudo add-apt-repository -y ppa:pi-rho/dev
 - sudo apt-add-repository -y ppa:fish-shell/release-2
 - sudo apt-get update
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,200 @@
 CHANGELOG
 =========

+0.12.0
+------
+
+- Enhanced ranking algorithm
+- Minor bug fixes
+
+0.11.4
+------
+
+- Added `--hscroll-off=COL` option (default: 10) (#513)
+- Some fixes in Vim plugin and shell extensions
+
+0.11.3
+------
+
+- Graceful exit on SIGTERM (#482)
+- `$SHELL` instead of `sh` for `execute` action and `$FZF_DEFAULT_COMMAND` (#481)
+- Changes in fuzzy completion API
+    - [`_fzf_compgen_{path,dir}`](https://github.com/junegunn/fzf/commit/9617647)
+    - [`_fzf_complete_COMMAND_post`](https://github.com/junegunn/fzf/commit/8206746)
+      for post-processing
+
+0.11.2
+------
+
+- `--tiebreak` now accepts comma-separated list of sort criteria
+    - Each criterion should appear only once in the list
+    - `index` is only allowed at the end of the list
+    - `index` is implicitly appended to the list when not specified
+    - Default is `length` (or equivalently `length,index`)
+- `begin` criterion will ignore leading whitespaces when calculating the index
+- Added `toggle-in` and `toggle-out` actions
+    - Switch direction depending on `--reverse`-ness
+    - `export FZF_DEFAULT_OPTS="--bind tab:toggle-out,shift-tab:toggle-in"`
+- Reduced the initial delay when `--tac` is not given
+    - fzf defers the initial rendering of the screen up to 100ms if the input
+      stream is ongoing to prevent unnecessary redraw during the initial
+      phase. However, 100ms delay is quite noticeable and might give the
+      impression that fzf is not snappy enough. This commit reduces the
+      maximum delay down to 20ms when `--tac` is not specified, in which case
+      the input list quickly fills the entire screen.
+
+0.11.1
+------
+
+- Added `--tabstop=SPACES` option
+
+0.11.0
+------
+
+- Added OR operator for extended-search mode
+- Added `--execute-multi` action
+- Fixed incorrect cursor position when unicode wide characters are used in
+  `--prompt`
+- Fixes and improvements in shell extensions
+
+0.10.9
+------
+
+- Extended-search mode is now enabled by default
+    - `--extended-exact` is deprecated and instead we have `--exact` for
+      orthogonally controlling "exactness" of search
+- Fixed not to display non-printable characters
+- Added `double-click` for `--bind` option
+- More robust handling of SIGWINCH
+
+0.10.8
+------
+
+- Fixed panic when trying to set colors after colors are disabled (#370)
+
+0.10.7
+------
+
+- Fixed unserialized interrupt handling during execute action which often
+  caused invalid memory access and crash
+- Changed `--tiebreak=length` (default) to use trimmed length when `--nth` is
+  used
+
+0.10.6
+------
+
+- Replaced `--header-file` with `--header` option
+- `--header` and `--header-lines` can be used together
+- Changed exit status
+    - 0: Okay
+    - 1: No match
+    - 2: Error
+    - 130: Interrupted
+- 64-bit linux binary is statically-linked with ncurses to avoid
+  compatibility issues.
+
+0.10.5
+------
+
+- `'`-prefix to unquote the term in `--extended-exact` mode
+- Backward scan when `--tiebreak=end` is set
+
+0.10.4
+------
+
+- Fixed to remove ANSI code from output when `--with-nth` is set
+
+0.10.3
+------
+
+- Fixed slow performance of `--with-nth` when used with `--delimiter`
+    - Regular expression engine of Golang as of now is very slow, so the fixed
+      version will treat the given delimiter pattern as a plain string instead
+      of a regular expression unless it contains special characters and is
+      a valid regular expression.
+    - Simpler regular expression for delimiter for better performance
+
+0.10.2
+------
+
+### Fixes and improvements
+
+- Improvement in perceived response time of queries
+    - Eager, efficient rune array conversion
+- Graceful exit when failed to initialize ncurses (invalid $TERM)
+- Improved ranking algorithm when `--nth` option is set
+- Changed the default command not to fail when there are files whose names
+  start with dash
+
+0.10.1
+------
+
+### New features
+
+- Added `--margin` option
+- Added options for sticky header
+    - `--header-file`
+    - `--header-lines`
+- Added `cancel` action which clears the input or closes the finder when the
+  input is already empty
+    - e.g. `export FZF_DEFAULT_OPTS="--bind esc:cancel"`
+- Added `delete-char/eof` action to differentiate `CTRL-D` and `DEL`
+
+### Minor improvements/fixes
+
+- Fixed to allow binding colon and comma keys
+- Fixed ANSI processor to handle color regions spanning multiple lines
+
+0.10.0
+------
+
+### New features
+
+- More actions for `--bind`
+    - `select-all`
+    - `deselect-all`
+    - `toggle-all`
+    - `ignore`
+- `execute(...)` action for running arbitrary command without leaving fzf
+    - `fzf --bind "ctrl-m:execute(less {})"`
+    - `fzf --bind "ctrl-t:execute(tmux new-window -d 'vim {}')"`
+    - If the command contains parentheses, use any of the follows alternative
+      notations to avoid parse errors
+        - `execute[...]`
+        - `execute~...~`
+        - `execute!...!`
+        - `execute@...@`
+        - `execute#...#`
+        - `execute$...$`
+        - `execute%...%`
+        - `execute^...^`
+        - `execute&...&`
+        - `execute*...*`
+        - `execute;...;`
+        - `execute/.../`
+        - `execute|...|`
+        - `execute:...`
+            - This is the special form that frees you from parse errors as it
+              does not expect the closing character
+            - The catch is that it should be the last one in the
+              comma-separated list
+- Added support for optional search history
+    - `--history HISTORY_FILE`
+        - When used, `CTRL-N` and `CTRL-P` are automatically remapped to
+          `next-history` and `previous-history`
+    - `--history-size MAX_ENTRIES` (default: 1000)
+- Cyclic scrolling can be enabled with `--cycle`
+- Fixed the bug where the spinner was not spinning on idle input stream
+    - e.g. `sleep 100 | fzf`
+
+### Minor improvements/fixes
+
+- Added synonyms for key names that can be specified for `--bind`,
+  `--toggle-sort`, and `--expect`
+- Fixed the color of multi-select marker on the current line
+- Fixed to allow `^pattern$` in extended-search mode
+
+
 0.9.13
 ------

--- a/2
+++ b/2
@@ -1,6 +1,6 @@
 The MIT License (MIT)

-Copyright (c) 2015 Junegunn Choi
+Copyright (c) 2016 Junegunn Choi

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-<img src="https://raw.githubusercontent.com/junegunn/i/master/fzf.png" height="170" alt="fzf - a command-line fuzzy finder"> [![travis-ci](https://travis-ci.org/junegunn/fzf.svg?branch=master)](https://travis-ci.org/junegunn/fzf) <a href="http://flattr.com/thing/3115381/junegunnfzf-on-GitHub" target="_blank"><img src="http://api.flattr.com/button/flattr-badge-large.png" alt="Flattr this" title="Flattr this" border="0" /></a>
+<img src="https://raw.githubusercontent.com/junegunn/i/master/fzf.png" height="170" alt="fzf - a command-line fuzzy finder"> [![travis-ci](https://travis-ci.org/junegunn/fzf.svg?branch=master)](https://travis-ci.org/junegunn/fzf)
 ===

 fzf is a general-purpose command-line fuzzy finder.
@@ -21,7 +21,7 @@ Pros
 Installation
 ------------

-fzf project consists of the followings:
+fzf project consists of the following:

 - `fzf` executable
 - `fzf-tmux` script for launching fzf in a tmux pane
@@ -50,10 +50,10 @@ git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
 On OS X, you can use [Homebrew](http://brew.sh/) to install fzf.

 ```sh
-brew reinstall --HEAD fzf
+brew install fzf

 # Install shell extensions
-/usr/local/Cellar/fzf/HEAD/install
+/usr/local/opt/fzf/install
 ```

 #### Install as Vim plugin
@@ -68,7 +68,7 @@ Or you can have [vim-plug](https://github.com/junegunn/vim-plug) manage fzf
 (recommended):

 ```vim
-Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': 'yes \| ./install' }
+Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' }
 ```

 #### Upgrading fzf
@@ -78,7 +78,7 @@ while. Please follow the instruction below depending on the installation
 method.

 - git: `cd ~/.fzf && git pull && ./install`
- brew: `brew reinstall --HEAD fzf`
+- brew: `brew update; brew reinstall fzf`
 - vim-plug: `:PlugUpdate fzf`

 Usage
@@ -108,24 +108,41 @@ vim $(fzf)
 - Mouse: scroll, click, double-click; shift-click and shift-scroll on
  multi-select mode

-#### Extended-search mode
+#### Search syntax

-With `-x` or `--extended` option, fzf will start in "extended-search mode".
+Unless otherwise specified, fzf starts in "extended-search mode" where you can
+type in multiple search terms delimited by spaces. e.g. `^music .mp3$ sbtrkt
+!rmx`

-In this mode, you can specify multiple patterns delimited by spaces,
-such as: `^music .mp3$ sbtrkt !rmx`
+| Token    | Match type           | Description                      |
+| -------- | -------------------- | -------------------------------- |
+| `sbtrkt` | fuzzy-match          | Items that match `sbtrkt`        |
+| `^music` | prefix-exact-match   | Items that start with `music`    |
+| `.mp3$`  | suffix-exact-match   | Items that end with `.mp3`       |
+| `'wild`  | exact-match (quoted) | Items that include `wild`        |
+| `!rmx`   | inverse-fuzzy-match  | Items that do not match `rmx`    |
+| `!'fire` | inverse-exact-match  | Items that do not include `fire` |

-| Token    | Description                      | Match type           |
-| -------- | -------------------------------- | -------------------- |
-| `^music` | Items that start with `music`    | prefix-exact-match   |
-| `.mp3$`  | Items that end with `.mp3`       | suffix-exact-match   |
-| `sbtrkt` | Items that match `sbtrkt`        | fuzzy-match          |
-| `!rmx`   | Items that do not match `rmx`    | inverse-fuzzy-match  |
-| `'wild`  | Items that include `wild`        | exact-match (quoted) |
-| `!'fire` | Items that do not include `fire` | inverse-exact-match  |
+If you don't prefer fuzzy matching and do not wish to "quote" every word,
+start fzf with `-e` or `--exact` option. Note that when  `--exact` is set,
+`'`-prefix "unquotes" the term.

-If you don't need fuzzy matching and do not wish to "quote" every word, start
-fzf with `-e` or `--extended-exact` option.
+A single bar character term acts as an OR operator. For example, the following
+query matches entries that start with `core` and end with either `go`, `rb`,
+or `py`.
+
+```
+^core go$ | rb$ | py$
+```
+
+#### Environment variables
+
+- `FZF_DEFAULT_COMMAND`
+    - Default command to use when input is tty
+    - e.g. `export FZF_DEFAULT_COMMAND='ag -g ""'`
+- `FZF_DEFAULT_OPTS`
+    - Default options
+    - e.g. `export FZF_DEFAULT_OPTS="--reverse --inline-info"`

 Examples
 --------
@@ -140,8 +157,9 @@ Key bindings for command line
 The install script will setup the following key bindings for bash, zsh, and
 fish.

- `CTRL-T` - Paste the selected file path(s) into the command line
- `CTRL-R` - Paste the selected command from history into the command line
+- `CTRL-T` - Paste the selected files and directories onto the command line
+    - Set `FZF_CTRL_T_COMMAND` to override the default command
+- `CTRL-R` - Paste the selected command from history onto the command line
    - Sort is disabled by default to respect chronological ordering
    - Press `CTRL-R` again to toggle sort
 - `ALT-C` - cd into the selected directory
@@ -241,11 +259,33 @@ export FZF_COMPLETION_TRIGGER='~~'

 # Options to fzf command
 export FZF_COMPLETION_OPTS='+c -x'
+
+# Use ag instead of the default find command for listing candidates.
+# - The first argument to the function is the base path to start traversal
+# - Note that ag only lists files not directories
+# - See the source code (completion.{bash,zsh}) for the details.
+_fzf_compgen_path() {
+  ag -g "" "$1"
+}
+```
+
+#### Supported commands
+
+On bash, fuzzy completion is enabled only for a predefined set of commands
+(`complete | grep _fzf` to see the list). But you can enable it for other
+commands as well like follows.
+
+```sh
+# There are also _fzf_path_completion and _fzf_dir_completion
+complete -F _fzf_file_completion -o default -o bashdefault doge
 ```

 Usage as Vim plugin
 -------------------

+This repository only enables basic integration with Vim. If you're looking for
+more, check out [fzf.vim](https://github.com/junegunn/fzf.vim) project.
+
 (Note: To use fzf in GVim, an external terminal emulator is required.)

 #### `:FZF[!]`
@@ -278,10 +318,8 @@ customization.

 #### `fzf#run([options])`

-For more advanced uses, you can call `fzf#run()` function which returns the list
-of the selected items.
-
-`fzf#run()` may take an options-dictionary:
+For more advanced uses, you can use `fzf#run()` function with the following
+options.

 | Option name                | Type          | Description                                                      |
 | -------------------------- | ------------- | ---------------------------------------------------------------- |
@@ -297,65 +335,7 @@ of the selected items.
 | `launcher`                 | string        | External terminal emulator to start fzf with (GVim only)         |
 | `launcher`                 | funcref       | Function for generating `launcher` string (GVim only)            |

-_However on Neovim `fzf#run` is asynchronous and does not return values so you
-should use `sink` or `sink*` to process the output from fzf._
-
-##### Examples
-
-If `sink` option is not given, `fzf#run` will simply return the list.
-
-```vim
-let items = fzf#run({ 'options': '-m +c', 'dir': '~', 'source': 'ls' })
-```
-
-But if `sink` is given as a string, the command will be executed for each
-selected item.
-
-```vim
-" Each selected item will be opened in a new tab
-let items = fzf#run({ 'sink': 'tabe', 'options': '-m +c', 'dir': '~', 'source': 'ls' })
-```
-
-We can also use a Vim list as the source as follows:
-
-```vim
-" Choose a color scheme with fzf
-nnoremap <silent> <Leader>C :call fzf#run({
-\   'source':
-\     map(split(globpath(&rtp, "colors/*.vim"), "\n"),
-\         "substitute(fnamemodify(v:val, ':t'), '\\..\\{-}$', '', '')"),
-\   'sink':     'colo',
-\   'options':  '+m',
-\   'left':     20,
-\   'launcher': 'xterm -geometry 20x30 -e bash -ic %s'
-\ })<CR>
-```
-
-`sink` option can be a function reference. The following example creates a
-handy mapping that selects an open buffer.
-
-```vim
-" List of buffers
-function! s:buflist()
-  redir => ls
-  silent ls
-  redir END
-  return split(ls, '\n')
-endfunction
-
-function! s:bufopen(e)
-  execute 'buffer' matchstr(a:e, '^[ 0-9]*')
-endfunction
-
-nnoremap <silent> <Leader><Enter> :call fzf#run({
-\   'source':  reverse(<sid>buflist()),
-\   'sink':    function('<sid>bufopen'),
-\   'options': '+m',
-\   'down':    len(<sid>buflist()) + 2
-\ })<CR>
-```
-
-More examples can be found on [the wiki
+Examples can be found on [the wiki
 page](https://github.com/junegunn/fzf/wiki/Examples-(vim)).

 Tips
@@ -363,7 +343,7 @@ Tips

 #### Rendering issues

-If you have any rendering issues, check the followings:
+If you have any rendering issues, check the following:

 1. Make sure `$TERM` is correctly set. fzf will use 256-color only if it
   contains `256` (e.g. `xterm-256color`)
@@ -383,13 +363,16 @@ filtering:

 ```sh
 # Feed the output of ag into fzf
-ag -l -g "" | fzf
+ag -g "" | fzf

 # Setting ag as the default source for fzf
-export FZF_DEFAULT_COMMAND='ag -l -g ""'
+export FZF_DEFAULT_COMMAND='ag -g ""'

 # Now fzf (w/o pipe) will use ag instead of find
 fzf
+
+# To apply the command to CTRL-T as well
+export FZF_CTRL_T_COMMAND="$FZF_DEFAULT_COMMAND"
 ```

 #### `git ls-tree` for fast traversal
@@ -400,7 +383,8 @@ speed of the traversal.
 ```sh
 export FZF_DEFAULT_COMMAND='
  (git ls-tree -r --name-only HEAD ||
-   find * -name ".*" -prune -o -type f -print -o -type l -print) 2> /dev/null'
+   find . -path "*/\.*" -prune -o -type f -print -o -type l -print |
+      sed s/^..//) 2> /dev/null'
 ```

 #### Fish shell
@@ -414,14 +398,6 @@ of fzf to a temporary file.
 fzf > $TMPDIR/fzf.result; and vim (cat $TMPDIR/fzf.result)
 ```

-#### Handling UTF-8 NFD paths on OSX
-
-Use iconv to convert NFD paths to NFC:
-
-```sh
-find . | iconv -f utf-8-mac -t utf8//ignore | fzf
-```
-
 License
 -------

--- a/bin/fzf-tmux
+++ b/bin/fzf-tmux
@@ -82,55 +82,77 @@ while [ $# -gt 0 ]; do
  shift
 done

-if [ -z "$TMUX_PANE" ]; then
+if [ -z "$TMUX" ]; then
  fzf "${args[@]}"
  exit $?
 fi

+# Handle zoomed tmux pane by moving it to a temp window
+if tmux list-panes -F '#F' | grep -q Z; then
+  zoomed=1
+  original_window=$(tmux display-message -p "#{window_id}")
+  tmp_window=$(tmux new-window -d -P -F "#{window_id}" "bash -c 'while :; do for c in \\| / - \\\\; do sleep 0.2; printf \"\\r\$c fzf-tmux is running\\r\"; done; done'")
+  tmux swap-pane -t $tmp_window \; select-window -t $tmp_window
+fi
+
 set -e

 # Clean up named pipes on exit
 id=$RANDOM
-argsf=/tmp/fzf-args-$id
-fifo1=/tmp/fzf-fifo1-$id
-fifo2=/tmp/fzf-fifo2-$id
-fifo3=/tmp/fzf-fifo3-$id
+argsf="${TMPDIR:-/tmp}/fzf-args-$id"
+fifo1="${TMPDIR:-/tmp}/fzf-fifo1-$id"
+fifo2="${TMPDIR:-/tmp}/fzf-fifo2-$id"
+fifo3="${TMPDIR:-/tmp}/fzf-fifo3-$id"
 cleanup() {
  rm -f $argsf $fifo1 $fifo2 $fifo3
+
+  # Remove temp window if we were zoomed
+  if [ -n "$zoomed" ]; then
+    tmux swap-pane -t $original_window \; \
+      select-window -t $original_window \; \
+      kill-window -t $tmp_window \; \
+      resize-pane -Z
+  fi
 }
 trap cleanup EXIT SIGINT SIGTERM

 fail() {
  >&2 echo "$1"
-  exit 1
+  exit 2
 }
 fzf="$(which fzf 2> /dev/null)" || fzf="$(dirname "$0")/fzf"
 [ -x "$fzf" ] || fail "fzf executable not found"

-envs="env "
+envs="env TERM=$TERM "
 [ -n "$FZF_DEFAULT_OPTS"    ] && envs="$envs FZF_DEFAULT_OPTS=$(printf %q "$FZF_DEFAULT_OPTS")"
 [ -n "$FZF_DEFAULT_COMMAND" ] && envs="$envs FZF_DEFAULT_COMMAND=$(printf %q "$FZF_DEFAULT_COMMAND")"

-mkfifo $fifo2
-mkfifo $fifo3
+mkfifo -m o+w $fifo2
+mkfifo -m o+w $fifo3

 # Build arguments to fzf
 opts=""
 for arg in "${args[@]}"; do
-  opts="$opts \"${arg//\"/\\\"}\""
+  arg="${arg//\"/\\\"}"
+  arg="${arg//\`/\\\`}"
+  opts="$opts \"$arg\""
 done

 if [ -n "$term" -o -t 0 ]; then
  cat <<< "$fzf $opts > $fifo2; echo \$? > $fifo3 $close" > $argsf
-  tmux set-window-option -q synchronize-panes off \;\
-    split-window $opt "cd $(printf %q "$PWD");$envs bash $argsf" $swap
+  tmux set-window-option synchronize-panes off \;\
+    set-window-option remain-on-exit off \;\
+    split-window $opt "cd $(printf %q "$PWD");$envs bash $argsf" $swap \
+    > /dev/null 2>&1
 else
  mkfifo $fifo1
  cat <<< "$fzf $opts < $fifo1 > $fifo2; echo \$? > $fifo3 $close" > $argsf
-  tmux set-window-option -q synchronize-panes off \;\
-    split-window $opt "$envs bash $argsf" $swap
+  tmux set-window-option synchronize-panes off \;\
+    set-window-option remain-on-exit off \;\
+    split-window $opt "$envs bash $argsf" $swap \
+    > /dev/null 2>&1
  cat <&0 > $fifo1 &
 fi
 cat $fifo2
-[ "$(cat $fifo3)" = '0' ]
+exit "$(cat $fifo3)"

--- a/10
+++ b/10
@@ -206,11 +206,11 @@ class FZF
        @expect = true
      when /^--expect=(.*)$/
        @expect = true
-      when '--toggle-sort', '--tiebreak', '--color', '--bind'
+      when '--toggle-sort', '--tiebreak', '--color', '--bind', '--history', '--history-size'
        argv.shift
      when '--tac', '--no-tac', '--sync', '--no-sync', '--hscroll', '--no-hscroll',
-           '--inline-info', '--no-inline-info', /^--bind=(.*)$/,
-           /^--color=(.*)$/, /^--toggle-sort=(.*)$/, /^--tiebreak=(.*)$/
+           '--inline-info', '--no-inline-info', '--read0', '--cycle', /^--bind=(.*)$/,
+           /^--color=(.*)$/, /^--toggle-sort=(.*)$/, /^--tiebreak=(.*)$/, /^--history(-max)?=(.*)$/
        # XXX
      else
        usage 1, "illegal option: #{o}"
@@ -370,7 +370,7 @@ class FZF
    +i                    Case-sensitive match
    -n, --nth=N[,..]      Comma-separated list of field index expressions
                          for limiting search scope. Each can be a non-zero
-                          integer or a range expression ([BEGIN]..[END])
+                          integer or a range expression ([BEGIN]..[END]).
        --with-nth=N[,..] Transform the item using index expressions for search
    -d, --delimiter=STR   Field delimiter regex for --nth (default: AWK-style)

@@ -396,7 +396,7 @@ class FZF

  Environment variables
    FZF_DEFAULT_COMMAND   Default command to use when input is tty
-    FZF_DEFAULT_OPTS      Defaults options. (e.g. "-x -m --sort 10000")] + $/ + $/
+    FZF_DEFAULT_OPTS      Default options (e.g. "-x -m --sort 10000")] + $/ + $/
   exit x
  end

--- a/260
+++ b/260
@@ -1,35 +1,91 @@
 #!/usr/bin/env bash

-version=0.9.13
+set -u

-cd $(dirname $BASH_SOURCE)
-fzf_base=$(pwd)
+[[ "$@" =~ --pre ]] && version=0.12.0 pre=1 ||
+                       version=0.12.0 pre=0

-# If stdin is a tty, we are "interactive".
-[ -t 0 ] && interactive=yes
+auto_completion=
+key_bindings=
+update_config=2
+binary_arch=
+
+help() {
+  cat << EOF
+usage: $0 [OPTIONS]
+
+    --help               Show this message
+    --bin                Download fzf binary only; Do not generate ~/.fzf.{bash,zsh}
+    --all                Download fzf binary and update configuration files
+                         to enable key bindings and fuzzy completion
+    --[no-]key-bindings  Enable/disable key bindings (CTRL-T, CTRL-R, ALT-C)
+    --[no-]completion    Enable/disable fuzzy completion (bash & zsh)
+    --[no-]update-rc     Whether or not to update shell configuration files
+
+    --32                 Download 32-bit binary
+    --64                 Download 64-bit binary
+EOF
+}
+
+for opt in "$@"; do
+  case $opt in
+    --help)
+      help
+      exit 0
+      ;;
+    --all)
+      auto_completion=1
+      key_bindings=1
+      update_config=1
+      ;;
+    --key-bindings)    key_bindings=1    ;;
+    --no-key-bindings) key_bindings=0    ;;
+    --completion)      auto_completion=1 ;;
+    --no-completion)   auto_completion=0 ;;
+    --update-rc)       update_config=1   ;;
+    --no-update-rc)    update_config=0   ;;
+    --32)              binary_arch=386   ;;
+    --64)              binary_arch=amd64 ;;
+    --bin|--pre)       ;;
+    *)
+      echo "unknown option: $opt"
+      help
+      exit 1
+      ;;
+  esac
+done
+
+cd "$(dirname "${BASH_SOURCE[0]}")"
+fzf_base="$(pwd)"

 ask() {
+  # If stdin is a tty, we are "interactive".
  # non-interactive shell: wait for a linefeed
  #     interactive shell: continue after a single keypress
-  [ -n "$interactive" ] && read_n='-n 1' || read_n=
+  read_n=$([ -t 0 ] && echo "-n 1")

  read -p "$1 ([y]/n) " $read_n -r
  echo
-  [[ ! $REPLY =~ ^[Nn]$ ]]
+  [[ $REPLY =~ ^[Nn]$ ]]
 }

 check_binary() {
  echo -n "  - Checking fzf executable ... "
-  local output=$("$fzf_base"/bin/fzf --version 2>&1)
-  if [ "$version" = "$output" ]; then
+  local output
+  output=$("$fzf_base"/bin/fzf --version 2>&1)
+  if [ $? -ne 0 ]; then
+    echo "Error: $output"
+    binary_error="Invalid binary"
+  elif [ "$version" != "$output" ]; then
+    echo "$output != $version"
+    binary_error="Invalid version"
+  else
    echo "$output"
    binary_error=""
-  else
-    echo "$output != $version"
-    rm -f "$fzf_base"/bin/fzf
-    binary_error="Invalid binary"
-    return 1
+    return 0
  fi
+  rm -f "$fzf_base"/bin/fzf
+  return 1
 }

 symlink() {
@@ -43,14 +99,28 @@ symlink() {
  fi
 }

+link_fzf_in_path() {
+  if which_fzf="$(command -v fzf)"; then
+    echo "  - Found in \$PATH"
+    echo "  - Creating symlink: $which_fzf -> bin/fzf"
+    (cd "$fzf_base"/bin && rm -f fzf && ln -sf "$which_fzf" fzf)
+    check_binary && return
+  fi
+  return 1
+}
+
 download() {
  echo "Downloading bin/fzf ..."
-  if [[ ! $1 =~ dev && -x "$fzf_base"/bin/fzf ]]; then
+  if [ $pre = 0 ]; then
+    if [ -x "$fzf_base"/bin/fzf ]; then
      echo "  - Already exists"
      check_binary && return
-  elif [ -x "$fzf_base"/bin/$1 ]; then
+    fi
+    if [ -x "$fzf_base"/bin/$1 ]; then
      symlink $1 && check_binary && return
    fi
+    link_fzf_in_path && return
+  fi
  mkdir -p "$fzf_base"/bin && cd "$fzf_base"/bin
  if [ $? -ne 0 ]; then
    binary_error="Failed to create bin directory"
@@ -58,9 +128,9 @@ download() {
  fi

  local url=https://github.com/junegunn/fzf-bin/releases/download/$version/${1}.tgz
-  if which curl > /dev/null; then
+  if command -v curl > /dev/null; then
    curl -fL $url | tar -xz
-  elif which wget > /dev/null; then
+  elif command -v wget > /dev/null; then
    wget -O - $url | tar -xz
  else
    binary_error="curl or wget not found"
@@ -80,25 +150,19 @@ archi=$(uname -sm)
 binary_available=1
 binary_error=""
 case "$archi" in
-  Darwin\ x86_64) download fzf-$version-darwin_amd64 ;;
-  Darwin\ i*86)   download fzf-$version-darwin_386   ;;
-  Linux\ x86_64)  download fzf-$version-linux_amd64  ;;
-  Linux\ i*86)    download fzf-$version-linux_386    ;;
+  Darwin\ x86_64) download fzf-$version-darwin_${binary_arch:-amd64} ;;
+  Darwin\ i*86)   download fzf-$version-darwin_${binary_arch:-386}   ;;
+  Linux\ x86_64)  download fzf-$version-linux_${binary_arch:-amd64}  ;;
+  Linux\ i*86)    download fzf-$version-linux_${binary_arch:-386}    ;;
  *)              binary_available=0 binary_error=1  ;;
 esac

-cd "$fzf_base"
-if [ -n "$binary_error" ]; then
-  if [ $binary_available -eq 0 ]; then
-    echo "No prebuilt binary for $archi ... "
-  else
-    echo "  - $binary_error !!!"
-  fi
+install_ruby_fzf() {
  echo "Installing legacy Ruby version ..."

  # ruby executable
  echo -n "Checking Ruby executable ... "
-  ruby=`which ruby`
+  ruby=$(command -v ruby)
  if [ $? -ne 0 ]; then
    echo "ruby executable not found !!!"
    exit 1
@@ -106,7 +170,7 @@ if [ -n "$binary_error" ]; then

  # System ruby is preferred
  system_ruby=/usr/bin/ruby
-  if [ -x $system_ruby -a $system_ruby != "$ruby" ]; then
+  if [ -x $system_ruby ] && [ $system_ruby != "$ruby" ]; then
    $system_ruby --disable-gems -rcurses -e0 2> /dev/null
    [ $? -eq 0 ] && ruby=$system_ruby
  fi
@@ -159,43 +223,72 @@ if [ -n "$binary_error" ]; then
  echo "$fzf_cmd \"\$@\"" >> "$fzf_base"/bin/fzf
  chmod +x "$fzf_base"/bin/fzf
  echo "OK"
+}
+
+cd "$fzf_base"
+if [ -n "$binary_error" ]; then
+  if [ $binary_available -eq 0 ]; then
+    echo "No prebuilt binary for $archi ..."
+    if command -v go > /dev/null; then
+      echo -n "Building binary (go get github.com/junegunn/fzf/src/fzf) ... "
+      if go get github.com/junegunn/fzf/src/fzf; then
+        echo "OK"
+        link_fzf_in_path
+      else
+        echo "Failed to build binary ..."
+        install_ruby_fzf
+      fi
+    else
+      echo "go executable not found. Cannot build binary ..."
+      install_ruby_fzf
+    fi
+  else
+    echo "  - $binary_error !!!"
+    exit 1
+  fi
 fi

 [[ "$*" =~ "--bin" ]] && exit 0

 # Auto-completion
-ask "Do you want to add auto-completion support?"
-auto_completion=$?
+if [ -z "$auto_completion" ]; then
+  ask "Do you want to enable fuzzy auto-completion?"
+  auto_completion=$?
+fi

 # Key-bindings
-ask "Do you want to add key bindings?"
-key_bindings=$?
+if [ -z "$key_bindings" ]; then
+  ask "Do you want to enable key bindings?"
+  key_bindings=$?
+fi

 echo
-for shell in bash zsh; do
+has_zsh=$(command -v zsh > /dev/null && echo 1 || echo 0)
+shells=$([ $has_zsh -eq 1 ] && echo "bash zsh" || echo "bash")
+for shell in $shells; do
  echo -n "Generate ~/.fzf.$shell ... "
  src=~/.fzf.${shell}

-  fzf_completion="[[ \$- =~ i ]] && source \"$fzf_base/shell/completion.${shell}\" 2> /dev/null"
-  if [ $auto_completion -ne 0 ]; then
+  fzf_completion="[[ \$- == *i* ]] && source \"$fzf_base/shell/completion.${shell}\" 2> /dev/null"
+  if [ $auto_completion -eq 0 ]; then
    fzf_completion="# $fzf_completion"
  fi

  fzf_key_bindings="source \"$fzf_base/shell/key-bindings.${shell}\""
-  if [ $key_bindings -ne 0 ]; then
+  if [ $key_bindings -eq 0 ]; then
    fzf_key_bindings="# $fzf_key_bindings"
  fi

  cat > $src << EOF
 # Setup fzf
 # ---------
-if [[ ! "\$PATH" =~ "$fzf_base/bin" ]]; then
+if [[ ! "\$PATH" == *$fzf_base/bin* ]]; then
  export PATH="\$PATH:$fzf_base/bin"
 fi

 # Man path
 # --------
-if [[ ! "\$MANPATH" =~ "$fzf_base/man" && -d "$fzf_base/man" ]]; then
+if [[ ! "\$MANPATH" == *$fzf_base/man* && -d "$fzf_base/man" ]]; then
  export MANPATH="\$MANPATH:$fzf_base/man"
 fi

@@ -212,9 +305,8 @@ EOF
 done

 # fish
-has_fish=0
-if [ -n "$(which fish 2> /dev/null)" ]; then
-  has_fish=1
+has_fish=$(command -v fish > /dev/null && echo 1 || echo 0)
+if [ $has_fish -eq 1 ]; then
  echo -n "Update fish_user_paths ... "
  fish << EOF
  echo \$fish_user_paths | grep $fzf_base/bin > /dev/null
@@ -228,50 +320,74 @@ EOF
    rm -f ~/.config/fish/functions/fzf.fish && echo "OK" || echo "Failed"
  fi

-  if [ $key_bindings -eq 0 ]; then
-    echo -n "Symlink ~/.config/fish/functions/fzf_key_bindings.fish ... "
-    ln -sf $fzf_base/shell/key-bindings.fish \
-           ~/.config/fish/functions/fzf_key_bindings.fish && echo "OK" || echo "Failed"
+  fish_binding=~/.config/fish/functions/fzf_key_bindings.fish
+  if [ $key_bindings -ne 0 ]; then
+    echo -n "Symlink $fish_binding ... "
+    ln -sf "$fzf_base/shell/key-bindings.fish" \
+           "$fish_binding" && echo "OK" || echo "Failed"
+  else
+    echo -n "Removing $fish_binding ... "
+    rm -f "$fish_binding"
+    echo "OK"
  fi
 fi

 append_line() {
-  echo "Update $2:"
-  echo "  - $1"
-  [ -f "$2" ] || touch "$2"
-  if [ $# -lt 3 ]; then
-    line=$(\grep -nF "$1" "$2" | sed 's/:.*//' | tr '\n' ' ')
+  set -e
+
+  local update line file pat lno
+  update="$1"
+  line="$2"
+  file="$3"
+  pat="${4:-}"
+
+  echo "Update $file:"
+  echo "  - $line"
+  [ -f "$file" ] || touch "$file"
+  if [ $# -lt 4 ]; then
+    lno=$(\grep -nF "$line" "$file" | sed 's/:.*//' | tr '\n' ' ')
  else
-    line=$(\grep -nF "$3" "$2" | sed 's/:.*//' | tr '\n' ' ')
+    lno=$(\grep -nF "$pat" "$file" | sed 's/:.*//' | tr '\n' ' ')
  fi
-  if [ -n "$line" ]; then
-    echo "    - Already exists: line #$line"
+  if [ -n "$lno" ]; then
+    echo "    - Already exists: line #$lno"
  else
-    echo "$1" >> "$2"
+    if [ $update -eq 1 ]; then
+      echo >> "$file"
+      echo "$line" >> "$file"
      echo "    + Added"
+    else
+      echo "    ~ Skipped"
+    fi
  fi
  echo
+  set +e
 }

+if [ $update_config -eq 2 ]; then
+  echo
+  ask "Do you want to update your shell configuration files?"
+  update_config=$?
+fi
 echo
-for shell in bash zsh; do
-  append_line "[ -f ~/.fzf.${shell} ] && source ~/.fzf.${shell}" ~/.${shell}rc "~/.fzf.${shell}"
+for shell in $shells; do
+  [ $shell = zsh ] && dest=${ZDOTDIR:-~}/.zshrc || dest=~/.bashrc
+  append_line $update_config "[ -f ~/.fzf.${shell} ] && source ~/.fzf.${shell}" "$dest" "~/.fzf.${shell}"
 done

-if [ $key_bindings -eq 0 -a $has_fish -eq 1 ]; then
+if [ $key_bindings -eq 1 ] && [ $has_fish -eq 1 ]; then
  bind_file=~/.config/fish/functions/fish_user_key_bindings.fish
-  append_line "fzf_key_bindings" "$bind_file"
+  append_line $update_config "fzf_key_bindings" "$bind_file"
 fi

-cat << EOF
-Finished. Restart your shell or reload config file.
-   source ~/.bashrc  # bash
-   source ~/.zshrc   # zsh
-EOF
-[ $has_fish -eq 1 ] && echo "   fzf_key_bindings  # fish"; cat << EOF
-
-Use uninstall script to remove fzf.
-
-For more information, see: https://github.com/junegunn/fzf
-EOF
+if [ $update_config -eq 1 ]; then
+  echo 'Finished. Restart your shell or reload config file.'
+  echo '   source ~/.bashrc  # bash'
+  [ $has_zsh  -eq 1 ] && echo "   source ${ZDOTDIR:-~}/.zshrc   # zsh"
+  [ $has_fish -eq 1 ] && [ $key_bindings -eq 1 ] && echo '   fzf_key_bindings  # fish'
+  echo
+  echo 'Use uninstall script to remove fzf.'
+  echo
+fi
+echo 'For more information, see: https://github.com/junegunn/fzf'

--- a/man/man1/fzf.1
+++ b/man/man1/fzf.1
@@ -1,7 +1,7 @@
 .ig
 The MIT License (MIT)

-Copyright (c) 2015 Junegunn Choi
+Copyright (c) 2016 Junegunn Choi

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -21,7 +21,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 ..
-.TH fzf 1 "June 2015" "fzf 0.9.13" "fzf - a command-line fuzzy finder"
+.TH fzf 1 "Apr 2016" "fzf 0.12.0" "fzf - a command-line fuzzy finder"

 .SH NAME
 fzf - a command-line fuzzy finder
@@ -36,10 +36,11 @@ fzf is a general-purpose command-line fuzzy finder.
 .SS Search mode
 .TP
 .B "-x, --extended"
-Extended-search mode
+Extended-search mode. Since 0.10.9, this is enabled by default. You can disable
+it with \fB+x\fR or \fB--no-extended\fR.
 .TP
-.B "-e, --extended-exact"
-Extended-search mode (exact match)
+.B "-e, --exact"
+Enable exact-match
 .TP
 .B "-i"
 Case-insensitive match (default: smart-case match)
@@ -52,10 +53,10 @@ Comma-separated list of field index expressions for limiting search scope.
 See \fBFIELD INDEX EXPRESSION\fR for details.
 .TP
 .BI "--with-nth=" "N[,..]"
-Transform the item using the list of index expressions for search
+Transform each item using index expressions within finder
 .TP
 .BI "-d, --delimiter=" "STR"
-Field delimiter regex for \fI--nth\fR and \fI--with-nth\fR (default: AWK-style)
+Field delimiter regex for \fB--nth\fR and \fB--with-nth\fR (default: AWK-style)
 .SS Search result
 .TP
 .B "+s, --no-sort"
@@ -67,10 +68,10 @@ Reverse the order of the input
 e.g. \fBhistory | fzf --tac --no-sort\fR
 .RE
 .TP
-.BI "--tiebreak=" "CRI"
-Sort criterion to use when the scores are tied
+.BI "--tiebreak=" "CRI[,..]"
+Comma-separated list of sort criteria to apply when the scores are tied.
 .br
-.R ""
+
 .br
 .BR length "  Prefers item with shorter length"
 .br
@@ -80,6 +81,15 @@ Sort criterion to use when the scores are tied
 .br
 .BR index "   Prefers item that appeared earlier in the input stream"
 .br
+
+.br
+- Each criterion should appear only once in the list
+.br
+- \fBindex\fR is only allowed at the end of the list
+.br
+- \fBindex\fR is implicitly appended to the list when not specified
+.br
+- Default is \fBlength\fR (or equivalently \fBlength\fR,index)
 .SS Interface
 .TP
 .B "-m, --multi"
@@ -122,6 +132,7 @@ e.g. \fBfzf --color=bg+:24\fR
    \fBpointer \fRPointer to the current line
    \fBmarker  \fRMulti-select marker
    \fBspinner \fRStreaming input indicator
+    \fBheader  \fRHeader
 .RE
 .TP
 .B "--black"
@@ -130,9 +141,45 @@ Use black background
 .B "--reverse"
 Reverse orientation
 .TP
+.BI "--margin=" MARGIN
+Comma-separated expression for margins around the finder.
+.br
+
+.br
+.RS
+.BR TRBL "     Same margin for top, right, bottom, and left"
+.br
+.BR TB,RL "    Vertical, horizontal margin"
+.br
+.BR T,RL,B "   Top, horizontal, bottom margin"
+.br
+.BR T,R,B,L "  Top, right, bottom, left margin"
+.br
+
+.br
+Each part can be given in absolute number or in percentage relative to the
+terminal size with \fB%\fR suffix.
+.br
+
+.br
+e.g. \fBfzf --margin 10%\fR
+     \fBfzf --margin 1,5%\fR
+.RE
+.TP
+.BI "--tabstop=" SPACES
+Number of spaces for a tab character (default: 8)
+.TP
+.B "--cycle"
+Enable cyclic scroll
+.TP
 .B "--no-hscroll"
 Disable horizontal scroll
 .TP
+.BI "--hscroll-off=" "COL"
+Number of screen columns to keep to the right of the highlighted substring
+(default: 10). Setting it to a large value will cause the text to be positioned
+on the center of the screen.
+.TP
 .B "--inline-info"
 Display finder info inline with the query
 .TP
@@ -140,8 +187,7 @@ Display finder info inline with the query
 Input prompt (default: '> ')
 .TP
 .BI "--toggle-sort=" "KEY"
-Key to toggle sort (\fIctrl-[a-z]\fR, \fIalt-[a-z]\fR, \fIf[1-4]\fR,
-or any single character)
+Key to toggle sort. For the list of the allowed key names, see \fB--bind\fR.
 .TP
 .BI "--bind=" "KEYBINDS"
 Comma-separated list of custom key bindings. Each key binding expression
@@ -151,38 +197,132 @@ e.g. \fBfzf --bind=ctrl-j:accept,ctrl-k:kill-line\fR
 .RE

 .RS
-.B KEY:
-    \fIctrl-[a-z]\fR, \fIalt-[a-z]\fR, \fIf[1-4]\fR, or any single character
+.B AVAILABLE KEYS:    (SYNONYMS)
+    \fIctrl-[a-z]\fR
+    \fIalt-[a-z]\fR
+    \fIf[1-4]\fR
+    \fIenter\fR       (\fIreturn\fR \fIctrl-m\fR)
+    \fIspace\fR
+    \fIbspace\fR      (\fIbs\fR)
+    \fIalt-bspace\fR  (\fIalt-bs\fR)
+    \fItab\fR
+    \fIbtab\fR        (\fIshift-tab\fR)
+    \fIesc\fR
+    \fIdel\fR
+    \fIup\fR
+    \fIdown\fR
+    \fIleft\fR
+    \fIright\fR
+    \fIhome\fR
+    \fIend\fR
+    \fIpgup\fR        (\fIpage-up\fR)
+    \fIpgdn\fR        (\fIpage-down\fR)
+    \fIshift-left\fR
+    \fIshift-right\fR
+    \fIdouble-click\fR
+    or any single character
 .RE

 .RS
-.B ACTION:
-    abort
-    accept
-    backward-char
-    backward-delete-char
-    backward-kill-word
-    backward-word
-    beginning-of-line
-    clear-screen
-    delete-char
-    down
-    end-of-line
-    forward-char
-    forward-word
-    kill-line (not bound)
-    kill-word
-    page-down
-    page-up
-    toggle (not bound)
-    toggle-down
-    toggle-sort (not bound; equivalent to \fB--toggle-sort\fR)
-    toggle-up
-    unix-line-discard
-    unix-word-rubout
-    up
-    yank
+  \fBACTION:               DEFAULT BINDINGS (NOTES):
+    \fBabort\fR                 \fIctrl-c  ctrl-g  ctrl-q  esc\fR
+    \fBaccept\fR                \fIenter   double-click\fR
+    \fBbackward-char\fR         \fIctrl-b  left\fR
+    \fBbackward-delete-char\fR  \fIctrl-h  bspace\fR
+    \fBbackward-kill-word\fR    \fIalt-bs\fR
+    \fBbackward-word\fR         \fIalt-b   shift-left\fR
+    \fBbeginning-of-line\fR     \fIctrl-a  home\fR
+    \fBcancel\fR
+    \fBclear-screen\fR          \fIctrl-l\fR
+    \fBdelete-char\fR           \fIdel\fR
+    \fBdelete-char/eof\fR       \fIctrl-d\fR
+    \fBdeselect-all\fR
+    \fBdown\fR                  \fIctrl-j  ctrl-n  down\fR
+    \fBend-of-line\fR           \fIctrl-e  end\fR
+    \fBexecute(...)\fR          (see below for the details)
+    \fBexecute-multi(...)\fR    (see below for the details)
+    \fBforward-char\fR          \fIctrl-f  right\fR
+    \fBforward-word\fR          \fIalt-f   shift-right\fR
+    \fBignore\fR
+    \fBkill-line\fR
+    \fBkill-word\fR             \fIalt-d\fR
+    \fBnext-history\fR          (\fIctrl-n\fR on \fB--history\fR)
+    \fBpage-down\fR             \fIpgdn\fR
+    \fBpage-up\fR               \fIpgup\fR
+    \fBprevious-history\fR      (\fIctrl-p\fR on \fB--history\fR)
+    \fBselect-all\fR
+    \fBtoggle\fR
+    \fBtoggle-all\fR
+    \fBtoggle-down\fR           \fIctrl-i  (tab)\fR
+    \fBtoggle-in\fR             (\fB--reverse\fR ? \fBtoggle-up\fR : \fBtoggle-down\fR)
+    \fBtoggle-out\fR            (\fB--reverse\fR ? \fBtoggle-down\fR : \fBtoggle-up\fR)
+    \fBtoggle-sort\fR           (equivalent to \fB--toggle-sort\fR)
+    \fBtoggle-up\fR             \fIbtab    (shift-tab)\fR
+    \fBunix-line-discard\fR     \fIctrl-u\fR
+    \fBunix-word-rubout\fR      \fIctrl-w\fR
+    \fBup\fR                    \fIctrl-k  ctrl-p  up\fR
+    \fByank\fR                  \fIctrl-y\fR
 .RE
+
+.RS
+With \fBexecute(...)\fR action, you can execute arbitrary commands without
+leaving fzf. For example, you can turn fzf into a simple file browser by
+binding \fBenter\fR key to \fBless\fR command like follows.
+
+.RS
+\fBfzf --bind "enter:execute(less {})"\fR
+.RE
+
+\fB{}\fR is the placeholder for the double-quoted string of the current line.
+If the command contains parentheses, you can use any of the following
+alternative notations to avoid parse errors.
+
+    \fBexecute[...]\fR
+    \fBexecute~...~\fR
+    \fBexecute!...!\fR
+    \fBexecute@...@\fR
+    \fBexecute#...#\fR
+    \fBexecute$...$\fR
+    \fBexecute%...%\fR
+    \fBexecute^...^\fR
+    \fBexecute&...&\fR
+    \fBexecute*...*\fR
+    \fBexecute;...;\fR
+    \fBexecute/.../\fR
+    \fBexecute|...|\fR
+    \fBexecute:...\fR
+.RS
+This is the special form that frees you from parse errors as it does not expect
+the closing character. The catch is that it should be the last one in the
+comma-separated list.
+.RE
+
+\fBexecute-multi(...)\fR is an alternative action that executes the command
+with the selected entries when multi-select is enabled (\fB--multi\fR). With
+this action, \fB{}\fR is replaced with the double-quoted strings of the
+selected entries separated by spaces.
+
+.RE
+.TP
+.BI "--history=" "HISTORY_FILE"
+Load search history from the specified file and update the file on completion.
+When enabled, \fBCTRL-N\fR and \fBCTRL-P\fR are automatically remapped to
+\fBnext-history\fR and \fBprevious-history\fR.
+.TP
+.BI "--history-size=" "N"
+Maximum number of entries in the history file (default: 1000). The file is
+automatically truncated when the number of the lines exceeds the value.
+.TP
+.BI "--header=" "STR"
+The given string will be printed as the sticky header. The lines are displayed
+in the given order from top to bottom regardless of \fB--reverse\fR option, and
+are not affected by \fB--with-nth\fR. ANSI color codes are processed even when
+\fB--ansi\fR is not set.
+.TP
+.BI "--header-lines=" "N"
+The first N lines of the input are treated as the sticky header. When
+\fB--with-nth\fR is set, the lines are transformed just like the other
+lines that follow.
 .SS Scripting
 .TP
 .BI "-q, --query=" "STR"
@@ -202,10 +342,9 @@ fzf becomes a fuzzy-version of grep.
 Print query as the first line
 .TP
 .BI "--expect=" "KEY[,..]"
-Comma-separated list of keys (\fIctrl-[a-z]\fR, \fIalt-[a-z]\fR, \fIf[1-4]\fR,
-or any single character) that can be used to complete fzf in addition to the
-default enter key. When this option is set, fzf will print the name of the key
-pressed as the first line of its output (or as the second line if
+Comma-separated list of keys that can be used to complete fzf in addition to
+the default enter key. When this option is set, fzf will print the name of the
+key pressed as the first line of its output (or as the second line if
 \fB--print-query\fR is also used). The line will be empty if fzf is completed
 with the default enter key.
 .RS
@@ -225,17 +364,21 @@ e.g. \fBfzf --multi | fzf --sync\fR
 Default command to use when input is tty
 .TP
 .B FZF_DEFAULT_OPTS
-Default options. e.g. \fB--extended --ansi\fR
+Default options. e.g. \fBexport FZF_DEFAULT_OPTS="--extended --cycle"\fR

 .SH EXIT STATUS
 .BR 0 "      Normal exit"
 .br
-.BR 1 "      Interrupted with \fBCTRL-C\fR or \fBESC\fR"
+.BR 1 "      No match"
+.br
+.BR 2 "      Error"
+.br
+.BR 130 "    Interrupted with \fBCTRL-C\fR or \fBESC\fR"

 .SH FIELD INDEX EXPRESSION

 A field index expression can be a non-zero integer or a range expression
-([BEGIN]..[END]). \fI--nth\fR and \fI--with-nth\fR take a comma-separated list
+([BEGIN]..[END]). \fB--nth\fR and \fB--with-nth\fR take a comma-separated list
 of field index expressions.

 .SS Examples
@@ -258,34 +401,51 @@ of field index expressions.

 .SH EXTENDED SEARCH MODE

-With \fI-x\fR or \fI--extended\fR option, fzf will start in "extended-search
-mode". In this mode, you can specify multiple patterns delimited by spaces,
-such as: \fB'wild ^music .mp3$ sbtrkt !rmx\fR
+Unless specified otherwise, fzf will start in "extended-search mode". In this
+mode, you can specify multiple patterns delimited by spaces, such as: \fB'wild
+^music .mp3$ sbtrkt !rmx\fR

 .SS Exact-match (quoted)
-A term that is prefixed by a single-quote character (') is interpreted as an
-"exact-match" (or "non-fuzzy") term. fzf will search for the exact occurrences
-of the string.
+A term that is prefixed by a single-quote character (\fB'\fR) is interpreted as
+an "exact-match" (or "non-fuzzy") term. fzf will search for the exact
+occurrences of the string.

 .SS Anchored-match
-A term can be prefixed by ^, or suffixed by $ to become an anchored-match term.
-Then fzf will search for the items that start with or end with the given
-string. An anchored-match term is also an exact-match term.
+A term can be prefixed by \fB^\fR, or suffixed by \fB$\fR to become an
+anchored-match term. Then fzf will search for the items that start with or end
+with the given string. An anchored-match term is also an exact-match term.

 .SS Negation
-If a term is prefixed by !, fzf will exclude the items that satisfy the term
-from the result.
+If a term is prefixed by \fB!\fR, fzf will exclude the items that satisfy the
+term from the result.

-.SS Extended-exact mode
-If you don't need fuzzy matching at all and do not wish to "quote" (prefixing
-with ') every word, start fzf with \fI-e\fR or \fI--extended-exact\fR option
-(instead of \fI-x\fR or \fI--extended\fR).
+.SS Exact-match by default
+If you don't prefer fuzzy matching and do not wish to "quote" (prefixing with
+\fB'\fR) every word, start fzf with \fB-e\fR or \fB--exact\fR option. Note that
+when \fB--exact\fR is set, \fB'\fR-prefix "unquotes" the term.
+
+.SS OR operator
+A single bar character term acts as an OR operator. For example, the following
+query matches entries that start with \fBcore\fR and end with either \fBgo\fR,
+\fBrb\fR, or \fBpy\fR.
+
+e.g. \fB^core go$ | rb$ | py$\fR

 .SH AUTHOR
 Junegunn Choi (\fIjunegunn.c@gmail.com\fR)

 .SH SEE ALSO
+.B Project homepage:
+.RS
 .I https://github.com/junegunn/fzf
+.RE
+.br
+
+.br
+.B Extra Vim plugin:
+.RS
+.I https://github.com/junegunn/fzf.vim
+.RE

 .SH LICENSE
 MIT
--- a/plugin/fzf.vim
+++ b/plugin/fzf.vim
@@ -1,4 +1,4 @@
-" Copyright (c) 2015 Junegunn Choi
+" Copyright (c) 2016 Junegunn Choi
 "
 " MIT License
 "
@@ -40,9 +40,7 @@ function! s:fzf_exec()
          \ input('fzf executable not found. Download binary? (y/n) ') =~? '^y'
      redraw
      echo
-      echohl WarningMsg
-      echo 'Downloading fzf binary. Please wait ...'
-      echohl None
+      call s:warn('Downloading fzf binary. Please wait ...')
      let s:installed = 1
      call system(s:install.' --bin')
      return s:fzf_exec()
@@ -76,7 +74,7 @@ function! s:shellesc(arg)
 endfunction

 function! s:escape(path)
-  return escape(a:path, ' %#\')
+  return escape(a:path, ' $%#''"\')
 endfunction

 " Upgrade legacy options
@@ -94,14 +92,24 @@ function! s:upgrade(dict)
  return copy
 endfunction

+function! s:error(msg)
+  echohl ErrorMsg
+  echom a:msg
+  echohl None
+endfunction
+
+function! s:warn(msg)
+  echohl WarningMsg
+  echom a:msg
+  echohl None
+endfunction
+
 function! fzf#run(...) abort
 try
  let oshell = &shell
  set shell=sh
-  if has('nvim') && bufexists('[FZF]')
-    echohl WarningMsg
-    echomsg 'FZF is already running!'
-    echohl None
+  if has('nvim') && bufexists('term://*:FZF')
+    call s:warn('FZF is already running!')
    return []
  endif
  let dict   = exists('a:1') ? s:upgrade(a:1) : {}
@@ -131,17 +139,13 @@ try
  let tmux = !has('nvim') && s:tmux_enabled() && s:splittable(dict)
  let command = prefix.(tmux ? s:fzf_tmux(dict) : fzf_exec).' '.optstr.' > '.temps.result

-  try
-    if tmux
-      return s:execute_tmux(dict, command, temps)
-    elseif has('nvim')
+  if has('nvim')
    return s:execute_term(dict, command, temps)
-    else
-      return s:execute(dict, command, temps)
  endif
-  finally
-    call s:popd(dict)
-  endtry
+
+  let ret = tmux ? s:execute_tmux(dict, command, temps) : s:execute(dict, command, temps)
+  call s:popd(dict, ret)
+  return ret
 finally
  let &shell = oshell
 endtry
@@ -160,7 +164,13 @@ function! s:fzf_tmux(dict)
  let size = ''
  for o in ['up', 'down', 'left', 'right']
    if s:present(a:dict, o)
-      let size = '-'.o[0].(a:dict[o] == 1 ? '' : a:dict[o])
+      let spec = a:dict[o]
+      if (o == 'up' || o == 'down') && spec[0] == '~'
+        let size = '-'.o[0].s:calc_size(&lines, spec[1:], a:dict)
+      else
+        " Legacy boolean option
+        let size = '-'.o[0].(spec == 1 ? '' : spec)
+      endif
      break
    endif
  endfor
@@ -179,23 +189,35 @@ function! s:pushd(dict)
      return 1
    endif
    let a:dict.prev_dir = cwd
-    execute 'chdir '.s:escape(a:dict.dir)
+    execute 'chdir' s:escape(a:dict.dir)
    let a:dict.dir = getcwd()
    return 1
  endif
  return 0
 endfunction

-function! s:popd(dict)
-  if has_key(a:dict, 'prev_dir')
-    execute 'chdir '.s:escape(remove(a:dict, 'prev_dir'))
+function! s:popd(dict, lines)
+  " Since anything can be done in the sink function, there is no telling that
+  " the change of the working directory was made by &autochdir setting.
+  "
+  " We use the following heuristic to determine whether to restore CWD:
+  " - Always restore the current directory when &autochdir is disabled.
+  "   FIXME This makes it impossible to change directory from inside the sink
+  "   function when &autochdir is not used.
+  " - In case of an error or an interrupt, a:lines will be empty.
+  "   And it will be an array of a single empty string when fzf was finished
+  "   without a match. In these cases, we presume that the change of the
+  "   directory is not expected and should be undone.
+  if has_key(a:dict, 'prev_dir') &&
+        \ (!&autochdir || (empty(a:lines) || len(a:lines) == 1 && empty(a:lines[0])))
+    execute 'chdir' s:escape(remove(a:dict, 'prev_dir'))
  endif
 endfunction

 function! s:xterm_launcher()
  let fmt = 'xterm -T "[fzf]" -bg "\%s" -fg "\%s" -geometry %dx%d+%d+%d -e bash -ic %%s'
  if has('gui_macvim')
-    let fmt .= '; osascript -e "tell application \"MacVim\" to activate"'
+    let fmt .= '&& osascript -e "tell application \"MacVim\" to activate"'
  endif
  return printf(fmt,
    \ synIDattr(hlID("Normal"), "bg"), synIDattr(hlID("Normal"), "fg"),
@@ -204,31 +226,36 @@ endfunction
 unlet! s:launcher
 let s:launcher = function('s:xterm_launcher')

-function! s:execute(dict, command, temps)
+function! s:exit_handler(code, command, ...)
+  if a:code == 130
+    return 0
+  elseif a:code > 1
+    call s:error('Error running ' . a:command)
+    if !empty(a:000)
+      sleep
+    endif
+    return 0
+  endif
+  return 1
+endfunction
+
+function! s:execute(dict, command, temps) abort
  call s:pushd(a:dict)
  silent! !clear 2> /dev/null
+  let escaped = escape(substitute(a:command, '\n', '\\n', 'g'), '%#')
  if has('gui_running')
    let Launcher = get(a:dict, 'launcher', get(g:, 'Fzf_launcher', get(g:, 'fzf_launcher', s:launcher)))
    let fmt = type(Launcher) == 2 ? call(Launcher, []) : Launcher
-    let command = printf(fmt, "'".substitute(a:command, "'", "'\"'\"'", 'g')."'")
+    let command = printf(fmt, "'".substitute(escaped, "'", "'\"'\"'", 'g')."'")
  else
-    let command = a:command
+    let command = escaped
  endif
  execute 'silent !'.command
  redraw!
-  if v:shell_error
-    " Do not print error message on exit status 1
-    if v:shell_error > 1
-      echohl ErrorMsg
-      echo 'Error running ' . command
-    endif
-    return []
-  else
-    return s:callback(a:dict, a:temps)
-  endif
+  return s:exit_handler(v:shell_error, command) ? s:callback(a:dict, a:temps) : []
 endfunction

-function! s:execute_tmux(dict, command, temps)
+function! s:execute_tmux(dict, command, temps) abort
  let command = a:command
  if s:pushd(a:dict)
    " -c '#{pane_current_path}' is only available on tmux 1.9 or above
@@ -237,15 +264,28 @@ function! s:execute_tmux(dict, command, temps)

  call system(command)
  redraw!
-  return s:callback(a:dict, a:temps)
+  return s:exit_handler(v:shell_error, command) ? s:callback(a:dict, a:temps) : []
 endfunction

-function! s:calc_size(max, val)
+function! s:calc_size(max, val, dict)
  if a:val =~ '%$'
-    return a:max * str2nr(a:val[:-2]) / 100
+    let size = a:max * str2nr(a:val[:-2]) / 100
  else
-    return min([a:max, a:val])
+    let size = min([a:max, str2nr(a:val)])
  endif
+
+  let srcsz = -1
+  if type(get(a:dict, 'source', 0)) == type([])
+    let srcsz = len(a:dict.source)
+  endif
+
+  let opts = get(a:dict, 'options', '').$FZF_DEFAULT_OPTS
+  let margin = stridx(opts, '--inline-info') > stridx(opts, '--no-inline-info') ? 1 : 2
+  return srcsz >= 0 ? min([srcsz + margin, size]) : size
+endfunction
+
+function! s:getpos()
+  return {'tab': tabpagenr(), 'win': winnr(), 'cnt': winnr('$'), 'tcnt': tabpagenr('$')}
 endfunction

 function! s:split(dict)
@@ -254,13 +294,17 @@ function! s:split(dict)
  \ 'down':  ['botright', 'resize', &lines],
  \ 'left':  ['vertical topleft', 'vertical resize', &columns],
  \ 'right': ['vertical botright', 'vertical resize', &columns] }
-  let s:ptab = tabpagenr()
+  let s:ppos = s:getpos()
  try
    for [dir, triple] in items(directions)
      let val = get(a:dict, dir, '')
      if !empty(val)
        let [cmd, resz, max] = triple
-        let sz = s:calc_size(max, val)
+        if (dir == 'up' || dir == 'down') && val[0] == '~'
+          let sz = s:calc_size(max, val[1:], a:dict)
+        else
+          let sz = s:calc_size(max, val, {})
+        endif
        execute cmd sz.'new'
        execute resz sz
        return
@@ -269,52 +313,66 @@ function! s:split(dict)
    if s:present(a:dict, 'window')
      execute a:dict.window
    else
-      tabnew
+      execute (tabpagenr()-1).'tabnew'
    endif
  finally
    setlocal winfixwidth winfixheight buftype=nofile bufhidden=wipe nobuflisted
  endtry
 endfunction

-function! s:execute_term(dict, command, temps)
+function! s:execute_term(dict, command, temps) abort
  call s:split(a:dict)
-  call s:pushd(a:dict)

-  let fzf = { 'buf': bufnr('%'), 'dict': a:dict, 'temps': a:temps }
+  let fzf = { 'buf': bufnr('%'), 'dict': a:dict, 'temps': a:temps, 'name': 'FZF' }
+  let s:command = a:command
  function! fzf.on_exit(id, code)
-    let tab = tabpagenr()
+    let pos = s:getpos()
+    let inplace = pos == s:ppos " {'window': 'enew'}
+    if !inplace
      if bufnr('') == self.buf
        " We use close instead of bd! since Vim does not close the split when
-      " there's no other listed buffer
+        " there's no other listed buffer (nvim +'set nobuflisted')
        close
-      " FIXME This should be unnecessary due to `bufhidden=wipe` but in some
-      " cases Neovim fails to clean up the buffer and `bufexists('[FZF]')
-      " returns 1 even when it cannot be seen anywhere else. e.g. `FZF!`
-      silent! execute 'bd!' self.buf
      endif
-    if s:ptab == tab
+      if pos.tab == s:ppos.tab
        wincmd p
      endif
+    endif
+
+    if !s:exit_handler(a:code, s:command, 1)
+      return
+    endif
+
    call s:pushd(self.dict)
+    let ret = []
    try
-      redraw!
-      call s:callback(self.dict, self.temps)
+      let ret = s:callback(self.dict, self.temps)
+
+      if inplace && bufnr('') == self.buf
+        execute "normal! \<c-^>"
+        " No other listed buffer
+        if bufnr('') == self.buf
+          bd!
+        endif
+      endif
    finally
-      call s:popd(self.dict)
+      call s:popd(self.dict, ret)
    endtry
  endfunction

+  call s:pushd(a:dict)
  call termopen(a:command, fzf)
-  silent file [FZF]
+  call s:popd(a:dict, [])
+  setlocal nospell
+  setf fzf
  startinsert
  return []
 endfunction

-function! s:callback(dict, temps)
+function! s:callback(dict, temps) abort
+let lines = []
 try
-  if !filereadable(a:temps.result)
-    let lines = []
-  else
+  if filereadable(a:temps.result)
    let lines = readfile(a:temps.result)
    if has_key(a:dict, 'sink')
      for line in lines
@@ -333,18 +391,18 @@ try
  for tf in values(a:temps)
    silent! call delete(tf)
  endfor
-
-  return lines
 catch
  if stridx(v:exception, ':E325:') < 0
    echoerr v:exception
  endif
+finally
+  return lines
 endtry
 endfunction

 let s:default_action = {
  \ 'ctrl-m': 'e',
-  \ 'ctrl-t': 'tabedit',
+  \ 'ctrl-t': 'tab split',
  \ 'ctrl-x': 'split',
  \ 'ctrl-v': 'vsplit' }

@@ -354,9 +412,31 @@ function! s:cmd_callback(lines) abort
  endif
  let key = remove(a:lines, 0)
  let cmd = get(s:action, key, 'e')
+  if len(a:lines) > 1
+    augroup fzf_swap
+      autocmd SwapExists * let v:swapchoice='o'
+            \| call s:warn('fzf: E325: swap file exists: '.expand('<afile>'))
+    augroup END
+  endif
+  try
+    let empty = empty(expand('%')) && line('$') == 1 && empty(getline(1)) && !&modified
+    let autochdir = &autochdir
+    set noautochdir
    for item in a:lines
+      if empty
+        execute 'e' s:escape(item)
+        let empty = 0
+      else
        execute cmd s:escape(item)
+      endif
+      if exists('#BufEnter') && isdirectory(item)
+        doautocmd BufEnter
+      endif
    endfor
+  finally
+    let &autochdir = autochdir
+    silent! autocmd! fzf_swap
+  endtry
 endfunction

 function! s:cmd(bang, ...) abort
@@ -364,7 +444,7 @@ function! s:cmd(bang, ...) abort
  let args = extend(['--expect='.join(keys(s:action), ',')], a:000)
  let opts = {}
  if len(args) > 0 && isdirectory(expand(args[-1]))
-    let opts.dir = remove(args, -1)
+    let opts.dir = substitute(remove(args, -1), '\\\(["'']\)', '\1', 'g')
  endif
  if !a:bang
    let opts.down = get(g:, 'fzf_height', get(g:, 'fzf_tmux_height', s:default_height))
--- a/shell/completion.bash
+++ b/shell/completion.bash
@@ -10,9 +10,29 @@
 # - $FZF_COMPLETION_TRIGGER (default: '**')
 # - $FZF_COMPLETION_OPTS    (default: empty)

+# To use custom commands instead of find, override _fzf_compgen_{path,dir}
+if ! declare -f _fzf_compgen_path > /dev/null; then
+  _fzf_compgen_path() {
+    echo "$1"
+    \find -L "$1" \
+      -name .git -prune -o -name .svn -prune -o \( -type d -o -type f -o -type l \) \
+      -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
+  }
+fi
+
+if ! declare -f _fzf_compgen_dir > /dev/null; then
+  _fzf_compgen_dir() {
+    \find -L "$1" \
+      -name .git -prune -o -name .svn -prune -o -type d \
+      -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
+  }
+fi
+
+###########################################################
+
 _fzf_orig_completion_filter() {
-  sed 's/.*-F *\([^ ]*\).* \([^ ]*\)$/export _fzf_orig_completion_\2=\1;/' |
-  sed 's/[^a-z0-9_= ;]/_/g'
+  sed 's/^\(.*-F\) *\([^ ]*\).* \([^ ]*\)$/export _fzf_orig_completion_\3="\1 %s \3 #\2";/' |
+  awk -F= '{gsub(/[^a-z0-9_= ;]/, "_", $1); print $1"="$2}'
 }

 _fzf_opts_completion() {
@@ -22,7 +42,7 @@ _fzf_opts_completion() {
  prev="${COMP_WORDS[COMP_CWORD-1]}"
  opts="
    -x --extended
-    -e --extended-exact
+    -e --exact
    -i +i
    -n --nth
    -d --delimiter
@@ -45,21 +65,31 @@ _fzf_opts_completion() {
    --print-query
    --expect
    --toggle-sort
-    --sync"
+    --sync
+    --cycle
+    --history
+    --history-size
+    --header
+    --header-lines
+    --margin"

  case "${prev}" in
  --tiebreak)
-    COMPREPLY=( $(compgen -W "length begin end index" -- ${cur}) )
+    COMPREPLY=( $(compgen -W "length begin end index" -- "$cur") )
    return 0
    ;;
  --color)
-    COMPREPLY=( $(compgen -W "dark light 16 bw" -- ${cur}) )
+    COMPREPLY=( $(compgen -W "dark light 16 bw" -- "$cur") )
+    return 0
+    ;;
+  --history)
+    COMPREPLY=()
    return 0
    ;;
  esac

-  if [[ ${cur} =~ ^-|\+ ]]; then
-    COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+  if [[ "$cur" =~ ^-|\+ ]]; then
+    COMPREPLY=( $(compgen -W "${opts}" -- "$cur") )
    return 0
  fi

@@ -67,41 +97,43 @@ _fzf_opts_completion() {
 }

 _fzf_handle_dynamic_completion() {
-  local cmd orig ret
+  local cmd orig_var orig ret orig_cmd
  cmd="$1"
  shift
-
-  orig=$(eval "echo \$_fzf_orig_completion_$cmd")
+  orig_cmd="$1"
+  orig_var="_fzf_orig_completion_$cmd"
+  orig="${!orig_var##*#}"
  if [ -n "$orig" ] && type "$orig" > /dev/null 2>&1; then
    $orig "$@"
  elif [ -n "$_fzf_completion_loader" ]; then
    _completion_loader "$@"
    ret=$?
-    eval $(complete | \grep "\-F.* $cmd$" | _fzf_orig_completion_filter)
-    source $BASH_SOURCE
+    eval "$(complete | \grep "\-F.* $orig_cmd$" | _fzf_orig_completion_filter)"
+    source "${BASH_SOURCE[0]}"
    return $ret
  fi
 }

-_fzf_path_completion() {
+__fzf_generic_path_completion() {
  local cur base dir leftover matches trigger cmd fzf
-  [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
-  cmd=$(echo ${COMP_WORDS[0]} | sed 's/[^a-z0-9_=]/_/g')
+  [ "${FZF_TMUX:-1}" != 0 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
+  cmd=$(echo "${COMP_WORDS[0]}" | sed 's/[^a-z0-9_=]/_/g')
  COMPREPLY=()
  trigger=${FZF_COMPLETION_TRIGGER-'**'}
  cur="${COMP_WORDS[COMP_CWORD]}"
-  if [[ ${cur} == *"$trigger" ]]; then
+  if [[ "$cur" == *"$trigger" ]]; then
    base=${cur:0:${#cur}-${#trigger}}
-    eval base=$base
+    eval "base=$base"

    dir="$base"
-    while [ 1 ]; do
-      if [ -z "$dir" -o -d "$dir" ]; then
+    while true; do
+      if [ -z "$dir" ] || [ -d "$dir" ]; then
        leftover=${base/#"$dir"}
        leftover=${leftover/#\/}
-        [ "$dir" = './' ] && dir=''
+        [ -z "$dir" ] && dir='.'
+        [ "$dir" != "/" ] && dir="${dir/%\//}"
        tput sc
-        matches=$(find -L "$dir"* $1 2> /dev/null | $fzf $FZF_COMPLETION_OPTS $2 -q "$leftover" | while read item; do
+        matches=$(eval "$1 $(printf %q "$dir")" | $fzf $FZF_COMPLETION_OPTS $2 -q "$leftover" | while read -r item; do
          printf "%q$3 " "$item"
        done)
        matches=${matches% }
@@ -124,19 +156,21 @@ _fzf_path_completion() {
  fi
 }

-_fzf_list_completion() {
-  local cur selected trigger cmd src fzf
-  [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
-  read -r src
-  cmd=$(echo ${COMP_WORDS[0]} | sed 's/[^a-z0-9_=]/_/g')
+_fzf_complete() {
+  local cur selected trigger cmd fzf post
+  post="$(caller 0 | awk '{print $2}')_post"
+  type -t "$post" > /dev/null 2>&1 || post=cat
+  [ "${FZF_TMUX:-1}" != 0 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
+
+  cmd=$(echo "${COMP_WORDS[0]}" | sed 's/[^a-z0-9_=]/_/g')
  trigger=${FZF_COMPLETION_TRIGGER-'**'}
  cur="${COMP_WORDS[COMP_CWORD]}"
-  if [[ ${cur} == *"$trigger" ]]; then
+  if [[ "$cur" == *"$trigger" ]]; then
    cur=${cur:0:${#cur}-${#trigger}}

    tput sc
-    selected=$(eval "$src | $fzf $FZF_COMPLETION_OPTS $1 -q '$cur'" | tr '\n' ' ')
-    selected=${selected% }
+    selected=$(cat | $fzf $FZF_COMPLETION_OPTS $1 -q "$cur" | $post | tr '\n' ' ')
+    selected=${selected% } # Strip trailing space not to repeat "-o nospace"
    tput rc

    if [ -n "$selected" ]; then
@@ -149,29 +183,24 @@ _fzf_list_completion() {
  fi
 }

-_fzf_all_completion() {
-  _fzf_path_completion \
-    "-name .git -prune -o -name .svn -prune -o -type d -print -o -type f -print -o -type l -print" \
-    "-m" "" "$@"
+_fzf_path_completion() {
+  __fzf_generic_path_completion _fzf_compgen_path "-m" "" "$@"
 }

+# Deprecated. No file only completion.
 _fzf_file_completion() {
-  _fzf_path_completion \
-    "-name .git -prune -o -name .svn -prune -o -type f -print -o -type l -print" \
-    "-m" "" "$@"
+  _fzf_path_completion "$@"
 }

 _fzf_dir_completion() {
-  _fzf_path_completion \
-    "-name .git -prune -o -name .svn -prune -o -type d -print" \
-    "" "/" "$@"
+  __fzf_generic_path_completion _fzf_compgen_dir "" "/" "$@"
 }

-_fzf_kill_completion() {
+_fzf_complete_kill() {
  [ -n "${COMP_WORDS[COMP_CWORD]}" ] && return 1

  local selected fzf
-  [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
+  [ "${FZF_TMUX:-1}" != 0 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"
  tput sc
  selected=$(ps -ef | sed 1d | $fzf -m $FZF_COMPLETION_OPTS | awk '{print $2}' | tr '\n' ' ')
  tput rc
@@ -182,40 +211,48 @@ _fzf_kill_completion() {
  fi
 }

-_fzf_telnet_completion() {
-  _fzf_list_completion '+m' "$@" << "EOF"
-  \grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0' | awk '{if (length($2) > 0) {print $2}}' | sort -u
-EOF
+_fzf_complete_telnet() {
+  _fzf_complete '+m' "$@" < <(
+    \grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0' |
+        awk '{if (length($2) > 0) {print $2}}' | sort -u
+  )
 }

-_fzf_ssh_completion() {
-  _fzf_list_completion '+m' "$@" << "EOF"
-    cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | \grep -i '^host' | \grep -v '*') <(\grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0') | awk '{if (length($2) > 0) {print $2}}' | sort -u
-EOF
+_fzf_complete_ssh() {
+  _fzf_complete '+m' "$@" < <(
+    cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | \grep -i '^host' | \grep -v '*') \
+        <(\grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0') |
+        awk '{if (length($2) > 0) {print $2}}' | sort -u
+  )
 }

-_fzf_env_var_completion() {
-  _fzf_list_completion '-m' "$@" << "EOF"
+_fzf_complete_unset() {
+  _fzf_complete '-m' "$@" < <(
    declare -xp | sed 's/=.*//' | sed 's/.* //'
-EOF
+  )
 }

-_fzf_alias_completion() {
-  _fzf_list_completion '-m' "$@" << "EOF"
+_fzf_complete_export() {
+  _fzf_complete '-m' "$@" < <(
+    declare -xp | sed 's/=.*//' | sed 's/.* //'
+  )
+}
+
+_fzf_complete_unalias() {
+  _fzf_complete '-m' "$@" < <(
    alias | sed 's/=.*//' | sed 's/.* //'
-EOF
+  )
 }

 # fzf options
-complete -F _fzf_opts_completion fzf
+complete -o default -F _fzf_opts_completion fzf

-d_cmds="cd pushd rmdir"
-f_cmds="
-  awk cat diff diff3
-  emacs ex file ftp g++ gcc gvim head hg java
-  javac ld less more mvim patch perl python ruby
-  sed sftp sort source tail tee uniq vi view vim wc"
+d_cmds="${FZF_COMPLETION_DIR_COMMANDS:-cd pushd rmdir}"
 a_cmds="
+  awk cat diff diff3
+  emacs emacsclient ex file ftp g++ gcc gvim head hg java
+  javac ld less more mvim nvim patch perl python ruby
+  sed sftp sort source tail tee uniq vi view vim wc xdg-open
  basename bunzip2 bzip2 chmod chown curl cp dirname du
  find git grep gunzip gzip hg jar
  ln ls mv open rm rsync scp
@@ -223,42 +260,53 @@ a_cmds="
 x_cmds="kill ssh telnet unset unalias export"

 # Preserve existing completion
-if [ "$_fzf_completion_loaded" != '0.9.12' ]; then
+if [ "$_fzf_completion_loaded" != '0.11.3' ]; then
  # Really wish I could use associative array but OSX comes with bash 3.2 :(
  eval $(complete | \grep '\-F' | \grep -v _fzf_ |
-    \grep -E " ($(echo $d_cmds $f_cmds $a_cmds $x_cmds | sed 's/ /|/g' | sed 's/+/\\+/g'))$" | _fzf_orig_completion_filter)
-  export _fzf_completion_loaded=0.9.12
+    \grep -E " ($(echo $d_cmds $a_cmds $x_cmds | sed 's/ /|/g' | sed 's/+/\\+/g'))$" | _fzf_orig_completion_filter)
+  export _fzf_completion_loaded=0.11.3
 fi

 if type _completion_loader > /dev/null 2>&1; then
  _fzf_completion_loader=1
 fi

-# Directory
-for cmd in $d_cmds; do
-  complete -F _fzf_dir_completion -o nospace -o plusdirs $cmd
-done
-
-# File
-for cmd in $f_cmds; do
-  complete -F _fzf_file_completion -o default -o bashdefault $cmd
-done
+_fzf_defc() {
+  local cmd func opts orig_var orig
+  cmd="$1"
+  func="$2"
+  opts="$3"
+  orig_var="_fzf_orig_completion_$cmd"
+  orig="${!orig_var}"
+  if [ -n "$orig" ]; then
+    eval "$(printf "$orig" "$func")"
+  else
+    complete -F "$func" $opts "$cmd"
+  fi
+}

 # Anything
 for cmd in $a_cmds; do
-  complete -F _fzf_all_completion -o default -o bashdefault $cmd
+  _fzf_defc "$cmd" _fzf_path_completion "-o default -o bashdefault"
 done

+# Directory
+for cmd in $d_cmds; do
+  _fzf_defc "$cmd" _fzf_dir_completion "-o nospace -o plusdirs"
+done
+
+unset _fzf_defc
+
 # Kill completion
-complete -F _fzf_kill_completion -o nospace -o default -o bashdefault kill
+complete -F _fzf_complete_kill -o nospace -o default -o bashdefault kill

 # Host completion
-complete -F _fzf_ssh_completion -o default -o bashdefault ssh
-complete -F _fzf_telnet_completion -o default -o bashdefault telnet
+complete -F _fzf_complete_ssh -o default -o bashdefault ssh
+complete -F _fzf_complete_telnet -o default -o bashdefault telnet

 # Environment variables / Aliases
-complete -F _fzf_env_var_completion -o default -o bashdefault unset
-complete -F _fzf_env_var_completion -o default -o bashdefault export
-complete -F _fzf_alias_completion -o default -o bashdefault unalias
+complete -F _fzf_complete_unset -o default -o bashdefault unset
+complete -F _fzf_complete_export -o default -o bashdefault export
+complete -F _fzf_complete_unalias -o default -o bashdefault unalias

-unset cmd d_cmds f_cmds a_cmds x_cmds
+unset cmd d_cmds a_cmds x_cmds
--- a/shell/completion.zsh
+++ b/shell/completion.zsh
@@ -10,17 +10,38 @@
 # - $FZF_COMPLETION_TRIGGER (default: '**')
 # - $FZF_COMPLETION_OPTS    (default: empty)

-_fzf_path_completion() {
-  local base lbuf find_opts fzf_opts suffix tail fzf dir leftover matches nnm
+# To use custom commands instead of find, override _fzf_compgen_{path,dir}
+if ! declare -f _fzf_compgen_path > /dev/null; then
+  _fzf_compgen_path() {
+    echo "$1"
+    \find -L "$1" \
+      -name .git -prune -o -name .svn -prune -o \( -type d -o -type f -o -type l \) \
+      -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
+  }
+fi
+
+if ! declare -f _fzf_compgen_dir > /dev/null; then
+  _fzf_compgen_dir() {
+    \find -L "$1" \
+      -name .git -prune -o -name .svn -prune -o -type d \
+      -a -not -path "$1" -print 2> /dev/null | sed 's@^\./@@'
+  }
+fi
+
+###########################################################
+
+__fzf_generic_path_completion() {
+  local base lbuf compgen fzf_opts suffix tail fzf dir leftover matches nnm
+  # (Q) flag removes a quoting level: "foo\ bar" => "foo bar"
  base=${(Q)1}
  lbuf=$2
-  find_opts=$3
+  compgen=$3
  fzf_opts=$4
  suffix=$5
  tail=$6
  [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"

-  if ! setopt | grep nonomatch > /dev/null; then
+  if ! setopt | \grep nonomatch > /dev/null; then
    nnm=1
    setopt nonomatch
  fi
@@ -29,9 +50,10 @@ _fzf_path_completion() {
    if [ -z "$dir" -o -d ${~dir} ]; then
      leftover=${base/#"$dir"}
      leftover=${leftover/#\/}
-      [ "$dir" = './' ] && dir=''
+      [ -z "$dir" ] && dir='.'
+      [ "$dir" != "/" ] && dir="${dir/%\//}"
      dir=${~dir}
-      matches=$(\find -L $dir* ${=find_opts} 2> /dev/null | ${=fzf} ${=FZF_COMPLETION_OPTS} ${=fzf_opts} -q "$leftover" | while read item; do
+      matches=$(eval "$compgen $(printf %q "$dir")" | ${=fzf} ${=FZF_COMPLETION_OPTS} ${=fzf_opts} -q "$leftover" | while read item; do
        printf "%q$suffix " "$item"
      done)
      matches=${matches% }
@@ -47,65 +69,83 @@ _fzf_path_completion() {
  [ -n "$nnm" ] && unsetopt nonomatch
 }

-_fzf_all_completion() {
-  _fzf_path_completion "$1" "$2" \
-    "-name .git -prune -o -name .svn -prune -o -type d -print -o -type f -print -o -type l -print" \
+_fzf_path_completion() {
+  __fzf_generic_path_completion "$1" "$2" _fzf_compgen_path \
    "-m" "" " "
 }

 _fzf_dir_completion() {
-  _fzf_path_completion "$1" "$2" \
-    "-name .git -prune -o -name .svn -prune -o -type d -print" \
+  __fzf_generic_path_completion "$1" "$2" _fzf_compgen_dir \
    "" "/" ""
 }

-_fzf_list_completion() {
-  local prefix lbuf fzf_opts src fzf matches
-  prefix=$1
+_fzf_feed_fifo() (
+  rm -f "$1"
+  mkfifo "$1"
+  cat <&0 > "$1" &
+)
+
+_fzf_complete() {
+  local fifo fzf_opts lbuf fzf matches post
+  fifo="${TMPDIR:-/tmp}/fzf-complete-fifo-$$"
+  fzf_opts=$1
  lbuf=$2
-  fzf_opts=$3
-  read -r src
+  post="${funcstack[2]}_post"
+  type $post > /dev/null 2>&1 || post=cat
+
  [ ${FZF_TMUX:-1} -eq 1 ] && fzf="fzf-tmux -d ${FZF_TMUX_HEIGHT:-40%}" || fzf="fzf"

-  matches=$(eval "$src" | ${=fzf} ${=FZF_COMPLETION_OPTS} ${=fzf_opts} -q "$prefix")
+  _fzf_feed_fifo "$fifo"
+  matches=$(cat "$fifo" | ${=fzf} ${=FZF_COMPLETION_OPTS} ${=fzf_opts} -q "${(Q)prefix}" | $post | tr '\n' ' ')
  if [ -n "$matches" ]; then
-    LBUFFER="$lbuf$matches "
+    LBUFFER="$lbuf$matches"
  fi
  zle redisplay
+  rm -f "$fifo"
 }

-_fzf_telnet_completion() {
-  _fzf_list_completion "$1" "$2" '+m' << "EOF"
-  \grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0' | awk '{if (length($2) > 0) {print $2}}' | sort -u
-EOF
+_fzf_complete_telnet() {
+  _fzf_complete '+m' "$@" < <(
+    \grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0' |
+        awk '{if (length($2) > 0) {print $2}}' | sort -u
+  )
 }

-_fzf_ssh_completion() {
-  _fzf_list_completion "$1" "$2" '+m' << "EOF"
-    cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | \grep -i '^host' | \grep -v '*') <(\grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0') | awk '{if (length($2) > 0) {print $2}}' | sort -u
-EOF
+_fzf_complete_ssh() {
+  _fzf_complete '+m' "$@" < <(
+    cat <(cat ~/.ssh/config /etc/ssh/ssh_config 2> /dev/null | \grep -i '^host' | \grep -v '*') \
+        <(\grep -v '^\s*\(#\|$\)' /etc/hosts | \grep -Fv '0.0.0.0') |
+        awk '{if (length($2) > 0) {print $2}}' | sort -u
+  )
 }

-_fzf_env_var_completion() {
-  _fzf_list_completion "$1" "$2" '+m' << "EOF"
+_fzf_complete_export() {
+  _fzf_complete '-m' "$@" < <(
    declare -xp | sed 's/=.*//' | sed 's/.* //'
-EOF
+  )
 }

-_fzf_alias_completion() {
-  _fzf_list_completion "$1" "$2" '+m' << "EOF"
+_fzf_complete_unset() {
+  _fzf_complete '-m' "$@" < <(
+    declare -xp | sed 's/=.*//' | sed 's/.* //'
+  )
+}
+
+_fzf_complete_unalias() {
+  _fzf_complete '+m' "$@" < <(
    alias | sed 's/=.*//'
-EOF
+  )
 }

 fzf-completion() {
  local tokens cmd prefix trigger tail fzf matches lbuf d_cmds
+  setopt localoptions noshwordsplit

  # http://zsh.sourceforge.net/FAQ/zshfaq03.html
  # http://zsh.sourceforge.net/Doc/Release/Expansion.html#Parameter-Expansion-Flags
  tokens=(${(z)LBUFFER})
  if [ ${#tokens} -lt 1 ]; then
-    eval "zle ${fzf_default_completion:-expand-or-complete}"
+    zle ${fzf_default_completion:-expand-or-complete}
    return
  fi

@@ -126,33 +166,26 @@ fzf-completion() {
    zle redisplay
  # Trigger sequence given
  elif [ ${#tokens} -gt 1 -a "$tail" = "$trigger" ]; then
-    d_cmds=(cd pushd rmdir)
+    d_cmds=(${=FZF_COMPLETION_DIR_COMMANDS:-cd pushd rmdir})

    [ -z "$trigger"      ] && prefix=${tokens[-1]} || prefix=${tokens[-1]:0:-${#trigger}}
    [ -z "${tokens[-1]}" ] && lbuf=$LBUFFER        || lbuf=${LBUFFER:0:-${#tokens[-1]}}

-    if [ ${d_cmds[(i)$cmd]} -le ${#d_cmds} ]; then
-      _fzf_dir_completion "$prefix" $lbuf
-    elif [ $cmd = telnet ]; then
-      _fzf_telnet_completion "$prefix" $lbuf
-    elif [ $cmd = ssh ]; then
-      _fzf_ssh_completion "$prefix" $lbuf
-    elif [ $cmd = unset -o $cmd = export ]; then
-      _fzf_env_var_completion "$prefix" $lbuf
-    elif [ $cmd = unalias ]; then
-      _fzf_alias_completion "$prefix" $lbuf
+    if eval "type _fzf_complete_${cmd} > /dev/null"; then
+      eval "prefix=\"$prefix\" _fzf_complete_${cmd} \"$lbuf\""
+    elif [ ${d_cmds[(i)$cmd]} -le ${#d_cmds} ]; then
+      _fzf_dir_completion "$prefix" "$lbuf"
    else
-      _fzf_all_completion "$prefix" $lbuf
+      _fzf_path_completion "$prefix" "$lbuf"
    fi
  # Fall back to default completion
  else
-    eval "zle ${fzf_default_completion:-expand-or-complete}"
+    zle ${fzf_default_completion:-expand-or-complete}
  fi
 }

 [ -z "$fzf_default_completion" ] &&
-  fzf_default_completion=$(bindkey '^I' | grep -v undefined-key | awk '{print $2}')
+  fzf_default_completion=$(bindkey '^I' | \grep -v undefined-key | awk '{print $2}')

 zle     -N   fzf-completion
 bindkey '^I' fzf-completion
-
--- a/shell/key-bindings.bash
+++ b/shell/key-bindings.bash
@@ -1,10 +1,11 @@
 # Key bindings
 # ------------
 __fzf_select__() {
-  command find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
+  local cmd="${FZF_CTRL_T_COMMAND:-"command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
    -o -type f -print \
    -o -type d -print \
-    -o -type l -print 2> /dev/null | sed 1d | cut -b3- | fzf -m | while read item; do
+    -o -type l -print 2> /dev/null | sed 1d | cut -b3-"}"
+  eval "$cmd" | fzf -m | while read -r item; do
    printf '%q ' "$item"
  done
  echo
@@ -13,7 +14,7 @@ __fzf_select__() {
 if [[ $- =~ i ]]; then

 __fzfcmd() {
-  [ ${FZF_TMUX:-1} -eq 1 ] && echo "fzf-tmux -d${FZF_TMUX_HEIGHT:-40%}" || echo "fzf"
+  [ "${FZF_TMUX:-1}" != 0 ] && echo "fzf-tmux -d${FZF_TMUX_HEIGHT:-40%}" || echo "fzf"
 }

 __fzf_select_tmux__() {
@@ -24,25 +25,45 @@ __fzf_select_tmux__() {
  else
    height="-l $height"
  fi
-  tmux split-window $height "cd $(printf %q "$PWD");bash -c 'source ~/.fzf.bash; tmux send-keys -t $TMUX_PANE \"\$(__fzf_select__)\"'"
+
+  tmux split-window $height "cd $(printf %q "$PWD"); FZF_DEFAULT_OPTS=$(printf %q "$FZF_DEFAULT_OPTS") PATH=$(printf %q "$PATH") FZF_CTRL_T_COMMAND=$(printf %q "$FZF_CTRL_T_COMMAND") bash -c 'source \"${BASH_SOURCE[0]}\"; tmux send-keys -t $TMUX_PANE \"\$(__fzf_select__)\"'"
+}
+
+__fzf_select_tmux_auto__() {
+  if [ "${FZF_TMUX:-1}" != 0 ] && [ ${LINES:-40} -gt 15 ]; then
+    __fzf_select_tmux__
+  else
+    tmux send-keys -t "$TMUX_PANE" "$(__fzf_select__)"
+  fi
 }

 __fzf_cd__() {
-  local dir
-  dir=$(command find -L ${1:-.} \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
-    -o -type d -print 2> /dev/null | sed 1d | cut -b3- | $(__fzfcmd) +m) && printf 'cd %q' "$dir"
+  local cmd dir
+  cmd="${FZF_ALT_C_COMMAND:-"command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
+    -o -type d -print 2> /dev/null | sed 1d | cut -b3-"}"
+  dir=$(eval "$cmd" | $(__fzfcmd) +m) && printf 'cd %q' "$dir"
 }

-__fzf_history__() {
+__fzf_history__() (
  local line
+  shopt -u nocaseglob nocasematch
  line=$(
    HISTTIMEFORMAT= history |
-    $(__fzfcmd) +s --tac +m -n2..,.. --tiebreak=index --toggle-sort=ctrl-r |
-    \grep '^ *[0-9]') && sed 's/ *\([0-9]*\)\** .*/!\1/' <<< "$line"
-}
+    $(__fzfcmd) +s --tac +m -n2..,.. --tiebreak=index --toggle-sort=ctrl-r $FZF_CTRL_R_OPTS |
+    \grep '^ *[0-9]') &&
+    if [[ $- =~ H ]]; then
+      sed 's/^ *\([0-9]*\)\** .*/!\1/' <<< "$line"
+    else
+      sed 's/^ *\([0-9]*\)\** *//' <<< "$line"
+    fi
+)

 __use_tmux=0
-[ -n "$TMUX_PANE" -a ${FZF_TMUX:-1} -ne 0 -a ${LINES:-40} -gt 15 ] && __use_tmux=1
+__use_tmux_auto=0
+if [ -n "$TMUX_PANE" ]; then
+  [ "${FZF_TMUX:-1}" != 0 ] && [ ${LINES:-40} -gt 15 ] && __use_tmux=1
+  [ $BASH_VERSINFO -gt 3 ] && __use_tmux_auto=1
+fi

 if [ -z "$(set -o | \grep '^vi.*on')" ]; then
  # Required to refresh the prompt after fzf
@@ -50,7 +71,9 @@ if [ -z "$(set -o | \grep '^vi.*on')" ]; then
  bind '"\e^": history-expand-line'

  # CTRL-T - Paste the selected file path into the command line
-  if [ $__use_tmux -eq 1 ]; then
+  if [ $__use_tmux_auto -eq 1 ]; then
+    bind -x '"\C-t": "__fzf_select_tmux_auto__"'
+  elif [ $__use_tmux -eq 1 ]; then
    bind '"\C-t": " \C-u \C-a\C-k$(__fzf_select_tmux__)\e\C-e\C-y\C-a\C-d\C-y\ey\C-h"'
  else
    bind '"\C-t": " \C-u \C-a\C-k$(__fzf_select__)\e\C-e\C-y\C-a\C-y\ey\C-h\C-e\er \C-h"'
@@ -62,28 +85,39 @@ if [ -z "$(set -o | \grep '^vi.*on')" ]; then
  # ALT-C - cd into the selected directory
  bind '"\ec": " \C-e\C-u$(__fzf_cd__)\e\C-e\er\C-m"'
 else
+  # We'd usually use "\e" to enter vi-movement-mode so we can do our magic,
+  # but this incurs a very noticeable delay of a half second or so,
+  # because many other commands start with "\e".
+  # Instead, we bind an unused key, "\C-x\C-a",
+  # to also enter vi-movement-mode,
+  # and then use that thereafter.
+  # (We imagine that "\C-x\C-a" is relatively unlikely to be in use.)
+  bind '"\C-x\C-a": vi-movement-mode'
+
  bind '"\C-x\C-e": shell-expand-line'
  bind '"\C-x\C-r": redraw-current-line'
  bind '"\C-x^": history-expand-line'

  # CTRL-T - Paste the selected file path into the command line
  # - FIXME: Selected items are attached to the end regardless of cursor position
-  if [ $__use_tmux -eq 1 ]; then
-    bind '"\C-t": "\e$a \eddi$(__fzf_select_tmux__)\C-x\C-e\e0P$xa"'
+  if [ $__use_tmux_auto -eq 1 ]; then
+    bind -x '"\C-t": "__fzf_select_tmux_auto__"'
+  elif [ $__use_tmux -eq 1 ]; then
+    bind '"\C-t": "\C-x\C-a$a \C-x\C-addi$(__fzf_select_tmux__)\C-x\C-e\C-x\C-a0P$xa"'
  else
-    bind '"\C-t": "\e$a \eddi$(__fzf_select__)\C-x\C-e\e0Px$a \C-x\C-r\exa "'
+    bind '"\C-t": "\C-x\C-a$a \C-x\C-addi$(__fzf_select__)\C-x\C-e\C-x\C-a0Px$a \C-x\C-r\C-x\C-axa "'
  fi
  bind -m vi-command '"\C-t": "i\C-t"'

  # CTRL-R - Paste the selected command from history into the command line
-  bind '"\C-r": "\eddi$(__fzf_history__)\C-x\C-e\C-x^\e$a\C-x\C-r"'
+  bind '"\C-r": "\C-x\C-addi$(__fzf_history__)\C-x\C-e\C-x^\C-x\C-a$a\C-x\C-r"'
  bind -m vi-command '"\C-r": "i\C-r"'

  # ALT-C - cd into the selected directory
-  bind '"\ec": "\eddi$(__fzf_cd__)\C-x\C-e\C-x\C-r\C-m"'
-  bind -m vi-command '"\ec": "i\ec"'
+  bind '"\ec": "\C-x\C-addi$(__fzf_cd__)\C-x\C-e\C-x\C-r\C-m"'
+  bind -m vi-command '"\ec": "ddi$(__fzf_cd__)\C-x\C-e\C-x\C-r\C-m"'
 fi

-unset __use_tmux
+unset -v __use_tmux __use_tmux_auto

 fi
--- a/shell/key-bindings.fish
+++ b/shell/key-bindings.fish
@@ -14,26 +14,31 @@ function fzf_key_bindings
  end

  function __fzf_ctrl_t
-    command find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
+    set -q FZF_CTRL_T_COMMAND; or set -l FZF_CTRL_T_COMMAND "
+    command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
      -o -type f -print \
      -o -type d -print \
-      -o -type l -print 2> /dev/null | sed 1d | cut -b3- | eval (__fzfcmd) -m > $TMPDIR/fzf.result
+      -o -type l -print 2> /dev/null | sed 1d | cut -b3-"
+    eval "$FZF_CTRL_T_COMMAND | "(__fzfcmd)" -m > $TMPDIR/fzf.result"
+    and sleep 0
    and commandline -i (cat $TMPDIR/fzf.result | __fzf_escape)
    commandline -f repaint
    rm -f $TMPDIR/fzf.result
  end

  function __fzf_ctrl_r
-    history | eval (__fzfcmd) +s +m --tiebreak=index --toggle-sort=ctrl-r > $TMPDIR/fzf.result
+    history | eval (__fzfcmd) +s +m --tiebreak=index --toggle-sort=ctrl-r $FZF_CTRL_R_OPTS > $TMPDIR/fzf.result
    and commandline (cat $TMPDIR/fzf.result)
    commandline -f repaint
    rm -f $TMPDIR/fzf.result
  end

  function __fzf_alt_c
+    set -q FZF_ALT_C_COMMAND; or set -l FZF_ALT_C_COMMAND "
+    command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
+      -o -type d -print 2> /dev/null | sed 1d | cut -b3-"
    # Fish hangs if the command before pipe redirects (2> /dev/null)
-    command find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) \
-      -prune -o -type d -print 2> /dev/null | sed 1d | cut -b3- | eval (__fzfcmd) +m > $TMPDIR/fzf.result
+    eval "$FZF_ALT_C_COMMAND | "(__fzfcmd)" +m > $TMPDIR/fzf.result"
    [ (cat $TMPDIR/fzf.result | wc -l) -gt 0 ]
    and cd (cat $TMPDIR/fzf.result)
    commandline -f repaint
--- a/shell/key-bindings.zsh
+++ b/shell/key-bindings.zsh
@@ -1,11 +1,14 @@
 # Key bindings
 # ------------
+if [[ $- == *i* ]]; then
+
 # CTRL-T - Paste the selected file path(s) into the command line
 __fsel() {
-  command find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
+  local cmd="${FZF_CTRL_T_COMMAND:-"command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
    -o -type f -print \
    -o -type d -print \
-    -o -type l -print 2> /dev/null | sed 1d | cut -b3- | $(__fzfcmd) -m | while read item; do
+    -o -type l -print 2> /dev/null | sed 1d | cut -b3-"}"
+  eval "$cmd" | $(__fzfcmd) -m | while read item; do
    printf '%q ' "$item"
  done
  echo
@@ -15,8 +18,6 @@ __fzfcmd() {
  [ ${FZF_TMUX:-1} -eq 1 ] && echo "fzf-tmux -d${FZF_TMUX_HEIGHT:-40%}" || echo "fzf"
 }

-if [[ $- =~ i ]]; then
-
 fzf-file-widget() {
  LBUFFER="${LBUFFER}$(__fsel)"
  zle redisplay
@@ -26,8 +27,9 @@ bindkey '^T' fzf-file-widget

 # ALT-C - cd into the selected directory
 fzf-cd-widget() {
-  cd "${$(command find -L . \( -path '*/\.*' -o -fstype 'dev' -o -fstype 'proc' \) -prune \
-    -o -type d -print 2> /dev/null | sed 1d | cut -b3- | $(__fzfcmd) +m):-.}"
+  local cmd="${FZF_ALT_C_COMMAND:-"command find -L . \\( -path '*/\\.*' -o -fstype 'dev' -o -fstype 'proc' \\) -prune \
+    -o -type d -print 2> /dev/null | sed 1d | cut -b3-"}"
+  cd "${$(eval "$cmd" | $(__fzfcmd) +m):-.}"
  zle reset-prompt
 }
 zle     -N    fzf-cd-widget
@@ -35,17 +37,12 @@ bindkey '\ec' fzf-cd-widget

 # CTRL-R - Paste the selected command from history into the command line
 fzf-history-widget() {
-  local selected restore_no_bang_hist
-  if selected=$(fc -l 1 | $(__fzfcmd) +s --tac +m -n2..,.. --tiebreak=index --toggle-sort=ctrl-r -q "$LBUFFER"); then
-    num=$(echo "$selected" | head -n1 | awk '{print $1}' | sed 's/[^0-9]//g')
+  local selected num
+  selected=( $(fc -l 1 | $(__fzfcmd) +s --tac +m -n2..,.. --tiebreak=index --toggle-sort=ctrl-r ${=FZF_CTRL_R_OPTS} -q "${LBUFFER//$/\\$}") )
+  if [ -n "$selected" ]; then
+    num=$selected[1]
    if [ -n "$num" ]; then
-      LBUFFER=!$num
-      if setopt | grep nobanghist > /dev/null; then
-        restore_no_bang_hist=1
-        unsetopt no_bang_hist
-      fi
-      zle expand-history
-      [ -n "$restore_no_bang_hist" ] && setopt no_bang_hist
+      zle vi-fetch-history -n $num
    fi
  fi
  zle redisplay
--- a/src/Dockerfile.android
+++ b/src/Dockerfile.android
@@ -0,0 +1,40 @@
+FROM ubuntu:14.04
+MAINTAINER Junegunn Choi <junegunn.c@gmail.com>
+
+# apt-get
+RUN apt-get update && apt-get -y upgrade && \
+    apt-get install -y --force-yes git curl build-essential
+
+# Install Go 1.4
+RUN cd / && curl \
+    https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz | \
+    tar -xz && mv go go1.4 && \
+    sed -i 's@#define PTHREAD_KEYS_MAX 128@@' /go1.4/src/runtime/cgo/gcc_android_arm.c
+
+ENV GOROOT /go1.4
+ENV PATH /go1.4/bin:$PATH
+
+RUN cd / && \
+    curl -O http://dl.google.com/android/ndk/android-ndk-r10e-linux-x86_64.bin && \
+    chmod 755 /android-ndk* && /android-ndk-r10e-linux-x86_64.bin && \
+    mv android-ndk-r10e /android-ndk
+
+RUN cd /android-ndk && bash ./build/tools/make-standalone-toolchain.sh --platform=android-21 --install-dir=/ndk --arch=arm
+
+ENV NDK_CC /ndk/bin/arm-linux-androideabi-gcc
+
+RUN cd $GOROOT/src && \
+    CC_FOR_TARGET=$NDK_CC GOOS=android GOARCH=arm GOARM=7 ./make.bash
+
+RUN cd / && curl \
+    http://ftp.gnu.org/gnu/ncurses/ncurses-5.9.tar.gz | \
+    tar -xz && cd /ncurses-5.9 && \
+    ./configure CC=$NDK_CC CFLAGS="-fPIE -march=armv7-a -mfpu=neon -mhard-float -Wl,--no-warn-mismatch" LDFLAGS="-march=armv7-a -Wl,--no-warn-mismatch" --host=arm-linux --enable-overwrite --enable-const --without-cxx-binding  --without-shared --without-debug --enable-widec --enable-ext-colors --enable-ext-mouse --enable-pc-files --with-pkg-config-libdir=$PKG_CONFIG_LIBDIR --without-manpages --without-ada --disable-shared --without-tests --prefix=/ndk/sysroot/usr --with-default-terminfo-dirs=/usr/share/terminfo --with-terminfo-dirs=/usr/share/terminfo ac_cv_header_locale_h=n ac_cv_func_getpwent=no ac_cv_func_getpwnam=no ac_cv_func_getpwuid=no && \
+    sed -i 's@#define HAVE_LOCALE_H 1@/* #undef HAVE_LOCALE_H */@' include/ncurses_cfg.h && \
+    make && \
+    sed -i '0,/echo.*/{s/echo.*/exit 0/}' misc/run_tic.sh && \
+    make install && \
+    mv /ndk/sysroot/usr/lib/libncursesw.a /ndk/sysroot/usr/lib/libncurses.a
+
+# Default CMD
+CMD cd /fzf/src && /bin/bash
--- a/src/Dockerfile.arch
+++ b/src/Dockerfile.arch
@@ -2,6 +2,7 @@ FROM base/archlinux:2014.07.03
 MAINTAINER Junegunn Choi <junegunn.c@gmail.com>

 # apt-get
+RUN pacman-key --populate archlinux && pacman-key --refresh-keys
 RUN pacman-db-upgrade && pacman -Syu --noconfirm base-devel git

 # Install Go 1.4
@@ -9,7 +10,6 @@ RUN cd / && curl \
    https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz | \
    tar -xz && mv go go1.4

-ENV GOPATH /go
 ENV GOROOT /go1.4
 ENV PATH /go1.4/bin:$PATH

@@ -19,9 +19,6 @@ RUN echo '[multilib]' >> /etc/pacman.conf && \
    pacman-db-upgrade && yes | pacman -Sy gcc-multilib lib32-ncurses && \
    cd $GOROOT/src && GOARCH=386 ./make.bash

-# Volume
-VOLUME /go
-
 # Default CMD
-CMD cd /go/src/github.com/junegunn/fzf/src && /bin/bash
+CMD cd /fzf/src && /bin/bash

--- a/src/Dockerfile.centos
+++ b/src/Dockerfile.centos
@@ -1,21 +1,32 @@
-FROM centos:centos7
+FROM centos:centos6
 MAINTAINER Junegunn Choi <junegunn.c@gmail.com>

 # yum
-RUN yum install -y git gcc make tar ncurses-devel
+RUN yum install -y git gcc make tar glibc-devel glibc-devel.i686 \
+    ncurses-devel ncurses-static ncurses-devel.i686 \
+    gpm-devel gpm-static libgcc.i686

 # Install Go 1.4
 RUN cd / && curl \
    https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz | \
    tar -xz && mv go go1.4

-ENV GOPATH /go
-ENV GOROOT /go1.4
-ENV PATH /go1.4/bin:$PATH
+# Install Go 1.5
+RUN cd / && curl \
+    https://storage.googleapis.com/golang/go1.5.3.linux-amd64.tar.gz | \
+    tar -xz && mv go go1.5

-# Volume
-VOLUME /go
+# Install RPMs for building static 32-bit binary
+RUN curl ftp://ftp.pbone.net/mirror/ftp.centos.org/6.7/os/i386/Packages/ncurses-static-5.7-4.20090207.el6.i686.rpm -o rpm && rpm -i rpm && \
+    curl ftp://ftp.pbone.net/mirror/ftp.centos.org/6.7/os/i386/Packages/gpm-static-1.20.6-12.el6.i686.rpm -o rpm && rpm -i rpm
+
+ENV GOROOT_BOOTSTRAP /go1.4
+ENV GOROOT /go1.5
+ENV PATH /go1.5/bin:$PATH
+
+# For i386 build
+RUN cd $GOROOT/src && GOARCH=386 ./make.bash

 # Default CMD
-CMD cd /go/src/github.com/junegunn/fzf/src && /bin/bash
+CMD cd /fzf/src && /bin/bash

--- a/src/Dockerfile.ubuntu
+++ b/src/Dockerfile.ubuntu
@@ -3,14 +3,13 @@ MAINTAINER Junegunn Choi <junegunn.c@gmail.com>

 # apt-get
 RUN apt-get update && apt-get -y upgrade && \
-    apt-get install -y --force-yes git curl build-essential libncurses-dev
+    apt-get install -y --force-yes git curl build-essential libncurses-dev libgpm-dev

 # Install Go 1.4
 RUN cd / && curl \
    https://storage.googleapis.com/golang/go1.4.2.linux-amd64.tar.gz | \
    tar -xz && mv go go1.4

-ENV GOPATH /go
 ENV GOROOT /go1.4
 ENV PATH /go1.4/bin:$PATH

@@ -18,9 +17,6 @@ ENV PATH /go1.4/bin:$PATH
 RUN apt-get install -y lib32ncurses5-dev && \
    cd $GOROOT/src && GOARCH=386 ./make.bash

-# Volume
-VOLUME /go
-
 # Default CMD
-CMD cd /go/src/github.com/junegunn/fzf/src && /bin/bash
+CMD cd /fzf/src && /bin/bash

--- a/src/LICENSE
+++ b/src/LICENSE
@@ -1,6 +1,6 @@
 The MIT License (MIT)

-Copyright (c) 2015 Junegunn Choi
+Copyright (c) 2016 Junegunn Choi

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
--- a/src/Makefile
+++ b/src/Makefile
@@ -1,40 +1,55 @@
-ifndef GOPATH
-$(error GOPATH is undefined)
-endif
-
+ifndef GOOS
 UNAME_S := $(shell uname -s)
 ifeq ($(UNAME_S),Darwin)
 	GOOS := darwin
 else ifeq ($(UNAME_S),Linux)
 	GOOS := linux
 endif
+endif

 ifneq ($(shell uname -m),x86_64)
 $(error "Build on $(UNAME_M) is not supported, yet.")
 endif

 SOURCES     := $(wildcard *.go */*.go)
-BINDIR    := ../bin
-
+ROOTDIR     := $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))
+BINDIR      := $(shell dirname $(ROOTDIR))/bin
+GOPATH      := $(shell dirname $(ROOTDIR))/gopath
+SRCDIR      := $(GOPATH)/src/github.com/junegunn/fzf/src
+DOCKEROPTS  := -i -t -v $(ROOTDIR):/fzf/src
 BINARY32    := fzf-$(GOOS)_386
 BINARY64    := fzf-$(GOOS)_amd64
-VERSION    = $(shell fzf/$(BINARY64) --version)
-RELEASE32  = fzf-$(VERSION)-$(GOOS)_386
-RELEASE64  = fzf-$(VERSION)-$(GOOS)_amd64
+BINARYARM7  := fzf-$(GOOS)_arm7
+VERSION     := $(shell awk -F= '/version =/ {print $$2}' constants.go | tr -d "\" ")
+RELEASE32   := fzf-$(VERSION)-$(GOOS)_386
+RELEASE64   := fzf-$(VERSION)-$(GOOS)_amd64
+RELEASEARM7 := fzf-$(VERSION)-$(GOOS)_arm7
+export GOPATH

 all: release

-release: build
-	cd fzf && \
-	cp $(BINARY32) $(RELEASE32) && tar -czf $(RELEASE32).tgz $(RELEASE32) && \
-	cp $(BINARY64) $(RELEASE64) && tar -czf $(RELEASE64).tgz $(RELEASE64) && \
-	rm $(RELEASE32) $(RELEASE64)
+release: test build
+	-cd fzf && cp $(BINARY32) $(RELEASE32) && tar -czf $(RELEASE32).tgz $(RELEASE32)
+	cd fzf && cp $(BINARY64) $(RELEASE64) && tar -czf $(RELEASE64).tgz $(RELEASE64) && \
+	rm -f $(RELEASE32) $(RELEASE64)

-build: test fzf/$(BINARY32) fzf/$(BINARY64)
+build: fzf/$(BINARY32) fzf/$(BINARY64)

-test:
-	go get
-	go test -v ./...
+$(SRCDIR):
+	mkdir -p $(shell dirname $(SRCDIR))
+	ln -s $(ROOTDIR) $(SRCDIR)
+
+deps: $(SRCDIR) $(SOURCES)
+	cd $(SRCDIR) && go get
+
+android-build: $(SRCDIR)
+	cd $(SRCDIR) && GOARCH=arm GOARM=7 CGO_ENABLED=1 go get
+	cd $(SRCDIR)/fzf && GOARCH=arm GOARM=7 CGO_ENABLED=1 go build -a -ldflags="-extldflags=-pie" -o $(BINARYARM7)
+	cd $(SRCDIR)/fzf && cp $(BINARYARM7) $(RELEASEARM7) && tar -czf $(RELEASEARM7).tgz $(RELEASEARM7) && \
+	rm -f $(RELEASEARM7)
+
+test: deps
+	SHELL=/bin/sh go test -v ./...

 install: $(BINDIR)/fzf

@@ -42,13 +57,13 @@ uninstall:
 	rm -f $(BINDIR)/fzf $(BINDIR)/$(BINARY64)

 clean:
-	cd fzf && rm -f $(BINARY32) $(BINARY64) $(RELEASE32).tgz $(RELEASE64).tgz
+	cd fzf && rm -f fzf-*

-fzf/$(BINARY32): $(SOURCES)
-	cd fzf && GOARCH=386 CGO_ENABLED=1 go build -o $(BINARY32)
+fzf/$(BINARY32): deps
+	cd fzf && GOARCH=386 CGO_ENABLED=1 go build -a -tags "$(TAGS)" -o $(BINARY32)

-fzf/$(BINARY64): $(SOURCES)
-	cd fzf && go build -o $(BINARY64)
+fzf/$(BINARY64): deps
+	cd fzf && go build -a -tags "$(TAGS)" -o $(BINARY64)

 $(BINDIR)/fzf: fzf/$(BINARY64) | $(BINDIR)
 	cp -f fzf/$(BINARY64) $(BINDIR)
@@ -57,18 +72,42 @@ $(BINDIR)/fzf: fzf/$(BINARY64) | $(BINDIR)
 $(BINDIR):
 	mkdir -p $@

-# Linux distribution to build fzf on
-DISTRO := arch
+docker-arch:
+	docker build -t junegunn/arch-sandbox - < Dockerfile.arch

-docker:
-	docker build -t junegunn/$(DISTRO)-sandbox - < Dockerfile.$(DISTRO)
+docker-ubuntu:
+	docker build -t junegunn/ubuntu-sandbox - < Dockerfile.ubuntu

-linux: docker
-	docker run -i -t -v $(GOPATH):/go junegunn/$(DISTRO)-sandbox \
-		/bin/bash -ci 'cd /go/src/github.com/junegunn/fzf/src; make'
+docker-centos:
+	docker build -t junegunn/centos-sandbox - < Dockerfile.centos

-$(DISTRO): docker
-	docker run -i -t -v $(GOPATH):/go junegunn/$(DISTRO)-sandbox \
-		sh -c 'cd /go/src/github.com/junegunn/fzf/src; /bin/bash'
+docker-android:
+	docker build -t junegunn/android-sandbox - < Dockerfile.android

-.PHONY: all build release test install uninstall clean docker linux $(DISTRO)
+arch: docker-arch
+	docker run $(DOCKEROPTS) junegunn/$@-sandbox \
+		sh -c 'cd /fzf/src; /bin/bash'
+
+ubuntu: docker-ubuntu
+	docker run $(DOCKEROPTS) junegunn/$@-sandbox \
+		sh -c 'cd /fzf/src; /bin/bash'
+
+centos: docker-centos
+	docker run $(DOCKEROPTS) junegunn/$@-sandbox \
+		sh -c 'cd /fzf/src; /bin/bash'
+
+linux: docker-centos
+	docker run $(DOCKEROPTS) junegunn/centos-sandbox \
+		/bin/bash -ci 'cd /fzf/src; make TAGS=static'
+
+ubuntu-android: docker-android
+	docker run $(DOCKEROPTS) junegunn/android-sandbox \
+		sh -c 'cd /fzf/src; /bin/bash'
+
+android: docker-android
+	docker run $(DOCKEROPTS) junegunn/android-sandbox \
+		/bin/bash -ci 'cd /fzf/src; GOOS=android make android-build'
+
+.PHONY: all build deps release test install uninstall clean \
+	linux arch ubuntu centos docker-arch docker-ubuntu docker-centos \
+	android-build docker-android ubuntu-android android
--- a/src/algo/algo.go
+++ b/src/algo/algo.go
@@ -1,6 +1,7 @@
 package algo

 import (
+	"strings"
 	"unicode"

 	"github.com/junegunn/fzf/src/util"
@@ -14,10 +15,37 @@ import (
 * In short: They try to do as little work as possible.
 */

+func runeAt(runes []rune, index int, max int, forward bool) rune {
+	if forward {
+		return runes[index]
+	}
+	return runes[max-index-1]
+}
+
+// Result conatins the results of running a match function.
+type Result struct {
+	Start int32
+	End   int32
+
+	// Items are basically sorted by the lengths of matched substrings.
+	// But we slightly adjust the score with bonus for better results.
+	Bonus int32
+}
+
+type charClass int
+
+const (
+	charNonWord charClass = iota
+	charLower
+	charUpper
+	charLetter
+	charNumber
+)
+
 // FuzzyMatch performs fuzzy-match
-func FuzzyMatch(caseSensitive bool, runes *[]rune, pattern []rune) (int, int) {
+func FuzzyMatch(caseSensitive bool, forward bool, runes []rune, pattern []rune) Result {
 	if len(pattern) == 0 {
-		return 0, 0
+		return Result{0, 0, 0}
 	}

 	// 0. (FIXME) How to find the shortest match?
@@ -33,7 +61,11 @@ func FuzzyMatch(caseSensitive bool, runes *[]rune, pattern []rune) (int, int) {
 	sidx := -1
 	eidx := -1

-	for index, char := range *runes {
+	lenRunes := len(runes)
+	lenPattern := len(pattern)
+
+	for index := range runes {
+		char := runeAt(runes, index, lenRunes, forward)
 		// This is considerably faster than blindly applying strings.ToLower to the
 		// whole string
 		if !caseSensitive {
@@ -46,11 +78,12 @@ func FuzzyMatch(caseSensitive bool, runes *[]rune, pattern []rune) (int, int) {
 				char = unicode.To(unicode.LowerCase, char)
 			}
 		}
-		if char == pattern[pidx] {
+		pchar := runeAt(pattern, pidx, lenPattern, forward)
+		if char == pchar {
 			if sidx < 0 {
 				sidx = index
 			}
-			if pidx++; pidx == len(pattern) {
+			if pidx++; pidx == lenPattern {
 				eidx = index + 1
 				break
 			}
@@ -60,7 +93,7 @@ func FuzzyMatch(caseSensitive bool, runes *[]rune, pattern []rune) (int, int) {
 	if sidx >= 0 && eidx >= 0 {
 		pidx--
 		for index := eidx - 1; index >= sidx; index-- {
-			char := (*runes)[index]
+			char := runeAt(runes, index, lenRunes, forward)
 			if !caseSensitive {
 				if char >= 'A' && char <= 'Z' {
 					char += 32
@@ -68,16 +101,85 @@ func FuzzyMatch(caseSensitive bool, runes *[]rune, pattern []rune) (int, int) {
 					char = unicode.To(unicode.LowerCase, char)
 				}
 			}
-			if char == pattern[pidx] {
+
+			pchar := runeAt(pattern, pidx, lenPattern, forward)
+			if char == pchar {
 				if pidx--; pidx < 0 {
 					sidx = index
 					break
 				}
 			}
 		}
-		return sidx, eidx
+
+		// Calculate the bonus. This can't be done at the same time as the
+		// pattern scan above because 'forward' may be false.
+		if !forward {
+			sidx, eidx = lenRunes-eidx, lenRunes-sidx
 		}
-	return -1, -1
+
+		var bonus int32
+		pidx := 0
+		consecutive := false
+		prevClass := charNonWord
+		for index := 0; index < eidx; index++ {
+			char := runes[index]
+			var class charClass
+			if unicode.IsLower(char) {
+				class = charLower
+			} else if unicode.IsUpper(char) {
+				class = charUpper
+			} else if unicode.IsLetter(char) {
+				class = charLetter
+			} else if unicode.IsNumber(char) {
+				class = charNumber
+			} else {
+				class = charNonWord
+			}
+
+			var point int32
+			if prevClass == charNonWord && class != charNonWord {
+				// Word boundary
+				point = 2
+			} else if prevClass == charLower && class == charUpper ||
+				prevClass != charNumber && class == charNumber {
+				// camelCase letter123
+				point = 1
+			}
+			prevClass = class
+
+			if index >= sidx {
+				if !caseSensitive {
+					if char >= 'A' && char <= 'Z' {
+						char += 32
+					} else if char > unicode.MaxASCII {
+						char = unicode.To(unicode.LowerCase, char)
+					}
+				}
+				pchar := pattern[pidx]
+				if pchar == char {
+					// Boost bonus for the first character in the pattern
+					if pidx == 0 {
+						point *= 2
+					}
+					// Bonus to consecutive matching chars
+					if consecutive {
+						point++
+					}
+					bonus += point
+
+					if pidx++; pidx == lenPattern {
+						break
+					}
+					consecutive = true
+				} else {
+					consecutive = false
+				}
+			}
+		}
+
+		return Result{int32(sidx), int32(eidx), bonus}
+	}
+	return Result{-1, -1, 0}
 }

 // ExactMatchNaive is a basic string searching algorithm that handles case
@@ -87,20 +189,22 @@ func FuzzyMatch(caseSensitive bool, runes *[]rune, pattern []rune) (int, int) {
 //
 // We might try to implement better algorithms in the future:
 // http://en.wikipedia.org/wiki/String_searching_algorithm
-func ExactMatchNaive(caseSensitive bool, runes *[]rune, pattern []rune) (int, int) {
+func ExactMatchNaive(caseSensitive bool, forward bool, runes []rune, pattern []rune) Result {
+	// Note: ExactMatchNaive always return a zero bonus.
 	if len(pattern) == 0 {
-		return 0, 0
+		return Result{0, 0, 0}
 	}

-	numRunes := len(*runes)
-	plen := len(pattern)
-	if numRunes < plen {
-		return -1, -1
+	lenRunes := len(runes)
+	lenPattern := len(pattern)
+
+	if lenRunes < lenPattern {
+		return Result{-1, -1, 0}
 	}

 	pidx := 0
-	for index := 0; index < numRunes; index++ {
-		char := (*runes)[index]
+	for index := 0; index < lenRunes; index++ {
+		char := runeAt(runes, index, lenRunes, forward)
 		if !caseSensitive {
 			if char >= 'A' && char <= 'Z' {
 				char += 32
@@ -108,44 +212,50 @@ func ExactMatchNaive(caseSensitive bool, runes *[]rune, pattern []rune) (int, in
 				char = unicode.To(unicode.LowerCase, char)
 			}
 		}
-		if pattern[pidx] == char {
+		pchar := runeAt(pattern, pidx, lenPattern, forward)
+		if pchar == char {
 			pidx++
-			if pidx == plen {
-				return index - plen + 1, index + 1
+			if pidx == lenPattern {
+				if forward {
+					return Result{int32(index - lenPattern + 1), int32(index + 1), 0}
+				}
+				return Result{int32(lenRunes - (index + 1)), int32(lenRunes - (index - lenPattern + 1)), 0}
 			}
 		} else {
 			index -= pidx
 			pidx = 0
 		}
 	}
-	return -1, -1
+	return Result{-1, -1, 0}
 }

 // PrefixMatch performs prefix-match
-func PrefixMatch(caseSensitive bool, runes *[]rune, pattern []rune) (int, int) {
-	if len(*runes) < len(pattern) {
-		return -1, -1
+func PrefixMatch(caseSensitive bool, forward bool, runes []rune, pattern []rune) Result {
+	// Note: PrefixMatch always return a zero bonus.
+	if len(runes) < len(pattern) {
+		return Result{-1, -1, 0}
 	}

 	for index, r := range pattern {
-		char := (*runes)[index]
+		char := runes[index]
 		if !caseSensitive {
 			char = unicode.ToLower(char)
 		}
 		if char != r {
-			return -1, -1
+			return Result{-1, -1, 0}
 		}
 	}
-	return 0, len(pattern)
+	return Result{0, int32(len(pattern)), 0}
 }

 // SuffixMatch performs suffix-match
-func SuffixMatch(caseSensitive bool, input *[]rune, pattern []rune) (int, int) {
+func SuffixMatch(caseSensitive bool, forward bool, input []rune, pattern []rune) Result {
+	// Note: SuffixMatch always return a zero bonus.
 	runes := util.TrimRight(input)
 	trimmedLen := len(runes)
 	diff := trimmedLen - len(pattern)
 	if diff < 0 {
-		return -1, -1
+		return Result{-1, -1, 0}
 	}

 	for index, r := range pattern {
@@ -154,8 +264,24 @@ func SuffixMatch(caseSensitive bool, input *[]rune, pattern []rune) (int, int) {
 			char = unicode.ToLower(char)
 		}
 		if char != r {
-			return -1, -1
+			return Result{-1, -1, 0}
 		}
 	}
-	return trimmedLen - len(pattern), trimmedLen
+	return Result{int32(trimmedLen - len(pattern)), int32(trimmedLen), 0}
+}
+
+// EqualMatch performs equal-match
+func EqualMatch(caseSensitive bool, forward bool, runes []rune, pattern []rune) Result {
+	// Note: EqualMatch always return a zero bonus.
+	if len(runes) != len(pattern) {
+		return Result{-1, -1, 0}
+	}
+	runesStr := string(runes)
+	if !caseSensitive {
+		runesStr = strings.ToLower(runesStr)
+	}
+	if runesStr == string(pattern) {
+		return Result{0, int32(len(pattern)), 0}
+	}
+	return Result{-1, -1, 0}
 }
--- a/src/algo/algo_test.go
+++ b/src/algo/algo_test.go
@@ -5,48 +5,84 @@ import (
 	"testing"
 )

-func assertMatch(t *testing.T, fun func(bool, *[]rune, []rune) (int, int), caseSensitive bool, input string, pattern string, sidx int, eidx int) {
+func assertMatch(t *testing.T, fun func(bool, bool, []rune, []rune) Result, caseSensitive, forward bool, input, pattern string, sidx int32, eidx int32, bonus int32) {
 	if !caseSensitive {
 		pattern = strings.ToLower(pattern)
 	}
-	runes := []rune(input)
-	s, e := fun(caseSensitive, &runes, []rune(pattern))
-	if s != sidx {
-		t.Errorf("Invalid start index: %d (expected: %d, %s / %s)", s, sidx, input, pattern)
+	res := fun(caseSensitive, forward, []rune(input), []rune(pattern))
+	if res.Start != sidx {
+		t.Errorf("Invalid start index: %d (expected: %d, %s / %s)", res.Start, sidx, input, pattern)
 	}
-	if e != eidx {
-		t.Errorf("Invalid end index: %d (expected: %d, %s / %s)", e, eidx, input, pattern)
+	if res.End != eidx {
+		t.Errorf("Invalid end index: %d (expected: %d, %s / %s)", res.End, eidx, input, pattern)
+	}
+	if res.Bonus != bonus {
+		t.Errorf("Invalid bonus: %d (expected: %d, %s / %s)", res.Bonus, bonus, input, pattern)
 	}
 }

 func TestFuzzyMatch(t *testing.T) {
-	assertMatch(t, FuzzyMatch, false, "fooBarbaz", "oBZ", 2, 9)
-	assertMatch(t, FuzzyMatch, true, "fooBarbaz", "oBZ", -1, -1)
-	assertMatch(t, FuzzyMatch, true, "fooBarbaz", "oBz", 2, 9)
-	assertMatch(t, FuzzyMatch, true, "fooBarbaz", "fooBarbazz", -1, -1)
+	assertMatch(t, FuzzyMatch, false, true, "fooBarbaz", "oBZ", 2, 9, 2)
+	assertMatch(t, FuzzyMatch, false, true, "foo bar baz", "fbb", 0, 9, 8)
+	assertMatch(t, FuzzyMatch, false, true, "/AutomatorDocument.icns", "rdoc", 9, 13, 4)
+	assertMatch(t, FuzzyMatch, false, true, "/man1/zshcompctl.1", "zshc", 6, 10, 7)
+	assertMatch(t, FuzzyMatch, false, true, "/.oh-my-zsh/cache", "zshc", 8, 13, 8)
+	assertMatch(t, FuzzyMatch, false, true, "ab0123 456", "12356", 3, 10, 3)
+	assertMatch(t, FuzzyMatch, false, true, "abc123 456", "12356", 3, 10, 5)
+
+	assertMatch(t, FuzzyMatch, false, true, "foo/bar/baz", "fbb", 0, 9, 8)
+	assertMatch(t, FuzzyMatch, false, true, "fooBarBaz", "fbb", 0, 7, 6)
+	assertMatch(t, FuzzyMatch, false, true, "foo barbaz", "fbb", 0, 8, 6)
+	assertMatch(t, FuzzyMatch, false, true, "fooBar Baz", "foob", 0, 4, 8)
+	assertMatch(t, FuzzyMatch, true, true, "fooBarbaz", "oBZ", -1, -1, 0)
+	assertMatch(t, FuzzyMatch, true, true, "fooBarbaz", "oBz", 2, 9, 2)
+	assertMatch(t, FuzzyMatch, true, true, "Foo Bar Baz", "fbb", -1, -1, 0)
+	assertMatch(t, FuzzyMatch, true, true, "Foo/Bar/Baz", "FBB", 0, 9, 8)
+	assertMatch(t, FuzzyMatch, true, true, "FooBarBaz", "FBB", 0, 7, 6)
+	assertMatch(t, FuzzyMatch, true, true, "foo BarBaz", "fBB", 0, 8, 7)
+	assertMatch(t, FuzzyMatch, true, true, "FooBar Baz", "FooB", 0, 4, 8)
+	assertMatch(t, FuzzyMatch, true, true, "fooBarbaz", "fooBarbazz", -1, -1, 0)
+}
+
+func TestFuzzyMatchBackward(t *testing.T) {
+	assertMatch(t, FuzzyMatch, false, true, "foobar fb", "fb", 0, 4, 4)
+	assertMatch(t, FuzzyMatch, false, false, "foobar fb", "fb", 7, 9, 5)
 }

 func TestExactMatchNaive(t *testing.T) {
-	assertMatch(t, ExactMatchNaive, false, "fooBarbaz", "oBA", 2, 5)
-	assertMatch(t, ExactMatchNaive, true, "fooBarbaz", "oBA", -1, -1)
-	assertMatch(t, ExactMatchNaive, true, "fooBarbaz", "fooBarbazz", -1, -1)
+	for _, dir := range []bool{true, false} {
+		assertMatch(t, ExactMatchNaive, false, dir, "fooBarbaz", "oBA", 2, 5, 0)
+		assertMatch(t, ExactMatchNaive, true, dir, "fooBarbaz", "oBA", -1, -1, 0)
+		assertMatch(t, ExactMatchNaive, true, dir, "fooBarbaz", "fooBarbazz", -1, -1, 0)
+	}
+}
+
+func TestExactMatchNaiveBackward(t *testing.T) {
+	assertMatch(t, ExactMatchNaive, false, true, "foobar foob", "oo", 1, 3, 0)
+	assertMatch(t, ExactMatchNaive, false, false, "foobar foob", "oo", 8, 10, 0)
 }

 func TestPrefixMatch(t *testing.T) {
-	assertMatch(t, PrefixMatch, false, "fooBarbaz", "Foo", 0, 3)
-	assertMatch(t, PrefixMatch, true, "fooBarbaz", "Foo", -1, -1)
-	assertMatch(t, PrefixMatch, false, "fooBarbaz", "baz", -1, -1)
+	for _, dir := range []bool{true, false} {
+		assertMatch(t, PrefixMatch, false, dir, "fooBarbaz", "Foo", 0, 3, 0)
+		assertMatch(t, PrefixMatch, true, dir, "fooBarbaz", "Foo", -1, -1, 0)
+		assertMatch(t, PrefixMatch, false, dir, "fooBarbaz", "baz", -1, -1, 0)
+	}
 }

 func TestSuffixMatch(t *testing.T) {
-	assertMatch(t, SuffixMatch, false, "fooBarbaz", "Foo", -1, -1)
-	assertMatch(t, SuffixMatch, false, "fooBarbaz", "baz", 6, 9)
-	assertMatch(t, SuffixMatch, true, "fooBarbaz", "Baz", -1, -1)
+	for _, dir := range []bool{true, false} {
+		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz", "Foo", -1, -1, 0)
+		assertMatch(t, SuffixMatch, false, dir, "fooBarbaz", "baz", 6, 9, 0)
+		assertMatch(t, SuffixMatch, true, dir, "fooBarbaz", "Baz", -1, -1, 0)
+	}
 }

 func TestEmptyPattern(t *testing.T) {
-	assertMatch(t, FuzzyMatch, true, "foobar", "", 0, 0)
-	assertMatch(t, ExactMatchNaive, true, "foobar", "", 0, 0)
-	assertMatch(t, PrefixMatch, true, "foobar", "", 0, 0)
-	assertMatch(t, SuffixMatch, true, "foobar", "", 6, 6)
+	for _, dir := range []bool{true, false} {
+		assertMatch(t, FuzzyMatch, true, dir, "foobar", "", 0, 0, 0)
+		assertMatch(t, ExactMatchNaive, true, dir, "foobar", "", 0, 0, 0)
+		assertMatch(t, PrefixMatch, true, dir, "foobar", "", 0, 0, 0)
+		assertMatch(t, SuffixMatch, true, dir, "foobar", "", 6, 6, 0)
+	}
 }
--- a/src/ansi.go
+++ b/src/ansi.go
@@ -36,16 +36,18 @@ func init() {
 	ansiRegex = regexp.MustCompile("\x1b\\[[0-9;]*[mK]")
 }

-func extractColor(str *string) (*string, []ansiOffset) {
+func extractColor(str string, state *ansiState) (string, []ansiOffset, *ansiState) {
 	var offsets []ansiOffset
-
 	var output bytes.Buffer
-	var state *ansiState
+
+	if state != nil {
+		offsets = append(offsets, ansiOffset{[2]int32{0, 0}, *state})
+	}

 	idx := 0
-	for _, offset := range ansiRegex.FindAllStringIndex(*str, -1) {
-		output.WriteString((*str)[idx:offset[0]])
-		newState := interpretCode((*str)[offset[0]:offset[1]], state)
+	for _, offset := range ansiRegex.FindAllStringIndex(str, -1) {
+		output.WriteString(str[idx:offset[0]])
+		newState := interpretCode(str[offset[0]:offset[1]], state)

 		if !newState.equals(state) {
 			if state != nil {
@@ -67,7 +69,7 @@ func extractColor(str *string) (*string, []ansiOffset) {
 		idx = offset[1]
 	}

-	rest := (*str)[idx:]
+	rest := str[idx:]
 	if len(rest) > 0 {
 		output.WriteString(rest)
 		if state != nil {
@@ -75,8 +77,7 @@ func extractColor(str *string) (*string, []ansiOffset) {
 			(&offsets[len(offsets)-1]).offset[1] = int32(utf8.RuneCount(output.Bytes()))
 		}
 	}
-	outputStr := output.String()
-	return &outputStr, offsets
+	return output.String(), offsets, state
 }

 func interpretCode(ansiCode string, prevState *ansiState) *ansiState {
--- a/src/ansi_test.go
+++ b/src/ansi_test.go
@@ -14,79 +14,89 @@ func TestExtractColor(t *testing.T) {
 	}

 	src := "hello world"
+	var state *ansiState
 	clean := "\x1b[0m"
-	check := func(assertion func(ansiOffsets []ansiOffset)) {
-		output, ansiOffsets := extractColor(&src)
-		if *output != "hello world" {
+	check := func(assertion func(ansiOffsets []ansiOffset, state *ansiState)) {
+		output, ansiOffsets, newState := extractColor(src, state)
+		state = newState
+		if output != "hello world" {
 			t.Errorf("Invalid output: {}", output)
 		}
 		fmt.Println(src, ansiOffsets, clean)
-		assertion(ansiOffsets)
+		assertion(ansiOffsets, state)
 	}

-	check(func(offsets []ansiOffset) {
+	check(func(offsets []ansiOffset, state *ansiState) {
 		if len(offsets) > 0 {
 			t.Fail()
 		}
 	})

+	state = nil
 	src = "\x1b[0mhello world"
-	check(func(offsets []ansiOffset) {
+	check(func(offsets []ansiOffset, state *ansiState) {
 		if len(offsets) > 0 {
 			t.Fail()
 		}
 	})

+	state = nil
 	src = "\x1b[1mhello world"
-	check(func(offsets []ansiOffset) {
+	check(func(offsets []ansiOffset, state *ansiState) {
 		if len(offsets) != 1 {
 			t.Fail()
 		}
 		assert(offsets[0], 0, 11, -1, -1, true)
 	})

+	state = nil
 	src = "\x1b[1mhello \x1b[mworld"
-	check(func(offsets []ansiOffset) {
+	check(func(offsets []ansiOffset, state *ansiState) {
 		if len(offsets) != 1 {
 			t.Fail()
 		}
 		assert(offsets[0], 0, 6, -1, -1, true)
 	})

+	state = nil
 	src = "\x1b[1mhello \x1b[Kworld"
-	check(func(offsets []ansiOffset) {
+	check(func(offsets []ansiOffset, state *ansiState) {
 		if len(offsets) != 1 {
 			t.Fail()
 		}
 		assert(offsets[0], 0, 11, -1, -1, true)
 	})

+	state = nil
 	src = "hello \x1b[34;45;1mworld"
-	check(func(offsets []ansiOffset) {
+	check(func(offsets []ansiOffset, state *ansiState) {
 		if len(offsets) != 1 {
 			t.Fail()
 		}
 		assert(offsets[0], 6, 11, 4, 5, true)
 	})

+	state = nil
 	src = "hello \x1b[34;45;1mwor\x1b[34;45;1mld"
-	check(func(offsets []ansiOffset) {
+	check(func(offsets []ansiOffset, state *ansiState) {
 		if len(offsets) != 1 {
 			t.Fail()
 		}
 		assert(offsets[0], 6, 11, 4, 5, true)
 	})

+	state = nil
 	src = "hello \x1b[34;45;1mwor\x1b[0mld"
-	check(func(offsets []ansiOffset) {
+	check(func(offsets []ansiOffset, state *ansiState) {
 		if len(offsets) != 1 {
 			t.Fail()
 		}
 		assert(offsets[0], 6, 9, 4, 5, true)
 	})

+	state = nil
 	src = "hello \x1b[34;48;5;233;1mwo\x1b[38;5;161mr\x1b[0ml\x1b[38;5;161md"
-	check(func(offsets []ansiOffset) {
+	check(func(offsets []ansiOffset, state *ansiState) {
 		if len(offsets) != 3 {
 			t.Fail()
 		}
@@ -96,12 +106,47 @@ func TestExtractColor(t *testing.T) {
 	})

 	// {38,48};5;{38,48}
+	state = nil
 	src = "hello \x1b[38;5;38;48;5;48;1mwor\x1b[38;5;48;48;5;38ml\x1b[0md"
-	check(func(offsets []ansiOffset) {
+	check(func(offsets []ansiOffset, state *ansiState) {
 		if len(offsets) != 2 {
 			t.Fail()
 		}
 		assert(offsets[0], 6, 9, 38, 48, true)
 		assert(offsets[1], 9, 10, 48, 38, true)
 	})
+
+	src = "hello \x1b[32;1mworld"
+	check(func(offsets []ansiOffset, state *ansiState) {
+		if len(offsets) != 1 {
+			t.Fail()
+		}
+		if state.fg != 2 || state.bg != -1 || !state.bold {
+			t.Fail()
+		}
+		assert(offsets[0], 6, 11, 2, -1, true)
+	})
+
+	src = "hello world"
+	check(func(offsets []ansiOffset, state *ansiState) {
+		if len(offsets) != 1 {
+			t.Fail()
+		}
+		if state.fg != 2 || state.bg != -1 || !state.bold {
+			t.Fail()
+		}
+		assert(offsets[0], 0, 11, 2, -1, true)
+	})
+
+	src = "hello \x1b[0;38;5;200;48;5;100mworld"
+	check(func(offsets []ansiOffset, state *ansiState) {
+		if len(offsets) != 2 {
+			t.Fail()
+		}
+		if state.fg != 200 || state.bg != 100 || state.bold {
+			t.Fail()
+		}
+		assert(offsets[0], 0, 6, 2, -1, true)
+		assert(offsets[1], 6, 11, 200, 100, false)
+	})
 }
--- a/src/chunklist.go
+++ b/src/chunklist.go
@@ -7,7 +7,7 @@ type Chunk []*Item // >>> []Item

 // ItemBuilder is a closure type that builds Item object from a pointer to a
 // string and an integer
-type ItemBuilder func(*string, int) *Item
+type ItemBuilder func([]byte, int) *Item

 // ChunkList is a list of Chunks
 type ChunkList struct {
@@ -26,8 +26,13 @@ func NewChunkList(trans ItemBuilder) *ChunkList {
 		trans:  trans}
 }

-func (c *Chunk) push(trans ItemBuilder, data *string, index int) {
-	*c = append(*c, trans(data, index))
+func (c *Chunk) push(trans ItemBuilder, data []byte, index int) bool {
+	item := trans(data, index)
+	if item != nil {
+		*c = append(*c, item)
+		return true
+	}
+	return false
 }

 // IsFull returns true if the Chunk is full
@@ -48,7 +53,7 @@ func CountItems(cs []*Chunk) int {
 }

 // Push adds the item to the list
-func (cl *ChunkList) Push(data string) {
+func (cl *ChunkList) Push(data []byte) bool {
 	cl.mutex.Lock()
 	defer cl.mutex.Unlock()

@@ -57,8 +62,11 @@ func (cl *ChunkList) Push(data string) {
 		cl.chunks = append(cl.chunks, &newChunk)
 	}

-	cl.lastChunk().push(cl.trans, &data, cl.count)
+	if cl.lastChunk().push(cl.trans, data, cl.count) {
 		cl.count++
+		return true
+	}
+	return false
 }

 // Snapshot returns immutable snapshot of the ChunkList
--- a/src/chunklist_test.go
+++ b/src/chunklist_test.go
@@ -6,8 +6,11 @@ import (
 )

 func TestChunkList(t *testing.T) {
-	cl := NewChunkList(func(s *string, i int) *Item {
-		return &Item{text: s, rank: Rank{0, 0, uint32(i * 2)}}
+	// FIXME global
+	sortCriteria = []criterion{byMatchLen, byLength}
+
+	cl := NewChunkList(func(s []byte, i int) *Item {
+		return &Item{text: []rune(string(s)), rank: buildEmptyRank(int32(i * 2))}
 	})

 	// Snapshot
@@ -17,8 +20,8 @@ func TestChunkList(t *testing.T) {
 	}

 	// Add some data
-	cl.Push("hello")
-	cl.Push("world")
+	cl.Push([]byte("hello"))
+	cl.Push([]byte("world"))

 	// Previously created snapshot should remain the same
 	if len(snapshot) > 0 {
@@ -36,8 +39,11 @@ func TestChunkList(t *testing.T) {
 	if len(*chunk1) != 2 {
 		t.Error("Snapshot should contain only two items")
 	}
-	if *(*chunk1)[0].text != "hello" || (*chunk1)[0].rank.index != 0 ||
-		*(*chunk1)[1].text != "world" || (*chunk1)[1].rank.index != 2 {
+	last := func(arr [5]int32) int32 {
+		return arr[len(arr)-1]
+	}
+	if string((*chunk1)[0].text) != "hello" || last((*chunk1)[0].rank) != 0 ||
+		string((*chunk1)[1].text) != "world" || last((*chunk1)[1].rank) != 2 {
 		t.Error("Invalid data")
 	}
 	if chunk1.IsFull() {
@@ -46,7 +52,7 @@ func TestChunkList(t *testing.T) {

 	// Add more data
 	for i := 0; i < chunkSize*2; i++ {
-		cl.Push(fmt.Sprintf("item %d", i))
+		cl.Push([]byte(fmt.Sprintf("item %d", i)))
 	}

 	// Previous snapshot should remain the same
@@ -64,8 +70,8 @@ func TestChunkList(t *testing.T) {
 		t.Error("Unexpected number of items")
 	}

-	cl.Push("hello")
-	cl.Push("world")
+	cl.Push([]byte("hello"))
+	cl.Push([]byte("world"))

 	lastChunkCount := len(*snapshot[len(snapshot)-1])
 	if lastChunkCount != 2 {
--- a/src/constants.go
+++ b/src/constants.go
@@ -8,17 +8,18 @@ import (

 const (
 	// Current version
-	Version = "0.9.13"
+	version = "0.12.0"

 	// Core
 	coordinatorDelayMax  time.Duration = 100 * time.Millisecond
 	coordinatorDelayStep time.Duration = 10 * time.Millisecond

 	// Reader
-	defaultCommand = `find * -path '*/\.*' -prune -o -type f -print -o -type l -print 2> /dev/null`
+	defaultCommand = `find . -path '*/\.*' -prune -o -type f -print -o -type l -print 2> /dev/null | sed s/^..//`

 	// Terminal
-	initialDelay    = 100 * time.Millisecond
+	initialDelay    = 20 * time.Millisecond
+	initialDelayTac = 100 * time.Millisecond
 	spinnerDuration = 200 * time.Millisecond

 	// Matcher
@@ -32,6 +33,9 @@ const (

 	// Not to cache mergers with large lists
 	mergerCacheMax int = 100000
+
+	// History
+	defaultHistoryMax int = 1000
 )

 // fzf events
@@ -41,5 +45,13 @@ const (
 	EvtSearchNew
 	EvtSearchProgress
 	EvtSearchFin
+	EvtHeader
 	EvtClose
 )
+
+const (
+	exitOk        = 0
+	exitNoMatch   = 1
+	exitError     = 2
+	exitInterrupt = 130
+)
--- a/src/core.go
+++ b/src/core.go
@@ -3,7 +3,7 @@ Package fzf implements fzf, a command-line fuzzy finder.

 The MIT License (MIT)

-Copyright (c) 2015 Junegunn Choi
+Copyright (c) 2016 Junegunn Choi

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -44,6 +44,7 @@ Reader   -> EvtReadNew        -> Matcher  (restart)
 Terminal -> EvtSearchNew:bool -> Matcher  (restart)
 Matcher  -> EvtSearchProgress -> Terminal (update info)
 Matcher  -> EvtSearchFin      -> Terminal (update list)
+Matcher  -> EvtHeader         -> Terminal (update header)
 */

 // Run starts fzf
@@ -51,59 +52,77 @@ func Run(opts *Options) {
 	initProcs()

 	sort := opts.Sort > 0
-	rankTiebreak = opts.Tiebreak
+	sortCriteria = opts.Criteria

 	if opts.Version {
-		fmt.Println(Version)
-		os.Exit(0)
+		fmt.Println(version)
+		os.Exit(exitOk)
 	}

 	// Event channel
 	eventBox := util.NewEventBox()

 	// ANSI code processor
-	ansiProcessor := func(data *string) (*string, []ansiOffset) {
-		// By default, we do nothing
+	ansiProcessor := func(data []byte) ([]rune, []ansiOffset) {
+		return util.BytesToRunes(data), nil
+	}
+	ansiProcessorRunes := func(data []rune) ([]rune, []ansiOffset) {
 		return data, nil
 	}
 	if opts.Ansi {
 		if opts.Theme != nil {
-			ansiProcessor = func(data *string) (*string, []ansiOffset) {
-				return extractColor(data)
+			var state *ansiState
+			ansiProcessor = func(data []byte) ([]rune, []ansiOffset) {
+				trimmed, offsets, newState := extractColor(string(data), state)
+				state = newState
+				return []rune(trimmed), offsets
 			}
 		} else {
 			// When color is disabled but ansi option is given,
 			// we simply strip out ANSI codes from the input
-			ansiProcessor = func(data *string) (*string, []ansiOffset) {
-				trimmed, _ := extractColor(data)
-				return trimmed, nil
+			ansiProcessor = func(data []byte) ([]rune, []ansiOffset) {
+				trimmed, _, _ := extractColor(string(data), nil)
+				return []rune(trimmed), nil
 			}
 		}
+		ansiProcessorRunes = func(data []rune) ([]rune, []ansiOffset) {
+			return ansiProcessor([]byte(string(data)))
+		}
 	}

 	// Chunk list
 	var chunkList *ChunkList
+	header := make([]string, 0, opts.HeaderLines)
 	if len(opts.WithNth) == 0 {
-		chunkList = NewChunkList(func(data *string, index int) *Item {
-			data, colors := ansiProcessor(data)
+		chunkList = NewChunkList(func(data []byte, index int) *Item {
+			if len(header) < opts.HeaderLines {
+				header = append(header, string(data))
+				eventBox.Set(EvtHeader, header)
+				return nil
+			}
+			runes, colors := ansiProcessor(data)
 			return &Item{
-				text:   data,
-				index:  uint32(index),
+				text:   runes,
 				colors: colors,
-				rank:   Rank{0, 0, uint32(index)}}
+				rank:   buildEmptyRank(int32(index))}
 		})
 	} else {
-		chunkList = NewChunkList(func(data *string, index int) *Item {
-			tokens := Tokenize(data, opts.Delimiter)
+		chunkList = NewChunkList(func(data []byte, index int) *Item {
+			runes := util.BytesToRunes(data)
+			tokens := Tokenize(runes, opts.Delimiter)
 			trans := Transform(tokens, opts.WithNth)
+			if len(header) < opts.HeaderLines {
+				header = append(header, string(joinTokens(trans)))
+				eventBox.Set(EvtHeader, header)
+				return nil
+			}
 			item := Item{
 				text:     joinTokens(trans),
-				origText: data,
-				index:    uint32(index),
+				origText: &runes,
 				colors:   nil,
-				rank:     Rank{0, 0, uint32(index)}}
+				rank:     buildEmptyRank(int32(index))}

-			trimmed, colors := ansiProcessor(item.text)
+			trimmed, colors := ansiProcessorRunes(item.text)
 			item.text = trimmed
 			item.colors = colors
 			return &item
@@ -113,14 +132,27 @@ func Run(opts *Options) {
 	// Reader
 	streamingFilter := opts.Filter != nil && !sort && !opts.Tac && !opts.Sync
 	if !streamingFilter {
-		reader := Reader{func(str string) { chunkList.Push(str) }, eventBox}
+		reader := Reader{func(data []byte) bool {
+			return chunkList.Push(data)
+		}, eventBox, opts.ReadZero}
 		go reader.ReadSource()
 	}

 	// Matcher
+	forward := true
+	for _, cri := range opts.Criteria[1:] {
+		if cri == byEnd {
+			forward = false
+			break
+		}
+		if cri == byBegin {
+			break
+		}
+	}
 	patternBuilder := func(runes []rune) *Pattern {
 		return BuildPattern(
-			opts.Mode, opts.Case, opts.Nth, opts.Delimiter, runes)
+			opts.Fuzzy, opts.Extended, opts.Case, forward,
+			opts.Nth, opts.Delimiter, runes)
 	}
 	matcher := NewMatcher(patternBuilder, sort, opts.Tac, eventBox)

@@ -132,14 +164,17 @@ func Run(opts *Options) {

 		pattern := patternBuilder([]rune(*opts.Filter))

+		found := false
 		if streamingFilter {
 			reader := Reader{
-				func(str string) {
-					item := chunkList.trans(&str, 0)
-					if pattern.MatchItem(item) {
-						fmt.Println(*item.text)
+				func(runes []byte) bool {
+					item := chunkList.trans(runes, 0)
+					if item != nil && pattern.MatchItem(item) {
+						fmt.Println(string(item.text))
+						found = true
 					}
-				}, eventBox}
+					return false
+				}, eventBox, opts.ReadZero}
 			reader.ReadSource()
 		} else {
 			eventBox.Unwatch(EvtReadNew)
@@ -150,10 +185,14 @@ func Run(opts *Options) {
 				chunks:  snapshot,
 				pattern: pattern})
 			for i := 0; i < merger.Length(); i++ {
-				fmt.Println(merger.Get(i).AsString())
+				fmt.Println(merger.Get(i).AsString(opts.Ansi))
+				found = true
 			}
 		}
-		os.Exit(0)
+		if found {
+			os.Exit(exitOk)
+		}
+		os.Exit(exitNoMatch)
 	}

 	// Synchronous search
@@ -206,6 +245,9 @@ func Run(opts *Options) {
 						terminal.UpdateProgress(val)
 					}

+				case EvtHeader:
+					terminal.UpdateHeader(value.([]string))
+
 				case EvtSearchFin:
 					switch val := value.(type) {
 					case *Merger:
@@ -223,9 +265,12 @@ func Run(opts *Options) {
 										fmt.Println()
 									}
 									for i := 0; i < count; i++ {
-										fmt.Println(val.Get(i).AsString())
+										fmt.Println(val.Get(i).AsString(opts.Ansi))
 									}
-									os.Exit(0)
+									if count > 0 {
+										os.Exit(exitOk)
+									}
+									os.Exit(exitNoMatch)
 								}
 								deferred = false
 								terminal.startChan <- true
--- a/src/curses/curses.go
+++ b/src/curses/curses.go
@@ -3,18 +3,21 @@ package curses
 /*
 #include <ncurses.h>
 #include <locale.h>
-#cgo LDFLAGS: -lncurses
-void swapOutput() {
-  FILE* temp = stdout;
-  stdout = stderr;
-  stderr = temp;
+#cgo !static LDFLAGS: -lncurses
+#cgo static LDFLAGS: -l:libncursesw.a -l:libtinfo.a -l:libgpm.a -ldl
+#cgo android static LDFLAGS: -l:libncurses.a -fPIE -march=armv7-a -mfpu=neon -mhard-float -Wl,--no-warn-mismatch
+
+SCREEN *c_newterm () {
+	return newterm(NULL, stderr, stdin);
 }
+
 */
 import "C"

 import (
+	"fmt"
 	"os"
-	"os/signal"
+	"strings"
 	"syscall"
 	"time"
 	"unicode/utf8"
@@ -54,8 +57,10 @@ const (

 	Invalid
 	Mouse
+	DoubleClick

 	BTab
+	BSpace

 	Del
 	PgUp
@@ -98,6 +103,7 @@ const (
 	ColInfo
 	ColCursor
 	ColSelected
+	ColHeader
 	ColUser
 )

@@ -118,6 +124,7 @@ type ColorTheme struct {
 	Info         int16
 	Cursor       int16
 	Selected     int16
+	Header       int16
 }

 type Event struct {
@@ -142,6 +149,7 @@ var (
 	_colorMap     map[int]int
 	_prevDownTime time.Time
 	_clickY       []int
+	_screen       *C.SCREEN
 	Default16     *ColorTheme
 	Dark256       *ColorTheme
 	Light256      *ColorTheme
@@ -167,7 +175,8 @@ func init() {
 		Spinner:      C.COLOR_GREEN,
 		Info:         C.COLOR_WHITE,
 		Cursor:       C.COLOR_RED,
-		Selected:     C.COLOR_MAGENTA}
+		Selected:     C.COLOR_MAGENTA,
+		Header:       C.COLOR_CYAN}
 	Dark256 = &ColorTheme{
 		UseDefault:   true,
 		Fg:           15,
@@ -180,7 +189,8 @@ func init() {
 		Spinner:      148,
 		Info:         144,
 		Cursor:       161,
-		Selected:     168}
+		Selected:     168,
+		Header:       109}
 	Light256 = &ColorTheme{
 		UseDefault:   true,
 		Fg:           15,
@@ -193,7 +203,8 @@ func init() {
 		Spinner:      65,
 		Info:         101,
 		Cursor:       161,
-		Selected:     168}
+		Selected:     168,
+		Header:       31}
 }

 func attrColored(pair int, bold bool) C.int {
@@ -254,25 +265,19 @@ func Init(theme *ColorTheme, black bool, mouse bool) {
 		// syscall.Dup2(int(in.Fd()), int(os.Stdin.Fd()))
 	}

-	C.swapOutput()
-
 	C.setlocale(C.LC_ALL, C.CString(""))
-	C.initscr()
+	_screen = C.c_newterm()
+	if _screen == nil {
+		fmt.Println("Invalid $TERM: " + os.Getenv("TERM"))
+		os.Exit(2)
+	}
+	C.set_term(_screen)
 	if mouse {
 		C.mousemask(C.ALL_MOUSE_EVENTS, nil)
 	}
-	C.cbreak()
 	C.noecho()
 	C.raw() // stty dsusp undef

-	intChan := make(chan os.Signal, 1)
-	signal.Notify(intChan, os.Interrupt, os.Kill)
-	go func() {
-		<-intChan
-		Close()
-		os.Exit(1)
-	}()
-
 	if theme != nil {
 		C.start_color()
 		initPairs(theme, black)
@@ -312,11 +317,12 @@ func initPairs(theme *ColorTheme, black bool) {
 	C.init_pair(ColInfo, C.short(theme.Info), bg)
 	C.init_pair(ColCursor, C.short(theme.Cursor), darkBG)
 	C.init_pair(ColSelected, C.short(theme.Selected), darkBG)
+	C.init_pair(ColHeader, C.short(theme.Header), bg)
 }

 func Close() {
 	C.endwin()
-	C.swapOutput()
+	C.delscreen(_screen)
 }

 func GetBytes() []byte {
@@ -481,10 +487,14 @@ func GetChar() Event {
 	}()

 	switch _buf[0] {
-	case CtrlC, CtrlG, CtrlQ:
+	case CtrlC:
 		return Event{CtrlC, 0, nil}
+	case CtrlG:
+		return Event{CtrlG, 0, nil}
+	case CtrlQ:
+		return Event{CtrlQ, 0, nil}
 	case 127:
-		return Event{CtrlH, 0, nil}
+		return Event{BSpace, 0, nil}
 	case ESC:
 		return escSequence(&sz)
 	}
@@ -511,7 +521,12 @@ func MoveAndClear(y int, x int) {
 }

 func Print(text string) {
-	C.addstr(C.CString(text))
+	C.addstr(C.CString(strings.Map(func(r rune) rune {
+		if r < 32 {
+			return -1
+		}
+		return r
+	}, text)))
 }

 func CPrint(pair int, bold bool, text string) {
--- a/src/history.go
+++ b/src/history.go
@@ -0,0 +1,96 @@
+package fzf
+
+import (
+	"errors"
+	"io/ioutil"
+	"os"
+	"strings"
+)
+
+// History struct represents input history
+type History struct {
+	path     string
+	lines    []string
+	modified map[int]string
+	maxSize  int
+	cursor   int
+}
+
+// NewHistory returns the pointer to a new History struct
+func NewHistory(path string, maxSize int) (*History, error) {
+	fmtError := func(e error) error {
+		if os.IsPermission(e) {
+			return errors.New("permission denied: " + path)
+		}
+		return errors.New("invalid history file: " + e.Error())
+	}
+
+	// Read history file
+	data, err := ioutil.ReadFile(path)
+	if err != nil {
+		// If it doesn't exist, check if we can create a file with the name
+		if os.IsNotExist(err) {
+			data = []byte{}
+			if err := ioutil.WriteFile(path, data, 0600); err != nil {
+				return nil, fmtError(err)
+			}
+		} else {
+			return nil, fmtError(err)
+		}
+	}
+	// Split lines and limit the maximum number of lines
+	lines := strings.Split(strings.Trim(string(data), "\n"), "\n")
+	if len(lines[len(lines)-1]) > 0 {
+		lines = append(lines, "")
+	}
+	return &History{
+		path:     path,
+		maxSize:  maxSize,
+		lines:    lines,
+		modified: make(map[int]string),
+		cursor:   len(lines) - 1}, nil
+}
+
+func (h *History) append(line string) error {
+	// We don't append empty lines
+	if len(line) == 0 {
+		return nil
+	}
+
+	lines := append(h.lines[:len(h.lines)-1], line)
+	if len(lines) > h.maxSize {
+		lines = lines[len(lines)-h.maxSize : len(lines)]
+	}
+	h.lines = append(lines, "")
+	return ioutil.WriteFile(h.path, []byte(strings.Join(h.lines, "\n")), 0600)
+}
+
+func (h *History) override(str string) {
+	// You can update the history but they're not written to the file
+	if h.cursor == len(h.lines)-1 {
+		h.lines[h.cursor] = str
+	} else if h.cursor < len(h.lines)-1 {
+		h.modified[h.cursor] = str
+	}
+}
+
+func (h *History) current() string {
+	if str, prs := h.modified[h.cursor]; prs {
+		return str
+	}
+	return h.lines[h.cursor]
+}
+
+func (h *History) previous() string {
+	if h.cursor > 0 {
+		h.cursor--
+	}
+	return h.current()
+}
+
+func (h *History) next() string {
+	if h.cursor < len(h.lines)-1 {
+		h.cursor++
+	}
+	return h.current()
+}
--- a/src/history_test.go
+++ b/src/history_test.go
@@ -0,0 +1,59 @@
+package fzf
+
+import (
+	"os/user"
+	"testing"
+)
+
+func TestHistory(t *testing.T) {
+	maxHistory := 50
+
+	// Invalid arguments
+	user, _ := user.Current()
+	paths := []string{"/etc", "/proc"}
+	if user.Name != "root" {
+		paths = append(paths, "/etc/sudoers")
+	}
+	for _, path := range paths {
+		if _, e := NewHistory(path, maxHistory); e == nil {
+			t.Error("Error expected for: " + path)
+		}
+	}
+	{ // Append lines
+		h, _ := NewHistory("/tmp/fzf-history", maxHistory)
+		for i := 0; i < maxHistory+10; i++ {
+			h.append("foobar")
+		}
+	}
+	{ // Read lines
+		h, _ := NewHistory("/tmp/fzf-history", maxHistory)
+		if len(h.lines) != maxHistory+1 {
+			t.Errorf("Expected: %d, actual: %d\n", maxHistory+1, len(h.lines))
+		}
+		for i := 0; i < maxHistory; i++ {
+			if h.lines[i] != "foobar" {
+				t.Error("Expected: foobar, actual: " + h.lines[i])
+			}
+		}
+	}
+	{ // Append lines
+		h, _ := NewHistory("/tmp/fzf-history", maxHistory)
+		h.append("barfoo")
+		h.append("")
+		h.append("foobarbaz")
+	}
+	{ // Read lines again
+		h, _ := NewHistory("/tmp/fzf-history", maxHistory)
+		if len(h.lines) != maxHistory+1 {
+			t.Errorf("Expected: %d, actual: %d\n", maxHistory+1, len(h.lines))
+		}
+		compare := func(idx int, exp string) {
+			if h.lines[idx] != exp {
+				t.Errorf("Expected: %s, actual: %s\n", exp, h.lines[idx])
+			}
+		}
+		compare(maxHistory-3, "foobar")
+		compare(maxHistory-2, "barfoo")
+		compare(maxHistory-1, "foobarbaz")
+	}
+}
--- a/src/item.go
+++ b/src/item.go
@@ -6,8 +6,8 @@ import (
 	"github.com/junegunn/fzf/src/curses"
 )

-// Offset holds two 32-bit integers denoting the offsets of a matched substring
-type Offset [2]int32
+// Offset holds three 32-bit integers denoting the offsets of a matched substring
+type Offset [3]int32

 type colorOffset struct {
 	offset [2]int32
@@ -17,36 +17,50 @@ type colorOffset struct {

 // Item represents each input line
 type Item struct {
-	text        *string
-	origText    *string
-	transformed *[]Token
-	index       uint32
+	text        []rune
+	origText    *[]rune
+	transformed []Token
 	offsets     []Offset
 	colors      []ansiOffset
-	rank        Rank
+	rank        [5]int32
+	bonus       int32
 }

-// Rank is used to sort the search result
-type Rank struct {
-	matchlen uint16
-	tiebreak uint16
-	index    uint32
+// Sort criteria to use. Never changes once fzf is started.
+var sortCriteria []criterion
+
+func isRankValid(rank [5]int32) bool {
+	// Exclude ordinal index
+	for _, r := range rank[:4] {
+		if r > 0 {
+			return true
+		}
+	}
+	return false
 }

-// Tiebreak criterion to use. Never changes once fzf is started.
-var rankTiebreak tiebreak
+func buildEmptyRank(index int32) [5]int32 {
+	return [5]int32{0, 0, 0, 0, index}
+}
+
+func (item *Item) Index() int32 {
+	return item.rank[4]
+}

 // Rank calculates rank of the Item
-func (i *Item) Rank(cache bool) Rank {
-	if cache && (i.rank.matchlen > 0 || i.rank.tiebreak > 0) {
-		return i.rank
+func (item *Item) Rank(cache bool) [5]int32 {
+	if cache && isRankValid(item.rank) {
+		return item.rank
 	}
 	matchlen := 0
 	prevEnd := 0
-	minBegin := math.MaxUint16
-	for _, offset := range i.offsets {
+	lenSum := 0
+	minBegin := math.MaxInt32
+	for _, offset := range item.offsets {
 		begin := int(offset[0])
 		end := int(offset[1])
+		trimLen := int(offset[2])
+		lenSum += trimLen
 		if prevEnd > begin {
 			begin = prevEnd
 		}
@@ -60,43 +74,76 @@ func (i *Item) Rank(cache bool) Rank {
 			matchlen += end - begin
 		}
 	}
-	var tiebreak uint16
-	switch rankTiebreak {
+	rank := buildEmptyRank(item.Index())
+	for idx, criterion := range sortCriteria {
+		var val int32
+		switch criterion {
+		case byMatchLen:
+			if matchlen == 0 {
+				val = math.MaxInt32
+			} else {
+				// It is extremely unlikely that bonus exceeds 128
+				val = 128*int32(matchlen) - item.bonus
+			}
 		case byLength:
-		tiebreak = uint16(len(*i.text))
+			// It is guaranteed that .transformed in not null in normal execution
+			if item.transformed != nil {
+				// If offsets is empty, lenSum will be 0, but we don't care
+				val = int32(lenSum)
+			} else {
+				val = int32(len(item.text))
+			}
 		case byBegin:
-		// We can't just look at i.offsets[0][0] because it can be an inverse term
-		tiebreak = uint16(minBegin)
+			// We can't just look at item.offsets[0][0] because it can be an inverse term
+			whitePrefixLen := 0
+			for idx, r := range item.text {
+				whitePrefixLen = idx
+				if idx == minBegin || r != ' ' && r != '\t' {
+					break
+				}
+			}
+			val = int32(minBegin - whitePrefixLen)
 		case byEnd:
 			if prevEnd > 0 {
-			tiebreak = uint16(1 + len(*i.text) - prevEnd)
+				val = int32(1 + len(item.text) - prevEnd)
 			} else {
 				// Empty offsets due to inverse terms.
-			tiebreak = 1
+				val = 1
 			}
-	case byIndex:
-		tiebreak = 1
 		}
-	rank := Rank{uint16(matchlen), tiebreak, i.index}
+		rank[idx] = val
+	}
 	if cache {
-		i.rank = rank
+		item.rank = rank
 	}
 	return rank
 }

 // AsString returns the original string
-func (i *Item) AsString() string {
-	if i.origText != nil {
-		return *i.origText
+func (item *Item) AsString(stripAnsi bool) string {
+	return *item.StringPtr(stripAnsi)
+}
+
+// StringPtr returns the pointer to the original string
+func (item *Item) StringPtr(stripAnsi bool) *string {
+	if item.origText != nil {
+		if stripAnsi {
+			trimmed, _, _ := extractColor(string(*item.origText), nil)
+			return &trimmed
 		}
-	return *i.text
+		orig := string(*item.origText)
+		return &orig
+	}
+	str := string(item.text)
+	return &str
 }

 func (item *Item) colorOffsets(color int, bold bool, current bool) []colorOffset {
 	if len(item.colors) == 0 {
 		var offsets []colorOffset
 		for _, off := range item.offsets {
-			offsets = append(offsets, colorOffset{offset: off, color: color, bold: bold})
+
+			offsets = append(offsets, colorOffset{offset: [2]int32{off[0], off[1]}, color: color, bold: bold})
 		}
 		return offsets
 	}
@@ -140,7 +187,7 @@ func (item *Item) colorOffsets(color int, bold bool, current bool) []colorOffset
 		if curr != 0 && idx > start {
 			if curr == -1 {
 				offsets = append(offsets, colorOffset{
-					offset: Offset{int32(start), int32(idx)}, color: color, bold: bold})
+					offset: [2]int32{int32(start), int32(idx)}, color: color, bold: bold})
 			} else {
 				ansi := item.colors[curr-1]
 				fg := ansi.color.fg
@@ -160,7 +207,7 @@ func (item *Item) colorOffsets(color int, bold bool, current bool) []colorOffset
 					}
 				}
 				offsets = append(offsets, colorOffset{
-					offset: Offset{int32(start), int32(idx)},
+					offset: [2]int32{int32(start), int32(idx)},
 					color:  curses.PairFor(fg, bg),
 					bold:   ansi.color.bold || bold})
 			}
@@ -230,18 +277,15 @@ func (a ByRelevanceTac) Less(i, j int) bool {
 	return compareRanks(irank, jrank, true)
 }

-func compareRanks(irank Rank, jrank Rank, tac bool) bool {
-	if irank.matchlen < jrank.matchlen {
+func compareRanks(irank [5]int32, jrank [5]int32, tac bool) bool {
+	for idx := 0; idx < 4; idx++ {
+		left := irank[idx]
+		right := jrank[idx]
+		if left < right {
 			return true
-	} else if irank.matchlen > jrank.matchlen {
+		} else if left > right {
 			return false
 		}
-
-	if irank.tiebreak < jrank.tiebreak {
-		return true
-	} else if irank.tiebreak > jrank.tiebreak {
-		return false
 	}
-
-	return (irank.index <= jrank.index) != tac
+	return (irank[4] <= jrank[4]) != tac
 }
--- a/src/item_test.go
+++ b/src/item_test.go
@@ -1,6 +1,7 @@
 package fzf

 import (
+	"math"
 	"sort"
 	"testing"

@@ -22,31 +23,34 @@ func TestOffsetSort(t *testing.T) {
 }

 func TestRankComparison(t *testing.T) {
-	if compareRanks(Rank{3, 0, 5}, Rank{2, 0, 7}, false) ||
-		!compareRanks(Rank{3, 0, 5}, Rank{3, 0, 6}, false) ||
-		!compareRanks(Rank{1, 2, 3}, Rank{1, 3, 2}, false) ||
-		!compareRanks(Rank{0, 0, 0}, Rank{0, 0, 0}, false) {
+	if compareRanks([5]int32{3, 0, 0, 0, 5}, [5]int32{2, 0, 0, 0, 7}, false) ||
+		!compareRanks([5]int32{3, 0, 0, 0, 5}, [5]int32{3, 0, 0, 0, 6}, false) ||
+		!compareRanks([5]int32{1, 2, 0, 0, 3}, [5]int32{1, 3, 0, 0, 2}, false) ||
+		!compareRanks([5]int32{0, 0, 0, 0, 0}, [5]int32{0, 0, 0, 0, 0}, false) {
 		t.Error("Invalid order")
 	}

-	if compareRanks(Rank{3, 0, 5}, Rank{2, 0, 7}, true) ||
-		!compareRanks(Rank{3, 0, 5}, Rank{3, 0, 6}, false) ||
-		!compareRanks(Rank{1, 2, 3}, Rank{1, 3, 2}, true) ||
-		!compareRanks(Rank{0, 0, 0}, Rank{0, 0, 0}, false) {
+	if compareRanks([5]int32{3, 0, 0, 0, 5}, [5]int32{2, 0, 0, 0, 7}, true) ||
+		!compareRanks([5]int32{3, 0, 0, 0, 5}, [5]int32{3, 0, 0, 0, 6}, false) ||
+		!compareRanks([5]int32{1, 2, 0, 0, 3}, [5]int32{1, 3, 0, 0, 2}, true) ||
+		!compareRanks([5]int32{0, 0, 0, 0, 0}, [5]int32{0, 0, 0, 0, 0}, false) {
 		t.Error("Invalid order (tac)")
 	}
 }

 // Match length, string length, index
 func TestItemRank(t *testing.T) {
-	strs := []string{"foo", "foobar", "bar", "baz"}
-	item1 := Item{text: &strs[0], index: 1, offsets: []Offset{}}
+	// FIXME global
+	sortCriteria = []criterion{byMatchLen, byLength}
+
+	strs := [][]rune{[]rune("foo"), []rune("foobar"), []rune("bar"), []rune("baz")}
+	item1 := Item{text: strs[0], offsets: []Offset{}, rank: [5]int32{0, 0, 0, 0, 1}}
 	rank1 := item1.Rank(true)
-	if rank1.matchlen != 0 || rank1.tiebreak != 3 || rank1.index != 1 {
+	if rank1[0] != math.MaxInt32 || rank1[1] != 3 || rank1[4] != 1 {
 		t.Error(item1.Rank(true))
 	}
 	// Only differ in index
-	item2 := Item{text: &strs[0], index: 0, offsets: []Offset{}}
+	item2 := Item{text: strs[0], offsets: []Offset{}}

 	items := []*Item{&item1, &item2}
 	sort.Sort(ByRelevance(items))
@@ -62,15 +66,15 @@ func TestItemRank(t *testing.T) {
 	}

 	// Sort by relevance
-	item3 := Item{text: &strs[1], rank: Rank{0, 0, 2}, offsets: []Offset{Offset{1, 3}, Offset{5, 7}}}
-	item4 := Item{text: &strs[1], rank: Rank{0, 0, 2}, offsets: []Offset{Offset{1, 2}, Offset{6, 7}}}
-	item5 := Item{text: &strs[2], rank: Rank{0, 0, 2}, offsets: []Offset{Offset{1, 3}, Offset{5, 7}}}
-	item6 := Item{text: &strs[2], rank: Rank{0, 0, 2}, offsets: []Offset{Offset{1, 2}, Offset{6, 7}}}
+	item3 := Item{text: strs[1], rank: [5]int32{0, 0, 0, 0, 2}, offsets: []Offset{Offset{1, 3}, Offset{5, 7}}}
+	item4 := Item{text: strs[1], rank: [5]int32{0, 0, 0, 0, 2}, offsets: []Offset{Offset{1, 2}, Offset{6, 7}}}
+	item5 := Item{text: strs[2], rank: [5]int32{0, 0, 0, 0, 2}, offsets: []Offset{Offset{1, 3}, Offset{5, 7}}}
+	item6 := Item{text: strs[2], rank: [5]int32{0, 0, 0, 0, 2}, offsets: []Offset{Offset{1, 2}, Offset{6, 7}}}
 	items = []*Item{&item1, &item2, &item3, &item4, &item5, &item6}
 	sort.Sort(ByRelevance(items))
-	if items[0] != &item2 || items[1] != &item1 ||
-		items[2] != &item6 || items[3] != &item4 ||
-		items[4] != &item5 || items[5] != &item3 {
+	if items[0] != &item6 || items[1] != &item4 ||
+		items[2] != &item5 || items[3] != &item3 ||
+		items[4] != &item2 || items[5] != &item1 {
 		t.Error(items)
 	}
 }
--- a/src/matcher.go
+++ b/src/matcher.go
@@ -96,7 +96,7 @@ func (m *Matcher) Loop() {
 		}

 		if !cancelled {
-			if merger.Cacheable() {
+			if merger.cacheable() {
 				m.mergerCache[patternString] = merger
 			}
 			merger.final = request.final
@@ -200,7 +200,7 @@ func (m *Matcher) scan(request MatchRequest) (*Merger, bool) {
 	}

 	partialResults := make([][]*Item, numSlices)
-	for range slices {
+	for _, _ = range slices {
 		partialResult := <-resultChan
 		partialResults[partialResult.index] = partialResult.matches
 	}
--- a/src/merger.go
+++ b/src/merger.go
@@ -82,13 +82,13 @@ func (mg *Merger) Get(idx int) *Item {
 	panic(fmt.Sprintf("Index out of bounds (unsorted, %d/%d)", idx, mg.count))
 }

-func (mg *Merger) Cacheable() bool {
+func (mg *Merger) cacheable() bool {
 	return mg.count < mergerCacheMax
 }

 func (mg *Merger) mergedGet(idx int) *Item {
 	for i := len(mg.merged); i <= idx; i++ {
-		minRank := Rank{0, 0, 0}
+		minRank := buildEmptyRank(0)
 		minIdx := -1
 		for listIdx, list := range mg.lists {
 			cursor := mg.cursors[listIdx]
--- a/src/merger_test.go
+++ b/src/merger_test.go
@@ -22,8 +22,8 @@ func randItem() *Item {
 		offsets[idx] = Offset{sidx, eidx}
 	}
 	return &Item{
-		text:    &str,
-		index:   rand.Uint32(),
+		text:    []rune(str),
+		rank:    buildEmptyRank(rand.Int31()),
 		offsets: offsets}
 }

--- a/src/options.go
+++ b/src/options.go
@@ -1,7 +1,6 @@
 package fzf

 import (
-	"fmt"
 	"os"
 	"regexp"
 	"strconv"
@@ -15,21 +14,21 @@ import (

 const usage = `usage: fzf [options]

-  Search mode
+  Search
    -x, --extended        Extended-search mode
-    -e, --extended-exact  Extended-search mode (exact match)
+                          (enabled by default; +x or --no-extended to disable)
+    -e, --exact           Enable Exact-match
    -i                    Case-insensitive match (default: smart-case match)
    +i                    Case-sensitive match
    -n, --nth=N[,..]      Comma-separated list of field index expressions
                          for limiting search scope. Each can be a non-zero
-                          integer or a range expression ([BEGIN]..[END])
-        --with-nth=N[,..] Transform the item using index expressions for search
+                          integer or a range expression ([BEGIN]..[END]).
+    --with-nth=N[,..]     Transform item using index expressions within finder
    -d, --delimiter=STR   Field delimiter regex for --nth (default: AWK-style)
-
-  Search result
    +s, --no-sort         Do not sort the result
    --tac                 Reverse the order of the input
-        --tiebreak=CRI    Sort criterion when the scores are tied;
+    --tiebreak=CRI[,..]   Comma-separated list of sort criteria to apply
+                          when the scores are tied;
                          [length|begin|end|index] (default: length)

  Interface
@@ -39,11 +38,19 @@ const usage = `usage: fzf [options]
    --color=COLSPEC       Base scheme (dark|light|16|bw) and/or custom colors
    --black               Use black background
    --reverse             Reverse orientation
+    --margin=MARGIN       Screen margin (TRBL / TB,RL / T,RL,B / T,R,B,L)
+    --tabstop=SPACES      Number of spaces for a tab character (default: 8)
+    --cycle               Enable cyclic scroll
    --no-hscroll          Disable horizontal scroll
+    --hscroll-off=COL     Number of screen columns to keep to the right of the
+                          highlighted substring (default: 10)
    --inline-info         Display finder info inline with the query
    --prompt=STR          Input prompt (default: '> ')
-        --toggle-sort=KEY Key to toggle sort
    --bind=KEYBINDS       Custom key bindings. Refer to the man page.
+    --history=FILE        History file
+    --history-size=N      Maximum number of history entries (default: 1000)
+    --header=STR          String to print as header
+    --header-lines=N      The first N lines of the input are treated as header

  Scripting
    -q, --query=STR       Start the finder with the given query
@@ -56,20 +63,10 @@ const usage = `usage: fzf [options]

  Environment variables
    FZF_DEFAULT_COMMAND   Default command to use when input is tty
-    FZF_DEFAULT_OPTS      Defaults options. (e.g. '-x -m')
+    FZF_DEFAULT_OPTS      Default options (e.g. '--reverse --inline-info')

 `

-// Mode denotes the current search mode
-type Mode int
-
-// Search modes
-const (
-	ModeFuzzy Mode = iota
-	ModeExtended
-	ModeExtendedExact
-)
-
 // Case denotes case-sensitivity of search
 type Case int

@@ -81,32 +78,39 @@ const (
 )

 // Sort criteria
-type tiebreak int
+type criterion int

 const (
-	byLength tiebreak = iota
+	byMatchLen criterion = iota
+	byLength
 	byBegin
 	byEnd
-	byIndex
 )

+func defaultMargin() [4]string {
+	return [4]string{"0", "0", "0", "0"}
+}
+
 // Options stores the values of command-line options
 type Options struct {
-	Mode       Mode
+	Fuzzy       bool
+	Extended    bool
 	Case        Case
 	Nth         []Range
 	WithNth     []Range
-	Delimiter  *regexp.Regexp
+	Delimiter   Delimiter
 	Sort        int
 	Tac         bool
-	Tiebreak   tiebreak
+	Criteria    []criterion
 	Multi       bool
 	Ansi        bool
 	Mouse       bool
 	Theme       *curses.ColorTheme
 	Black       bool
 	Reverse     bool
+	Cycle       bool
 	Hscroll     bool
+	HscrollOff  int
 	InlineInfo  bool
 	Prompt      string
 	Query       string
@@ -114,10 +118,17 @@ type Options struct {
 	Exit0       bool
 	Filter      *string
 	ToggleSort  bool
-	Expect     []int
+	Expect      map[int]string
 	Keymap      map[int]actionType
+	Execmap     map[int]string
 	PrintQuery  bool
+	ReadZero    bool
 	Sync        bool
+	History     *History
+	Header      []string
+	HeaderLines int
+	Margin      [4]string
+	Tabstop     int
 	Version     bool
 }

@@ -130,21 +141,24 @@ func defaultTheme() *curses.ColorTheme {

 func defaultOptions() *Options {
 	return &Options{
-		Mode:       ModeFuzzy,
+		Fuzzy:       true,
+		Extended:    true,
 		Case:        CaseSmart,
 		Nth:         make([]Range, 0),
 		WithNth:     make([]Range, 0),
-		Delimiter:  nil,
+		Delimiter:   Delimiter{},
 		Sort:        1000,
 		Tac:         false,
-		Tiebreak:   byLength,
+		Criteria:    []criterion{byMatchLen, byLength},
 		Multi:       false,
 		Ansi:        false,
 		Mouse:       true,
 		Theme:       defaultTheme(),
 		Black:       false,
 		Reverse:     false,
+		Cycle:       false,
 		Hscroll:     true,
+		HscrollOff:  10,
 		InlineInfo:  false,
 		Prompt:      "> ",
 		Query:       "",
@@ -152,28 +166,35 @@ func defaultOptions() *Options {
 		Exit0:       false,
 		Filter:      nil,
 		ToggleSort:  false,
-		Expect:     []int{},
-		Keymap:     defaultKeymap(),
+		Expect:      make(map[int]string),
+		Keymap:      make(map[int]actionType),
+		Execmap:     make(map[int]string),
 		PrintQuery:  false,
+		ReadZero:    false,
 		Sync:        false,
+		History:     nil,
+		Header:      make([]string, 0),
+		HeaderLines: 0,
+		Margin:      defaultMargin(),
+		Tabstop:     8,
 		Version:     false}
 }

-func help(ok int) {
+func help(code int) {
 	os.Stderr.WriteString(usage)
-	os.Exit(ok)
+	os.Exit(code)
 }

 func errorExit(msg string) {
 	os.Stderr.WriteString(msg + "\n")
-	help(1)
+	os.Exit(exitError)
 }

-func optString(arg string, prefix string) (bool, string) {
-	rx, _ := regexp.Compile(fmt.Sprintf("^(?:%s)(.*)$", prefix))
-	matches := rx.FindStringSubmatch(arg)
-	if len(matches) > 1 {
-		return true, matches[1]
+func optString(arg string, prefixes ...string) (bool, string) {
+	for _, prefix := range prefixes {
+		if strings.HasPrefix(arg, prefix) {
+			return true, arg[len(prefix):]
+		}
 	}
 	return false, ""
 }
@@ -195,6 +216,31 @@ func optionalNextString(args []string, i *int) string {
 	return ""
 }

+func atoi(str string) int {
+	num, err := strconv.Atoi(str)
+	if err != nil {
+		errorExit("not a valid integer: " + str)
+	}
+	return num
+}
+
+func atof(str string) float64 {
+	num, err := strconv.ParseFloat(str, 64)
+	if err != nil {
+		errorExit("not a valid number: " + str)
+	}
+	return num
+}
+
+func nextInt(args []string, i *int, message string) int {
+	if len(args) > *i+1 {
+		*i++
+	} else {
+		errorExit(message)
+	}
+	return atoi(args[*i])
+}
+
 func optionalNumeric(args []string, i *int) int {
 	if len(args) > *i+1 {
 		if strings.IndexAny(args[*i+1], "0123456789") == 0 {
@@ -221,24 +267,30 @@ func splitNth(str string) []Range {
 	return ranges
 }

-func delimiterRegexp(str string) *regexp.Regexp {
-	rx, e := regexp.Compile(str)
-	if e != nil {
-		str = regexp.QuoteMeta(str)
+func delimiterRegexp(str string) Delimiter {
+	// Special handling of \t
+	str = strings.Replace(str, "\\t", "\t", -1)
+
+	// 1. Pattern does not contain any special character
+	if regexp.QuoteMeta(str) == str {
+		return Delimiter{str: &str}
 	}

-	rx, e = regexp.Compile(fmt.Sprintf("(?:.*?%s)|(?:.+?$)", str))
+	rx, e := regexp.Compile(str)
+	// 2. Pattern is not a valid regular expression
 	if e != nil {
-		errorExit("invalid regular expression: " + e.Error())
+		return Delimiter{str: &str}
 	}
-	return rx
+
+	// 3. Pattern as regular expression. Slow.
+	return Delimiter{regex: rx}
 }

 func isAlphabet(char uint8) bool {
 	return char >= 'a' && char <= 'z'
 }

-func parseKeyChords(str string, message string) []int {
+func parseKeyChords(str string, message string) map[int]string {
 	if len(str) == 0 {
 		errorExit(message)
 	}
@@ -248,46 +300,113 @@ func parseKeyChords(str string, message string) []int {
 		tokens = append(tokens, ",")
 	}

-	var chords []int
+	chords := make(map[int]string)
 	for _, key := range tokens {
 		if len(key) == 0 {
 			continue // ignore
 		}
 		lkey := strings.ToLower(key)
+		chord := 0
+		switch lkey {
+		case "up":
+			chord = curses.Up
+		case "down":
+			chord = curses.Down
+		case "left":
+			chord = curses.Left
+		case "right":
+			chord = curses.Right
+		case "enter", "return":
+			chord = curses.CtrlM
+		case "space":
+			chord = curses.AltZ + int(' ')
+		case "bspace", "bs":
+			chord = curses.BSpace
+		case "alt-bs", "alt-bspace":
+			chord = curses.AltBS
+		case "tab":
+			chord = curses.Tab
+		case "btab", "shift-tab":
+			chord = curses.BTab
+		case "esc":
+			chord = curses.ESC
+		case "del":
+			chord = curses.Del
+		case "home":
+			chord = curses.Home
+		case "end":
+			chord = curses.End
+		case "pgup", "page-up":
+			chord = curses.PgUp
+		case "pgdn", "page-down":
+			chord = curses.PgDn
+		case "shift-left":
+			chord = curses.SLeft
+		case "shift-right":
+			chord = curses.SRight
+		case "double-click":
+			chord = curses.DoubleClick
+		default:
 			if len(key) == 6 && strings.HasPrefix(lkey, "ctrl-") && isAlphabet(lkey[5]) {
-			chords = append(chords, curses.CtrlA+int(lkey[5])-'a')
+				chord = curses.CtrlA + int(lkey[5]) - 'a'
 			} else if len(key) == 5 && strings.HasPrefix(lkey, "alt-") && isAlphabet(lkey[4]) {
-			chords = append(chords, curses.AltA+int(lkey[4])-'a')
+				chord = curses.AltA + int(lkey[4]) - 'a'
 			} else if len(key) == 2 && strings.HasPrefix(lkey, "f") && key[1] >= '1' && key[1] <= '4' {
-			chords = append(chords, curses.F1+int(key[1])-'1')
+				chord = curses.F1 + int(key[1]) - '1'
 			} else if utf8.RuneCountInString(key) == 1 {
-			chords = append(chords, curses.AltZ+int([]rune(key)[0]))
+				chord = curses.AltZ + int([]rune(key)[0])
 			} else {
 				errorExit("unsupported key: " + key)
 			}
 		}
+		if chord > 0 {
+			chords[chord] = key
+		}
+	}
 	return chords
 }

-func parseTiebreak(str string) tiebreak {
-	switch strings.ToLower(str) {
-	case "length":
-		return byLength
+func parseTiebreak(str string) []criterion {
+	criteria := []criterion{byMatchLen}
+	hasIndex := false
+	hasLength := false
+	hasBegin := false
+	hasEnd := false
+	check := func(notExpected *bool, name string) {
+		if *notExpected {
+			errorExit("duplicate sort criteria: " + name)
+		}
+		if hasIndex {
+			errorExit("index should be the last criterion")
+		}
+		*notExpected = true
+	}
+	for _, str := range strings.Split(strings.ToLower(str), ",") {
+		switch str {
 		case "index":
-		return byIndex
+			check(&hasIndex, "index")
+		case "length":
+			check(&hasLength, "length")
+			criteria = append(criteria, byLength)
 		case "begin":
-		return byBegin
+			check(&hasBegin, "begin")
+			criteria = append(criteria, byBegin)
 		case "end":
-		return byEnd
+			check(&hasEnd, "end")
+			criteria = append(criteria, byEnd)
 		default:
 			errorExit("invalid sort criterion: " + str)
 		}
-	return byLength
+	}
+	return criteria
 }

 func dupeTheme(theme *curses.ColorTheme) *curses.ColorTheme {
+	if theme != nil {
 		dupe := *theme
 		return &dupe
+	}
+	return nil
 }

 func parseTheme(defaultTheme *curses.ColorTheme, str string) *curses.ColorTheme {
@@ -308,7 +427,7 @@ func parseTheme(defaultTheme *curses.ColorTheme, str string) *curses.ColorTheme
 			}
 			// Color is disabled
 			if theme == nil {
-				errorExit("colors disabled; cannot customize colors")
+				continue
 			}

 			pair := strings.Split(str, ":")
@@ -345,6 +464,8 @@ func parseTheme(defaultTheme *curses.ColorTheme, str string) *curses.ColorTheme
 				theme.Cursor = ansi
 			case "marker":
 				theme.Selected = ansi
+			case "header":
+				theme.Header = ansi
 			default:
 				fail()
 			}
@@ -353,22 +474,60 @@ func parseTheme(defaultTheme *curses.ColorTheme, str string) *curses.ColorTheme
 	return theme
 }

-func parseKeymap(keymap map[int]actionType, toggleSort bool, str string) (map[int]actionType, bool) {
-	for _, pairStr := range strings.Split(str, ",") {
-		fail := func() {
-			errorExit("invalid key binding: " + pairStr)
+var executeRegexp *regexp.Regexp
+
+func firstKey(keymap map[int]string) int {
+	for k := range keymap {
+		return k
 	}
-		pair := strings.Split(pairStr, ":")
-		if len(pair) != 2 {
-			fail()
+	return 0
+}
+
+const (
+	escapedColon = 0
+	escapedComma = 1
+)
+
+func parseKeymap(keymap map[int]actionType, execmap map[int]string, str string) {
+	if executeRegexp == nil {
+		// Backreferences are not supported.
+		// "~!@#$%^&*;/|".each_char.map { |c| Regexp.escape(c) }.map { |c| "#{c}[^#{c}]*#{c}" }.join('|')
+		executeRegexp = regexp.MustCompile(
+			"(?s):execute(-multi)?:.*|:execute(-multi)?(\\([^)]*\\)|\\[[^\\]]*\\]|~[^~]*~|![^!]*!|@[^@]*@|\\#[^\\#]*\\#|\\$[^\\$]*\\$|%[^%]*%|\\^[^\\^]*\\^|&[^&]*&|\\*[^\\*]*\\*|;[^;]*;|/[^/]*/|\\|[^\\|]*\\|)")
 	}
+	masked := executeRegexp.ReplaceAllStringFunc(str, func(src string) string {
+		if strings.HasPrefix(src, ":execute-multi") {
+			return ":execute-multi(" + strings.Repeat(" ", len(src)-len(":execute-multi()")) + ")"
+		}
+		return ":execute(" + strings.Repeat(" ", len(src)-len(":execute()")) + ")"
+	})
+	masked = strings.Replace(masked, "::", string([]rune{escapedColon, ':'}), -1)
+	masked = strings.Replace(masked, ",:", string([]rune{escapedComma, ':'}), -1)
+
+	idx := 0
+	for _, pairStr := range strings.Split(masked, ",") {
+		origPairStr := str[idx : idx+len(pairStr)]
+		idx += len(pairStr) + 1
+
+		pair := strings.SplitN(pairStr, ":", 2)
+		if len(pair) < 2 {
+			errorExit("bind action not specified: " + origPairStr)
+		}
+		var key int
+		if len(pair[0]) == 1 && pair[0][0] == escapedColon {
+			key = ':' + curses.AltZ
+		} else if len(pair[0]) == 1 && pair[0][0] == escapedComma {
+			key = ',' + curses.AltZ
+		} else {
 			keys := parseKeyChords(pair[0], "key name required")
-		if len(keys) != 1 {
-			fail()
+			key = firstKey(keys)
 		}
-		key := keys[0]
-		act := strings.ToLower(pair[1])
-		switch act {
+
+		act := origPairStr[len(pair[0])+1 : len(origPairStr)]
+		actLower := strings.ToLower(act)
+		switch actLower {
+		case "ignore":
+			keymap[key] = actIgnore
 		case "beginning-of-line":
 			keymap[key] = actBeginningOfLine
 		case "abort":
@@ -385,8 +544,12 @@ func parseKeymap(keymap map[int]actionType, toggleSort bool, str string) (map[in
 			keymap[key] = actClearScreen
 		case "delete-char":
 			keymap[key] = actDeleteChar
+		case "delete-char/eof":
+			keymap[key] = actDeleteCharEOF
 		case "end-of-line":
 			keymap[key] = actEndOfLine
+		case "cancel":
+			keymap[key] = actCancel
 		case "forward-char":
 			keymap[key] = actForwardChar
 		case "forward-word":
@@ -407,6 +570,16 @@ func parseKeymap(keymap map[int]actionType, toggleSort bool, str string) (map[in
 			keymap[key] = actToggleDown
 		case "toggle-up":
 			keymap[key] = actToggleUp
+		case "toggle-in":
+			keymap[key] = actToggleIn
+		case "toggle-out":
+			keymap[key] = actToggleOut
+		case "toggle-all":
+			keymap[key] = actToggleAll
+		case "select-all":
+			keymap[key] = actSelectAll
+		case "deselect-all":
+			keymap[key] = actDeselectAll
 		case "toggle":
 			keymap[key] = actToggle
 		case "down":
@@ -417,37 +590,147 @@ func parseKeymap(keymap map[int]actionType, toggleSort bool, str string) (map[in
 			keymap[key] = actPageUp
 		case "page-down":
 			keymap[key] = actPageDown
+		case "previous-history":
+			keymap[key] = actPreviousHistory
+		case "next-history":
+			keymap[key] = actNextHistory
 		case "toggle-sort":
 			keymap[key] = actToggleSort
-			toggleSort = true
 		default:
+			if isExecuteAction(actLower) {
+				var offset int
+				if strings.HasPrefix(actLower, "execute-multi") {
+					keymap[key] = actExecuteMulti
+					offset = len("execute-multi")
+				} else {
+					keymap[key] = actExecute
+					offset = len("execute")
+				}
+				if act[offset] == ':' {
+					execmap[key] = act[offset+1:]
+				} else {
+					execmap[key] = act[offset+1 : len(act)-1]
+				}
+			} else {
 				errorExit("unknown action: " + act)
 			}
 		}
-	return keymap, toggleSort
+	}
 }

-func checkToggleSort(keymap map[int]actionType, str string) map[int]actionType {
+func isExecuteAction(str string) bool {
+	if !strings.HasPrefix(str, "execute") || len(str) < len("execute()") {
+		return false
+	}
+	b := str[len("execute")]
+	if strings.HasPrefix(str, "execute-multi") {
+		if len(str) < len("execute-multi()") {
+			return false
+		}
+		b = str[len("execute-multi")]
+	}
+	e := str[len(str)-1]
+	if b == ':' || b == '(' && e == ')' || b == '[' && e == ']' ||
+		b == e && strings.ContainsAny(string(b), "~!@#$%^&*;/|") {
+		return true
+	}
+	return false
+}
+
+func parseToggleSort(keymap map[int]actionType, str string) {
 	keys := parseKeyChords(str, "key name required")
 	if len(keys) != 1 {
 		errorExit("multiple keys specified")
 	}
-	keymap[keys[0]] = actToggleSort
-	return keymap
+	keymap[firstKey(keys)] = actToggleSort
+}
+
+func strLines(str string) []string {
+	return strings.Split(strings.TrimSuffix(str, "\n"), "\n")
+}
+
+func parseMargin(margin string) [4]string {
+	margins := strings.Split(margin, ",")
+	checked := func(str string) string {
+		if strings.HasSuffix(str, "%") {
+			val := atof(str[:len(str)-1])
+			if val < 0 {
+				errorExit("margin must be non-negative")
+			}
+			if val > 100 {
+				errorExit("margin too large")
+			}
+		} else {
+			val := atoi(str)
+			if val < 0 {
+				errorExit("margin must be non-negative")
+			}
+		}
+		return str
+	}
+	switch len(margins) {
+	case 1:
+		m := checked(margins[0])
+		return [4]string{m, m, m, m}
+	case 2:
+		tb := checked(margins[0])
+		rl := checked(margins[1])
+		return [4]string{tb, rl, tb, rl}
+	case 3:
+		t := checked(margins[0])
+		rl := checked(margins[1])
+		b := checked(margins[2])
+		return [4]string{t, rl, b, rl}
+	case 4:
+		return [4]string{
+			checked(margins[0]), checked(margins[1]),
+			checked(margins[2]), checked(margins[3])}
+	default:
+		errorExit("invalid margin: " + margin)
+	}
+	return defaultMargin()
 }

 func parseOptions(opts *Options, allArgs []string) {
+	var historyMax int
+	if opts.History == nil {
+		historyMax = defaultHistoryMax
+	} else {
+		historyMax = opts.History.maxSize
+	}
+	setHistory := func(path string) {
+		h, e := NewHistory(path, historyMax)
+		if e != nil {
+			errorExit(e.Error())
+		}
+		opts.History = h
+	}
+	setHistoryMax := func(max int) {
+		historyMax = max
+		if historyMax < 1 {
+			errorExit("history max must be a positive integer")
+		}
+		if opts.History != nil {
+			opts.History.maxSize = historyMax
+		}
+	}
 	for i := 0; i < len(allArgs); i++ {
 		arg := allArgs[i]
 		switch arg {
 		case "-h", "--help":
-			help(0)
+			help(exitOk)
 		case "-x", "--extended":
-			opts.Mode = ModeExtended
-		case "-e", "--extended-exact":
-			opts.Mode = ModeExtendedExact
-		case "+x", "--no-extended", "+e", "--no-extended-exact":
-			opts.Mode = ModeFuzzy
+			opts.Extended = true
+		case "-e", "--exact":
+			opts.Fuzzy = false
+		case "--extended-exact":
+			// Note that we now don't have --no-extended-exact
+			opts.Fuzzy = false
+			opts.Extended = true
+		case "+x", "--no-extended":
+			opts.Extended = false
+		case "+e", "--no-exact":
+			opts.Fuzzy = true
 		case "-q", "--query":
 			opts.Query = nextString(allArgs, &i, "query string required")
 		case "-f", "--filter":
@@ -456,9 +739,9 @@ func parseOptions(opts *Options, allArgs []string) {
 		case "--expect":
 			opts.Expect = parseKeyChords(nextString(allArgs, &i, "key names required"), "key names required")
 		case "--tiebreak":
-			opts.Tiebreak = parseTiebreak(nextString(allArgs, &i, "sort criterion required"))
+			opts.Criteria = parseTiebreak(nextString(allArgs, &i, "sort criterion required"))
 		case "--bind":
-			opts.Keymap, opts.ToggleSort = parseKeymap(opts.Keymap, opts.ToggleSort, nextString(allArgs, &i, "bind expression required"))
+			parseKeymap(opts.Keymap, opts.Execmap, nextString(allArgs, &i, "bind expression required"))
 		case "--color":
 			spec := optionalNextString(allArgs, &i)
 			if len(spec) == 0 {
@@ -467,8 +750,7 @@ func parseOptions(opts *Options, allArgs []string) {
 				opts.Theme = parseTheme(opts.Theme, spec)
 			}
 		case "--toggle-sort":
-			opts.Keymap = checkToggleSort(opts.Keymap, nextString(allArgs, &i, "key name required"))
-			opts.ToggleSort = true
+			parseToggleSort(opts.Keymap, nextString(allArgs, &i, "key name required"))
 		case "-d", "--delimiter":
 			opts.Delimiter = delimiterRegexp(nextString(allArgs, &i, "delimiter required"))
 		case "-n", "--nth":
@@ -509,10 +791,16 @@ func parseOptions(opts *Options, allArgs []string) {
 			opts.Reverse = true
 		case "--no-reverse":
 			opts.Reverse = false
+		case "--cycle":
+			opts.Cycle = true
+		case "--no-cycle":
+			opts.Cycle = false
 		case "--hscroll":
 			opts.Hscroll = true
 		case "--no-hscroll":
 			opts.Hscroll = false
+		case "--hscroll-off":
+			opts.HscrollOff = nextInt(allArgs, &i, "hscroll offset required")
 		case "--inline-info":
 			opts.InlineInfo = true
 		case "--no-inline-info":
@@ -525,6 +813,10 @@ func parseOptions(opts *Options, allArgs []string) {
 			opts.Exit0 = true
 		case "+0", "--no-exit-0":
 			opts.Exit0 = false
+		case "--read0":
+			opts.ReadZero = true
+		case "--no-read0":
+			opts.ReadZero = false
 		case "--print-query":
 			opts.PrintQuery = true
 		case "--no-print-query":
@@ -537,43 +829,112 @@ func parseOptions(opts *Options, allArgs []string) {
 			opts.Sync = false
 		case "--async":
 			opts.Sync = false
+		case "--no-history":
+			opts.History = nil
+		case "--history":
+			setHistory(nextString(allArgs, &i, "history file path required"))
+		case "--history-size":
+			setHistoryMax(nextInt(allArgs, &i, "history max size required"))
+		case "--no-header":
+			opts.Header = []string{}
+		case "--no-header-lines":
+			opts.HeaderLines = 0
+		case "--header":
+			opts.Header = strLines(nextString(allArgs, &i, "header string required"))
+		case "--header-lines":
+			opts.HeaderLines = atoi(
+				nextString(allArgs, &i, "number of header lines required"))
+		case "--no-margin":
+			opts.Margin = defaultMargin()
+		case "--margin":
+			opts.Margin = parseMargin(
+				nextString(allArgs, &i, "margin required (TRBL / TB,RL / T,RL,B / T,R,B,L)"))
+		case "--tabstop":
+			opts.Tabstop = nextInt(allArgs, &i, "tab stop required")
 		case "--version":
 			opts.Version = true
 		default:
-			if match, value := optString(arg, "-q|--query="); match {
+			if match, value := optString(arg, "-q", "--query="); match {
 				opts.Query = value
-			} else if match, value := optString(arg, "-f|--filter="); match {
+			} else if match, value := optString(arg, "-f", "--filter="); match {
 				opts.Filter = &value
-			} else if match, value := optString(arg, "-d|--delimiter="); match {
+			} else if match, value := optString(arg, "-d", "--delimiter="); match {
 				opts.Delimiter = delimiterRegexp(value)
 			} else if match, value := optString(arg, "--prompt="); match {
 				opts.Prompt = value
-			} else if match, value := optString(arg, "-n|--nth="); match {
+			} else if match, value := optString(arg, "-n", "--nth="); match {
 				opts.Nth = splitNth(value)
 			} else if match, value := optString(arg, "--with-nth="); match {
 				opts.WithNth = splitNth(value)
-			} else if match, _ := optString(arg, "-s|--sort="); match {
+			} else if match, _ := optString(arg, "-s", "--sort="); match {
 				opts.Sort = 1 // Don't care
 			} else if match, value := optString(arg, "--toggle-sort="); match {
-				opts.Keymap = checkToggleSort(opts.Keymap, value)
-				opts.ToggleSort = true
+				parseToggleSort(opts.Keymap, value)
 			} else if match, value := optString(arg, "--expect="); match {
 				opts.Expect = parseKeyChords(value, "key names required")
 			} else if match, value := optString(arg, "--tiebreak="); match {
-				opts.Tiebreak = parseTiebreak(value)
+				opts.Criteria = parseTiebreak(value)
 			} else if match, value := optString(arg, "--color="); match {
 				opts.Theme = parseTheme(opts.Theme, value)
 			} else if match, value := optString(arg, "--bind="); match {
-				opts.Keymap, opts.ToggleSort = parseKeymap(opts.Keymap, opts.ToggleSort, value)
+				parseKeymap(opts.Keymap, opts.Execmap, value)
+			} else if match, value := optString(arg, "--history="); match {
+				setHistory(value)
+			} else if match, value := optString(arg, "--history-size="); match {
+				setHistoryMax(atoi(value))
+			} else if match, value := optString(arg, "--header="); match {
+				opts.Header = strLines(value)
+			} else if match, value := optString(arg, "--header-lines="); match {
+				opts.HeaderLines = atoi(value)
+			} else if match, value := optString(arg, "--margin="); match {
+				opts.Margin = parseMargin(value)
+			} else if match, value := optString(arg, "--tabstop="); match {
+				opts.Tabstop = atoi(value)
+			} else if match, value := optString(arg, "--hscroll-off="); match {
+				opts.HscrollOff = atoi(value)
 			} else {
 				errorExit("unknown option: " + arg)
 			}
 		}
 	}

+	if opts.HeaderLines < 0 {
+		errorExit("header lines must be a non-negative integer")
+	}
+
+	if opts.HscrollOff < 0 {
+		errorExit("hscroll offset must be a non-negative integer")
+	}
+
+	if opts.Tabstop < 1 {
+		errorExit("tab stop must be a positive integer")
+	}
+}
+
+func postProcessOptions(opts *Options) {
+	// Default actions for CTRL-N / CTRL-P when --history is set
+	if opts.History != nil {
+		if _, prs := opts.Keymap[curses.CtrlP]; !prs {
+			opts.Keymap[curses.CtrlP] = actPreviousHistory
+		}
+		if _, prs := opts.Keymap[curses.CtrlN]; !prs {
+			opts.Keymap[curses.CtrlN] = actNextHistory
+		}
+	}
+
+	// Extend the default key map
+	keymap := defaultKeymap()
+	for key, act := range opts.Keymap {
+		if act == actToggleSort {
+			opts.ToggleSort = true
+		}
+		keymap[key] = act
+	}
+	opts.Keymap = keymap
+
 	// If we're not using extended search mode, --nth option becomes irrelevant
 	// if it contains the whole range
-	if opts.Mode == ModeFuzzy || len(opts.Nth) == 1 {
+	if !opts.Extended || len(opts.Nth) == 1 {
 		for _, r := range opts.Nth {
 			if r.begin == rangeEllipsis && r.end == rangeEllipsis {
 				opts.Nth = make([]Range, 0)
@@ -589,9 +950,13 @@ func ParseOptions() *Options {

 	// Options from Env var
 	words, _ := shellwords.Parse(os.Getenv("FZF_DEFAULT_OPTS"))
+	if len(words) > 0 {
 		parseOptions(opts, words)
+	}

 	// Options from command-line arguments
 	parseOptions(opts, os.Args[1:])
+
+	postProcessOptions(opts)
 	return opts
 }
--- a/src/options_test.go
+++ b/src/options_test.go
@@ -1,17 +1,66 @@
 package fzf

 import (
+	"fmt"
 	"testing"

 	"github.com/junegunn/fzf/src/curses"
 )

 func TestDelimiterRegex(t *testing.T) {
-	rx := delimiterRegexp("*")
-	tokens := rx.FindAllString("-*--*---**---", -1)
-	if tokens[0] != "-*" || tokens[1] != "--*" || tokens[2] != "---*" ||
-		tokens[3] != "*" || tokens[4] != "---" {
-		t.Errorf("%s %s %d", rx, tokens, len(tokens))
+	// Valid regex
+	delim := delimiterRegexp(".")
+	if delim.regex == nil || delim.str != nil {
+		t.Error(delim)
+	}
+	// Broken regex -> string
+	delim = delimiterRegexp("[0-9")
+	if delim.regex != nil || *delim.str != "[0-9" {
+		t.Error(delim)
+	}
+	// Valid regex
+	delim = delimiterRegexp("[0-9]")
+	if delim.regex.String() != "[0-9]" || delim.str != nil {
+		t.Error(delim)
+	}
+	// Tab character
+	delim = delimiterRegexp("\t")
+	if delim.regex != nil || *delim.str != "\t" {
+		t.Error(delim)
+	}
+	// Tab expression
+	delim = delimiterRegexp("\\t")
+	if delim.regex != nil || *delim.str != "\t" {
+		t.Error(delim)
+	}
+	// Tabs -> regex
+	delim = delimiterRegexp("\t+")
+	if delim.regex == nil || delim.str != nil {
+		t.Error(delim)
+	}
+}
+
+func TestDelimiterRegexString(t *testing.T) {
+	delim := delimiterRegexp("*")
+	tokens := Tokenize([]rune("-*--*---**---"), delim)
+	if delim.regex != nil ||
+		string(tokens[0].text) != "-*" ||
+		string(tokens[1].text) != "--*" ||
+		string(tokens[2].text) != "---*" ||
+		string(tokens[3].text) != "*" ||
+		string(tokens[4].text) != "---" {
+		t.Errorf("%s %s %d", delim, tokens, len(tokens))
+	}
+}
+
+func TestDelimiterRegexRegex(t *testing.T) {
+	delim := delimiterRegexp("--\\*")
+	tokens := Tokenize([]rune("-*--*---**---"), delim)
+	if delim.str != nil ||
+		string(tokens[0].text) != "-*--*" ||
+		string(tokens[1].text) != "---*" ||
+		string(tokens[2].text) != "*---" {
+		t.Errorf("%s %d", tokens, len(tokens))
 	}
 }

@@ -47,14 +96,16 @@ func TestIrrelevantNth(t *testing.T) {
 		opts := defaultOptions()
 		words := []string{"--nth", "..", "-x"}
 		parseOptions(opts, words)
+		postProcessOptions(opts)
 		if len(opts.Nth) != 0 {
 			t.Errorf("nth should be empty: %s", opts.Nth)
 		}
 	}
-	for _, words := range [][]string{[]string{"--nth", "..,3"}, []string{"--nth", "3,1.."}, []string{"--nth", "..-1,1"}} {
+	for _, words := range [][]string{[]string{"--nth", "..,3", "+x"}, []string{"--nth", "3,1..", "+x"}, []string{"--nth", "..-1,1", "+x"}} {
 		{
 			opts := defaultOptions()
 			parseOptions(opts, words)
+			postProcessOptions(opts)
 			if len(opts.Nth) != 0 {
 				t.Errorf("nth should be empty: %s", opts.Nth)
 			}
@@ -63,6 +114,7 @@ func TestIrrelevantNth(t *testing.T) {
 			opts := defaultOptions()
 			words = append(words, "-x")
 			parseOptions(opts, words)
+			postProcessOptions(opts)
 			if len(opts.Nth) != 2 {
 				t.Errorf("nth should not be empty: %s", opts.Nth)
 			}
@@ -71,63 +123,101 @@ func TestIrrelevantNth(t *testing.T) {
 }

 func TestParseKeys(t *testing.T) {
-	keys := parseKeyChords("ctrl-z,alt-z,f2,@,Alt-a,!,ctrl-G,J,g", "")
-	check := func(key int, expected int) {
-		if key != expected {
-			t.Errorf("%d != %d", key, expected)
+	pairs := parseKeyChords("ctrl-z,alt-z,f2,@,Alt-a,!,ctrl-G,J,g", "")
+	check := func(i int, s string) {
+		if pairs[i] != s {
+			t.Errorf("%s != %s", pairs[i], s)
 		}
 	}
-	check(len(keys), 9)
-	check(keys[0], curses.CtrlZ)
-	check(keys[1], curses.AltZ)
-	check(keys[2], curses.F2)
-	check(keys[3], curses.AltZ+'@')
-	check(keys[4], curses.AltA)
-	check(keys[5], curses.AltZ+'!')
-	check(keys[6], curses.CtrlA+'g'-'a')
-	check(keys[7], curses.AltZ+'J')
-	check(keys[8], curses.AltZ+'g')
+	if len(pairs) != 9 {
+		t.Error(9)
+	}
+	check(curses.CtrlZ, "ctrl-z")
+	check(curses.AltZ, "alt-z")
+	check(curses.F2, "f2")
+	check(curses.AltZ+'@', "@")
+	check(curses.AltA, "Alt-a")
+	check(curses.AltZ+'!', "!")
+	check(curses.CtrlA+'g'-'a', "ctrl-G")
+	check(curses.AltZ+'J', "J")
+	check(curses.AltZ+'g', "g")
+
+	// Synonyms
+	pairs = parseKeyChords("enter,Return,space,tab,btab,esc,up,down,left,right", "")
+	if len(pairs) != 9 {
+		t.Error(9)
+	}
+	check(curses.CtrlM, "Return")
+	check(curses.AltZ+' ', "space")
+	check(curses.Tab, "tab")
+	check(curses.BTab, "btab")
+	check(curses.ESC, "esc")
+	check(curses.Up, "up")
+	check(curses.Down, "down")
+	check(curses.Left, "left")
+	check(curses.Right, "right")
+
+	pairs = parseKeyChords("Tab,Ctrl-I,PgUp,page-up,pgdn,Page-Down,Home,End,Alt-BS,Alt-BSpace,shift-left,shift-right,btab,shift-tab,return,Enter,bspace", "")
+	if len(pairs) != 11 {
+		t.Error(11)
+	}
+	check(curses.Tab, "Ctrl-I")
+	check(curses.PgUp, "page-up")
+	check(curses.PgDn, "Page-Down")
+	check(curses.Home, "Home")
+	check(curses.End, "End")
+	check(curses.AltBS, "Alt-BSpace")
+	check(curses.SLeft, "shift-left")
+	check(curses.SRight, "shift-right")
+	check(curses.BTab, "shift-tab")
+	check(curses.CtrlM, "Enter")
+	check(curses.BSpace, "bspace")
 }

 func TestParseKeysWithComma(t *testing.T) {
-	check := func(key int, expected int) {
-		if key != expected {
-			t.Errorf("%d != %d", key, expected)
+	checkN := func(a int, b int) {
+		if a != b {
+			t.Errorf("%d != %d", a, b)
+		}
+	}
+	check := func(pairs map[int]string, i int, s string) {
+		if pairs[i] != s {
+			t.Errorf("%s != %s", pairs[i], s)
 		}
 	}

-	keys := parseKeyChords(",", "")
-	check(len(keys), 1)
-	check(keys[0], curses.AltZ+',')
+	pairs := parseKeyChords(",", "")
+	checkN(len(pairs), 1)
+	check(pairs, curses.AltZ+',', ",")

-	keys = parseKeyChords(",,a,b", "")
-	check(len(keys), 3)
-	check(keys[0], curses.AltZ+'a')
-	check(keys[1], curses.AltZ+'b')
-	check(keys[2], curses.AltZ+',')
+	pairs = parseKeyChords(",,a,b", "")
+	checkN(len(pairs), 3)
+	check(pairs, curses.AltZ+'a', "a")
+	check(pairs, curses.AltZ+'b', "b")
+	check(pairs, curses.AltZ+',', ",")

-	keys = parseKeyChords("a,b,,", "")
-	check(len(keys), 3)
-	check(keys[0], curses.AltZ+'a')
-	check(keys[1], curses.AltZ+'b')
-	check(keys[2], curses.AltZ+',')
+	pairs = parseKeyChords("a,b,,", "")
+	checkN(len(pairs), 3)
+	check(pairs, curses.AltZ+'a', "a")
+	check(pairs, curses.AltZ+'b', "b")
+	check(pairs, curses.AltZ+',', ",")

-	keys = parseKeyChords("a,,,b", "")
-	check(len(keys), 3)
-	check(keys[0], curses.AltZ+'a')
-	check(keys[1], curses.AltZ+'b')
-	check(keys[2], curses.AltZ+',')
+	pairs = parseKeyChords("a,,,b", "")
+	checkN(len(pairs), 3)
+	check(pairs, curses.AltZ+'a', "a")
+	check(pairs, curses.AltZ+'b', "b")
+	check(pairs, curses.AltZ+',', ",")

-	keys = parseKeyChords("a,,,b,c", "")
-	check(len(keys), 4)
-	check(keys[0], curses.AltZ+'a')
-	check(keys[1], curses.AltZ+'b')
-	check(keys[2], curses.AltZ+'c')
-	check(keys[3], curses.AltZ+',')
+	pairs = parseKeyChords("a,,,b,c", "")
+	checkN(len(pairs), 4)
+	check(pairs, curses.AltZ+'a', "a")
+	check(pairs, curses.AltZ+'b', "b")
+	check(pairs, curses.AltZ+'c', "c")
+	check(pairs, curses.AltZ+',', ",")

-	keys = parseKeyChords(",,,", "")
-	check(len(keys), 1)
-	check(keys[0], curses.AltZ+',')
+	pairs = parseKeyChords(",,,", "")
+	checkN(len(pairs), 1)
+	check(pairs, curses.AltZ+',', ",")
 }

 func TestBind(t *testing.T) {
@@ -136,23 +226,43 @@ func TestBind(t *testing.T) {
 			t.Errorf("%d != %d", action, expected)
 		}
 	}
-	keymap := defaultKeymap()
-	check(actBeginningOfLine, keymap[curses.CtrlA])
-	keymap, toggleSort :=
-		parseKeymap(keymap, false,
-			"ctrl-a:kill-line,ctrl-b:toggle-sort,c:page-up,alt-z:page-down")
-	if !toggleSort {
-		t.Errorf("toggleSort not set")
+	checkString := func(action string, expected string) {
+		if action != expected {
+			t.Errorf("%d != %d", action, expected)
 		}
+	}
+	keymap := defaultKeymap()
+	execmap := make(map[int]string)
+	check(actBeginningOfLine, keymap[curses.CtrlA])
+	parseKeymap(keymap, execmap,
+		"ctrl-a:kill-line,ctrl-b:toggle-sort,c:page-up,alt-z:page-down,"+
+			"f1:execute(ls {}),f2:execute/echo {}, {}, {}/,f3:execute[echo '({})'],f4:execute;less {};,"+
+			"alt-a:execute@echo (,),[,],/,:,;,%,{}@,alt-b:execute;echo (,),[,],/,:,@,%,{};"+
+			",,:abort,::accept,X:execute:\nfoobar,Y:execute(baz)")
 	check(actKillLine, keymap[curses.CtrlA])
 	check(actToggleSort, keymap[curses.CtrlB])
 	check(actPageUp, keymap[curses.AltZ+'c'])
+	check(actAbort, keymap[curses.AltZ+','])
+	check(actAccept, keymap[curses.AltZ+':'])
 	check(actPageDown, keymap[curses.AltZ])
+	check(actExecute, keymap[curses.F1])
+	check(actExecute, keymap[curses.F2])
+	check(actExecute, keymap[curses.F3])
+	check(actExecute, keymap[curses.F4])
+	checkString("ls {}", execmap[curses.F1])
+	checkString("echo {}, {}, {}", execmap[curses.F2])
+	checkString("echo '({})'", execmap[curses.F3])
+	checkString("less {}", execmap[curses.F4])
+	checkString("echo (,),[,],/,:,;,%,{}", execmap[curses.AltA])
+	checkString("echo (,),[,],/,:,@,%,{}", execmap[curses.AltB])
+	checkString("\nfoobar,Y:execute(baz)", execmap[curses.AltZ+'X'])

-	keymap, toggleSort = parseKeymap(keymap, false, "f1:abort")
-	if toggleSort {
-		t.Errorf("toggleSort set")
+	for idx, char := range []rune{'~', '!', '@', '#', '$', '%', '^', '&', '*', '|', ';', '/'} {
+		parseKeymap(keymap, execmap, fmt.Sprintf("%d:execute%cfoobar%c", idx%10, char, char))
+		checkString("foobar", execmap[curses.AltZ+int([]rune(fmt.Sprintf("%d", idx%10))[0])])
 	}
+
+	parseKeymap(keymap, execmap, "f1:abort")
 	check(actAbort, keymap[curses.F1])
 }

@@ -201,3 +311,65 @@ func TestColorSpec(t *testing.T) {
 		t.Errorf("using default colors")
 	}
 }
+
+func TestParseNilTheme(t *testing.T) {
+	var theme *curses.ColorTheme
+	newTheme := parseTheme(theme, "prompt:12")
+	if newTheme != nil {
+		t.Errorf("color is disabled. keep it that way.")
+	}
+	newTheme = parseTheme(theme, "prompt:12,dark,prompt:13")
+	if newTheme.Prompt != 13 {
+		t.Errorf("color should now be enabled and customized")
+	}
+}
+
+func TestDefaultCtrlNP(t *testing.T) {
+	check := func(words []string, key int, expected actionType) {
+		opts := defaultOptions()
+		parseOptions(opts, words)
+		postProcessOptions(opts)
+		if opts.Keymap[key] != expected {
+			t.Error()
+		}
+	}
+	check([]string{}, curses.CtrlN, actDown)
+	check([]string{}, curses.CtrlP, actUp)
+
+	check([]string{"--bind=ctrl-n:accept"}, curses.CtrlN, actAccept)
+	check([]string{"--bind=ctrl-p:accept"}, curses.CtrlP, actAccept)
+
+	hist := "--history=/tmp/foo"
+	check([]string{hist}, curses.CtrlN, actNextHistory)
+	check([]string{hist}, curses.CtrlP, actPreviousHistory)
+
+	check([]string{hist, "--bind=ctrl-n:accept"}, curses.CtrlN, actAccept)
+	check([]string{hist, "--bind=ctrl-n:accept"}, curses.CtrlP, actPreviousHistory)
+
+	check([]string{hist, "--bind=ctrl-p:accept"}, curses.CtrlN, actNextHistory)
+	check([]string{hist, "--bind=ctrl-p:accept"}, curses.CtrlP, actAccept)
+}
+
+func TestToggle(t *testing.T) {
+	optsFor := func(words ...string) *Options {
+		opts := defaultOptions()
+		parseOptions(opts, words)
+		postProcessOptions(opts)
+		return opts
+	}
+
+	opts := optsFor()
+	if opts.ToggleSort {
+		t.Error()
+	}
+
+	opts = optsFor("--bind=a:toggle-sort")
+	if !opts.ToggleSort {
+		t.Error()
+	}
+
+	opts = optsFor("--bind=a:toggle-sort", "--bind=a:up")
+	if opts.ToggleSort {
+		t.Error()
+	}
+}
--- a/src/pattern.go
+++ b/src/pattern.go
@@ -6,6 +6,7 @@ import (
 	"strings"

 	"github.com/junegunn/fzf/src/algo"
+	"github.com/junegunn/fzf/src/util"
 )

 // fuzzy
@@ -24,6 +25,7 @@ const (
 	termExact
 	termPrefix
 	termSuffix
+	termEqual
 )

 type term struct {
@@ -34,16 +36,20 @@ type term struct {
 	origText      []rune
 }

+type termSet []term
+
 // Pattern represents search pattern
 type Pattern struct {
-	mode          Mode
+	fuzzy         bool
+	extended      bool
 	caseSensitive bool
+	forward       bool
 	text          []rune
-	terms         []term
-	hasInvTerm    bool
-	delimiter     *regexp.Regexp
+	termSets      []termSet
+	cacheable     bool
+	delimiter     Delimiter
 	nth           []Range
-	procFun       map[termType]func(bool, *[]rune, []rune) (int, int)
+	procFun       map[termType]func(bool, bool, []rune, []rune) algo.Result
 }

 var (
@@ -60,7 +66,7 @@ func init() {

 func clearPatternCache() {
 	// We can uniquely identify the pattern for a given string since
-	// mode and caseMode do not change while the program is running
+	// search mode and caseMode do not change while the program is running
 	_patternCache = make(map[string]*Pattern)
 }

@@ -69,14 +75,13 @@ func clearChunkCache() {
 }

 // BuildPattern builds Pattern object from the given arguments
-func BuildPattern(mode Mode, caseMode Case,
-	nth []Range, delimiter *regexp.Regexp, runes []rune) *Pattern {
+func BuildPattern(fuzzy bool, extended bool, caseMode Case, forward bool,
+	nth []Range, delimiter Delimiter, runes []rune) *Pattern {

 	var asString string
-	switch mode {
-	case ModeExtended, ModeExtendedExact:
+	if extended {
 		asString = strings.Trim(string(runes), " ")
-	default:
+	} else {
 		asString = string(runes)
 	}

@@ -85,18 +90,23 @@ func BuildPattern(mode Mode, caseMode Case,
 		return cached
 	}

-	caseSensitive, hasInvTerm := true, false
-	terms := []term{}
+	caseSensitive, cacheable := true, true
+	termSets := []termSet{}

-	switch mode {
-	case ModeExtended, ModeExtendedExact:
-		terms = parseTerms(mode, caseMode, asString)
-		for _, term := range terms {
-			if term.inv {
-				hasInvTerm = true
+	if extended {
+		termSets = parseTerms(fuzzy, caseMode, asString)
+	Loop:
+		for _, termSet := range termSets {
+			for idx, term := range termSet {
+				// If the query contains inverse search terms or OR operators,
+				// we cannot cache the search scope
+				if idx > 0 || term.inv {
+					cacheable = false
+					break Loop
 				}
 			}
-	default:
+		}
+	} else {
 		lowerString := strings.ToLower(asString)
 		caseSensitive = caseMode == CaseRespect ||
 			caseMode == CaseSmart && lowerString != asString
@@ -106,16 +116,19 @@ func BuildPattern(mode Mode, caseMode Case,
 	}

 	ptr := &Pattern{
-		mode:          mode,
+		fuzzy:         fuzzy,
+		extended:      extended,
 		caseSensitive: caseSensitive,
+		forward:       forward,
 		text:          []rune(asString),
-		terms:         terms,
-		hasInvTerm:    hasInvTerm,
+		termSets:      termSets,
+		cacheable:     cacheable,
 		nth:           nth,
 		delimiter:     delimiter,
-		procFun:       make(map[termType]func(bool, *[]rune, []rune) (int, int))}
+		procFun:       make(map[termType]func(bool, bool, []rune, []rune) algo.Result)}

 	ptr.procFun[termFuzzy] = algo.FuzzyMatch
+	ptr.procFun[termEqual] = algo.EqualMatch
 	ptr.procFun[termExact] = algo.ExactMatchNaive
 	ptr.procFun[termPrefix] = algo.PrefixMatch
 	ptr.procFun[termSuffix] = algo.SuffixMatch
@@ -124,9 +137,11 @@ func BuildPattern(mode Mode, caseMode Case,
 	return ptr
 }

-func parseTerms(mode Mode, caseMode Case, str string) []term {
+func parseTerms(fuzzy bool, caseMode Case, str string) []termSet {
 	tokens := _splitRegex.Split(str, -1)
-	terms := []term{}
+	sets := []termSet{}
+	set := termSet{}
+	switchSet := false
 	for _, token := range tokens {
 		typ, inv, text := termFuzzy, false, token
 		lowerText := strings.ToLower(text)
@@ -136,46 +151,68 @@ func parseTerms(mode Mode, caseMode Case, str string) []term {
 			text = lowerText
 		}
 		origText := []rune(text)
-		if mode == ModeExtendedExact {
+		if !fuzzy {
 			typ = termExact
 		}

+		if text == "|" {
+			switchSet = false
+			continue
+		}
+
 		if strings.HasPrefix(text, "!") {
 			inv = true
 			text = text[1:]
 		}

 		if strings.HasPrefix(text, "'") {
-			if mode == ModeExtended {
+			// Flip exactness
+			if fuzzy {
 				typ = termExact
 				text = text[1:]
+			} else {
+				typ = termFuzzy
+				text = text[1:]
 			}
 		} else if strings.HasPrefix(text, "^") {
+			if strings.HasSuffix(text, "$") {
+				typ = termEqual
+				text = text[1 : len(text)-1]
+			} else {
 				typ = termPrefix
 				text = text[1:]
+			}
 		} else if strings.HasSuffix(text, "$") {
 			typ = termSuffix
 			text = text[:len(text)-1]
 		}

 		if len(text) > 0 {
-			terms = append(terms, term{
+			if switchSet {
+				sets = append(sets, set)
+				set = termSet{}
+			}
+			set = append(set, term{
 				typ:           typ,
 				inv:           inv,
 				text:          []rune(text),
 				caseSensitive: caseSensitive,
 				origText:      origText})
+			switchSet = true
 		}
 	}
-	return terms
+	if len(set) > 0 {
+		sets = append(sets, set)
+	}
+	return sets
 }

 // IsEmpty returns true if the pattern is effectively empty
 func (p *Pattern) IsEmpty() bool {
-	if p.mode == ModeFuzzy {
+	if !p.extended {
 		return len(p.text) == 0
 	}
-	return len(p.terms) == 0
+	return len(p.termSets) == 0
 }

 // AsString returns the search query in string type
@@ -185,15 +222,14 @@ func (p *Pattern) AsString() string {

 // CacheKey is used to build string to be used as the key of result cache
 func (p *Pattern) CacheKey() string {
-	if p.mode == ModeFuzzy {
+	if !p.extended {
 		return p.AsString()
 	}
 	cacheableTerms := []string{}
-	for _, term := range p.terms {
-		if term.inv {
-			continue
+	for _, termSet := range p.termSets {
+		if len(termSet) == 1 && !termSet[0].inv {
+			cacheableTerms = append(cacheableTerms, string(termSet[0].origText))
 		}
-		cacheableTerms = append(cacheableTerms, string(term.origText))
 	}
 	return strings.Join(cacheableTerms, " ")
 }
@@ -204,7 +240,7 @@ func (p *Pattern) Match(chunk *Chunk) []*Item {

 	// ChunkCache: Exact match
 	cacheKey := p.CacheKey()
-	if !p.hasInvTerm { // Because we're excluding Inv-term from cache key
+	if p.cacheable {
 		if cached, found := _cache.Find(chunk, cacheKey); found {
 			return cached
 		}
@@ -229,7 +265,7 @@ Loop:

 	matches := p.matchChunk(space)

-	if !p.hasInvTerm {
+	if p.cacheable {
 		_cache.Add(chunk, cacheKey, matches)
 	}
 	return matches
@@ -237,17 +273,18 @@ Loop:

 func (p *Pattern) matchChunk(chunk *Chunk) []*Item {
 	matches := []*Item{}
-	if p.mode == ModeFuzzy {
+	if !p.extended {
 		for _, item := range *chunk {
-			if sidx, eidx := p.fuzzyMatch(item); sidx >= 0 {
+			offset, bonus := p.basicMatch(item)
+			if sidx := offset[0]; sidx >= 0 {
 				matches = append(matches,
-					dupItem(item, []Offset{Offset{int32(sidx), int32(eidx)}}))
+					dupItem(item, []Offset{offset}, bonus))
 			}
 		}
 	} else {
 		for _, item := range *chunk {
-			if offsets := p.extendedMatch(item); len(offsets) == len(p.terms) {
-				matches = append(matches, dupItem(item, offsets))
+			if offsets, bonus := p.extendedMatch(item); len(offsets) == len(p.termSets) {
+				matches = append(matches, dupItem(item, offsets, bonus))
 			}
 		}
 	}
@@ -256,73 +293,90 @@ func (p *Pattern) matchChunk(chunk *Chunk) []*Item {

 // MatchItem returns true if the Item is a match
 func (p *Pattern) MatchItem(item *Item) bool {
-	if p.mode == ModeFuzzy {
-		sidx, _ := p.fuzzyMatch(item)
+	if !p.extended {
+		offset, _ := p.basicMatch(item)
+		sidx := offset[0]
 		return sidx >= 0
 	}
-	offsets := p.extendedMatch(item)
-	return len(offsets) == len(p.terms)
+	offsets, _ := p.extendedMatch(item)
+	return len(offsets) == len(p.termSets)
 }

-func dupItem(item *Item, offsets []Offset) *Item {
+func dupItem(item *Item, offsets []Offset, bonus int32) *Item {
 	sort.Sort(ByOrder(offsets))
 	return &Item{
 		text:        item.text,
 		origText:    item.origText,
 		transformed: item.transformed,
-		index:       item.index,
 		offsets:     offsets,
+		bonus:       bonus,
 		colors:      item.colors,
-		rank:        Rank{0, 0, item.index}}
+		rank:        buildEmptyRank(item.Index())}
 }

-func (p *Pattern) fuzzyMatch(item *Item) (int, int) {
+func (p *Pattern) basicMatch(item *Item) (Offset, int32) {
 	input := p.prepareInput(item)
-	return p.iter(algo.FuzzyMatch, input, p.caseSensitive, p.text)
+	if p.fuzzy {
+		return p.iter(algo.FuzzyMatch, input, p.caseSensitive, p.forward, p.text)
+	}
+	return p.iter(algo.ExactMatchNaive, input, p.caseSensitive, p.forward, p.text)
 }

-func (p *Pattern) extendedMatch(item *Item) []Offset {
+func (p *Pattern) extendedMatch(item *Item) ([]Offset, int32) {
 	input := p.prepareInput(item)
 	offsets := []Offset{}
-	for _, term := range p.terms {
+	var totalBonus int32
+	for _, termSet := range p.termSets {
+		var offset *Offset
+		var bonus int32
+		for _, term := range termSet {
 			pfun := p.procFun[term.typ]
-		if sidx, eidx := p.iter(pfun, input, term.caseSensitive, term.text); sidx >= 0 {
+			off, pen := p.iter(pfun, input, term.caseSensitive, p.forward, term.text)
+			if sidx := off[0]; sidx >= 0 {
 				if term.inv {
+					continue
+				}
+				offset, bonus = &off, pen
 				break
-			}
-			offsets = append(offsets, Offset{int32(sidx), int32(eidx)})
 			} else if term.inv {
-			offsets = append(offsets, Offset{0, 0})
+				offset, bonus = &Offset{0, 0, 0}, 0
+				continue
 			}
 		}
-	return offsets
+		if offset != nil {
+			offsets = append(offsets, *offset)
+			totalBonus += bonus
+		}
+	}
+	return offsets, totalBonus
 }

-func (p *Pattern) prepareInput(item *Item) *[]Token {
+func (p *Pattern) prepareInput(item *Item) []Token {
 	if item.transformed != nil {
 		return item.transformed
 	}

-	var ret *[]Token
+	var ret []Token
 	if len(p.nth) > 0 {
 		tokens := Tokenize(item.text, p.delimiter)
 		ret = Transform(tokens, p.nth)
 	} else {
-		runes := []rune(*item.text)
-		trans := []Token{Token{text: &runes, prefixLength: 0}}
-		ret = &trans
+		ret = []Token{Token{text: item.text, prefixLength: 0, trimLength: util.TrimLen(item.text)}}
 	}
 	item.transformed = ret
 	return ret
 }

-func (p *Pattern) iter(pfun func(bool, *[]rune, []rune) (int, int),
-	tokens *[]Token, caseSensitive bool, pattern []rune) (int, int) {
-	for _, part := range *tokens {
-		prefixLength := part.prefixLength
-		if sidx, eidx := pfun(caseSensitive, part.text, pattern); sidx >= 0 {
-			return sidx + prefixLength, eidx + prefixLength
+func (p *Pattern) iter(pfun func(bool, bool, []rune, []rune) algo.Result,
+	tokens []Token, caseSensitive bool, forward bool, pattern []rune) (Offset, int32) {
+	for _, part := range tokens {
+		prefixLength := int32(part.prefixLength)
+		if res := pfun(caseSensitive, forward, part.text, pattern); res.Start >= 0 {
+			var sidx int32 = res.Start + prefixLength
+			var eidx int32 = res.End + prefixLength
+			return Offset{sidx, eidx, int32(part.trimLength)}, res.Bonus
 		}
 	}
-	return -1, -1
+	// TODO: math.MaxUint16
+	return Offset{-1, -1, -1}, 0.0
 }
--- a/src/pattern_test.go
+++ b/src/pattern_test.go
@@ -1,26 +1,33 @@
 package fzf

 import (
+	"reflect"
 	"testing"

 	"github.com/junegunn/fzf/src/algo"
 )

 func TestParseTermsExtended(t *testing.T) {
-	terms := parseTerms(ModeExtended, CaseSmart,
-		"aaa 'bbb ^ccc ddd$ !eee !'fff !^ggg !hhh$")
-	if len(terms) != 8 ||
-		terms[0].typ != termFuzzy || terms[0].inv ||
-		terms[1].typ != termExact || terms[1].inv ||
-		terms[2].typ != termPrefix || terms[2].inv ||
-		terms[3].typ != termSuffix || terms[3].inv ||
-		terms[4].typ != termFuzzy || !terms[4].inv ||
-		terms[5].typ != termExact || !terms[5].inv ||
-		terms[6].typ != termPrefix || !terms[6].inv ||
-		terms[7].typ != termSuffix || !terms[7].inv {
+	terms := parseTerms(true, CaseSmart,
+		"| aaa 'bbb ^ccc ddd$ !eee !'fff !^ggg !hhh$ | ^iii$ ^xxx | 'yyy | | zzz$ | !ZZZ |")
+	if len(terms) != 9 ||
+		terms[0][0].typ != termFuzzy || terms[0][0].inv ||
+		terms[1][0].typ != termExact || terms[1][0].inv ||
+		terms[2][0].typ != termPrefix || terms[2][0].inv ||
+		terms[3][0].typ != termSuffix || terms[3][0].inv ||
+		terms[4][0].typ != termFuzzy || !terms[4][0].inv ||
+		terms[5][0].typ != termExact || !terms[5][0].inv ||
+		terms[6][0].typ != termPrefix || !terms[6][0].inv ||
+		terms[7][0].typ != termSuffix || !terms[7][0].inv ||
+		terms[7][1].typ != termEqual || terms[7][1].inv ||
+		terms[8][0].typ != termPrefix || terms[8][0].inv ||
+		terms[8][1].typ != termExact || terms[8][1].inv ||
+		terms[8][2].typ != termSuffix || terms[8][2].inv ||
+		terms[8][3].typ != termFuzzy || !terms[8][3].inv {
 		t.Errorf("%s", terms)
 	}
-	for idx, term := range terms {
+	for idx, termSet := range terms[:8] {
+		term := termSet[0]
 		if len(term.text) != 3 {
 			t.Errorf("%s", term)
 		}
@@ -28,26 +35,31 @@ func TestParseTermsExtended(t *testing.T) {
 			t.Errorf("%s", term)
 		}
 	}
+	for _, term := range terms[8] {
+		if len(term.origText) != 4 {
+			t.Errorf("%s", term)
+		}
+	}
 }

 func TestParseTermsExtendedExact(t *testing.T) {
-	terms := parseTerms(ModeExtendedExact, CaseSmart,
+	terms := parseTerms(false, CaseSmart,
 		"aaa 'bbb ^ccc ddd$ !eee !'fff !^ggg !hhh$")
 	if len(terms) != 8 ||
-		terms[0].typ != termExact || terms[0].inv || len(terms[0].text) != 3 ||
-		terms[1].typ != termExact || terms[1].inv || len(terms[1].text) != 4 ||
-		terms[2].typ != termPrefix || terms[2].inv || len(terms[2].text) != 3 ||
-		terms[3].typ != termSuffix || terms[3].inv || len(terms[3].text) != 3 ||
-		terms[4].typ != termExact || !terms[4].inv || len(terms[4].text) != 3 ||
-		terms[5].typ != termExact || !terms[5].inv || len(terms[5].text) != 4 ||
-		terms[6].typ != termPrefix || !terms[6].inv || len(terms[6].text) != 3 ||
-		terms[7].typ != termSuffix || !terms[7].inv || len(terms[7].text) != 3 {
+		terms[0][0].typ != termExact || terms[0][0].inv || len(terms[0][0].text) != 3 ||
+		terms[1][0].typ != termFuzzy || terms[1][0].inv || len(terms[1][0].text) != 3 ||
+		terms[2][0].typ != termPrefix || terms[2][0].inv || len(terms[2][0].text) != 3 ||
+		terms[3][0].typ != termSuffix || terms[3][0].inv || len(terms[3][0].text) != 3 ||
+		terms[4][0].typ != termExact || !terms[4][0].inv || len(terms[4][0].text) != 3 ||
+		terms[5][0].typ != termFuzzy || !terms[5][0].inv || len(terms[5][0].text) != 3 ||
+		terms[6][0].typ != termPrefix || !terms[6][0].inv || len(terms[6][0].text) != 3 ||
+		terms[7][0].typ != termSuffix || !terms[7][0].inv || len(terms[7][0].text) != 3 {
 		t.Errorf("%s", terms)
 	}
 }

 func TestParseTermsEmpty(t *testing.T) {
-	terms := parseTerms(ModeExtended, CaseSmart, "' $ ^ !' !^ !$")
+	terms := parseTerms(true, CaseSmart, "' $ ^ !' !^ !$")
 	if len(terms) != 0 {
 		t.Errorf("%s", terms)
 	}
@@ -56,29 +68,45 @@ func TestParseTermsEmpty(t *testing.T) {
 func TestExact(t *testing.T) {
 	defer clearPatternCache()
 	clearPatternCache()
-	pattern := BuildPattern(ModeExtended, CaseSmart,
-		[]Range{}, nil, []rune("'abc"))
-	runes := []rune("aabbcc abc")
-	sidx, eidx := algo.ExactMatchNaive(pattern.caseSensitive, &runes, pattern.terms[0].text)
-	if sidx != 7 || eidx != 10 {
-		t.Errorf("%s / %d / %d", pattern.terms, sidx, eidx)
+	pattern := BuildPattern(true, true, CaseSmart, true,
+		[]Range{}, Delimiter{}, []rune("'abc"))
+	res := algo.ExactMatchNaive(
+		pattern.caseSensitive, pattern.forward, []rune("aabbcc abc"), pattern.termSets[0][0].text)
+	if res.Start != 7 || res.End != 10 {
+		t.Errorf("%s / %d / %d", pattern.termSets, res.Start, res.End)
 	}
 }

+func TestEqual(t *testing.T) {
+	defer clearPatternCache()
+	clearPatternCache()
+	pattern := BuildPattern(true, true, CaseSmart, true, []Range{}, Delimiter{}, []rune("^AbC$"))
+
+	match := func(str string, sidxExpected int32, eidxExpected int32) {
+		res := algo.EqualMatch(
+			pattern.caseSensitive, pattern.forward, []rune(str), pattern.termSets[0][0].text)
+		if res.Start != sidxExpected || res.End != eidxExpected {
+			t.Errorf("%s / %d / %d", pattern.termSets, res.Start, res.End)
+		}
+	}
+	match("ABC", -1, -1)
+	match("AbC", 0, 3)
+}
+
 func TestCaseSensitivity(t *testing.T) {
 	defer clearPatternCache()
 	clearPatternCache()
-	pat1 := BuildPattern(ModeFuzzy, CaseSmart, []Range{}, nil, []rune("abc"))
+	pat1 := BuildPattern(true, false, CaseSmart, true, []Range{}, Delimiter{}, []rune("abc"))
 	clearPatternCache()
-	pat2 := BuildPattern(ModeFuzzy, CaseSmart, []Range{}, nil, []rune("Abc"))
+	pat2 := BuildPattern(true, false, CaseSmart, true, []Range{}, Delimiter{}, []rune("Abc"))
 	clearPatternCache()
-	pat3 := BuildPattern(ModeFuzzy, CaseIgnore, []Range{}, nil, []rune("abc"))
+	pat3 := BuildPattern(true, false, CaseIgnore, true, []Range{}, Delimiter{}, []rune("abc"))
 	clearPatternCache()
-	pat4 := BuildPattern(ModeFuzzy, CaseIgnore, []Range{}, nil, []rune("Abc"))
+	pat4 := BuildPattern(true, false, CaseIgnore, true, []Range{}, Delimiter{}, []rune("Abc"))
 	clearPatternCache()
-	pat5 := BuildPattern(ModeFuzzy, CaseRespect, []Range{}, nil, []rune("abc"))
+	pat5 := BuildPattern(true, false, CaseRespect, true, []Range{}, Delimiter{}, []rune("abc"))
 	clearPatternCache()
-	pat6 := BuildPattern(ModeFuzzy, CaseRespect, []Range{}, nil, []rune("Abc"))
+	pat6 := BuildPattern(true, false, CaseRespect, true, []Range{}, Delimiter{}, []rune("Abc"))

 	if string(pat1.text) != "abc" || pat1.caseSensitive != false ||
 		string(pat2.text) != "Abc" || pat2.caseSensitive != true ||
@@ -91,26 +119,46 @@ func TestCaseSensitivity(t *testing.T) {
 }

 func TestOrigTextAndTransformed(t *testing.T) {
-	strptr := func(str string) *string {
-		return &str
-	}
-	pattern := BuildPattern(ModeExtended, CaseSmart, []Range{}, nil, []rune("jg"))
-	tokens := Tokenize(strptr("junegunn"), nil)
+	pattern := BuildPattern(true, true, CaseSmart, true, []Range{}, Delimiter{}, []rune("jg"))
+	tokens := Tokenize([]rune("junegunn"), Delimiter{})
 	trans := Transform(tokens, []Range{Range{1, 1}})

-	for _, mode := range []Mode{ModeFuzzy, ModeExtended} {
+	origRunes := []rune("junegunn.choi")
+	for _, extended := range []bool{false, true} {
 		chunk := Chunk{
 			&Item{
-				text:        strptr("junegunn"),
-				origText:    strptr("junegunn.choi"),
+				text:        []rune("junegunn"),
+				origText:    &origRunes,
 				transformed: trans},
 		}
-		pattern.mode = mode
+		pattern.extended = extended
 		matches := pattern.matchChunk(&chunk)
-		if *matches[0].text != "junegunn" || *matches[0].origText != "junegunn.choi" ||
+		if string(matches[0].text) != "junegunn" || string(*matches[0].origText) != "junegunn.choi" ||
 			matches[0].offsets[0][0] != 0 || matches[0].offsets[0][1] != 5 ||
-			matches[0].transformed != trans {
+			!reflect.DeepEqual(matches[0].transformed, trans) {
 			t.Error("Invalid match result", matches)
 		}
 	}
 }
+
+func TestCacheKey(t *testing.T) {
+	test := func(extended bool, patStr string, expected string, cacheable bool) {
+		pat := BuildPattern(true, extended, CaseSmart, true, []Range{}, Delimiter{}, []rune(patStr))
+		if pat.CacheKey() != expected {
+			t.Errorf("Expected: %s, actual: %s", expected, pat.CacheKey())
+		}
+		if pat.cacheable != cacheable {
+			t.Errorf("Expected: %s, actual: %s (%s)", cacheable, pat.cacheable, patStr)
+		}
+		clearPatternCache()
+	}
+	test(false, "foo !bar", "foo !bar", true)
+	test(false, "foo | bar !baz", "foo | bar !baz", true)
+	test(true, "foo  bar  baz", "foo bar baz", true)
+	test(true, "foo !bar", "foo", false)
+	test(true, "foo !bar   baz", "foo baz", false)
+	test(true, "foo | bar baz", "baz", false)
+	test(true, "foo | bar | baz", "", false)
+	test(true, "foo | bar !baz", "", false)
+	test(true, "| | | foo", "foo", true)
+}
--- a/src/reader.go
+++ b/src/reader.go
@@ -4,15 +4,15 @@ import (
 	"bufio"
 	"io"
 	"os"
-	"os/exec"

 	"github.com/junegunn/fzf/src/util"
 )

 // Reader reads from command or standard input
 type Reader struct {
-	pusher   func(string)
+	pusher   func([]byte) bool
 	eventBox *util.EventBox
+	delimNil bool
 }

 // ReadSource reads data from the default command or from standard input
@@ -30,32 +30,27 @@ func (r *Reader) ReadSource() {
 }

 func (r *Reader) feed(src io.Reader) {
+	delim := byte('\n')
+	if r.delimNil {
+		delim = '\000'
+	}
 	reader := bufio.NewReader(src)
-	eof := false
-Loop:
-	for !eof {
-		buf := []byte{}
-		iter := 0 // TODO: max size?
 	for {
-			// "ReadLine either returns a non-nil line or it returns an error, never both"
-			line, isPrefix, err := reader.ReadLine()
-			eof = err == io.EOF
-			if eof {
-				break
-			} else if err != nil {
-				break Loop
+		// ReadBytes returns err != nil if and only if the returned data does not
+		// end in delim.
+		bytea, err := reader.ReadBytes(delim)
+		if len(bytea) > 0 {
+			if err == nil {
+				bytea = bytea[:len(bytea)-1]
 			}
-			iter++
-			buf = append(buf, line...)
-			if !isPrefix {
-				break
-			}
-		}
-		if iter > 0 {
-			r.pusher(string(buf))
+			if r.pusher(bytea) {
 				r.eventBox.Set(EvtReadNew, nil)
 			}
 		}
+		if err != nil {
+			break
+		}
+	}
 }

 func (r *Reader) readFromStdin() {
@@ -63,7 +58,7 @@ func (r *Reader) readFromStdin() {
 }

 func (r *Reader) readFromCommand(cmd string) {
-	listCommand := exec.Command("sh", "-c", cmd)
+	listCommand := util.ExecCommand(cmd)
 	out, err := listCommand.StdoutPipe()
 	if err != nil {
 		return
--- a/src/reader_test.go
+++ b/src/reader_test.go
@@ -10,7 +10,7 @@ func TestReadFromCommand(t *testing.T) {
 	strs := []string{}
 	eb := util.NewEventBox()
 	reader := Reader{
-		pusher:   func(s string) { strs = append(strs, s) },
+		pusher:   func(s []byte) bool { strs = append(strs, string(s)); return true },
 		eventBox: eb}

 	// Check EventBox
--- a/src/terminal.go
+++ b/src/terminal.go
@@ -7,6 +7,7 @@ import (
 	"os/signal"
 	"regexp"
 	"sort"
+	"strconv"
 	"strings"
 	"sync"
 	"syscall"
@@ -20,10 +21,12 @@ import (

 // Terminal represents terminal input/output
 type Terminal struct {
+	initDelay  time.Duration
 	inlineInfo bool
 	prompt     string
 	reverse    bool
 	hscroll    bool
+	hscrollOff int
 	cx         int
 	cy         int
 	offset     int
@@ -32,15 +35,23 @@ type Terminal struct {
 	multi      bool
 	sort       bool
 	toggleSort bool
-	expect     []int
+	expect     map[int]string
 	keymap     map[int]actionType
-	pressed    int
+	execmap    map[int]string
+	pressed    string
 	printQuery bool
+	history    *History
+	cycle      bool
+	header     []string
+	header0    []string
+	ansi       bool
+	margin     [4]string
+	marginInt  [4]int
 	count      int
 	progress   int
 	reading    bool
 	merger     *Merger
-	selected   map[uint32]selectedItem
+	selected   map[int32]selectedItem
 	reqBox     *util.EventBox
 	eventBox   *util.EventBox
 	mutex      sync.Mutex
@@ -70,10 +81,12 @@ func (a byTimeOrder) Less(i, j int) bool {

 var _spinner = []string{`-`, `\`, `|`, `/`, `-`, `\`, `|`, `/`}
 var _runeWidths = make(map[rune]int)
+var _tabStop int

 const (
 	reqPrompt util.EventType = iota
 	reqInfo
+	reqHeader
 	reqList
 	reqRefresh
 	reqRedraw
@@ -94,8 +107,10 @@ const (
 	actBackwardChar
 	actBackwardDeleteChar
 	actBackwardWord
+	actCancel
 	actClearScreen
 	actDeleteChar
+	actDeleteCharEOF
 	actEndOfLine
 	actForwardChar
 	actForwardWord
@@ -105,14 +120,23 @@ const (
 	actUnixWordRubout
 	actYank
 	actBackwardKillWord
+	actSelectAll
+	actDeselectAll
 	actToggle
+	actToggleAll
 	actToggleDown
 	actToggleUp
+	actToggleIn
+	actToggleOut
 	actDown
 	actUp
 	actPageUp
 	actPageDown
 	actToggleSort
+	actPreviousHistory
+	actNextHistory
+	actExecute
+	actExecuteMulti
 )

 func defaultKeymap() map[int]actionType {
@@ -124,10 +148,11 @@ func defaultKeymap() map[int]actionType {
 	keymap[C.CtrlG] = actAbort
 	keymap[C.CtrlQ] = actAbort
 	keymap[C.ESC] = actAbort
-	keymap[C.CtrlD] = actDeleteChar
+	keymap[C.CtrlD] = actDeleteCharEOF
 	keymap[C.CtrlE] = actEndOfLine
 	keymap[C.CtrlF] = actForwardChar
 	keymap[C.CtrlH] = actBackwardDeleteChar
+	keymap[C.BSpace] = actBackwardDeleteChar
 	keymap[C.Tab] = actToggleDown
 	keymap[C.BTab] = actToggleUp
 	keymap[C.CtrlJ] = actDown
@@ -154,23 +179,39 @@ func defaultKeymap() map[int]actionType {

 	keymap[C.Home] = actBeginningOfLine
 	keymap[C.End] = actEndOfLine
-	keymap[C.Del] = actDeleteChar // FIXME Del vs. CTRL-D
+	keymap[C.Del] = actDeleteChar
 	keymap[C.PgUp] = actPageUp
 	keymap[C.PgDn] = actPageDown

 	keymap[C.Rune] = actRune
 	keymap[C.Mouse] = actMouse
+	keymap[C.DoubleClick] = actAccept
 	return keymap
 }

 // NewTerminal returns new Terminal object
 func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 	input := []rune(opts.Query)
+	var header []string
+	if opts.Reverse {
+		header = opts.Header
+	} else {
+		header = reverseStringArray(opts.Header)
+	}
+	_tabStop = opts.Tabstop
+	var delay time.Duration
+	if opts.Tac {
+		delay = initialDelayTac
+	} else {
+		delay = initialDelay
+	}
 	return &Terminal{
+		initDelay:  delay,
 		inlineInfo: opts.InlineInfo,
 		prompt:     opts.Prompt,
 		reverse:    opts.Reverse,
 		hscroll:    opts.Hscroll,
+		hscrollOff: opts.HscrollOff,
 		cx:         len(input),
 		cy:         0,
 		offset:     0,
@@ -181,10 +222,19 @@ func NewTerminal(opts *Options, eventBox *util.EventBox) *Terminal {
 		toggleSort: opts.ToggleSort,
 		expect:     opts.Expect,
 		keymap:     opts.Keymap,
-		pressed:    0,
+		execmap:    opts.Execmap,
+		pressed:    "",
 		printQuery: opts.PrintQuery,
+		history:    opts.History,
+		margin:     opts.Margin,
+		marginInt:  [4]int{0, 0, 0, 0},
+		cycle:      opts.Cycle,
+		header:     header,
+		header0:    header,
+		ansi:       opts.Ansi,
+		reading:    true,
 		merger:     EmptyMerger,
-		selected:   make(map[uint32]selectedItem),
+		selected:   make(map[int32]selectedItem),
 		reqBox:     util.NewEventBox(),
 		eventBox:   eventBox,
 		mutex:      sync.Mutex{},
@@ -214,6 +264,23 @@ func (t *Terminal) UpdateCount(cnt int, final bool) {
 	}
 }

+func reverseStringArray(input []string) []string {
+	size := len(input)
+	reversed := make([]string, size)
+	for idx, str := range input {
+		reversed[size-idx-1] = str
+	}
+	return reversed
+}
+
+// UpdateHeader updates the header
+func (t *Terminal) UpdateHeader(header []string) {
+	t.mutex.Lock()
+	t.header = append(append([]string{}, t.header0...), header...)
+	t.mutex.Unlock()
+	t.reqBox.Set(reqHeader, nil)
+}
+
 // UpdateProgress updates the search progress
 func (t *Terminal) UpdateProgress(progress float32) {
 	t.mutex.Lock()
@@ -237,43 +304,40 @@ func (t *Terminal) UpdateList(merger *Merger) {
 	t.reqBox.Set(reqList, nil)
 }

-func (t *Terminal) output() {
+func (t *Terminal) output() bool {
 	if t.printQuery {
 		fmt.Println(string(t.input))
 	}
 	if len(t.expect) > 0 {
-		if t.pressed == 0 {
-			fmt.Println()
-		} else if util.Between(t.pressed, C.AltA, C.AltZ) {
-			fmt.Printf("alt-%c\n", t.pressed+'a'-C.AltA)
-		} else if util.Between(t.pressed, C.F1, C.F4) {
-			fmt.Printf("f%c\n", t.pressed+'1'-C.F1)
-		} else if util.Between(t.pressed, C.CtrlA, C.CtrlZ) {
-			fmt.Printf("ctrl-%c\n", t.pressed+'a'-C.CtrlA)
-		} else {
-			fmt.Printf("%c\n", t.pressed-C.AltZ)
+		fmt.Println(t.pressed)
 	}
-	}
-	if len(t.selected) == 0 {
+	found := len(t.selected) > 0
+	if !found {
 		cnt := t.merger.Length()
 		if cnt > 0 && cnt > t.cy {
-			fmt.Println(t.merger.Get(t.cy).AsString())
+			fmt.Println(t.merger.Get(t.cy).AsString(t.ansi))
+			found = true
 		}
 	} else {
+		for _, sel := range t.sortSelected() {
+			fmt.Println(*sel.text)
+		}
+	}
+	return found
+}
+
+func (t *Terminal) sortSelected() []selectedItem {
 	sels := make([]selectedItem, 0, len(t.selected))
 	for _, sel := range t.selected {
 		sels = append(sels, sel)
 	}
 	sort.Sort(byTimeOrder(sels))
-		for _, sel := range sels {
-			fmt.Println(*sel.text)
-		}
-	}
+	return sels
 }

 func runeWidth(r rune, prefixWidth int) int {
 	if r == '\t' {
-		return 8 - prefixWidth%8
+		return _tabStop - prefixWidth%_tabStop
 	} else if w, found := _runeWidths[r]; found {
 		return w
 	} else {
@@ -291,10 +355,50 @@ func displayWidth(runes []rune) int {
 	return l
 }

+const minWidth = 16
+const minHeight = 4
+
+func (t *Terminal) calculateMargins() {
+	screenWidth := C.MaxX()
+	screenHeight := C.MaxY()
+	for idx, str := range t.margin {
+		if str == "0" {
+			t.marginInt[idx] = 0
+		} else if strings.HasSuffix(str, "%") {
+			num, _ := strconv.ParseFloat(str[:len(str)-1], 64)
+			var val float64
+			if idx%2 == 0 {
+				val = float64(screenHeight)
+			} else {
+				val = float64(screenWidth)
+			}
+			t.marginInt[idx] = int(val * num * 0.01)
+		} else {
+			num, _ := strconv.Atoi(str)
+			t.marginInt[idx] = num
+		}
+	}
+	adjust := func(idx1 int, idx2 int, max int, min int) {
+		if max >= min {
+			margin := t.marginInt[idx1] + t.marginInt[idx2]
+			if max-margin < min {
+				desired := max - min
+				t.marginInt[idx1] = desired * t.marginInt[idx1] / margin
+				t.marginInt[idx2] = desired * t.marginInt[idx2] / margin
+			}
+		}
+	}
+	adjust(1, 3, screenWidth, minWidth)
+	adjust(0, 2, screenHeight, minHeight)
+}
+
 func (t *Terminal) move(y int, x int, clear bool) {
+	x += t.marginInt[3]
 	maxy := C.MaxY()
 	if !t.reverse {
-		y = maxy - y - 1
+		y = maxy - y - 1 - t.marginInt[2]
+	} else {
+		y += t.marginInt[0]
 	}

 	if clear {
@@ -305,7 +409,7 @@ func (t *Terminal) move(y int, x int, clear bool) {
 }

 func (t *Terminal) placeCursor() {
-	t.move(0, len(t.prompt)+displayWidth(t.input[:t.cx]), false)
+	t.move(0, displayWidth([]rune(t.prompt))+displayWidth(t.input[:t.cx]), false)
 }

 func (t *Terminal) printPrompt() {
@@ -316,7 +420,7 @@ func (t *Terminal) printPrompt() {

 func (t *Terminal) printInfo() {
 	if t.inlineInfo {
-		t.move(0, len(t.prompt)+displayWidth(t.input)+1, true)
+		t.move(0, displayWidth([]rune(t.prompt))+displayWidth(t.input)+1, true)
 		if t.reading {
 			C.CPrint(C.ColSpinner, true, " < ")
 		} else {
@@ -349,17 +453,45 @@ func (t *Terminal) printInfo() {
 	C.CPrint(C.ColInfo, false, output)
 }

+func (t *Terminal) maxHeight() int {
+	return C.MaxY() - t.marginInt[0] - t.marginInt[2]
+}
+
+func (t *Terminal) printHeader() {
+	if len(t.header) == 0 {
+		return
+	}
+	max := t.maxHeight()
+	var state *ansiState
+	for idx, lineStr := range t.header {
+		line := idx + 2
+		if t.inlineInfo {
+			line--
+		}
+		if line >= max {
+			continue
+		}
+		trimmed, colors, newState := extractColor(lineStr, state)
+		state = newState
+		item := &Item{
+			text:   []rune(trimmed),
+			colors: colors,
+			rank:   buildEmptyRank(0)}
+
+		t.move(line, 2, true)
+		t.printHighlighted(item, false, C.ColHeader, 0, false)
+	}
+}
+
 func (t *Terminal) printList() {
 	t.constrain()

 	maxy := t.maxItems()
 	count := t.merger.Length() - t.offset
 	for i := 0; i < maxy; i++ {
-		var line int
+		line := i + 2 + len(t.header)
 		if t.inlineInfo {
-			line = i + 1
-		} else {
-			line = i + 2
+			line--
 		}
 		t.move(line, 0, true)
 		if i < count {
@@ -369,11 +501,11 @@ func (t *Terminal) printList() {
 }

 func (t *Terminal) printItem(item *Item, current bool) {
-	_, selected := t.selected[item.index]
+	_, selected := t.selected[item.Index()]
 	if current {
 		C.CPrint(C.ColCursor, true, ">")
 		if selected {
-			C.CPrint(C.ColCurrent, true, ">")
+			C.CPrint(C.ColSelected, true, ">")
 		} else {
 			C.CPrint(C.ColCurrent, true, " ")
 		}
@@ -426,17 +558,17 @@ func trimLeft(runes []rune, width int) ([]rune, int32) {
 }

 func (t *Terminal) printHighlighted(item *Item, bold bool, col1 int, col2 int, current bool) {
-	var maxe int32
+	var maxe int
 	for _, offset := range item.offsets {
-		if offset[1] > maxe {
-			maxe = offset[1]
-		}
+		maxe = util.Max(maxe, int(offset[1]))
 	}

 	// Overflow
-	text := []rune(*item.text)
+	text := make([]rune, len(item.text))
+	copy(text, item.text)
 	offsets := item.colorOffsets(col2, bold, current)
-	maxWidth := C.MaxX() - 3
+	maxWidth := C.MaxX() - 3 - t.marginInt[1] - t.marginInt[3]
+	maxe = util.Constrain(maxe+util.Min(maxWidth/2-2, t.hscrollOff), 0, len(text))
 	fullWidth := displayWidth(text)
 	if fullWidth > maxWidth {
 		if t.hscroll {
@@ -519,9 +651,11 @@ func processTabs(runes []rune, prefixWidth int) (string, int) {
 }

 func (t *Terminal) printAll() {
+	t.calculateMargins()
 	t.printList()
 	t.printPrompt()
 	t.printInfo()
+	t.printHeader()
 }

 func (t *Terminal) refresh() {
@@ -577,24 +711,35 @@ func (t *Terminal) rubout(pattern string) {
 }

 func keyMatch(key int, event C.Event) bool {
-	return event.Type == key || event.Type == C.Rune && int(event.Char) == key-C.AltZ
+	return event.Type == key ||
+		event.Type == C.Rune && int(event.Char) == key-C.AltZ ||
+		event.Type == C.Mouse && key == C.DoubleClick && event.MouseEvent.Double
+}
+
+func quoteEntry(entry string) string {
+	return fmt.Sprintf("%q", entry)
+}
+
+func executeCommand(template string, replacement string) {
+	command := strings.Replace(template, "{}", replacement, -1)
+	cmd := util.ExecCommand(command)
+	cmd.Stdin = os.Stdin
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	C.Endwin()
+	cmd.Run()
+	C.Refresh()
 }

 // Loop is called to start Terminal I/O
 func (t *Terminal) Loop() {
 	<-t.startChan
 	{ // Late initialization
-		t.mutex.Lock()
-		t.initFunc()
-		t.printPrompt()
-		t.placeCursor()
-		C.Refresh()
-		t.printInfo()
-		t.mutex.Unlock()
+		intChan := make(chan os.Signal, 1)
+		signal.Notify(intChan, os.Interrupt, os.Kill, syscall.SIGTERM)
 		go func() {
-			timer := time.NewTimer(initialDelay)
-			<-timer.C
-			t.reqBox.Set(reqRefresh, nil)
+			<-intChan
+			t.reqBox.Set(reqQuit, nil)
 		}()

 		resizeChan := make(chan os.Signal, 1)
@@ -605,6 +750,42 @@ func (t *Terminal) Loop() {
 				t.reqBox.Set(reqRedraw, nil)
 			}
 		}()
+
+		t.mutex.Lock()
+		t.initFunc()
+		t.calculateMargins()
+		t.printPrompt()
+		t.placeCursor()
+		C.Refresh()
+		t.printInfo()
+		t.printHeader()
+		t.mutex.Unlock()
+		go func() {
+			timer := time.NewTimer(t.initDelay)
+			<-timer.C
+			t.reqBox.Set(reqRefresh, nil)
+		}()
+
+		// Keep the spinner spinning
+		go func() {
+			for {
+				t.mutex.Lock()
+				reading := t.reading
+				t.mutex.Unlock()
+				if !reading {
+					break
+				}
+				time.Sleep(spinnerDuration)
+				t.reqBox.Set(reqInfo, nil)
+			}
+		}()
+	}
+
+	exit := func(code int) {
+		if code <= exitNoMatch && t.history != nil {
+			t.history.append(string(t.input))
+		}
+		os.Exit(code)
 	}

 	go func() {
@@ -623,6 +804,8 @@ func (t *Terminal) Loop() {
 						t.printInfo()
 					case reqList:
 						t.printList()
+					case reqHeader:
+						t.printHeader()
 					case reqRefresh:
 						t.suppress = false
 					case reqRedraw:
@@ -632,11 +815,13 @@ func (t *Terminal) Loop() {
 						t.printAll()
 					case reqClose:
 						C.Close()
-						t.output()
-						os.Exit(0)
+						if t.output() {
+							exit(exitOk)
+						}
+						exit(exitNoMatch)
 					case reqQuit:
 						C.Close()
-						os.Exit(1)
+						exit(exitInterrupt)
 					}
 				}
 				t.placeCursor()
@@ -661,47 +846,60 @@ func (t *Terminal) Loop() {
 				}
 			}
 		}
+		selectItem := func(item *Item) bool {
+			if _, found := t.selected[item.Index()]; !found {
+				t.selected[item.Index()] = selectedItem{time.Now(), item.StringPtr(t.ansi)}
+				return true
+			}
+			return false
+		}
+		toggleY := func(y int) {
+			item := t.merger.Get(y)
+			if !selectItem(item) {
+				delete(t.selected, item.Index())
+			}
+		}
 		toggle := func() {
 			if t.cy < t.merger.Length() {
-				item := t.merger.Get(t.cy)
-				if _, found := t.selected[item.index]; !found {
-					var strptr *string
-					if item.origText != nil {
-						strptr = item.origText
-					} else {
-						strptr = item.text
-					}
-					t.selected[item.index] = selectedItem{time.Now(), strptr}
-				} else {
-					delete(t.selected, item.index)
-				}
+				toggleY(t.cy)
 				req(reqInfo)
 			}
 		}
-		for _, key := range t.expect {
+		for key, ret := range t.expect {
 			if keyMatch(key, event) {
-				t.pressed = key
+				t.pressed = ret
 				req(reqClose)
 				break
 			}
 		}

-		action := t.keymap[event.Type]
-		if event.Type == C.Rune {
-			code := int(event.Char) + int(C.AltZ)
-			if act, prs := t.keymap[code]; prs {
-				action = act
-			}
-		}
+		var doAction func(actionType, int) bool
+		doAction = func(action actionType, mapkey int) bool {
 			switch action {
+			case actIgnore:
+			case actExecute:
+				if t.cy >= 0 && t.cy < t.merger.Length() {
+					item := t.merger.Get(t.cy)
+					executeCommand(t.execmap[mapkey], quoteEntry(item.AsString(t.ansi)))
+				}
+			case actExecuteMulti:
+				if len(t.selected) > 0 {
+					sels := make([]string, len(t.selected))
+					for i, sel := range t.sortSelected() {
+						sels[i] = quoteEntry(*sel.text)
+					}
+					executeCommand(t.execmap[mapkey], strings.Join(sels, " "))
+				} else {
+					return doAction(actExecute, mapkey)
+				}
 			case actInvalid:
 				t.mutex.Unlock()
-			continue
+				return false
 			case actToggleSort:
 				t.sort = !t.sort
 				t.eventBox.Set(EvtSearchNew, t.sort)
 				t.mutex.Unlock()
-			continue
+				return false
 			case actBeginningOfLine:
 				t.cx = 0
 			case actBackwardChar:
@@ -711,11 +909,21 @@ func (t *Terminal) Loop() {
 			case actAbort:
 				req(reqQuit)
 			case actDeleteChar:
+				t.delChar()
+			case actDeleteCharEOF:
 				if !t.delChar() && t.cx == 0 {
 					req(reqQuit)
 				}
 			case actEndOfLine:
 				t.cx = len(t.input)
+			case actCancel:
+				if len(t.input) == 0 {
+					req(reqQuit)
+				} else {
+					t.yanked = t.input
+					t.input = []rune{}
+					t.cx = 0
+				}
 			case actForwardChar:
 				if t.cx < len(t.input) {
 					t.cx++
@@ -725,11 +933,44 @@ func (t *Terminal) Loop() {
 					t.input = append(t.input[:t.cx-1], t.input[t.cx:]...)
 					t.cx--
 				}
+			case actSelectAll:
+				if t.multi {
+					for i := 0; i < t.merger.Length(); i++ {
+						item := t.merger.Get(i)
+						selectItem(item)
+					}
+					req(reqList, reqInfo)
+				}
+			case actDeselectAll:
+				if t.multi {
+					for i := 0; i < t.merger.Length(); i++ {
+						item := t.merger.Get(i)
+						delete(t.selected, item.Index())
+					}
+					req(reqList, reqInfo)
+				}
 			case actToggle:
 				if t.multi && t.merger.Length() > 0 {
 					toggle()
 					req(reqList)
 				}
+			case actToggleAll:
+				if t.multi {
+					for i := 0; i < t.merger.Length(); i++ {
+						toggleY(i)
+					}
+					req(reqList, reqInfo)
+				}
+			case actToggleIn:
+				if t.reverse {
+					return doAction(actToggleUp, mapkey)
+				}
+				return doAction(actToggleDown, mapkey)
+			case actToggleOut:
+				if t.reverse {
+					return doAction(actToggleDown, mapkey)
+				}
+				return doAction(actToggleUp, mapkey)
 			case actToggleDown:
 				if t.multi && t.merger.Length() > 0 {
 					toggle()
@@ -796,16 +1037,21 @@ func (t *Terminal) Loop() {
 				prefix := copySlice(t.input[:t.cx])
 				t.input = append(append(prefix, event.Char), t.input[t.cx:]...)
 				t.cx++
+			case actPreviousHistory:
+				if t.history != nil {
+					t.history.override(string(t.input))
+					t.input = []rune(t.history.previous())
+					t.cx = len(t.input)
+				}
+			case actNextHistory:
+				if t.history != nil {
+					t.history.override(string(t.input))
+					t.input = []rune(t.history.next())
+					t.cx = len(t.input)
+				}
 			case actMouse:
 				me := event.MouseEvent
-			mx, my := util.Constrain(me.X-len(t.prompt), 0, len(t.input)), me.Y
-			if !t.reverse {
-				my = C.MaxY() - my - 1
-			}
-			min := 2
-			if t.inlineInfo {
-				min = 1
-			}
+				mx, my := me.X, me.Y
 				if me.S != 0 {
 					// Scroll
 					if t.merger.Length() > 0 {
@@ -815,11 +1061,23 @@ func (t *Terminal) Loop() {
 						t.vmove(me.S)
 						req(reqList)
 					}
-			} else if me.Double {
+				} else if mx >= t.marginInt[3] && mx < C.MaxX()-t.marginInt[1] &&
+					my >= t.marginInt[0] && my < C.MaxY()-t.marginInt[2] {
+					mx -= t.marginInt[3]
+					my -= t.marginInt[0]
+					mx = util.Constrain(mx-displayWidth([]rune(t.prompt)), 0, len(t.input))
+					if !t.reverse {
+						my = t.maxHeight() - my - 1
+					}
+					min := 2 + len(t.header)
+					if t.inlineInfo {
+						min--
+					}
+					if me.Double {
 						// Double-click
 						if my >= min {
 							if t.vset(t.offset+my-min) && t.cy < t.merger.Length() {
-						req(reqClose)
+								return doAction(t.keymap[C.DoubleClick], C.DoubleClick)
 							}
 						}
 					} else if me.Down {
@@ -835,6 +1093,20 @@ func (t *Terminal) Loop() {
 						}
 					}
 				}
+			}
+			return true
+		}
+		action := t.keymap[event.Type]
+		mapkey := event.Type
+		if event.Type == C.Rune {
+			mapkey = int(event.Char) + int(C.AltZ)
+			if act, prs := t.keymap[mapkey]; prs {
+				action = act
+			}
+		}
+		if !doAction(action, mapkey) {
+			continue
+		}
 		changed := string(previousInput) != string(t.input)
 		t.mutex.Unlock() // Must be unlocked before touching reqBox

@@ -853,28 +1125,33 @@ func (t *Terminal) constrain() {
 	diffpos := t.cy - t.offset

 	t.cy = util.Constrain(t.cy, 0, count-1)
-
-	if t.cy > t.offset+(height-1) {
-		// Ceil
-		t.offset = t.cy - (height - 1)
-	} else if t.offset > t.cy {
-		// Floor
-		t.offset = t.cy
-	}
-
+	t.offset = util.Constrain(t.offset, t.cy-height+1, t.cy)
 	// Adjustment
 	if count-t.offset < height {
 		t.offset = util.Max(0, count-height)
 		t.cy = util.Constrain(t.offset+diffpos, 0, count-1)
 	}
+	t.offset = util.Max(0, t.offset)
 }

 func (t *Terminal) vmove(o int) {
 	if t.reverse {
-		t.vset(t.cy - o)
-	} else {
-		t.vset(t.cy + o)
+		o *= -1
 	}
+	dest := t.cy + o
+	if t.cycle {
+		max := t.merger.Length() - 1
+		if dest > max {
+			if t.cy == max {
+				dest = 0
+			}
+		} else if dest < 0 {
+			if t.cy == 0 {
+				dest = max
+			}
+		}
+	}
+	t.vset(dest)
 }

 func (t *Terminal) vset(o int) bool {
@@ -883,9 +1160,9 @@ func (t *Terminal) vset(o int) bool {
 }

 func (t *Terminal) maxItems() int {
+	max := t.maxHeight() - 2 - len(t.header)
 	if t.inlineInfo {
-		return C.MaxY() - 1
-	} else {
-		return C.MaxY() - 2
+		max++
 	}
+	return util.Max(max, 0)
 }
--- a/src/tokenizer.go
+++ b/src/tokenizer.go
@@ -18,8 +18,15 @@ type Range struct {

 // Token contains the tokenized part of the strings and its prefix length
 type Token struct {
-	text         *[]rune
+	text         []rune
 	prefixLength int
+	trimLength   int
+}
+
+// Delimiter for tokenizing the input
+type Delimiter struct {
+	regex *regexp.Regexp
+	str   *string
 }

 func newRange(begin int, end int) Range {
@@ -68,16 +75,15 @@ func ParseRange(str *string) (Range, bool) {
 	return newRange(n, n), true
 }

-func withPrefixLengths(tokens []string, begin int) []Token {
+func withPrefixLengths(tokens [][]rune, begin int) []Token {
 	ret := make([]Token, len(tokens))

 	prefixLength := begin
 	for idx, token := range tokens {
 		// Need to define a new local variable instead of the reused token to take
 		// the pointer to it
-		runes := []rune(token)
-		ret[idx] = Token{text: &runes, prefixLength: prefixLength}
-		prefixLength += len([]rune(token))
+		ret[idx] = Token{token, prefixLength, util.TrimLen(token)}
+		prefixLength += len(token)
 	}
 	return ret
 }
@@ -88,13 +94,13 @@ const (
 	awkWhite
 )

-func awkTokenizer(input *string) ([]string, int) {
+func awkTokenizer(input []rune) ([][]rune, int) {
 	// 9, 32
-	ret := []string{}
+	ret := [][]rune{}
 	str := []rune{}
 	prefixLength := 0
 	state := awkNil
-	for _, r := range []rune(*input) {
+	for _, r := range input {
 		white := r == 9 || r == 32
 		switch state {
 		case awkNil:
@@ -113,47 +119,69 @@ func awkTokenizer(input *string) ([]string, int) {
 			if white {
 				str = append(str, r)
 			} else {
-				ret = append(ret, string(str))
+				ret = append(ret, str)
 				state = awkBlack
 				str = []rune{r}
 			}
 		}
 	}
 	if len(str) > 0 {
-		ret = append(ret, string(str))
+		ret = append(ret, str)
 	}
 	return ret, prefixLength
 }

 // Tokenize tokenizes the given string with the delimiter
-func Tokenize(str *string, delimiter *regexp.Regexp) []Token {
-	if delimiter == nil {
+func Tokenize(runes []rune, delimiter Delimiter) []Token {
+	if delimiter.str == nil && delimiter.regex == nil {
 		// AWK-style (\S+\s*)
-		tokens, prefixLength := awkTokenizer(str)
+		tokens, prefixLength := awkTokenizer(runes)
 		return withPrefixLengths(tokens, prefixLength)
 	}
-	tokens := delimiter.FindAllString(*str, -1)
-	return withPrefixLengths(tokens, 0)
-}

-func joinTokens(tokens *[]Token) *string {
-	ret := ""
-	for _, token := range *tokens {
-		ret += string(*token.text)
+	var tokens []string
+	if delimiter.str != nil {
+		tokens = strings.Split(string(runes), *delimiter.str)
+		for i := 0; i < len(tokens)-1; i++ {
+			tokens[i] = tokens[i] + *delimiter.str
 		}
-	return &ret
+	} else if delimiter.regex != nil {
+		str := string(runes)
+		for len(str) > 0 {
+			loc := delimiter.regex.FindStringIndex(str)
+			if loc == nil {
+				loc = []int{0, len(str)}
+			}
+			last := util.Max(loc[1], 1)
+			tokens = append(tokens, str[:last])
+			str = str[last:]
+		}
+	}
+	asRunes := make([][]rune, len(tokens))
+	for i, token := range tokens {
+		asRunes[i] = []rune(token)
+	}
+	return withPrefixLengths(asRunes, 0)
 }

-func joinTokensAsRunes(tokens *[]Token) *[]rune {
+func joinTokens(tokens []Token) []rune {
 	ret := []rune{}
-	for _, token := range *tokens {
-		ret = append(ret, *token.text...)
+	for _, token := range tokens {
+		ret = append(ret, token.text...)
 	}
-	return &ret
+	return ret
+}
+
+func joinTokensAsRunes(tokens []Token) []rune {
+	ret := []rune{}
+	for _, token := range tokens {
+		ret = append(ret, token.text...)
+	}
+	return ret
 }

 // Transform is used to transform the input when --with-nth option is given
-func Transform(tokens []Token, withNth []Range) *[]Token {
+func Transform(tokens []Token, withNth []Range) []Token {
 	transTokens := make([]Token, len(withNth))
 	numTokens := len(tokens)
 	for idx, r := range withNth {
@@ -162,14 +190,14 @@ func Transform(tokens []Token, withNth []Range) *[]Token {
 		if r.begin == r.end {
 			idx := r.begin
 			if idx == rangeEllipsis {
-				part = append(part, *joinTokensAsRunes(&tokens)...)
+				part = append(part, joinTokensAsRunes(tokens)...)
 			} else {
 				if idx < 0 {
 					idx += numTokens + 1
 				}
 				if idx >= 1 && idx <= numTokens {
 					minIdx = idx - 1
-					part = append(part, *tokens[idx-1].text...)
+					part = append(part, tokens[idx-1].text...)
 				}
 			}
 		} else {
@@ -196,7 +224,7 @@ func Transform(tokens []Token, withNth []Range) *[]Token {
 			minIdx = util.Max(0, begin-1)
 			for idx := begin; idx <= end; idx++ {
 				if idx >= 1 && idx <= numTokens {
-					part = append(part, *tokens[idx-1].text...)
+					part = append(part, tokens[idx-1].text...)
 				}
 			}
 		}
@@ -206,7 +234,7 @@ func Transform(tokens []Token, withNth []Range) *[]Token {
 		} else {
 			prefixLength = 0
 		}
-		transTokens[idx] = Token{&part, prefixLength}
+		transTokens[idx] = Token{part, prefixLength, util.TrimLen(part)}
 	}
-	return &transTokens
+	return transTokens
 }
--- a/src/tokenizer_test.go
+++ b/src/tokenizer_test.go
@@ -43,14 +43,23 @@ func TestParseRange(t *testing.T) {
 func TestTokenize(t *testing.T) {
 	// AWK-style
 	input := "  abc:  def:  ghi  "
-	tokens := Tokenize(&input, nil)
-	if string(*tokens[0].text) != "abc:  " || tokens[0].prefixLength != 2 {
+	tokens := Tokenize([]rune(input), Delimiter{})
+	if string(tokens[0].text) != "abc:  " || tokens[0].prefixLength != 2 || tokens[0].trimLength != 4 {
 		t.Errorf("%s", tokens)
 	}

 	// With delimiter
-	tokens = Tokenize(&input, delimiterRegexp(":"))
-	if string(*tokens[0].text) != "  abc:" || tokens[0].prefixLength != 0 {
+	tokens = Tokenize([]rune(input), delimiterRegexp(":"))
+	if string(tokens[0].text) != "  abc:" || tokens[0].prefixLength != 0 || tokens[0].trimLength != 4 {
+		t.Errorf("%s", tokens)
+	}
+
+	// With delimiter regex
+	tokens = Tokenize([]rune(input), delimiterRegexp("\\s+"))
+	if string(tokens[0].text) != "  " || tokens[0].prefixLength != 0 || tokens[0].trimLength != 0 ||
+		string(tokens[1].text) != "abc:  " || tokens[1].prefixLength != 2 || tokens[1].trimLength != 4 ||
+		string(tokens[2].text) != "def:  " || tokens[2].prefixLength != 8 || tokens[2].trimLength != 4 ||
+		string(tokens[3].text) != "ghi  " || tokens[3].prefixLength != 14 || tokens[3].trimLength != 3 {
 		t.Errorf("%s", tokens)
 	}
 }
@@ -58,39 +67,39 @@ func TestTokenize(t *testing.T) {
 func TestTransform(t *testing.T) {
 	input := "  abc:  def:  ghi:  jkl"
 	{
-		tokens := Tokenize(&input, nil)
+		tokens := Tokenize([]rune(input), Delimiter{})
 		{
 			ranges := splitNth("1,2,3")
 			tx := Transform(tokens, ranges)
-			if *joinTokens(tx) != "abc:  def:  ghi:  " {
-				t.Errorf("%s", *tx)
+			if string(joinTokens(tx)) != "abc:  def:  ghi:  " {
+				t.Errorf("%s", tx)
 			}
 		}
 		{
 			ranges := splitNth("1..2,3,2..,1")
 			tx := Transform(tokens, ranges)
-			if *joinTokens(tx) != "abc:  def:  ghi:  def:  ghi:  jklabc:  " ||
-				len(*tx) != 4 ||
-				string(*(*tx)[0].text) != "abc:  def:  " || (*tx)[0].prefixLength != 2 ||
-				string(*(*tx)[1].text) != "ghi:  " || (*tx)[1].prefixLength != 14 ||
-				string(*(*tx)[2].text) != "def:  ghi:  jkl" || (*tx)[2].prefixLength != 8 ||
-				string(*(*tx)[3].text) != "abc:  " || (*tx)[3].prefixLength != 2 {
-				t.Errorf("%s", *tx)
+			if string(joinTokens(tx)) != "abc:  def:  ghi:  def:  ghi:  jklabc:  " ||
+				len(tx) != 4 ||
+				string(tx[0].text) != "abc:  def:  " || tx[0].prefixLength != 2 ||
+				string(tx[1].text) != "ghi:  " || tx[1].prefixLength != 14 ||
+				string(tx[2].text) != "def:  ghi:  jkl" || tx[2].prefixLength != 8 ||
+				string(tx[3].text) != "abc:  " || tx[3].prefixLength != 2 {
+				t.Errorf("%s", tx)
 			}
 		}
 	}
 	{
-		tokens := Tokenize(&input, delimiterRegexp(":"))
+		tokens := Tokenize([]rune(input), delimiterRegexp(":"))
 		{
 			ranges := splitNth("1..2,3,2..,1")
 			tx := Transform(tokens, ranges)
-			if *joinTokens(tx) != "  abc:  def:  ghi:  def:  ghi:  jkl  abc:" ||
-				len(*tx) != 4 ||
-				string(*(*tx)[0].text) != "  abc:  def:" || (*tx)[0].prefixLength != 0 ||
-				string(*(*tx)[1].text) != "  ghi:" || (*tx)[1].prefixLength != 12 ||
-				string(*(*tx)[2].text) != "  def:  ghi:  jkl" || (*tx)[2].prefixLength != 6 ||
-				string(*(*tx)[3].text) != "  abc:" || (*tx)[3].prefixLength != 0 {
-				t.Errorf("%s", *tx)
+			if string(joinTokens(tx)) != "  abc:  def:  ghi:  def:  ghi:  jkl  abc:" ||
+				len(tx) != 4 ||
+				string(tx[0].text) != "  abc:  def:" || tx[0].prefixLength != 0 ||
+				string(tx[1].text) != "  ghi:" || tx[1].prefixLength != 12 ||
+				string(tx[2].text) != "  def:  ghi:  jkl" || tx[2].prefixLength != 6 ||
+				string(tx[3].text) != "  abc:" || tx[3].prefixLength != 0 {
+				t.Errorf("%s", tx)
 			}
 		}
 	}
--- a/src/util/util.go
+++ b/src/util/util.go
@@ -5,7 +5,9 @@ import "C"

 import (
 	"os"
+	"os/exec"
 	"time"
+	"unicode/utf8"
 )

 // Max returns the largest integer
@@ -19,7 +21,15 @@ func Max(first int, items ...int) int {
 	return max
 }

-// Max32 returns the smallest 32-bit integer
+// Min returns the smallest integer
+func Min(first int, second int) int {
+	if first <= second {
+		return first
+	}
+	return second
+}
+
+// Min32 returns the smallest 32-bit integer
 func Min32(first int32, second int32) int32 {
 	if first <= second {
 		return first
@@ -69,22 +79,68 @@ func DurWithin(
 	return val
 }

-func Between(val int, min int, max int) bool {
-	return val >= min && val <= max
-}
-
 // IsTty returns true is stdin is a terminal
 func IsTty() bool {
 	return int(C.isatty(C.int(os.Stdin.Fd()))) != 0
 }

-func TrimRight(runes *[]rune) []rune {
+// TrimRight returns rune array with trailing white spaces cut off
+func TrimRight(runes []rune) []rune {
 	var i int
-	for i = len(*runes) - 1; i >= 0; i-- {
-		char := (*runes)[i]
+	for i = len(runes) - 1; i >= 0; i-- {
+		char := runes[i]
 		if char != ' ' && char != '\t' {
 			break
 		}
 	}
-	return (*runes)[0 : i+1]
+	return runes[0 : i+1]
+}
+
+// BytesToRunes converts byte array into rune array
+func BytesToRunes(bytea []byte) []rune {
+	runes := make([]rune, 0, len(bytea))
+	for i := 0; i < len(bytea); {
+		if bytea[i] < utf8.RuneSelf {
+			runes = append(runes, rune(bytea[i]))
+			i++
+		} else {
+			r, sz := utf8.DecodeRune(bytea[i:])
+			i += sz
+			runes = append(runes, r)
+		}
+	}
+	return runes
+}
+
+// TrimLen returns the length of trimmed rune array
+func TrimLen(runes []rune) int {
+	var i int
+	for i = len(runes) - 1; i >= 0; i-- {
+		char := runes[i]
+		if char != ' ' && char != '\t' {
+			break
+		}
+	}
+	// Completely empty
+	if i < 0 {
+		return 0
+	}
+
+	var j int
+	for j = 0; j < len(runes); j++ {
+		char := runes[j]
+		if char != ' ' && char != '\t' {
+			break
+		}
+	}
+	return i - j + 1
+}
+
+// ExecCommand executes the given command with $SHELL
+func ExecCommand(command string) *exec.Cmd {
+	shell := os.Getenv("SHELL")
+	if len(shell) == 0 {
+		shell = "sh"
+	}
+	return exec.Command(shell, "-c", command)
 }
--- a/src/util/util_test.go
+++ b/src/util/util_test.go
@@ -20,3 +20,23 @@ func TestContrain(t *testing.T) {
 		t.Error("Expected", 3)
 	}
 }
+
+func TestTrimLen(t *testing.T) {
+	check := func(str string, exp int) {
+		trimmed := TrimLen([]rune(str))
+		if trimmed != exp {
+			t.Errorf("Invalid TrimLen result for '%s': %d (expected %d)",
+				str, trimmed, exp)
+		}
+	}
+	check("hello", 5)
+	check("hello ", 5)
+	check("hello  ", 5)
+	check(" hello", 5)
+	check("  hello", 5)
+	check(" hello ", 5)
+	check("  hello  ", 5)
+	check("h   o", 5)
+	check("  h   o  ", 5)
+	check("         ", 0)
+}
--- a/test/fzf.vader
+++ b/test/fzf.vader
@@ -1,6 +1,7 @@
 Execute (Setup):
  let g:dir = fnamemodify(g:vader_file, ':p:h')
  Log 'Test directory: ' . g:dir
+  Save &acd

 Execute (fzf#run with dir option):
  let cwd = getcwd()
@@ -35,6 +36,34 @@ Execute (fzf#run with string source):
  let result = sort(fzf#run({ 'source': 'echo hi', 'options': '-f i' }))
  AssertEqual ['hi'], result

+Execute (fzf#run with dir option and noautochdir):
+  set noacd
+  let cwd = getcwd()
+  call fzf#run({'source': ['/foobar'], 'sink': 'e', 'dir': '/tmp', 'options': '-1'})
+  " No change in working directory
+  AssertEqual cwd, getcwd()
+
+Execute (Incomplete fzf#run with dir option and autochdir):
+  set acd
+  let cwd = getcwd()
+  call fzf#run({'source': [], 'sink': 'e', 'dir': '/tmp', 'options': '-0'})
+  " No change in working directory even if &acd is set
+  AssertEqual cwd, getcwd()
+
+Execute (fzf#run with dir option and autochdir):
+  set acd
+  let cwd = getcwd()
+  call fzf#run({'source': ['/foobar'], 'sink': 'e', 'dir': '/tmp', 'options': '-1'})
+  " Working directory changed due to &acd
+  AssertEqual '/', getcwd()
+
+Execute (fzf#run with dir option and autochdir when final cwd is same as dir):
+  set acd
+  cd /tmp
+  call fzf#run({'source': ['/foobar'], 'sink': 'e', 'dir': '/', 'options': '-1'})
+  " Working directory changed due to &acd
+  AssertEqual '/', getcwd()
+
 Execute (Cleanup):
  unlet g:dir
  Restore
--- a/test/test_go.rb
+++ b/test/test_go.rb