refresh side panels when resetting to upstream

2026-09-29 02:35:39 -04:00 · 2020-01-08 22:25:35 +11:00
113 changed files with 3591 additions and 4406 deletions
@@ -0,0 +1,62 @@
+version: 2
+jobs:
+  build:
+    docker:
+      - image: circleci/golang:1.13
+    environment:
+      GO111MODULE: "on"
+    working_directory: /go/src/github.com/jesseduffield/lazygit
+    steps:
+      - checkout
+      - run:
+          name: Run gofmt -s
+          command: |
+            if [ $(find . ! -path "./vendor/*" -name "*.go" -exec gofmt -s -d {} \;|wc -l) -gt 0 ]; then
+             find . ! -path "./vendor/*" -name "*.go" -exec gofmt -s -d {} \;
+             exit 1;
+            fi
+      - restore_cache:
+          keys:
+            - pkg-cache-{{ checksum "go.sum" }}-v5
+      - run:
+          name: Run tests
+          command: |
+            ./test.sh
+      - run:
+          name: Push on codecov result
+          command: |
+            bash <(curl -s https://codecov.io/bash)
+      - run:
+          name: Compile project on every platform
+          command: |
+            go get github.com/mitchellh/gox
+            GOFLAGS=-mod=vendor gox -parallel 10 -os "linux freebsd netbsd windows" -osarch "darwin/i386 darwin/amd64"
+      - save_cache:
+          key: pkg-cache-{{ checksum "go.sum" }}-v5
+          paths:
+            - ~/.cache/go-build
+
+  release:
+    docker:
+      - image: circleci/golang:1.13
+    working_directory: /go/src/github.com/jesseduffield/lazygit
+    steps:
+      - checkout
+      - run:
+          name: Run gorelease
+          command: |
+            curl -sL https://git.io/goreleaser | bash
+
+workflows:
+  version: 2
+  build:
+    jobs:
+      - build
+  release:
+    jobs:
+      - release:
+          filters:
+            tags:
+              only: /v[0-9]+(\.[0-9]+)*/
+            branches:
+              ignore: /.*/
@@ -1,34 +0,0 @@
-name: Continuous Delivery
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-jobs:
-  cd:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-      - name: Unshallow repo
-        run: git fetch --prune --unshallow
-      - name: Setup Go
-        uses: actions/setup-go@v1
-        with:
-          go-version: 1.14.x
-      - name: Run goreleaser
-        uses: goreleaser/goreleaser-action@v1
-        with:
-          args: release --rm-dist
-        env:
-          GITHUB_TOKEN: ${{secrets.GITHUB_API_TOKEN}}
-      - name: Get tag
-        id: tag
-        uses: dawidd6/action-get-tag@v1
-      - name: Bump Homebrew
-        uses: dawidd6/action-homebrew-bump-formula@v1
-        with:
-          token: ${{secrets.GITHUB_API_TOKEN}}
-          formula: lazygit
-          url: "https://github.com/${{github.repository}}/archive/${{steps.tag.outputs.tag}}.tar.gz"
@@ -1,37 +0,0 @@
-name: Continuous Integration
-
-on: push
-
-jobs:
-  ci:
-    runs-on: ubuntu-latest
-    env:
-      GOFLAGS: -mod=vendor
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v2
-      - name: Setup Go
-        uses: actions/setup-go@v1
-        with:
-          go-version: 1.14.x
-      - name: Cache build
-        uses: actions/cache@v1
-        with:
-          path: ~/.cache/go-build
-          key: ${{runner.os}}-go-${{hashFiles('**/go.sum')}}
-          restore-keys: |
-            ${{runner.os}}-go-
-      - name: Format code
-        run: |
-          if [ $(find . ! -path "./vendor/*" -name "*.go" -exec gofmt -s -d {} \;|wc -l) -gt 0 ]; then
-           find . ! -path "./vendor/*" -name "*.go" -exec gofmt -s -d {} \;
-           exit 1
-          fi
-      - name: Test code
-        run: |
-          ./test.sh
-      - name: Build binaries
-        run: |
-          go get github.com/mitchellh/gox
-          export PATH="$(go env GOPATH)/bin:$PATH"
-          gox -parallel 4 -os "linux freebsd netbsd windows" -osarch "darwin/i386 darwin/amd64"
@@ -13,23 +13,20 @@ builds:
      - arm
      - arm64
      - 386
-    ignore:
-      - goos: freebsd
-        goarch: arm64
    # Default is `-s -w -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.Date}}`.
    ldflags:
      - -s -w -X main.version={{.Version}} -X main.commit={{.Commit}} -X main.date={{.Date}} -X main.buildSource=binaryRelease

-archives:
-  - replacements:
-      darwin: Darwin
-      linux: Linux
-      windows: Windows
-      386: 32-bit
-      amd64: x86_64
-    format_overrides:
-      - goos: windows
-        format: zip
+archive:
+  replacements:
+    darwin: Darwin
+    linux: Linux
+    windows: Windows
+    386: 32-bit
+    amd64: x86_64
+  format_overrides:
+    - goos: windows
+      format: zip
 checksum:
  name_template: 'checksums.txt'
 snapshot:
@@ -41,28 +38,27 @@ changelog:
      - '^docs:'
      - '^test:'
      - '^bump'
-brews:
-  -
-    # Reporitory to push the tap to.
-    github:
-      owner: jesseduffield
-      name: homebrew-lazygit
+brew:
+  # Reporitory to push the tap to.
+  github:
+    owner: jesseduffield
+    name: homebrew-lazygit

-    # Your app's homepage.
-    # Default is empty.
-    homepage: 'https://github.com/jesseduffield/lazygit/'
+  # Your app's homepage.
+  # Default is empty.
+  homepage: 'https://github.com/jesseduffield/lazygit/'

-    # Your app's description.
-    # Default is empty.
-    description: 'A simple terminal UI for git commands, written in Go'
+  # Your app's description.
+  # Default is empty.
+  description: 'A simple terminal UI for git commands, written in Go'

-    # # Packages your package depends on.
-    # dependencies:
-    #   - git
-    #   - zsh
-    # # Packages that conflict with your package.
-    # conflicts:
-    #   - svn
-    #   - bash
+  # # Packages your package depends on.
+  # dependencies:
+  #   - git
+  #   - zsh
+  # # Packages that conflict with your package.
+  # conflicts:
+  #   - svn
+  #   - bash

-  # test comment to see if goreleaser only releases on new commits
+# test comment to see if goreleaser only releases on new commits
@@ -2,12 +2,12 @@
 # docker build -t lazygit .
 # docker run -it lazygit:latest /bin/sh -l

-FROM golang:1.14-alpine3.11
+FROM golang:1.13-alpine3.10
 WORKDIR /go/src/github.com/jesseduffield/lazygit/
 COPY ./ .
 RUN CGO_ENABLED=0 GOOS=linux go build

-FROM alpine:3.11
+FROM alpine:3.10
 RUN apk add -U git xdg-utils
 WORKDIR /go/src/github.com/jesseduffield/lazygit/
 COPY --from=0 /go/src/github.com/jesseduffield/lazygit /go/src/github.com/jesseduffield/lazygit
@@ -1,8 +1,8 @@
-# lazygit ![CI](https://github.com/jesseduffield/lazygit/workflows/Continuous%20Integration/badge.svg) [![Go Report Card](https://goreportcard.com/badge/github.com/jesseduffield/lazygit)](https://goreportcard.com/report/github.com/jesseduffield/lazygit) [![GolangCI](https://golangci.com/badges/github.com/jesseduffield/lazygit.svg)](https://golangci.com) [![GoDoc](https://godoc.org/github.com/jesseduffield/lazygit?status.svg)](http://godoc.org/github.com/jesseduffield/lazygit) [![GitHub tag](https://img.shields.io/github/tag/jesseduffield/lazygit.svg)]() [![TODOs](https://badgen.net/https/api.tickgit.com/badgen/github.com/jesseduffield/lazygit)](https://www.tickgit.com/browse?repo=github.com/jesseduffield/lazygit)
+# lazygit [![CircleCI](https://circleci.com/gh/jesseduffield/lazygit.svg?style=svg)](https://circleci.com/gh/jesseduffield/lazygit) [![codecov](https://codecov.io/gh/jesseduffield/lazygit/branch/master/graph/badge.svg)](https://codecov.io/gh/jesseduffield/lazygit) [![Go Report Card](https://goreportcard.com/badge/github.com/jesseduffield/lazygit)](https://goreportcard.com/report/github.com/jesseduffield/lazygit) [![GolangCI](https://golangci.com/badges/github.com/jesseduffield/lazygit.svg)](https://golangci.com) [![GoDoc](https://godoc.org/github.com/jesseduffield/lazygit?status.svg)](http://godoc.org/github.com/jesseduffield/lazygit) [![GitHub tag](https://img.shields.io/github/tag/jesseduffield/lazygit.svg)]()

 A simple terminal UI for git commands, written in Go with the [gocui](https://github.com/jroimartin/gocui 'gocui') library.

-Rant time: You've heard it before, git is _powerful_, but what good is that power when everything is so damn hard to do? Interactive rebasing requires you to edit a goddamn TODO file in your editor? *Are you kidding me?* To stage part of a file you need to use a command line program stepping through each hunk and if a hunk can't be split down any further but contains code you don't want to stage, bad luck? *Are you KIDDING me?!* Sometimes you get asked to stash your changes when switching branches only to realise that after you switch and unstash that there weren't even any conflicts and it would have been fine to just checkout the branch directly? *YOU HAVE GOT TO BE KIDDING ME!*
+Rant time: You've heard it before, git is _powerful_, but what good is that power when everything is so damn hard to do? Interactive rebasing requires you to edit a goddamn TODO file in your editor? *Are you kidding me?* To stage part of a file you need to use a command line program stepping through each hunk and if a hunk can't be split down any further but contains code you don't want to stage, bad luck? *Are you KIDDING me?!* Sometimes you get asked to stash your changes when switching branches only to realise that after you switch and unstash that there weren't even any conflicts and it would have been fine to just checkout the branch directly? *YOU HAVE GOT TO BE KIDDING ME!* 

 If you're a mere mortal like me and you're tired of hearing how powerful git is when in your daily life it's a powerful pain in your ass, lazygit might be for you.

@@ -24,11 +24,9 @@ Github Sponsors is matching all donations dollar-for-dollar for 12 months so if
 ## Installation

 ### Homebrew
-
 Normally the lazygit formula can be found in the Homebrew core but we suggest you tap our formula to get the frequently updated one. It works with Linux, too.

 Tap:
-
 ```
 brew install jesseduffield/lazygit/lazygit
 ```
@@ -40,10 +38,8 @@ brew install lazygit
 ```

 ### MacPorts
-
 Latest version built from github releases.
 Tap:
-
 ```
 sudo port install lazygit
 ```
@@ -67,17 +63,6 @@ They follow upstream latest releases
 ```sh
 sudo xbps-install -S lazygit
 ```
-### Scoop (Windows)
-
-You can install `lazygit` using [scoop](https://scoop.sh/). It's in the `extras` bucket:
-
-```sh
-# Add the extras bucket
-scoop bucket add extras
-
-# Install lazygit
-scoop install lazygit
-```

 ### Arch Linux

@@ -86,11 +71,11 @@ Packages for Arch Linux are available via AUR (Arch User Repository).
 There are two packages. The stable one which is built with the latest release
 and the git version which builds from the most recent commit.

- Stable: <https://aur.archlinux.org/packages/lazygit/>
- Development: <https://aur.archlinux.org/packages/lazygit-git/>
+- Stable: https://aur.archlinux.org/packages/lazygit/
+- Development: https://aur.archlinux.org/packages/lazygit-git/

 Instruction of how to install AUR content can be found here:
-<https://wiki.archlinux.org/index.php/Arch_User_Repository>
+https://wiki.archlinux.org/index.php/Arch_User_Repository

 ### Fedora and CentOS 7

@@ -103,7 +88,7 @@ sudo dnf install lazygit

 ### Conda

-Released versions are available for different platforms, see <https://anaconda.org/conda-forge/lazygit>
+Released versions are available for different platforms, see https://anaconda.org/conda-forge/lazygit

 ```sh
 conda install -c conda-forge lazygit
@@ -135,11 +120,10 @@ whichever rc file you're using).
 - Rebase Magic tutorial [here](https://youtu.be/4XaToVut_hs)
 - List of keybindings
  [here](/docs/keybindings).
-
+  
 ## Changing Directory On Exit

 If you change repos in lazygit and want your shell to change directory into that repo on exiting lazygit, add this to your `~/.zshrc` (or other rc file):
-
 ```
 lg()
 {
@@ -153,17 +137,8 @@ lg()
    fi
 }
 ```
-
 Then `source ~/.zshrc` and from now on when you call `lg` and exit you'll switch directories to whatever you were in inside lazyigt. To override this behaviour you can exit using `shift+Q` rather than just `q`.

-## Configuration
-
-Check the [configuration docs](docs/Config.md).
-
-## Custom Pagers
-
-See the [docs](docs/Custom_Pagers.md)
-
 ## Cool features

 - Adding files easily
@@ -1,37 +1,27 @@
-# User Config
+# User Config:

-Default path for the config file:
+Default path for the config file: `~/.config/jesseduffield/lazygit/config.yml`

-* Linux: `~/.config/jesseduffield/lazygit/config.yml`
-* MacOS: `~/Library/Application Support/jesseduffield/lazygit/config.yml`
-
-## Default
+## Default:

 ```yaml
  gui:
    # stuff relating to the UI
    scrollHeight: 2 # how many lines you scroll by
    scrollPastBottom: true # enable scrolling past the bottom
-    sidePanelWidth: 0.3333 # number from 0 to 1
    theme:
      lightTheme: false # For terminals with a light background
      activeBorderColor:
        - white
        - bold
      inactiveBorderColor:
-        - green
+        - white
      optionsTextColor:
        - blue
-      selectedLineBgColor:
-        - blue
    commitLength:
      show: true
    mouseEvents: true
-    skipUnstageLineWarning: false
  git:
-    paging:
-      colorArg: always
-      useConfig: false
    merging:
      # only applicable to unix users
      manualCommit: false
@@ -57,8 +47,6 @@ Default path for the config file:
      nextBlock: '<right>' # goto the next block / panel
      prevBlock-alt: 'h' # goto the previous block / panel
      nextBlock-alt: 'l' # goto the next block / panel
-      nextMatch: 'n'
-      prevMatch: 'N'
      optionMenu: 'x' # show help menu
      optionMenu-alt1: '?' # show help menu
      select: '<space>'
@@ -73,16 +61,14 @@ Default path for the config file:
      scrollDownMain-alt1: 'J' # main panel scrool down
      scrollUpMain-alt2: '<c-u>' # main panel scrool up
      scrollDownMain-alt2: '<c-d>' # main panel scrool down
-      executeCustomCommand: ':'
+      executeCustomCommand: 'X'
      createRebaseOptionsMenu: 'm'
      pushFiles: 'P'
      pullFiles: 'p'
      refresh: 'R'
      createPatchOptionsMenu: '<c-p>'
-      nextTab: ']'
-      prevTab: '['
-      nextScreenMode: '+'
-      prevScreenMode: '_'
+      nextBranchTab: ']'
+      prevBranchTab: '['
    status:
      checkForUpdate: 'u'
      recentRepos: '<enter>'
@@ -126,9 +112,8 @@ Default path for the config file:
      cherryPickCopyRange: 'C'
      pasteCommits: 'v'
      tagCommit: 'T'
-      toggleDiffCommit: 'i'
+      toggleDiffCommit: 'h'
      checkoutCommit: '<space>'
-      resetCherryPick: '<c-R>'
    stash:
      popStash: 'g'
    commitFiles:
@@ -141,30 +126,30 @@ Default path for the config file:
      undo: 'z'
 ```

-## Platform Defaults
+## Platform Defaults:

-### Windows
+### Windows:

 ```yaml
  os:
    openCommand: 'cmd /c "start "" {{filename}}"'
 ```

-### Linux
+### Linux:

 ```yaml
  os:
    openCommand: 'sh -c "xdg-open {{filename}} >/dev/null"'
 ```

-### OSX
+### OSX:

 ```yaml
  os:
    openCommand: 'open {{filename}}'
 ```

-### Recommended Config Values
+### Recommended Config Values:

 for users of VSCode

@@ -173,7 +158,7 @@ for users of VSCode
    openCommand: 'code -r {{filename}}'
 ```

-## Color Attributes
+## Color Attributes:

 For color attributes you can choose an array of attributes (with max one color attribute)
 The available attributes are:
@@ -191,7 +176,7 @@ The available attributes are:
 - reverse # useful for high-contrast
 - underline

-## Light terminal theme
+## Light terminal theme:

 If you have issues with a light terminal theme where you can't read / see the text add these settings

@@ -204,20 +189,17 @@ If you have issues with a light terminal theme where you can't read / see the te
        - bold
      inactiveBorderColor:
        - black
-      selectedLineBgColor:
-        - blue
 ```

-## Example Coloring
+## Example Coloring:

 ![border example](/docs/resources/colored-border-example.png)

-## Keybindings
+## Keybindings:
+For all possible keybinding options, check [Custom_Keybinding.md](https://github.com/jesseduffield/lazygit/blob/master/docs/keybindings/Custom_Keybinding.md) <++>

-For all possible keybinding options, check [Custom_Keybinding.md](https://github.com/jesseduffield/lazygit/blob/master/docs/keybindings/Custom_Keybinding.md)
-
-### Example Keybindings For Colemak Users

+#### Example Keybindings For Colemak Users:
 ```yaml
  keybinding:
    universal:
@@ -225,8 +207,6 @@ For all possible keybinding options, check [Custom_Keybinding.md](https://github
      nextItem-alt: 'e'
      prevBlock-alt: 'n'
      nextBlock-alt: 'i'
-      nextMatch: '='
-      prevMatch: '-'
      new: 'k'
      edit: 'o'
      openFile: 'O'
@@ -239,24 +219,5 @@ For all possible keybinding options, check [Custom_Keybinding.md](https://github
    commits:
      moveDownCommit: '<c-e>'
      moveUpCommit: '<c-u>'
-      toggleDiffCommit: 'l'
-    branches:
-      viewGitFlowOptions: 'I'
 ```

-## Custom pull request URLs
-
-Some git provider setups (e.g. on-premises GitLab) can have distinct URLs for git-related calls and
-the web interface/API itself. To work with those, Lazygit needs to know where it needs to create
-the pull request. You can do so on your `config.yml` file using the following syntax:
-
-```yaml
-services:
-  "<gitDomain>": "<provider>:<webDomain>"
-```
-
-Where:
-
- `gitDomain` stands for the domain used by git itself (i.e. the one present on clone URLs), e.g. `git.work.com`
- `provider` is one of `github`, `bitbucket` or `gitlab`
- `webDomain` is the URL where your git service exposes a web interface and APIs, e.g. `gitservice.work.com`
@@ -1,64 +0,0 @@
-# Custom Pagers
-
-Lazygit supports custom pagers, [configured](/docs/Config.md) in the config.yml file (which can be opened by pressing 'o' in the Status panel).
-
-Support does not extend to windows users, because we're making use of a package which doesn't have windows support.
-
-## Default:
-
-```yaml
-git:
-  paging:
-    colorArg: always
-    useConfig: false
-```
-
-the `colorArg` key is for whether you want the `--color=always` arg in your `git diff` command. Some pagers want it set to always, others want it set to 'never'.
-
-## Delta:
-
-```yaml
-git:
-  paging:
-    colorArg: always
-    pager: delta --dark --paging=never --24-bit-color=never
-```
-
-![](https://i.imgur.com/QJpQkF3.png)
-
-## Diff-so-fancy
-
-```yaml
-git:
-  paging:
-    colorArg: always
-    pager: diff-so-fancy
-```
-
-![](https://i.imgur.com/rjH1TpT.png)
-
-## ydiff
-
-```yaml
-gui:
-  sidePanelWidth: 0.2 # gives you more space to show things side-by-side
-git:
-  paging:
-    colorArg: never
-    pager: ydiff -p cat -s --wrap --width={{columnWidth}}
-```
-
-![](https://i.imgur.com/vaa8z0H.png)
-
-Be careful with this one, I think the homebrew and pip versions are behind master. I needed to directly download the ydiff script to get the no-pager functionality working.
-
-## Using git config
-
-```yaml
-git:
-  paging:
-    colorArg: always
-    useConfig: true
-```
-
-If you set `useConfig: true`, lazygit will use whatever pager is specified in $GIT_PAGER, $PAGER, or your git config. If the pager ends with something like ' | less' we will strip that part out, because less doesn't play nice with our rendering approach. If the custom pager uses less under the hood, that will also break rendering (hence the `--paging=never` flag for the `delta` pager).
@@ -1,29 +1,47 @@
-# Lazygit Keybindings
+# Lazygit menu

-## Global Keybindings
+## Global

 <pre>
-  <kbd>pgup</kbd>: scroll up main panel (fn+up)
-  <kbd>pgdown</kbd>: scroll down main panel (fn+down)
  <kbd>m</kbd>: view merge/rebase options
  <kbd>ctrl+p</kbd>: view custom patch options
  <kbd>P</kbd>: push
  <kbd>p</kbd>: pull
  <kbd>R</kbd>: refresh
-  <kbd>x</kbd>: open menu
-  <kbd>+</kbd>: next screen mode (normal/half/fullscreen)
-  <kbd>_</kbd>: prev screen mode
-  <kbd>:</kbd>: execute custom command
 </pre>

-## Branches Panel
+## Status

 <pre>
-  <kbd>]</kbd>: next tab
-  <kbd>[</kbd>: previous tab
+  <kbd>e</kbd>: edit config file
+  <kbd>o</kbd>: open config file
+  <kbd>u</kbd>: check for update
+  <kbd>s</kbd>: switch to a recent repo
 </pre>

-## Branches Panel (Branches Tab)
+## Files
+
+<pre>
+  <kbd>c</kbd>: commit changes
+  <kbd>w</kbd>: commit changes without pre-commit hook
+  <kbd>A</kbd>: amend last commit
+  <kbd>C</kbd>: commit changes using git editor
+  <kbd>space</kbd>: toggle staged
+  <kbd>d</kbd>: view 'discard changes' options
+  <kbd>e</kbd>: edit file
+  <kbd>o</kbd>: open file
+  <kbd>i</kbd>: add to .gitignore
+  <kbd>r</kbd>: refresh files
+  <kbd>S</kbd>: stash files
+  <kbd>a</kbd>: stage/unstage all
+  <kbd>t</kbd>: add patch
+  <kbd>D</kbd>: view reset options
+  <kbd>enter</kbd>: stage individual hunks/lines
+  <kbd>f</kbd>: fetch
+  <kbd>X</kbd>: execute custom command
+</pre>
+
+## Branches

 <pre>
  <kbd>space</kbd>: checkout
@@ -32,70 +50,12 @@
  <kbd>F</kbd>: force checkout
  <kbd>n</kbd>: new branch
  <kbd>d</kbd>: delete branch
-  <kbd>r</kbd>: rebase checked-out branch onto this branch
+  <kbd>r</kbd>: rebase branch
  <kbd>M</kbd>: merge into currently checked out branch
-  <kbd>i</kbd>: show git-flow options
  <kbd>f</kbd>: fast-forward this branch from its upstream
-  <kbd>g</kbd>: view reset options
-  <kbd>R</kbd>: rename branch
-  <kbd>/</kbd>: start search
 </pre>

-## Branches Panel (Remote Branches (in Remotes tab))
-
-<pre>
-  <kbd>esc</kbd>: return to remotes list
-  <kbd>g</kbd>: view reset options
-  <kbd>space</kbd>: checkout
-  <kbd>M</kbd>: merge into currently checked out branch
-  <kbd>d</kbd>: delete branch
-  <kbd>r</kbd>: rebase checked-out branch onto this branch
-  <kbd>u</kbd>: set as upstream of checked-out branch
-  <kbd>/</kbd>: start search
-</pre>
-
-## Branches Panel (Remotes Tab)
-
-<pre>
-  <kbd>f</kbd>: fetch remote
-  <kbd>n</kbd>: add new remote
-  <kbd>d</kbd>: remove remote
-  <kbd>e</kbd>: edit remote
-  <kbd>/</kbd>: start search
-</pre>
-
-## Branches Panel (Tags Tab)
-
-<pre>
-  <kbd>space</kbd>: checkout
-  <kbd>d</kbd>: delete tag
-  <kbd>P</kbd>: push tag
-  <kbd>n</kbd>: create tag
-  <kbd>g</kbd>: view reset options
-  <kbd>/</kbd>: start search
-</pre>
-
-## Commit Files Panel
-
-<pre>
-  <kbd>esc</kbd>: go back
-  <kbd>c</kbd>: checkout file
-  <kbd>d</kbd>: discard this commit's changes to this file
-  <kbd>o</kbd>: open file
-  <kbd>space</kbd>: toggle file included in patch
-  <kbd>enter</kbd>: enter file to add selected lines to the patch
-  <kbd>/</kbd>: start search
-</pre>
-
-## Commits Panel
-
-<pre>
-  <kbd>]</kbd>: next tab
-  <kbd>[</kbd>: previous tab
-  <kbd>/</kbd>: start search
-</pre>
-
-## Commits Panel (Commits Tab)
+## Commits

 <pre>
  <kbd>s</kbd>: squash down
@@ -116,43 +76,46 @@
  <kbd>C</kbd>: copy commit range (cherry-pick)
  <kbd>v</kbd>: paste commits (cherry-pick)
  <kbd>enter</kbd>: view commit's files
-  <kbd>space</kbd>: checkout commit
-  <kbd>i</kbd>: select commit to diff with another commit
-  <kbd>T</kbd>: tag commit
-  <kbd>ctrl+r</kbd>: reset cherry-picked (copied) commits selection
+  <kbd>space</kbd>: select commit to diff with another commit
 </pre>

-## Commits Panel (Reflog Tab)
+## Stash

 <pre>
-  <kbd>space</kbd>: checkout commit
-  <kbd>g</kbd>: view reset options
+  <kbd>space</kbd>: apply
+  <kbd>g</kbd>: pop
+  <kbd>d</kbd>: drop
 </pre>

-## Files Panel
+## Commit files

 <pre>
-  <kbd>c</kbd>: commit changes
-  <kbd>w</kbd>: commit changes without pre-commit hook
-  <kbd>A</kbd>: amend last commit
-  <kbd>C</kbd>: commit changes using git editor
-  <kbd>space</kbd>: toggle staged
-  <kbd>d</kbd>: view 'discard changes' options
-  <kbd>e</kbd>: edit file
+  <kbd>esc</kbd>: go back
+  <kbd>c</kbd>: checkout file
+  <kbd>d</kbd>: discard this commit's changes to this file
  <kbd>o</kbd>: open file
-  <kbd>i</kbd>: add to .gitignore
-  <kbd>r</kbd>: refresh files
-  <kbd>s</kbd>: stash changes
-  <kbd>S</kbd>: view stash options
-  <kbd>a</kbd>: stage/unstage all
-  <kbd>D</kbd>: view reset options
-  <kbd>enter</kbd>: stage individual hunks/lines
-  <kbd>f</kbd>: fetch
-  <kbd>g</kbd>: view upstream reset options
-  <kbd>/</kbd>: start search
 </pre>

-## Main Panel (Merging)
+## Main (Normal)
+
+<pre>
+  <kbd>PgDn</kbd>: scroll down (fn+up)
+  <kbd>PgUp</kbd>: scroll up (fn+down)
+</pre>
+
+## Main (Staging)
+
+<pre>
+  <kbd>esc</kbd>: return to files panel
+  <kbd>▲</kbd>: select previous line
+  <kbd>▼</kbd>: select next line
+  <kbd>◄</kbd>: select previous hunk
+  <kbd>►</kbd>: select next hunk
+  <kbd>space</kbd>: stage line
+  <kbd>a</kbd>: stage hunk
+</pre>
+
+## Main (Merging)

 <pre>
  <kbd>esc</kbd>: return to files panel
@@ -164,71 +127,3 @@
  <kbd>▼</kbd>: select bottom hunk
  <kbd>z</kbd>: undo
 </pre>
-
-## Main Panel (Normal)
-
-<pre>
-  <kbd>￣</kbd>: scroll down (fn+up)
-  <kbd>￤</kbd>: scroll up (fn+down)
-</pre>
-
-## Main Panel (Patch Building)
-
-<pre>
-  <kbd>esc</kbd>: exit line-by-line mode
-  <kbd>▲</kbd>: select previous line
-  <kbd>▼</kbd>: select next line
-  <kbd>◄</kbd>: select previous hunk
-  <kbd>►</kbd>: select next hunk
-  <kbd>space</kbd>: add/remove line(s) to patch
-  <kbd>v</kbd>: toggle drag select
-  <kbd>V</kbd>: toggle drag select
-  <kbd>a</kbd>: toggle select hunk
-</pre>
-
-## Main Panel (Staging)
-
-<pre>
-  <kbd>esc</kbd>: return to files panel
-  <kbd>space</kbd>: toggle line staged / unstaged
-  <kbd>d</kbd>: delete change (git reset)
-  <kbd>tab</kbd>: switch to other panel
-  <kbd>▲</kbd>: select previous line
-  <kbd>▼</kbd>: select next line
-  <kbd>◄</kbd>: select previous hunk
-  <kbd>►</kbd>: select next hunk
-  <kbd>e</kbd>: edit file
-  <kbd>o</kbd>: open file
-  <kbd>v</kbd>: toggle drag select
-  <kbd>V</kbd>: toggle drag select
-  <kbd>a</kbd>: toggle select hunk
-  <kbd>c</kbd>: commit changes
-  <kbd>w</kbd>: commit changes without pre-commit hook
-  <kbd>C</kbd>: commit changes using git editor
-</pre>
-
-## Menu Panel
-
-<pre>
-  <kbd>esc</kbd>: close menu
-  <kbd>q</kbd>: close menu
-  <kbd>/</kbd>: start search
-</pre>
-
-## Stash Panel
-
-<pre>
-  <kbd>space</kbd>: apply
-  <kbd>g</kbd>: pop
-  <kbd>d</kbd>: drop
-  <kbd>/</kbd>: start search
-</pre>
-
-## Status Panel
-
-<pre>
-  <kbd>e</kbd>: edit config file
-  <kbd>o</kbd>: open config file
-  <kbd>u</kbd>: check for update
-  <kbd>enter</kbd>: switch to a recent repo
-</pre>
@@ -1,29 +1,46 @@
-# Lazygit Keybindings
+# Lazygit menu

 ## Global

 <pre>
-  <kbd>pgup</kbd>: scroll up main panel (fn+up)
-  <kbd>pgdown</kbd>: scroll down main panel (fn+down)
  <kbd>m</kbd>: bekijk merge/rebase opties
-  <kbd>ctrl+p</kbd>: view custom patch options
  <kbd>P</kbd>: push
  <kbd>p</kbd>: pull
  <kbd>R</kbd>: verversen
-  <kbd>x</kbd>: open menu
-  <kbd>+</kbd>: next screen mode (normal/half/fullscreen)
-  <kbd>_</kbd>: prev screen mode
-  <kbd>:</kbd>: voor aangepast commando uit
 </pre>

-## Branches Panel
+## Status

 <pre>
-  <kbd>]</kbd>: next tab
-  <kbd>[</kbd>: previous tab
+  <kbd>e</kbd>: verander config file
+  <kbd>o</kbd>: open config file
+  <kbd>u</kbd>: check voor updates
+  <kbd>s</kbd>: wissel naar een recente repo
 </pre>

-## Branches Panel (Branches Tab)
+## Bestanden
+
+<pre>
+  <kbd>c</kbd>: Commit veranderingen
+  <kbd>w</kbd>: commit veranderingen zonder pre-commit hook
+  <kbd>A</kbd>: wijzig laatste commit
+  <kbd>C</kbd>: commit veranderingen met de git editor
+  <kbd>space</kbd>: toggle staged
+  <kbd>d</kbd>: bekijk 'veranderingen ongedaan maken' opties
+  <kbd>e</kbd>: verander bestand
+  <kbd>o</kbd>: open bestand
+  <kbd>i</kbd>: voeg toe aan .gitignore
+  <kbd>r</kbd>: refresh bestanden
+  <kbd>S</kbd>: stash-bestanden
+  <kbd>a</kbd>: toggle staged alle
+  <kbd>t</kbd>: bewerkingen toevoegen
+  <kbd>D</kbd>: bekijk reset opties
+  <kbd>enter</kbd>: stage individuele hunks/lijnen
+  <kbd>f</kbd>: fetch
+  <kbd>X</kbd>: voor aangepast commando uit
+</pre>
+
+## Branches

 <pre>
  <kbd>space</kbd>: uitchecken
@@ -34,68 +51,10 @@
  <kbd>d</kbd>: verwijder branch
  <kbd>r</kbd>: rebase branch
  <kbd>M</kbd>: merge in met huidige checked out branch
-  <kbd>i</kbd>: show git-flow options
  <kbd>f</kbd>: fast-forward this branch from its upstream
-  <kbd>g</kbd>: bekijk reset opties
-  <kbd>R</kbd>: rename branch
-  <kbd>/</kbd>: start search
 </pre>

-## Branches Panel (Remote Branches (in Remotes tab))
-
-<pre>
-  <kbd>esc</kbd>: return to remotes list
-  <kbd>g</kbd>: bekijk reset opties
-  <kbd>space</kbd>: uitchecken
-  <kbd>M</kbd>: merge in met huidige checked out branch
-  <kbd>d</kbd>: verwijder branch
-  <kbd>r</kbd>: rebase branch
-  <kbd>u</kbd>: set as upstream of checked-out branch
-  <kbd>/</kbd>: start search
-</pre>
-
-## Branches Panel (Remotes Tab)
-
-<pre>
-  <kbd>f</kbd>: fetch remote
-  <kbd>n</kbd>: add new remote
-  <kbd>d</kbd>: remove remote
-  <kbd>e</kbd>: edit remote
-  <kbd>/</kbd>: start search
-</pre>
-
-## Branches Panel (Tags Tab)
-
-<pre>
-  <kbd>space</kbd>: uitchecken
-  <kbd>d</kbd>: delete tag
-  <kbd>P</kbd>: push tag
-  <kbd>n</kbd>: create tag
-  <kbd>g</kbd>: bekijk reset opties
-  <kbd>/</kbd>: start search
-</pre>
-
-## Commit bestanden Panel
-
-<pre>
-  <kbd>esc</kbd>: ga terug
-  <kbd>c</kbd>: bestand uitchecken
-  <kbd>d</kbd>: uitsluit deze commit zijn veranderingen aan dit bestand
-  <kbd>o</kbd>: open bestand
-  <kbd>space</kbd>: toggle file included in patch
-  <kbd>enter</kbd>: enter file to add selected lines to the patch
-  <kbd>/</kbd>: start search
-</pre>
-
-## Commits Panel
-
-<pre>
-  <kbd>]</kbd>: next tab
-  <kbd>[</kbd>: previous tab
-  <kbd>/</kbd>: start search
-</pre>
-
-## Commits Panel (Commits Tab)
+## Commits

 <pre>
  <kbd>s</kbd>: squash beneden
@@ -116,43 +75,39 @@
  <kbd>C</kbd>: kopiëer commit reeks (cherry-pick)
  <kbd>v</kbd>: plak commits (cherry-pick)
  <kbd>enter</kbd>: bekijk gecommite bestanden
-  <kbd>space</kbd>: checkout commit
-  <kbd>i</kbd>: select commit to diff with another commit
-  <kbd>T</kbd>: tag commit
-  <kbd>ctrl+r</kbd>: reset cherry-picked (copied) commits selection
+  <kbd>space</kbd>: select commit to diff with another commit
 </pre>

-## Commits Panel (Reflog Tab)
+## Stash

 <pre>
-  <kbd>space</kbd>: checkout commit
-  <kbd>g</kbd>: bekijk reset opties
+  <kbd>space</kbd>: toepassen
+  <kbd>g</kbd>: pop
+  <kbd>d</kbd>: drop
 </pre>

-## Bestanden Panel
+## Commit bestanden

 <pre>
-  <kbd>c</kbd>: Commit veranderingen
-  <kbd>w</kbd>: commit veranderingen zonder pre-commit hook
-  <kbd>A</kbd>: wijzig laatste commit
-  <kbd>C</kbd>: commit veranderingen met de git editor
-  <kbd>space</kbd>: toggle staged
-  <kbd>d</kbd>: bekijk 'veranderingen ongedaan maken' opties
-  <kbd>e</kbd>: verander bestand
+  <kbd>esc</kbd>: ga terug
+  <kbd>c</kbd>: bestand uitchecken
+  <kbd>d</kbd>: uitsluit deze commit zijn veranderingen aan dit bestand
  <kbd>o</kbd>: open bestand
-  <kbd>i</kbd>: voeg toe aan .gitignore
-  <kbd>r</kbd>: refresh bestanden
-  <kbd>s</kbd>: stash-bestanden
-  <kbd>S</kbd>: view stash options
-  <kbd>a</kbd>: toggle staged alle
-  <kbd>D</kbd>: bekijk reset opties
-  <kbd>enter</kbd>: stage individuele hunks/lijnen
-  <kbd>f</kbd>: fetch
-  <kbd>g</kbd>: view upstream reset options
-  <kbd>/</kbd>: start search
 </pre>

-## Hoofd Panel (Merging)
+## Hoofd (Stage Lines/Hunks)
+
+<pre>
+  <kbd>esc</kbd>: ga terug naar het bestanden paneel
+  <kbd>▲</kbd>: selecteer de vorige lijn
+  <kbd>▼</kbd>: selecteer de volgende lijn
+  <kbd>◄</kbd>: selecteer de vorige hunk
+  <kbd>►</kbd>: selecteer de volgende hunk
+  <kbd>space</kbd>: stage lijn
+  <kbd>a</kbd>: stage hunk
+</pre>
+
+## Hoofd (Merging)

 <pre>
  <kbd>esc</kbd>: ga terug naar het bestanden paneel
@@ -165,70 +120,9 @@
  <kbd>z</kbd>: ongedaan maken
 </pre>

-## Hoofd Panel (Normaal)
+## Hoofd (Normaal)

 <pre>
-  <kbd>￣</kbd>: scroll omlaag (fn+up)
-  <kbd>￤</kbd>: scroll omhoog (fn+down)
-</pre>
-
-## Hoofd Panel (Patch Building)
-
-<pre>
-  <kbd>esc</kbd>: exit line-by-line mode
-  <kbd>▲</kbd>: selecteer de vorige lijn
-  <kbd>▼</kbd>: selecteer de volgende lijn
-  <kbd>◄</kbd>: selecteer de vorige hunk
-  <kbd>►</kbd>: selecteer de volgende hunk
-  <kbd>space</kbd>: add/remove line(s) to patch
-  <kbd>v</kbd>: toggle drag select
-  <kbd>V</kbd>: toggle drag select
-  <kbd>a</kbd>: toggle select hunk
-</pre>
-
-## Hoofd Panel (Stage Lines/Hunks)
-
-<pre>
-  <kbd>esc</kbd>: ga terug naar het bestanden paneel
-  <kbd>space</kbd>: toggle line staged / unstaged
-  <kbd>d</kbd>: delete change (git reset)
-  <kbd>tab</kbd>: switch to other panel
-  <kbd>▲</kbd>: selecteer de vorige lijn
-  <kbd>▼</kbd>: selecteer de volgende lijn
-  <kbd>◄</kbd>: selecteer de vorige hunk
-  <kbd>►</kbd>: selecteer de volgende hunk
-  <kbd>e</kbd>: verander bestand
-  <kbd>o</kbd>: open bestand
-  <kbd>v</kbd>: toggle drag select
-  <kbd>V</kbd>: toggle drag select
-  <kbd>a</kbd>: toggle select hunk
-  <kbd>c</kbd>: Commit veranderingen
-  <kbd>w</kbd>: commit veranderingen zonder pre-commit hook
-  <kbd>C</kbd>: commit veranderingen met de git editor
-</pre>
-
-## Menu Panel
-
-<pre>
-  <kbd>esc</kbd>: close menu
-  <kbd>q</kbd>: close menu
-  <kbd>/</kbd>: start search
-</pre>
-
-## Stash Panel
-
-<pre>
-  <kbd>space</kbd>: toepassen
-  <kbd>g</kbd>: pop
-  <kbd>d</kbd>: drop
-  <kbd>/</kbd>: start search
-</pre>
-
-## Status Panel
-
-<pre>
-  <kbd>e</kbd>: verander config file
-  <kbd>o</kbd>: open config file
-  <kbd>u</kbd>: check voor updates
-  <kbd>enter</kbd>: wissel naar een recente repo
+  <kbd>PgDn</kbd>: scroll omlaag (fn+up)
+  <kbd>PgUp</kbd>: scroll omhoog (fn+down)
 </pre>
@@ -1,29 +1,46 @@
-# Lazygit Keybindings
+# Lazygit menu

 ## Globalne

 <pre>
-  <kbd>pgup</kbd>: scroll up main panel (fn+up)
-  <kbd>pgdown</kbd>: scroll down main panel (fn+down)
  <kbd>m</kbd>: view merge/rebase options
-  <kbd>ctrl+p</kbd>: view custom patch options
  <kbd>P</kbd>: push
  <kbd>p</kbd>: pull
  <kbd>R</kbd>: odśwież
-  <kbd>x</kbd>: open menu
-  <kbd>+</kbd>: next screen mode (normal/half/fullscreen)
-  <kbd>_</kbd>: prev screen mode
-  <kbd>:</kbd>: execute custom command
 </pre>

-## Gałęzie Panel
+## Status

 <pre>
-  <kbd>]</kbd>: next tab
-  <kbd>[</kbd>: previous tab
+  <kbd>e</kbd>: edytuj plik konfiguracyjny
+  <kbd>o</kbd>: otwórz plik konfiguracyjny
+  <kbd>u</kbd>: sprawdź aktualizacje
+  <kbd>s</kbd>: switch to a recent repo
 </pre>

-## Gałęzie Panel (Branches Tab)
+## Pliki
+
+<pre>
+  <kbd>c</kbd>: commituj zmiany
+  <kbd>w</kbd>: commit changes without pre-commit hook
+  <kbd>A</kbd>: zmień ostatnie zatwierdzenie
+  <kbd>C</kbd>: commituj zmiany używając edytora z gita
+  <kbd>space</kbd>: przełącz zatwierdzenie
+  <kbd>d</kbd>: view 'discard changes' options
+  <kbd>e</kbd>: edytuj plik
+  <kbd>o</kbd>: otwórz plik
+  <kbd>i</kbd>: dodaj do .gitignore
+  <kbd>r</kbd>: odśwież pliki
+  <kbd>S</kbd>: przechowaj pliki
+  <kbd>a</kbd>: przełącz wszystkie zatwierdzenia
+  <kbd>t</kbd>: dodaj łatkę
+  <kbd>D</kbd>: view reset options
+  <kbd>enter</kbd>: zatwierdź pojedyncze linie
+  <kbd>f</kbd>: fetch
+  <kbd>X</kbd>: execute custom command
+</pre>
+
+## Gałęzie

 <pre>
  <kbd>space</kbd>: przełącz
@@ -34,68 +51,10 @@
  <kbd>d</kbd>: usuń gałąź
  <kbd>r</kbd>: rebase branch
  <kbd>M</kbd>: scal do obecnej gałęzi
-  <kbd>i</kbd>: show git-flow options
  <kbd>f</kbd>: fast-forward this branch from its upstream
-  <kbd>g</kbd>: view reset options
-  <kbd>R</kbd>: rename branch
-  <kbd>/</kbd>: start search
 </pre>

-## Gałęzie Panel (Remote Branches (in Remotes tab))
-
-<pre>
-  <kbd>esc</kbd>: return to remotes list
-  <kbd>g</kbd>: view reset options
-  <kbd>space</kbd>: przełącz
-  <kbd>M</kbd>: scal do obecnej gałęzi
-  <kbd>d</kbd>: usuń gałąź
-  <kbd>r</kbd>: rebase branch
-  <kbd>u</kbd>: set as upstream of checked-out branch
-  <kbd>/</kbd>: start search
-</pre>
-
-## Gałęzie Panel (Remotes Tab)
-
-<pre>
-  <kbd>f</kbd>: fetch remote
-  <kbd>n</kbd>: add new remote
-  <kbd>d</kbd>: remove remote
-  <kbd>e</kbd>: edit remote
-  <kbd>/</kbd>: start search
-</pre>
-
-## Gałęzie Panel (Tags Tab)
-
-<pre>
-  <kbd>space</kbd>: przełącz
-  <kbd>d</kbd>: delete tag
-  <kbd>P</kbd>: push tag
-  <kbd>n</kbd>: create tag
-  <kbd>g</kbd>: view reset options
-  <kbd>/</kbd>: start search
-</pre>
-
-## Commit files Panel
-
-<pre>
-  <kbd>esc</kbd>: go back
-  <kbd>c</kbd>: checkout file
-  <kbd>d</kbd>: discard this commit's changes to this file
-  <kbd>o</kbd>: otwórz plik
-  <kbd>space</kbd>: toggle file included in patch
-  <kbd>enter</kbd>: enter file to add selected lines to the patch
-  <kbd>/</kbd>: start search
-</pre>
-
-## Commity Panel
-
-<pre>
-  <kbd>]</kbd>: next tab
-  <kbd>[</kbd>: previous tab
-  <kbd>/</kbd>: start search
-</pre>
-
-## Commity Panel (Commits Tab)
+## Commity

 <pre>
  <kbd>s</kbd>: ściśnij w dół
@@ -116,43 +75,46 @@
  <kbd>C</kbd>: copy commit range (cherry-pick)
  <kbd>v</kbd>: paste commits (cherry-pick)
  <kbd>enter</kbd>: view commit's files
-  <kbd>space</kbd>: checkout commit
-  <kbd>i</kbd>: select commit to diff with another commit
-  <kbd>T</kbd>: tag commit
-  <kbd>ctrl+r</kbd>: reset cherry-picked (copied) commits selection
+  <kbd>space</kbd>: select commit to diff with another commit
 </pre>

-## Commity Panel (Reflog Tab)
+## Schowek

 <pre>
-  <kbd>space</kbd>: checkout commit
-  <kbd>g</kbd>: view reset options
+  <kbd>space</kbd>: zastosuj
+  <kbd>g</kbd>: wyciągnij
+  <kbd>d</kbd>: porzuć
 </pre>

-## Pliki Panel
+## Commit files

 <pre>
-  <kbd>c</kbd>: commituj zmiany
-  <kbd>w</kbd>: commit changes without pre-commit hook
-  <kbd>A</kbd>: zmień ostatnie zatwierdzenie
-  <kbd>C</kbd>: commituj zmiany używając edytora z gita
-  <kbd>space</kbd>: przełącz zatwierdzenie
-  <kbd>d</kbd>: view 'discard changes' options
-  <kbd>e</kbd>: edytuj plik
+  <kbd>esc</kbd>: go back
+  <kbd>c</kbd>: checkout file
+  <kbd>d</kbd>: discard this commit's changes to this file
  <kbd>o</kbd>: otwórz plik
-  <kbd>i</kbd>: dodaj do .gitignore
-  <kbd>r</kbd>: odśwież pliki
-  <kbd>s</kbd>: przechowaj pliki
-  <kbd>S</kbd>: view stash options
-  <kbd>a</kbd>: przełącz wszystkie zatwierdzenia
-  <kbd>D</kbd>: view reset options
-  <kbd>enter</kbd>: zatwierdź pojedyncze linie
-  <kbd>f</kbd>: fetch
-  <kbd>g</kbd>: view upstream reset options
-  <kbd>/</kbd>: start search
 </pre>

-## Main Panel (Merging)
+## Main (Normal)
+
+<pre>
+  <kbd>PgDn</kbd>: scroll down (fn+up)
+  <kbd>PgUp</kbd>: scroll up (fn+down)
+</pre>
+
+## Main (Zatwierdzanie)
+
+<pre>
+  <kbd>esc</kbd>: wróć do panelu plików
+  <kbd>▲</kbd>: select previous line
+  <kbd>▼</kbd>: select next line
+  <kbd>◄</kbd>: select previous hunk
+  <kbd>►</kbd>: select next hunk
+  <kbd>space</kbd>: zatwierdź linię
+  <kbd>a</kbd>: zatwierdź kawałek
+</pre>
+
+## Main (Merging)

 <pre>
  <kbd>esc</kbd>: wróć do panelu plików
@@ -164,71 +126,3 @@
  <kbd>▼</kbd>: select bottom hunk
  <kbd>z</kbd>: undo
 </pre>
-
-## Main Panel (Normal)
-
-<pre>
-  <kbd>￣</kbd>: scroll down (fn+up)
-  <kbd>￤</kbd>: scroll up (fn+down)
-</pre>
-
-## Main Panel (Patch Building)
-
-<pre>
-  <kbd>esc</kbd>: exit line-by-line mode
-  <kbd>▲</kbd>: select previous line
-  <kbd>▼</kbd>: select next line
-  <kbd>◄</kbd>: select previous hunk
-  <kbd>►</kbd>: select next hunk
-  <kbd>space</kbd>: add/remove line(s) to patch
-  <kbd>v</kbd>: toggle drag select
-  <kbd>V</kbd>: toggle drag select
-  <kbd>a</kbd>: toggle select hunk
-</pre>
-
-## Main Panel (Zatwierdzanie)
-
-<pre>
-  <kbd>esc</kbd>: wróć do panelu plików
-  <kbd>space</kbd>: toggle line staged / unstaged
-  <kbd>d</kbd>: delete change (git reset)
-  <kbd>tab</kbd>: switch to other panel
-  <kbd>▲</kbd>: select previous line
-  <kbd>▼</kbd>: select next line
-  <kbd>◄</kbd>: select previous hunk
-  <kbd>►</kbd>: select next hunk
-  <kbd>e</kbd>: edytuj plik
-  <kbd>o</kbd>: otwórz plik
-  <kbd>v</kbd>: toggle drag select
-  <kbd>V</kbd>: toggle drag select
-  <kbd>a</kbd>: toggle select hunk
-  <kbd>c</kbd>: commituj zmiany
-  <kbd>w</kbd>: commit changes without pre-commit hook
-  <kbd>C</kbd>: commituj zmiany używając edytora z gita
-</pre>
-
-## Menu Panel
-
-<pre>
-  <kbd>esc</kbd>: close menu
-  <kbd>q</kbd>: close menu
-  <kbd>/</kbd>: start search
-</pre>
-
-## Schowek Panel
-
-<pre>
-  <kbd>space</kbd>: zastosuj
-  <kbd>g</kbd>: wyciągnij
-  <kbd>d</kbd>: porzuć
-  <kbd>/</kbd>: start search
-</pre>
-
-## Status Panel
-
-<pre>
-  <kbd>e</kbd>: edytuj plik konfiguracyjny
-  <kbd>o</kbd>: otwórz plik konfiguracyjny
-  <kbd>u</kbd>: sprawdź aktualizacje
-  <kbd>enter</kbd>: switch to a recent repo
-</pre>
@@ -1,6 +1,6 @@
 module github.com/jesseduffield/lazygit

-go 1.14
+go 1.13

 require (
 	github.com/cloudfoundry/jibber_jabber v0.0.0-20151120183258-bcc4c8345a21
@@ -11,16 +11,16 @@ require (
 	github.com/golang/protobuf v1.3.2 // indirect
 	github.com/google/go-cmp v0.3.1 // indirect
 	github.com/integrii/flaggy v1.4.0
-	github.com/jesseduffield/gocui v0.3.1-0.20200309001002-7765949e1c8a
+	github.com/jesseduffield/gocui v0.3.1-0.20191116013947-b13bda319532
 	github.com/jesseduffield/pty v1.2.1
-	github.com/jesseduffield/termbox-go v0.0.0-20200130214842-1d31d1faa3c9 // indirect
+	github.com/jesseduffield/rollrus v0.0.0-20190701125922-dd028cb0bfd7
+	github.com/jesseduffield/termbox-go v0.0.0-20190630083001-9dd53af7214e // indirect
 	github.com/kardianos/osext v0.0.0-20190222173326-2bc1f35cddc0
 	github.com/konsorten/go-windows-terminal-sequences v1.0.2 // indirect
 	github.com/mattn/go-colorable v0.1.4 // indirect
 	github.com/mattn/go-isatty v0.0.11 // indirect
-	github.com/mattn/go-runewidth v0.0.8
+	github.com/mattn/go-runewidth v0.0.7
 	github.com/mgutz/str v1.2.0
-	github.com/mitchellh/gox v1.0.1 // indirect
 	github.com/nicksnyder/go-i18n/v2 v2.0.3
 	github.com/onsi/ginkgo v1.10.3 // indirect
 	github.com/onsi/gomega v1.7.1 // indirect
@@ -54,6 +54,7 @@ github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfU
 github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
 github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
 github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
 github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
 github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=
 github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
@@ -68,8 +69,6 @@ github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoA
 github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
 github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
-github.com/hashicorp/go-version v1.0.0 h1:21MVWPKDphxa7ineQQTrCU5brh7OuVVAzGOCnnCPtE8=
-github.com/hashicorp/go-version v1.0.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
 github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
 github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
 github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
@@ -78,14 +77,16 @@ github.com/integrii/flaggy v1.4.0 h1:A1x7SYx4jqu5NSrY14z8Z+0UyX2S5ygfJJrfolWR3zM
 github.com/integrii/flaggy v1.4.0/go.mod h1:tnTxHeTJbah0gQ6/K0RW0J7fMUBk9MCF5blhm43LNpI=
 github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A=
 github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo=
-github.com/jesseduffield/gocui v0.3.1-0.20200301081700-d6e485450113 h1:jHZRVJUWsU8HaQ0crocz0i0BkpOqFLDJEO/AtBp+Ecs=
-github.com/jesseduffield/gocui v0.3.1-0.20200301081700-d6e485450113/go.mod h1:2RtZznzYKt8RLRwvFiSkXjU0Ei8WwHdubgnlaYH47dw=
-github.com/jesseduffield/gocui v0.3.1-0.20200309001002-7765949e1c8a h1:JSORQue6V4bMppr22dtUuYX+w79cgupo66PcGZ9ijlU=
-github.com/jesseduffield/gocui v0.3.1-0.20200309001002-7765949e1c8a/go.mod h1:2RtZznzYKt8RLRwvFiSkXjU0Ei8WwHdubgnlaYH47dw=
+github.com/jesseduffield/gocui v0.3.1-0.20191116013947-b13bda319532 h1:V1Lk2rm5/p27NjnlF2ezzkxDaisHNcveMNueSD7RYgs=
+github.com/jesseduffield/gocui v0.3.1-0.20191116013947-b13bda319532/go.mod h1:2RtZznzYKt8RLRwvFiSkXjU0Ei8WwHdubgnlaYH47dw=
 github.com/jesseduffield/pty v1.2.1 h1:7xYBiwNH0PpWqC8JmvrPq1a/ksNqyCavzWu9pbBGYWI=
 github.com/jesseduffield/pty v1.2.1/go.mod h1:7jlS40+UhOqkZJDIG1B/H21xnuET/+fvbbnHCa8wSIo=
-github.com/jesseduffield/termbox-go v0.0.0-20200130214842-1d31d1faa3c9 h1:iBBk1lhFwjwJw//J2m1yyz9S368GeXQTpMVACTyQMh0=
-github.com/jesseduffield/termbox-go v0.0.0-20200130214842-1d31d1faa3c9/go.mod h1:anMibpZtqNxjDbxrcDEAwSdaJ37vyUeM1f/M4uekib4=
+github.com/jesseduffield/roll v0.0.0-20190629104057-695be2e62b00 h1:+JaOkfBNYQYlGD7dgru8mCwYNEc5tRRI8mThlVANhSM=
+github.com/jesseduffield/roll v0.0.0-20190629104057-695be2e62b00/go.mod h1:cWNQljQAWYBp4wchyGfql4q2jRNZXxiE1KhVQgz+JaM=
+github.com/jesseduffield/rollrus v0.0.0-20190701125922-dd028cb0bfd7 h1:CRD7bVjlGIiV+M0jlsa+XWpneW0KY0e7Y4z3GWb5S4o=
+github.com/jesseduffield/rollrus v0.0.0-20190701125922-dd028cb0bfd7/go.mod h1:VspA3aTkEo0Q7TPCLmX1uHNP+Wb4iSDX09hmTRo1QYc=
+github.com/jesseduffield/termbox-go v0.0.0-20190630083001-9dd53af7214e h1:tth7wr6+sfSbdpRWWrwvLYyS56HyIRVfq0Qcl2h28wM=
+github.com/jesseduffield/termbox-go v0.0.0-20190630083001-9dd53af7214e/go.mod h1:anMibpZtqNxjDbxrcDEAwSdaJ37vyUeM1f/M4uekib4=
 github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI=
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
 github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
@@ -97,6 +98,7 @@ github.com/kevinburke/ssh_config v0.0.0-20190725054713-01f96b0aa0cd h1:Coekwdh0v
 github.com/kevinburke/ssh_config v0.0.0-20190725054713-01f96b0aa0cd/go.mod h1:CT57kijsi8u/K/BOFA39wgDQJ9CxiF4nAY/ojJ6r6mM=
 github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
 github.com/konsorten/go-windows-terminal-sequences v1.0.2 h1:DB17ag19krx9CFsz4o3enTrPXyIXCl+2iCXH/aMAp9s=
 github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
@@ -114,17 +116,13 @@ github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVc
 github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
 github.com/mattn/go-isatty v0.0.11 h1:FxPOTFNqGkuDUGi3H/qkUbQO4ZiBa2brKq5r0l8TGeM=
 github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOAqxQCu2WE=
-github.com/mattn/go-runewidth v0.0.8 h1:3tS41NlGYSmhhe/8fhGRzc+z3AYCw1Fe1WAyLuujKs0=
-github.com/mattn/go-runewidth v0.0.8/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
+github.com/mattn/go-runewidth v0.0.7 h1:Ei8KR0497xHyKJPAv59M1dkC+rOZCMBJ+t3fZ+twI54=
+github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
 github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
 github.com/mgutz/str v1.2.0 h1:4IzWSdIz9qPQWLfKZ0rJcV0jcUDpxvP4JVZ4GXQyvSw=
 github.com/mgutz/str v1.2.0/go.mod h1:w1v0ofgLaJdoD0HpQ3fycxKD1WtxpjSo151pK/31q6w=
 github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
 github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
-github.com/mitchellh/gox v1.0.1 h1:x0jD3dcHk9a9xPSDN6YEL4xL6Qz0dvNYm8yZqui5chI=
-github.com/mitchellh/gox v1.0.1/go.mod h1:ED6BioOGXMswlXa2zxfh/xdd5QhwYliBFn9V18Ap4z4=
-github.com/mitchellh/iochan v1.0.0 h1:C+X3KsSTLFVBr/tK1eYN/vs4rJcvsiLU338UhYPJWeY=
-github.com/mitchellh/iochan v1.0.0/go.mod h1:JwYml1nuB7xOzsp52dPpHFffvOCDupsG0QubkSMEySY=
 github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE=
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
@@ -137,6 +135,7 @@ github.com/onsi/ginkgo v1.10.3/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+
 github.com/onsi/gomega v1.7.1 h1:K0jcRCwNQM3vFGh1ppMtDh/+7ApJrjldlX8fA0jDTLQ=
 github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
 github.com/pelletier/go-buffruneio v0.2.0/go.mod h1:JkE26KsDizTr40EUHkXVtNPvgGtbSNq5BcowyYOWdKo=
+github.com/pelletier/go-toml v1.2.0 h1:T5zMGML61Wp+FlcbWjRDT7yAxhJNAiPPLOFECq181zc=
 github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
 github.com/pelletier/go-toml v1.6.0 h1:aetoXYr0Tv7xRU/V4B4IZJ2QcbtMUFoNb3ORp7TzIK4=
 github.com/pelletier/go-toml v1.6.0/go.mod h1:5N711Q9dKgbdkxHL+MEfF31hpT7l0S0s/t2kKREewys=
@@ -160,6 +159,7 @@ github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAm
 github.com/shibukawa/configdir v0.0.0-20170330084843-e180dbdc8da0 h1:Xuk8ma/ibJ1fOy4Ee11vHhUFHQNpHhrBneOCNHVXS5w=
 github.com/shibukawa/configdir v0.0.0-20170330084843-e180dbdc8da0/go.mod h1:7AwjWCpdPhkSmNAgUv5C7EJ4AbmjEB3r047r3DXWu3Y=
 github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/sirupsen/logrus v1.3.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
 github.com/sirupsen/logrus v1.4.2 h1:SPIRibHv4MatM3XXNO2BJeFLZwZ2LvZgfQ5+UNI2im4=
 github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM=
@@ -168,14 +168,17 @@ github.com/smartystreets/goconvey v1.6.4 h1:fv0U8FUIMPNf1L9lnHLvLhgicrIVChEkdzIK
 github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
 github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
 github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
+github.com/spf13/afero v1.1.2 h1:m8/z1t7/fwjysjQRYbP0RD+bUIF/8tJwPdEZsI83ACI=
 github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
 github.com/spf13/afero v1.2.2 h1:5jhuqJyZCZf2JRofRvN/nIFgIWNzPa3/Vz8mYylgbWc=
 github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk=
 github.com/spf13/cast v1.3.0 h1:oget//CVOEoFewqQxwr0Ej5yjygnqGkvggSE/gB35Q8=
 github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
+github.com/spf13/jwalterweatherman v1.0.0 h1:XHEdyB+EcvlqZamSM4ZOMGlc93t6AcsBEu9Gc1vn7yk=
 github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
 github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk=
 github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo=
+github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
 github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
@@ -210,6 +213,7 @@ golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnf
 golang.org/x/crypto v0.0.0-20190219172222-a4c6cb3142f2/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20190506204251-e1dfcc566284/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4 h1:HuIa8hRrWRSrqYzx1qI49NNxhdi2PrY7gxVSq1JjLDc=
 golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20191206172530-e9b2fee46413 h1:ULYEB3JvPRE/IfO+9uO7vKV/xzVTO7XPAwm8xbf4w2g=
 golang.org/x/crypto v0.0.0-20191206172530-e9b2fee46413/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
@@ -224,6 +228,7 @@ golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn
 golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190724013045-ca1201d0de80 h1:Ao/3l156eZf2AW5wK8a7/smtodRU+gha3+BeqJ69lRk=
 golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553 h1:efeOvDhwQ29Dj3SdAV/MJf8oukgn+8D8WgaCaRMchF8=
 golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
@@ -243,6 +248,7 @@ golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5h
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e h1:D5TXcfTk7xF7hvieo4QErS3qqCB4teTffacDWr7CI+0=
 golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20191210023423-ac6580df4449 h1:gSbV7h1NRL2G1xTg/owz62CST1oJBmxy4QpMMregXVQ=
@@ -264,6 +270,7 @@ google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZi
 google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo=
 gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"path/filepath"
 	"runtime"

 	"github.com/go-errors/errors"
@@ -19,6 +20,11 @@ var (
 	buildSource = "unknown"
 )

+func projectPath(path string) string {
+	gopath := os.Getenv("GOPATH")
+	return filepath.FromSlash(gopath + "/src/github.com/jesseduffield/lazygit/" + path)
+}
+
 func main() {
 	flaggy.DefaultParser.ShowVersionWithVersionFlag = false

@@ -14,6 +14,7 @@ import (
 	"github.com/jesseduffield/lazygit/pkg/gui"
 	"github.com/jesseduffield/lazygit/pkg/i18n"
 	"github.com/jesseduffield/lazygit/pkg/updates"
+	"github.com/jesseduffield/rollrus"
 	"github.com/shibukawa/configdir"
 	"github.com/sirupsen/logrus"
 )
@@ -72,7 +73,9 @@ func newDevelopmentLogger(config config.AppConfigurer) *logrus.Logger {

 func newLogger(config config.AppConfigurer) *logrus.Entry {
 	var log *logrus.Logger
+	environment := "production"
 	if config.GetDebug() || os.Getenv("DEBUG") == "TRUE" {
+		environment = "development"
 		log = newDevelopmentLogger(config)
 	} else {
 		log = newProductionLogger(config)
@@ -82,6 +85,11 @@ func newLogger(config config.AppConfigurer) *logrus.Entry {
 	// https://github.com/aybabtme/humanlog
 	log.Formatter = &logrus.JSONFormatter{}

+	if config.GetUserConfig().GetString("reporting") == "on" {
+		// this isn't really a secret token: it only has permission to push new rollbar items
+		hook := rollrus.NewHook("23432119147a4367abf7c0de2aa99a2d", environment)
+		log.Hooks.Add(hook)
+	}
 	return log.WithFields(logrus.Fields{
 		"debug":     config.GetDebug(),
 		"version":   config.GetVersion(),
@@ -1,12 +1,47 @@
 package commands

+import (
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/lazygit/pkg/theme"
+
+	"github.com/fatih/color"
+	"github.com/jesseduffield/lazygit/pkg/utils"
+)
+
 // Branch : A git branch
 // duplicating this for now
 type Branch struct {
-	Name         string
-	Recency      string
-	Pushables    string
-	Pullables    string
-	UpstreamName string
-	Head         bool
+	Name      string
+	Recency   string
+	Pushables string
+	Pullables string
+	Selected  bool
+}
+
+// GetDisplayStrings returns the display string of branch
+func (b *Branch) GetDisplayStrings(isFocused bool) []string {
+	displayName := utils.ColoredString(b.Name, GetBranchColor(b.Name))
+	if isFocused && b.Selected && b.Pushables != "" && b.Pullables != "" {
+		displayName = fmt.Sprintf("%s ↑%s↓%s", displayName, b.Pushables, b.Pullables)
+	}
+
+	return []string{b.Recency, displayName}
+}
+
+// GetBranchColor branch color
+func GetBranchColor(name string) color.Attribute {
+	branchType := strings.Split(name, "/")[0]
+
+	switch branchType {
+	case "feature":
+		return color.FgGreen
+	case "bugfix":
+		return color.FgYellow
+	case "hotfix":
+		return color.FgRed
+	default:
+		return theme.DefaultTextColor
+	}
 }
@@ -7,6 +7,8 @@ import (
 	"github.com/jesseduffield/lazygit/pkg/utils"

 	"github.com/sirupsen/logrus"
+
+	"gopkg.in/src-d/go-git.v4/plumbing"
 )

 // context:
@@ -34,127 +36,118 @@ func NewBranchListBuilder(log *logrus.Entry, gitCommand *GitCommand) (*BranchLis
 	}, nil
 }

-func (b *BranchListBuilder) obtainCurrentBranchName() string {
+func (b *BranchListBuilder) obtainCurrentBranch() *Branch {
 	branchName, err := b.GitCommand.CurrentBranchName()
 	if err != nil {
 		panic(err.Error())
 	}
-	return branchName
+
+	return &Branch{Name: strings.TrimSpace(branchName)}
 }

-func (b *BranchListBuilder) obtainBranches() []*Branch {
-	cmdStr := `git for-each-ref --sort=-committerdate --format="%(HEAD)|%(refname:short)|%(upstream:short)|%(upstream:track)" refs/heads`
-	output, err := b.GitCommand.OSCommand.RunCommandWithOutput(cmdStr)
+func (b *BranchListBuilder) obtainReflogBranches() []*Branch {
+	branches := make([]*Branch, 0)
+	// if we directly put this string in RunCommandWithOutput the compiler complains because it thinks it's a format string
+	unescaped := "git reflog -n100 --pretty='%cr|%gs' --grep-reflog='checkout: moving' HEAD"
+	rawString, err := b.GitCommand.OSCommand.RunCommandWithOutput(unescaped)
+	if err != nil {
+		return branches
+	}
+
+	branchLines := utils.SplitLines(rawString)
+	for _, line := range branchLines {
+		timeNumber, timeUnit, branchName := branchInfoFromLine(line)
+		timeUnit = abbreviatedTimeUnit(timeUnit)
+		branch := &Branch{Name: branchName, Recency: timeNumber + timeUnit}
+		branches = append(branches, branch)
+	}
+	return uniqueByName(branches)
+}
+
+func (b *BranchListBuilder) obtainSafeBranches() []*Branch {
+	branches := make([]*Branch, 0)
+
+	bIter, err := b.GitCommand.Repo.Branches()
 	if err != nil {
 		panic(err)
 	}
-
-	trimmedOutput := strings.TrimSpace(output)
-	outputLines := strings.Split(trimmedOutput, "\n")
-	branches := make([]*Branch, 0, len(outputLines))
-	for _, line := range outputLines {
-		if line == "" {
-			continue
-		}
-
-		split := strings.Split(line, SEPARATION_CHAR)
-
-		name := split[1]
-		branch := &Branch{
-			Name:      name,
-			Pullables: "?",
-			Pushables: "?",
-			Head:      split[0] == "*",
-		}
-
-		upstreamName := split[2]
-		if upstreamName == "" {
-			branches = append(branches, branch)
-			continue
-		}
-
-		branch.UpstreamName = upstreamName
-
-		track := split[3]
-		re := regexp.MustCompile(`ahead (\d+)`)
-		match := re.FindStringSubmatch(track)
-		if len(match) > 1 {
-			branch.Pushables = match[1]
-		} else {
-			branch.Pushables = "0"
-		}
-
-		re = regexp.MustCompile(`behind (\d+)`)
-		match = re.FindStringSubmatch(track)
-		if len(match) > 1 {
-			branch.Pullables = match[1]
-		} else {
-			branch.Pullables = "0"
-		}
-
-		branches = append(branches, branch)
-	}
+	bIter.ForEach(func(b *plumbing.Reference) error {
+		name := b.Name().Short()
+		branches = append(branches, &Branch{Name: name})
+		return nil
+	})

 	return branches
 }

+func (b *BranchListBuilder) appendNewBranches(finalBranches, newBranches, existingBranches []*Branch, included bool) []*Branch {
+	for _, newBranch := range newBranches {
+		if included == branchIncluded(newBranch.Name, existingBranches) {
+			finalBranches = append(finalBranches, newBranch)
+		}
+	}
+	return finalBranches
+}
+
+func sanitisedReflogName(reflogBranch *Branch, safeBranches []*Branch) string {
+	for _, safeBranch := range safeBranches {
+		if strings.ToLower(safeBranch.Name) == strings.ToLower(reflogBranch.Name) {
+			return safeBranch.Name
+		}
+	}
+	return reflogBranch.Name
+}
+
 // Build the list of branches for the current repo
 func (b *BranchListBuilder) Build() []*Branch {
-	currentBranchName := b.obtainCurrentBranchName()
-	branches := b.obtainBranches()
+	branches := make([]*Branch, 0)
+	head := b.obtainCurrentBranch()
+	safeBranches := b.obtainSafeBranches()

 	reflogBranches := b.obtainReflogBranches()
-
-	// loop through reflog branches. If there is a match, merge them, then remove it from the branches and keep it in the reflog branches
-	branchesWithRecency := make([]*Branch, 0)
-outer:
-	for _, reflogBranch := range reflogBranches {
-		for j, branch := range branches {
-			if branch.Head {
-				continue
-			}
-			if strings.EqualFold(reflogBranch.Name, branch.Name) {
-				branch.Recency = reflogBranch.Recency
-				branchesWithRecency = append(branchesWithRecency, branch)
-				branches = append(branches[0:j], branches[j+1:]...)
-				continue outer
-			}
-		}
+	for i, reflogBranch := range reflogBranches {
+		reflogBranches[i].Name = sanitisedReflogName(reflogBranch, safeBranches)
 	}

-	branches = append(branchesWithRecency, branches...)
+	branches = b.appendNewBranches(branches, reflogBranches, safeBranches, true)
+	branches = b.appendNewBranches(branches, safeBranches, branches, false)

-	foundHead := false
-	for i, branch := range branches {
-		if branch.Head {
-			foundHead = true
-			branch.Name = currentBranchName
-			branch.Recency = "  *"
-			branches = append(branches[0:i], branches[i+1:]...)
-			branches = append([]*Branch{branch}, branches...)
-			break
-		}
-	}
-	if !foundHead {
-		branches = append([]*Branch{{Name: currentBranchName, Head: true, Recency: "  *"}}, branches...)
+	if len(branches) == 0 || branches[0].Name != head.Name {
+		branches = append([]*Branch{head}, branches...)
 	}

+	branches[0].Recency = "  *"
+
 	return branches
 }

+func branchIncluded(branchName string, branches []*Branch) bool {
+	for _, existingBranch := range branches {
+		if strings.ToLower(existingBranch.Name) == strings.ToLower(branchName) {
+			return true
+		}
+	}
+	return false
+}
+
+func uniqueByName(branches []*Branch) []*Branch {
+	finalBranches := make([]*Branch, 0)
+	for _, branch := range branches {
+		if branchIncluded(branch.Name, finalBranches) {
+			continue
+		}
+		finalBranches = append(finalBranches, branch)
+	}
+	return finalBranches
+}
+
 // A line will have the form '10 days ago master' so we need to strip out the
 // useful information from that into timeNumber, timeUnit, and branchName
-func branchInfoFromLine(line string) (string, string) {
-	// example line: HEAD@{12 minutes ago}|checkout: moving from pulling-from-forks to tim77-patch-1
-	r := regexp.MustCompile(`HEAD\@\{([^\s]+) ([^\s]+) ago\}\|.*?([^\s]*)$`)
-	matches := r.FindStringSubmatch(strings.TrimSpace(line))
-	if len(matches) == 0 {
-		return "", ""
-	}
-	since := matches[1]
-	unit := matches[2]
-	branchName := matches[3]
-	return since + abbreviatedTimeUnit(unit), branchName
+func branchInfoFromLine(line string) (string, string, string) {
+	r := regexp.MustCompile("\\|.*\\s")
+	line = r.ReplaceAllString(line, " ")
+	words := strings.Split(line, " ")
+	return words[0], words[1], words[len(words)-1]
 }

 func abbreviatedTimeUnit(timeUnit string) string {
@@ -171,30 +164,3 @@ func abbreviatedTimeUnit(timeUnit string) string {
 	}
 	return timeUnitMap[timeUnit]
 }
-
-func (b *BranchListBuilder) obtainReflogBranches() []*Branch {
-	branches := make([]*Branch, 0)
-	// if we directly put this string in RunCommandWithOutput the compiler complains because it thinks it's a format string
-	unescaped := "git reflog --date=relative --pretty='%gd|%gs' --grep-reflog='checkout: moving' HEAD"
-	rawString, err := b.GitCommand.OSCommand.RunCommandWithOutput(unescaped)
-	if err != nil {
-		return branches
-	}
-
-	branchNameMap := map[string]bool{}
-
-	branchLines := utils.SplitLines(rawString)
-	for _, line := range branchLines {
-		recency, branchName := branchInfoFromLine(line)
-		if branchName == "" {
-			continue
-		}
-		if _, ok := branchNameMap[branchName]; ok {
-			continue
-		}
-		branchNameMap[branchName] = true
-		branch := &Branch{Name: branchName, Recency: recency}
-		branches = append(branches, branch)
-	}
-	return branches
-}
@@ -1,5 +1,13 @@
 package commands

+import (
+	"strings"
+
+	"github.com/fatih/color"
+	"github.com/jesseduffield/lazygit/pkg/theme"
+	"github.com/jesseduffield/lazygit/pkg/utils"
+)
+
 // Commit : A git commit
 type Commit struct {
 	Sha           string
@@ -9,7 +17,50 @@ type Commit struct {
 	Action        string // one of "", "pick", "edit", "squash", "reword", "drop", "fixup"
 	Copied        bool   // to know if this commit is ready to be cherry-picked somewhere
 	Tags          []string
-	ExtraInfo     string // something like 'HEAD -> master, tag: v0.15.2'
-	Author        string
-	Date          string
+}
+
+// GetDisplayStrings is a function.
+func (c *Commit) GetDisplayStrings(isFocused bool) []string {
+	red := color.New(color.FgRed)
+	yellow := color.New(color.FgYellow)
+	green := color.New(color.FgGreen)
+	blue := color.New(color.FgBlue)
+	cyan := color.New(color.FgCyan)
+	defaultColor := color.New(theme.DefaultTextColor)
+	magenta := color.New(color.FgMagenta)
+
+	// for some reason, setting the background to blue pads out the other commits
+	// horizontally. For the sake of accessibility I'm considering this a feature,
+	// not a bug
+	copied := color.New(color.FgCyan, color.BgBlue)
+
+	var shaColor *color.Color
+	switch c.Status {
+	case "unpushed":
+		shaColor = red
+	case "pushed":
+		shaColor = yellow
+	case "merged":
+		shaColor = green
+	case "rebasing":
+		shaColor = blue
+	case "selected":
+		shaColor = magenta
+	default:
+		shaColor = defaultColor
+	}
+
+	if c.Copied {
+		shaColor = copied
+	}
+
+	actionString := ""
+	tagString := ""
+	if c.Action != "" {
+		actionString = cyan.Sprint(utils.WithPadding(c.Action, 7)) + " "
+	} else if len(c.Tags) > 0 {
+		tagString = utils.ColoredString(strings.Join(c.Tags, " "), color.FgMagenta) + " "
+	}
+
+	return []string{shaColor.Sprint(c.Sha), actionString + tagString + defaultColor.Sprint(c.Name)}
 }
@@ -1,5 +1,10 @@
 package commands

+import (
+	"github.com/fatih/color"
+	"github.com/jesseduffield/lazygit/pkg/theme"
+)
+
 // CommitFile : A git commit file
 type CommitFile struct {
 	Sha           string
@@ -17,3 +22,21 @@ const (
 	// PART is for when you're only talking about specific lines that have been modified
 	PART
 )
+
+// GetDisplayStrings is a function.
+func (f *CommitFile) GetDisplayStrings(isFocused bool) []string {
+	yellow := color.New(color.FgYellow)
+	green := color.New(color.FgGreen)
+	defaultColor := color.New(theme.DefaultTextColor)
+
+	var colour *color.Color
+	switch f.Status {
+	case UNSELECTED:
+		colour = defaultColor
+	case WHOLE:
+		colour = green
+	case PART:
+		colour = yellow
+	}
+	return []string{colour.Sprint(f.DisplayString)}
+}
@@ -23,8 +23,6 @@ import (
 // if we find out we need to use one of these functions in the git.go file, we
 // can just pull them out of here and put them there and then call them from in here

-const SEPARATION_CHAR = "|"
-
 // CommitListBuilder returns a list of Branch objects for the current repo
 type CommitListBuilder struct {
 	Log                 *logrus.Entry
@@ -47,41 +45,8 @@ func NewCommitListBuilder(log *logrus.Entry, gitCommand *GitCommand, osCommand *
 	}, nil
 }

-// extractCommitFromLine takes a line from a git log and extracts the sha, message, date, and tag if present
-// then puts them into a commit object
-// example input:
-// 8ad01fe32fcc20f07bc6693f87aa4977c327f1e1|10 hours ago|Jesse Duffield| (HEAD -> master, tag: v0.15.2)|refresh commits when adding a tag
-func (c *CommitListBuilder) extractCommitFromLine(line string) *Commit {
-	split := strings.Split(line, SEPARATION_CHAR)
-
-	sha := split[0]
-	date := split[1]
-	author := split[2]
-	extraInfo := strings.TrimSpace(split[3])
-	message := strings.Join(split[4:], SEPARATION_CHAR)
-	tags := []string{}
-
-	if extraInfo != "" {
-		re := regexp.MustCompile(`tag: ([^,\)]+)`)
-		tagMatch := re.FindStringSubmatch(extraInfo)
-		if len(tagMatch) > 1 {
-			tags = append(tags, tagMatch[1])
-		}
-	}
-
-	return &Commit{
-		Sha:           sha,
-		Name:          message,
-		DisplayString: line,
-		Tags:          tags,
-		ExtraInfo:     extraInfo,
-		Date:          date,
-		Author:        author,
-	}
-}
-
 // GetCommits obtains the commits of the current branch
-func (c *CommitListBuilder) GetCommits(limit bool) ([]*Commit, error) {
+func (c *CommitListBuilder) GetCommits() ([]*Commit, error) {
 	commits := []*Commit{}
 	var rebasingCommits []*Commit
 	rebaseMode, err := c.GitCommand.RebaseMode()
@@ -100,14 +65,21 @@ func (c *CommitListBuilder) GetCommits(limit bool) ([]*Commit, error) {
 	}

 	unpushedCommits := c.getUnpushedCommits()
-	log := c.getLog(limit)
+	log := c.getLog()

 	// now we can split it up and turn it into commits
 	for _, line := range utils.SplitLines(log) {
-		commit := c.extractCommitFromLine(line)
-		_, unpushed := unpushedCommits[commit.Sha[:8]]
-		commit.Status = map[bool]string{true: "unpushed", false: "pushed"}[unpushed]
-		commits = append(commits, commit)
+		splitLine := strings.Split(line, " ")
+		sha := splitLine[0]
+		_, unpushed := unpushedCommits[sha]
+		status := map[bool]string{true: "unpushed", false: "pushed"}[unpushed]
+		commits = append(commits, &Commit{
+			Sha:           sha,
+			Name:          strings.Join(splitLine[1:], " "),
+			Status:        status,
+			DisplayString: strings.Join(splitLine, " "),
+			// TODO: add tags here
+		})
 	}
 	if rebaseMode != "" {
 		currentCommit := commits[len(rebasingCommits)]
@@ -218,7 +190,7 @@ func (c *CommitListBuilder) getInteractiveRebasingCommits() ([]*Commit, error) {
 		}
 		splitLine := strings.Split(line, " ")
 		commits = append([]*Commit{{
-			Sha:    splitLine[1],
+			Sha:    splitLine[1][0:7],
 			Name:   strings.Join(splitLine[2:], " "),
 			Status: "rebasing",
 			Action: splitLine[0],
@@ -235,7 +207,7 @@ func (c *CommitListBuilder) getInteractiveRebasingCommits() ([]*Commit, error) {
 // Subject: second commit on master
 func (c *CommitListBuilder) commitFromPatch(content string) (*Commit, error) {
 	lines := strings.Split(content, "\n")
-	sha := strings.Split(lines[0], " ")[1]
+	sha := strings.Split(lines[0], " ")[1][0:7]
 	name := strings.TrimPrefix(lines[3], "Subject: ")
 	return &Commit{
 		Sha:    sha,
@@ -298,7 +270,7 @@ func (c *CommitListBuilder) getMergeBase() (string, error) {
 // to the remote branch of the current branch, a map is returned to ease look up
 func (c *CommitListBuilder) getUnpushedCommits() map[string]bool {
 	pushables := map[string]bool{}
-	o, err := c.OSCommand.RunCommandWithOutput("git rev-list @{u}..HEAD --abbrev-commit --abbrev=8")
+	o, err := c.OSCommand.RunCommandWithOutput("git rev-list @{u}..HEAD --abbrev-commit")
 	if err != nil {
 		return pushables
 	}
@@ -309,15 +281,12 @@ func (c *CommitListBuilder) getUnpushedCommits() map[string]bool {
 	return pushables
 }

-// getLog gets the git log.
-func (c *CommitListBuilder) getLog(limit bool) string {
-	limitFlag := ""
-	if limit {
-		limitFlag = "-30"
-	}
-
-	result, err := c.OSCommand.RunCommandWithOutput(fmt.Sprintf("git log --oneline --pretty=format:\"%%H%s%%ar%s%%aN%s%%d%s%%s\" %s --abbrev=%d", SEPARATION_CHAR, SEPARATION_CHAR, SEPARATION_CHAR, SEPARATION_CHAR, limitFlag, 20))
-
+// getLog gets the git log (currently limited to 30 commits for performance
+// until we work out lazy loading
+func (c *CommitListBuilder) getLog() string {
+	// currently limiting to 30 for performance reasons
+	// TODO: add lazyloading when you scroll down
+	result, err := c.OSCommand.RunCommandWithOutput("git log --oneline -30")
 	if err != nil {
 		// assume if there is an error there are no commits yet for this branch
 		return ""
@@ -149,3 +149,170 @@ func TestCommitListBuilderGetMergeBase(t *testing.T) {
 		})
 	}
 }
+
+// TestCommitListBuilderGetLog is a function.
+func TestCommitListBuilderGetLog(t *testing.T) {
+	type scenario struct {
+		testName string
+		command  func(string, ...string) *exec.Cmd
+		test     func(string)
+	}
+
+	scenarios := []scenario{
+		{
+			"Retrieves logs",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+				assert.EqualValues(t, []string{"log", "--oneline", "-30"}, args)
+
+				return exec.Command("echo", "6f0b32f commands/git : add GetCommits tests refactor\n9d9d775 circle : remove new line")
+			},
+			func(output string) {
+				assert.EqualValues(t, "6f0b32f commands/git : add GetCommits tests refactor\n9d9d775 circle : remove new line\n", output)
+			},
+		},
+		{
+			"An error occurred when retrieving logs",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+				assert.EqualValues(t, []string{"log", "--oneline", "-30"}, args)
+				return exec.Command("test")
+			},
+			func(output string) {
+				assert.Empty(t, output)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.testName, func(t *testing.T) {
+			c := NewDummyCommitListBuilder()
+			c.OSCommand.SetCommand(s.command)
+			s.test(c.getLog())
+		})
+	}
+}
+
+// TestCommitListBuilderGetCommits is a function.
+func TestCommitListBuilderGetCommits(t *testing.T) {
+	type scenario struct {
+		testName string
+		command  func(string, ...string) *exec.Cmd
+		test     func([]*Commit, error)
+	}
+
+	scenarios := []scenario{
+		{
+			"No data found",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+
+				switch args[0] {
+				case "rev-list":
+					assert.EqualValues(t, []string{"rev-list", "@{u}..HEAD", "--abbrev-commit"}, args)
+					return exec.Command("echo")
+				case "log":
+					assert.EqualValues(t, []string{"log", "--oneline", "-30"}, args)
+					return exec.Command("echo")
+				case "merge-base":
+					assert.EqualValues(t, []string{"merge-base", "HEAD", "master"}, args)
+					return exec.Command("test")
+				case "symbolic-ref":
+					assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
+					return exec.Command("echo", "master")
+				}
+
+				return nil
+			},
+			func(commits []*Commit, err error) {
+				assert.NoError(t, err)
+				assert.Len(t, commits, 0)
+			},
+		},
+		{
+			"GetCommits returns 2 commits, 1 unpushed, the other merged",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+
+				switch args[0] {
+				case "rev-list":
+					assert.EqualValues(t, []string{"rev-list", "@{u}..HEAD", "--abbrev-commit"}, args)
+					return exec.Command("echo", "8a2bb0e")
+				case "log":
+					assert.EqualValues(t, []string{"log", "--oneline", "-30"}, args)
+					return exec.Command("echo", "8a2bb0e commit 1\n78976bc commit 2")
+				case "merge-base":
+					assert.EqualValues(t, []string{"merge-base", "HEAD", "master"}, args)
+					return exec.Command("echo", "78976bc")
+				case "symbolic-ref":
+					assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
+					return exec.Command("echo", "master")
+				}
+
+				return nil
+			},
+			func(commits []*Commit, err error) {
+				assert.NoError(t, err)
+				assert.Len(t, commits, 2)
+				assert.EqualValues(t, []*Commit{
+					{
+						Sha:           "8a2bb0e",
+						Name:          "commit 1",
+						Status:        "unpushed",
+						DisplayString: "8a2bb0e commit 1",
+					},
+					{
+						Sha:           "78976bc",
+						Name:          "commit 2",
+						Status:        "merged",
+						DisplayString: "78976bc commit 2",
+					},
+				}, commits)
+			},
+		},
+		{
+			"GetCommits bubbles up an error from setCommitMergedStatuses",
+			func(cmd string, args ...string) *exec.Cmd {
+				assert.EqualValues(t, "git", cmd)
+
+				switch args[0] {
+				case "rev-list":
+					assert.EqualValues(t, []string{"rev-list", "@{u}..HEAD", "--abbrev-commit"}, args)
+					return exec.Command("echo", "8a2bb0e")
+				case "log":
+					assert.EqualValues(t, []string{"log", "--oneline", "-30"}, args)
+					return exec.Command("echo", "8a2bb0e commit 1\n78976bc commit 2")
+				case "merge-base":
+					assert.EqualValues(t, []string{"merge-base", "HEAD", "master"}, args)
+					return exec.Command("echo", "78976bc")
+				case "symbolic-ref":
+					assert.EqualValues(t, []string{"symbolic-ref", "--short", "HEAD"}, args)
+					// here's where we are returning the error
+					return exec.Command("test")
+				case "branch":
+					assert.EqualValues(t, []string{"branch", "--contains"}, args)
+					// here too
+					return exec.Command("test")
+				case "rev-parse":
+					assert.EqualValues(t, []string{"rev-parse", "--short", "HEAD"}, args)
+					// here too
+					return exec.Command("test")
+				}
+
+				return nil
+			},
+			func(commits []*Commit, err error) {
+				assert.Error(t, err)
+				assert.Len(t, commits, 0)
+			},
+		},
+	}
+
+	for _, s := range scenarios {
+		t.Run(s.testName, func(t *testing.T) {
+			c := NewDummyCommitListBuilder()
+			c.OSCommand.SetCommand(s.command)
+			s.test(c.GetCommits())
+		})
+	}
+}
@@ -1,5 +1,7 @@
 package commands

+import "github.com/fatih/color"
+
 // File : A file from git status
 // duplicating this for now
 type File struct {
@@ -14,3 +16,23 @@ type File struct {
 	Type                    string // one of 'file', 'directory', and 'other'
 	ShortStatus             string // e.g. 'AD', ' A', 'M ', '??'
 }
+
+// GetDisplayStrings returns the display string of a file
+func (f *File) GetDisplayStrings(isFocused bool) []string {
+	// potentially inefficient to be instantiating these color
+	// objects with each render
+	red := color.New(color.FgRed)
+	green := color.New(color.FgGreen)
+	if !f.Tracked && !f.HasStagedChanges {
+		return []string{red.Sprint(f.DisplayString)}
+	}
+
+	output := green.Sprint(f.DisplayString[0:1])
+	output += red.Sprint(f.DisplayString[1:3])
+	if f.HasUnstagedChanges {
+		output += red.Sprint(f.Name)
+	} else {
+		output += green.Sprint(f.Name)
+	}
+	return []string{output}
+}
@@ -7,7 +7,6 @@ import (
 	"os/exec"
 	"path/filepath"
 	"regexp"
-	"strconv"
 	"strings"
 	"time"

@@ -177,8 +176,8 @@ func stashEntryFromLine(line string, index int) *StashEntry {
 }

 // GetStashEntryDiff stash diff
-func (c *GitCommand) ShowStashEntryCmdStr(index int) string {
-	return fmt.Sprintf("git stash show -p --color=%s stash@{%d}", c.colorArg(), index)
+func (c *GitCommand) GetStashEntryDiff(index int) (string, error) {
+	return c.OSCommand.RunCommandWithOutput("git stash show -p --color stash@{%d}", index)
 }

 // GetStatusFiles git status files
@@ -192,10 +191,10 @@ func (c *GitCommand) GetStatusFiles() []*File {
 		stagedChange := change[0:1]
 		unstagedChange := statusString[1:2]
 		filename := c.OSCommand.Unquote(statusString[3:])
-		untracked := utils.IncludesString([]string{"??", "A ", "AM"}, change)
-		hasNoStagedChanges := utils.IncludesString([]string{" ", "U", "?"}, stagedChange)
-		hasMergeConflicts := utils.IncludesString([]string{"DD", "AA", "UU", "AU", "UA", "UD", "DU"}, change)
-		hasInlineMergeConflicts := utils.IncludesString([]string{"UU", "AA"}, change)
+		_, untracked := map[string]bool{"??": true, "A ": true, "AM": true}[change]
+		_, hasNoStagedChanges := map[string]bool{" ": true, "U": true, "?": true}[stagedChange]
+		hasMergeConflicts := change == "UU" || change == "AA" || change == "DU"
+		hasInlineMergeConflicts := change == "UU" || change == "AA"

 		file := &File{
 			Name:                    filename,
@@ -327,8 +326,8 @@ func (c *GitCommand) ResetToCommit(sha string, strength string) error {
 }

 // NewBranch create new branch
-func (c *GitCommand) NewBranch(name string, baseBranch string) error {
-	return c.OSCommand.RunCommand("git checkout -b %s %s", name, baseBranch)
+func (c *GitCommand) NewBranch(name string) error {
+	return c.OSCommand.RunCommand("git checkout -b %s", name)
 }

 // CurrentBranchName is a function.
@@ -343,7 +342,7 @@ func (c *GitCommand) CurrentBranchName() (string, error) {
 		match := re.FindStringSubmatch(output)
 		branchName = match[1]
 	}
-	return strings.TrimSpace(branchName), nil
+	return utils.TrimTrailingNewline(branchName), nil
 }

 // DeleteBranch delete branch
@@ -405,17 +404,12 @@ func (c *GitCommand) AmendHead() (*exec.Cmd, error) {
 }

 // Pull pulls from repo
-func (c *GitCommand) Pull(args string, ask func(string) string) error {
-	return c.OSCommand.DetectUnamePass("git pull --no-edit "+args, ask)
-}
-
-// PullWithoutPasswordCheck assumes that the pull will not prompt the user for a password
-func (c *GitCommand) PullWithoutPasswordCheck(args string) error {
-	return c.OSCommand.RunCommand("git pull --no-edit " + args)
+func (c *GitCommand) Pull(ask func(string) string) error {
+	return c.OSCommand.DetectUnamePass("git pull --no-edit", ask)
 }

 // Push pushes to a branch
-func (c *GitCommand) Push(branchName string, force bool, upstream string, args string, ask func(string) string) error {
+func (c *GitCommand) Push(branchName string, force bool, upstream string, ask func(string) string) error {
 	forceFlag := ""
 	if force {
 		forceFlag = "--force-with-lease"
@@ -426,7 +420,7 @@ func (c *GitCommand) Push(branchName string, force bool, upstream string, args s
 		setUpstreamArg = "--set-upstream " + upstream
 	}

-	cmd := fmt.Sprintf("git push --follow-tags %s %s %s", forceFlag, setUpstreamArg, args)
+	cmd := fmt.Sprintf("git push --follow-tags %s %s", forceFlag, setUpstreamArg)
 	return c.OSCommand.DetectUnamePass(cmd, ask)
 }

@@ -544,8 +538,7 @@ func (c *GitCommand) PrepareCommitAmendSubProcess() *exec.Cmd {
 // Currently it limits the result to 100 commits, but when we get async stuff
 // working we can do lazy loading
 func (c *GitCommand) GetBranchGraph(branchName string) (string, error) {
-	cmdStr := c.GetBranchGraphCmdStr(branchName)
-	return c.OSCommand.RunCommandWithOutput(cmdStr)
+	return c.OSCommand.RunCommandWithOutput("git log --graph --color --abbrev-commit --decorate --date=relative --pretty=medium -100 %s", branchName)
 }

 func (c *GitCommand) GetUpstreamForBranch(branchName string) (string, error) {
@@ -558,12 +551,41 @@ func (c *GitCommand) Ignore(filename string) error {
 	return c.OSCommand.AppendLineToFile(".gitignore", filename)
 }

-func (c *GitCommand) ShowCmdStr(sha string) string {
-	return fmt.Sprintf("git show --color=%s --no-renames --stat -p %s", c.colorArg(), sha)
-}
+// Show shows the diff of a commit
+func (c *GitCommand) Show(sha string) (string, error) {
+	show, err := c.OSCommand.RunCommandWithOutput("git show --color --no-renames %s", sha)
+	if err != nil {
+		return "", err
+	}

-func (c *GitCommand) GetBranchGraphCmdStr(branchName string) string {
-	return fmt.Sprintf("git log --graph --color=always --abbrev-commit --decorate --date=relative --pretty=medium %s --", branchName)
+	// if this is a merge commit, we need to go a step further and get the diff between the two branches we merged
+	revList, err := c.OSCommand.RunCommandWithOutput("git rev-list -1 --merges %s^...%s", sha, sha)
+	if err != nil {
+		// turns out we get an error here when it's the first commit. We'll just return the original show
+		return show, nil
+	}
+	if len(revList) == 0 {
+		return show, nil
+	}
+
+	// we want to pull out 1a6a69a and 3b51d7c from this:
+	// commit ccc771d8b13d5b0d4635db4463556366470fd4f6
+	// Merge: 1a6a69a 3b51d7c
+	lines := utils.SplitLines(show)
+	if len(lines) < 2 {
+		return show, nil
+	}
+
+	secondLineWords := strings.Split(lines[1], " ")
+	if len(secondLineWords) < 3 {
+		return show, nil
+	}
+
+	mergeDiff, err := c.OSCommand.RunCommandWithOutput("git diff --color %s...%s", secondLineWords[1], secondLineWords[2])
+	if err != nil {
+		return "", err
+	}
+	return show + mergeDiff, nil
 }

 // GetRemoteURL returns current repo remote url
@@ -584,28 +606,24 @@ func (c *GitCommand) CheckRemoteBranchExists(branch *Branch) bool {

 // Diff returns the diff of a file
 func (c *GitCommand) Diff(file *File, plain bool, cached bool) string {
-	// for now we assume an error means the file was deleted
-	s, _ := c.OSCommand.RunCommandWithOutput(c.DiffCmdStr(file, plain, cached))
-	return s
-}
-
-func (c *GitCommand) DiffCmdStr(file *File, plain bool, cached bool) string {
 	cachedArg := ""
 	trackedArg := "--"
-	colorArg := c.colorArg()
+	colorArg := "--color"
 	split := strings.Split(file.Name, " -> ") // in case of a renamed file we get the new filename
 	fileName := c.OSCommand.Quote(split[len(split)-1])
 	if cached {
 		cachedArg = "--cached"
 	}
-	if !file.Tracked && !file.HasStagedChanges && !cached {
+	if !file.Tracked && !file.HasStagedChanges {
 		trackedArg = "--no-index /dev/null"
 	}
 	if plain {
-		colorArg = "never"
+		colorArg = ""
 	}

-	return fmt.Sprintf("git diff --color=%s %s %s %s", colorArg, cachedArg, trackedArg, fileName)
+	// for now we assume an error means the file was deleted
+	s, _ := c.OSCommand.RunCommandWithOutput("git diff %s %s %s %s", colorArg, cachedArg, trackedArg, fileName)
+	return s
 }

 func (c *GitCommand) ApplyPatch(patch string, flags ...string) error {
@@ -629,12 +647,10 @@ func (c *GitCommand) FastForward(branchName string, remoteName string, remoteBra

 func (c *GitCommand) RunSkipEditorCommand(command string) error {
 	cmd := c.OSCommand.ExecutableFromString(command)
-	lazyGitPath := c.OSCommand.GetLazygitPath()
 	cmd.Env = append(
 		cmd.Env,
 		"LAZYGIT_CLIENT_COMMAND=EXIT_IMMEDIATELY",
-		"EDITOR="+lazyGitPath,
-		"VISUAL="+lazyGitPath,
+		"EDITOR="+c.OSCommand.GetLazygitPath(),
 	)
 	return c.OSCommand.RunExecutable(cmd)
 }
@@ -866,7 +882,7 @@ func (c *GitCommand) CherryPickCommits(commits []*Commit) error {

 // GetCommitFiles get the specified commit files
 func (c *GitCommand) GetCommitFiles(commitSha string, patchManager *PatchManager) ([]*CommitFile, error) {
-	files, err := c.OSCommand.RunCommandWithOutput("git diff-tree --no-commit-id --name-only -r --no-renames %s", commitSha)
+	files, err := c.OSCommand.RunCommandWithOutput("git show --pretty= --name-only --no-renames %s", commitSha)
 	if err != nil {
 		return nil, err
 	}
@@ -892,17 +908,11 @@ func (c *GitCommand) GetCommitFiles(commitSha string, patchManager *PatchManager

 // ShowCommitFile get the diff of specified commit file
 func (c *GitCommand) ShowCommitFile(commitSha, fileName string, plain bool) (string, error) {
-	cmdStr := c.ShowCommitFileCmdStr(commitSha, fileName, plain)
-	return c.OSCommand.RunCommandWithOutput(cmdStr)
-}
-
-func (c *GitCommand) ShowCommitFileCmdStr(commitSha, fileName string, plain bool) string {
-	colorArg := c.colorArg()
+	colorArg := "--color"
 	if plain {
-		colorArg = "never"
+		colorArg = ""
 	}
-
-	return fmt.Sprintf("git show --no-renames --color=%s %s -- %s", colorArg, commitSha, fileName)
+	return c.OSCommand.RunCommandWithOutput("git show --no-renames %s %s -- %s", colorArg, commitSha, fileName)
 }

 // CheckoutFile checks out the file for the given commit
@@ -946,11 +956,6 @@ func (c *GitCommand) DiscardAnyUnstagedFileChanges() error {
 	return c.OSCommand.RunCommand("git checkout -- .")
 }

-// RemoveTrackedFiles will delete the given file(s) even if they are currently tracked
-func (c *GitCommand) RemoveTrackedFiles(name string) error {
-	return c.OSCommand.RunCommand("git rm -r --cached %s", name)
-}
-
 // RemoveUntrackedFiles runs `git clean -fd`
 func (c *GitCommand) RemoveUntrackedFiles() error {
 	return c.OSCommand.RunCommand("git clean -fd")
@@ -968,7 +973,7 @@ func (c *GitCommand) ResetSoft(ref string) error {

 // DiffCommits show diff between commits
 func (c *GitCommand) DiffCommits(sha1, sha2 string) (string, error) {
-	return c.OSCommand.RunCommandWithOutput("git diff --color=%s --stat -p %s %s", c.colorArg(), sha1, sha2)
+	return c.OSCommand.RunCommandWithOutput("git diff --color %s %s", sha1, sha2)
 }

 // CreateFixupCommit creates a commit that fixes up a previous commit
@@ -1093,6 +1098,10 @@ func (c *GitCommand) CreateLightweightTag(tagName string, commitSha string) erro
 	return c.OSCommand.RunCommand("git tag %s %s", tagName, commitSha)
 }

+func (c *GitCommand) ShowTag(tagName string) (string, error) {
+	return c.OSCommand.RunCommandWithOutput("git tag -n99 %s", tagName)
+}
+
 func (c *GitCommand) DeleteTag(tagName string) error {
 	return c.OSCommand.RunCommand("git tag -d %s", tagName)
 }
@@ -1104,69 +1113,3 @@ func (c *GitCommand) PushTag(remoteName string, tagName string) error {
 func (c *GitCommand) FetchRemote(remoteName string) error {
 	return c.OSCommand.RunCommand("git fetch %s", remoteName)
 }
-
-func (c *GitCommand) GetReflogCommits() ([]*Commit, error) {
-	output, err := c.OSCommand.RunCommandWithOutput("git reflog --abbrev=20")
-	if err != nil {
-		// assume error means we have no reflog
-		return []*Commit{}, nil
-	}
-
-	lines := strings.Split(strings.TrimSpace(output), "\n")
-	commits := make([]*Commit, 0)
-	re := regexp.MustCompile(`(\w+).*HEAD@\{\d+\}: (.*)`)
-	for _, line := range lines {
-		match := re.FindStringSubmatch(line)
-		if len(match) <= 1 {
-			continue
-		}
-
-		commit := &Commit{
-			Sha:    match[1],
-			Name:   match[2],
-			Status: "reflog",
-		}
-
-		commits = append(commits, commit)
-	}
-
-	return commits, nil
-}
-
-func (c *GitCommand) ConfiguredPager() string {
-	if os.Getenv("GIT_PAGER") != "" {
-		return os.Getenv("GIT_PAGER")
-	}
-	if os.Getenv("PAGER") != "" {
-		return os.Getenv("PAGER")
-	}
-	output, err := c.OSCommand.RunCommandWithOutput("git config --get-all core.pager")
-	if err != nil {
-		return ""
-	}
-	trimmedOutput := strings.TrimSpace(output)
-	return strings.Split(trimmedOutput, "\n")[0]
-}
-
-func (c *GitCommand) GetPager(width int) string {
-	useConfig := c.Config.GetUserConfig().GetBool("git.paging.useConfig")
-	if useConfig {
-		pager := c.ConfiguredPager()
-		return strings.Split(pager, "| less")[0]
-	}
-
-	templateValues := map[string]string{
-		"columnWidth": strconv.Itoa(width/2 - 6),
-	}
-
-	pagerTemplate := c.Config.GetUserConfig().GetString("git.paging.pager")
-	return utils.ResolvePlaceholderString(pagerTemplate, templateValues)
-}
-
-func (c *GitCommand) colorArg() string {
-	return c.Config.GetUserConfig().GetString("git.paging.colorArg")
-}
-
-func (c *GitCommand) RenameBranch(oldName string, newName string) error {
-	return c.OSCommand.RunCommand("git branch --move %s %s", oldName, newName)
-}
@@ -5,7 +5,6 @@ import (
 	"io/ioutil"
 	"os"
 	"os/exec"
-	"regexp"
 	"testing"
 	"time"

@@ -319,6 +318,21 @@ func TestGitCommandGetStashEntries(t *testing.T) {
 	}
 }

+// TestGitCommandGetStashEntryDiff is a function.
+func TestGitCommandGetStashEntryDiff(t *testing.T) {
+	gitCmd := NewDummyGitCommand()
+	gitCmd.OSCommand.command = func(cmd string, args ...string) *exec.Cmd {
+		assert.EqualValues(t, "git", cmd)
+		assert.EqualValues(t, []string{"stash", "show", "-p", "--color", "stash@{1}"}, args)
+
+		return exec.Command("echo")
+	}
+
+	_, err := gitCmd.GetStashEntryDiff(1)
+
+	assert.NoError(t, err)
+}
+
 // TestGitCommandGetStatusFiles is a function.
 func TestGitCommandGetStatusFiles(t *testing.T) {
 	type scenario struct {
@@ -636,12 +650,12 @@ func TestGitCommandNewBranch(t *testing.T) {
 	gitCmd := NewDummyGitCommand()
 	gitCmd.OSCommand.command = func(cmd string, args ...string) *exec.Cmd {
 		assert.EqualValues(t, "git", cmd)
-		assert.EqualValues(t, []string{"checkout", "-b", "test", "master"}, args)
+		assert.EqualValues(t, []string{"checkout", "-b", "test"}, args)

 		return exec.Command("echo")
 	}

-	assert.NoError(t, gitCmd.NewBranch("test", "master"))
+	assert.NoError(t, gitCmd.NewBranch("test"))
 }

 // TestGitCommandDeleteBranch is a function.
@@ -1016,7 +1030,7 @@ func TestGitCommandPush(t *testing.T) {
 		t.Run(s.testName, func(t *testing.T) {
 			gitCmd := NewDummyGitCommand()
 			gitCmd.OSCommand.command = s.command
-			err := gitCmd.Push("test", s.forcePush, "", "", func(passOrUname string) string {
+			err := gitCmd.Push("test", s.forcePush, "", func(passOrUname string) string {
 				return "\n"
 			})
 			s.test(err)
@@ -1397,6 +1411,66 @@ func TestGitCommandDiscardAllFileChanges(t *testing.T) {
 	}
 }

+// TestGitCommandShow is a function.
+func TestGitCommandShow(t *testing.T) {
+	type scenario struct {
+		testName string
+		arg      string
+		command  func(string, ...string) *exec.Cmd
+		test     func(string, error)
+	}
+
+	scenarios := []scenario{
+		{
+			"regular commit",
+			"456abcde",
+			test.CreateMockCommand(t, []*test.CommandSwapper{
+				{
+					Expect:  "git show --color --no-renames 456abcde",
+					Replace: "echo \"commit ccc771d8b13d5b0d4635db4463556366470fd4f6\nblah\"",
+				},
+				{
+					Expect:  "git rev-list -1 --merges 456abcde^...456abcde",
+					Replace: "echo",
+				},
+			}),
+			func(result string, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, "commit ccc771d8b13d5b0d4635db4463556366470fd4f6\nblah\n", result)
+			},
+		},
+		{
+			"merge commit",
+			"456abcde",
+			test.CreateMockCommand(t, []*test.CommandSwapper{
+				{
+					Expect:  "git show --color --no-renames 456abcde",
+					Replace: "echo \"commit ccc771d8b13d5b0d4635db4463556366470fd4f6\nMerge: 1a6a69a 3b51d7c\"",
+				},
+				{
+					Expect:  "git rev-list -1 --merges 456abcde^...456abcde",
+					Replace: "echo aa30e006433628ba9281652952b34d8aacda9c01",
+				},
+				{
+					Expect:  "git diff --color 1a6a69a...3b51d7c",
+					Replace: "echo blah",
+				},
+			}),
+			func(result string, err error) {
+				assert.NoError(t, err)
+				assert.Equal(t, "commit ccc771d8b13d5b0d4635db4463556366470fd4f6\nMerge: 1a6a69a 3b51d7c\nblah\n", result)
+			},
+		},
+	}
+
+	gitCmd := NewDummyGitCommand()
+
+	for _, s := range scenarios {
+		gitCmd.OSCommand.command = s.command
+		s.test(gitCmd.Show(s.arg))
+	}
+}
+
 // TestGitCommandCheckout is a function.
 func TestGitCommandCheckout(t *testing.T) {
 	type scenario struct {
@@ -1449,7 +1523,7 @@ func TestGitCommandGetBranchGraph(t *testing.T) {
 	gitCmd := NewDummyGitCommand()
 	gitCmd.OSCommand.command = func(cmd string, args ...string) *exec.Cmd {
 		assert.EqualValues(t, "git", cmd)
-		assert.EqualValues(t, []string{"log", "--graph", "--color=always", "--abbrev-commit", "--decorate", "--date=relative", "--pretty=medium", "test", "--"}, args)
+		assert.EqualValues(t, []string{"log", "--graph", "--color", "--abbrev-commit", "--decorate", "--date=relative", "--pretty=medium", "-100", "test"}, args)

 		return exec.Command("echo")
 	}
@@ -1473,7 +1547,7 @@ func TestGitCommandDiff(t *testing.T) {
 			"Default case",
 			func(cmd string, args ...string) *exec.Cmd {
 				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"diff", "--color=", "--", "test.txt"}, args)
+				assert.EqualValues(t, []string{"diff", "--color", "--", "test.txt"}, args)

 				return exec.Command("echo")
 			},
@@ -1489,7 +1563,7 @@ func TestGitCommandDiff(t *testing.T) {
 			"cached",
 			func(cmd string, args ...string) *exec.Cmd {
 				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"diff", "--color=", "--cached", "--", "test.txt"}, args)
+				assert.EqualValues(t, []string{"diff", "--color", "--cached", "--", "test.txt"}, args)

 				return exec.Command("echo")
 			},
@@ -1505,7 +1579,7 @@ func TestGitCommandDiff(t *testing.T) {
 			"plain",
 			func(cmd string, args ...string) *exec.Cmd {
 				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"diff", "--color=never", "--", "test.txt"}, args)
+				assert.EqualValues(t, []string{"diff", "--", "test.txt"}, args)

 				return exec.Command("echo")
 			},
@@ -1521,7 +1595,7 @@ func TestGitCommandDiff(t *testing.T) {
 			"File not tracked and file has no staged changes",
 			func(cmd string, args ...string) *exec.Cmd {
 				assert.EqualValues(t, "git", cmd)
-				assert.EqualValues(t, []string{"diff", "--color=", "--no-index", "/dev/null", "test.txt"}, args)
+				assert.EqualValues(t, []string{"diff", "--color", "--no-index", "/dev/null", "test.txt"}, args)

 				return exec.Command("echo")
 			},
@@ -1871,7 +1945,7 @@ func TestGitCommandShowCommitFile(t *testing.T) {
 			"hello.txt",
 			test.CreateMockCommand(t, []*test.CommandSwapper{
 				{
-					Expect:  "git show --no-renames --color=never 123456 -- hello.txt",
+					Expect:  "git show --no-renames 123456 -- hello.txt",
 					Replace: "echo -n hello",
 				},
 			}),
@@ -1907,7 +1981,7 @@ func TestGitCommandGetCommitFiles(t *testing.T) {
 			"123456",
 			test.CreateMockCommand(t, []*test.CommandSwapper{
 				{
-					Expect:  "git diff-tree --no-commit-id --name-only -r --no-renames 123456",
+					Expect:  "git show --pretty= --name-only --no-renames 123456",
 					Replace: "echo 'hello\nworld'",
 				},
 			}),
@@ -2102,37 +2176,6 @@ func TestGitCommandCreateFixupCommit(t *testing.T) {
 	}
 }

-// TestGitCommandSkipEditorCommand confirms that SkipEditorCommand injects
-// environment variables that suppress an interactive editor
-func TestGitCommandSkipEditorCommand(t *testing.T) {
-	cmd := NewDummyGitCommand()
-
-	cmd.OSCommand.SetBeforeExecuteCmd(func(cmd *exec.Cmd) {
-		test.AssertContainsMatch(
-			t,
-			cmd.Env,
-			regexp.MustCompile("^VISUAL="),
-			"expected VISUAL to be set for a non-interactive external command",
-		)
-
-		test.AssertContainsMatch(
-			t,
-			cmd.Env,
-			regexp.MustCompile("^EDITOR="),
-			"expected EDITOR to be set for a non-interactive external command",
-		)
-
-		test.AssertContainsMatch(
-			t,
-			cmd.Env,
-			regexp.MustCompile("^LAZYGIT_CLIENT_COMMAND=EXIT_IMMEDIATELY$"),
-			"expected LAZYGIT_CLIENT_COMMAND to be set for a non-interactive external command",
-		)
-	})
-
-	_ = cmd.RunSkipEditorCommand("true")
-}
-
 func TestFindDotGitDir(t *testing.T) {
 	type scenario struct {
 		testName string
@@ -36,7 +36,6 @@ type OSCommand struct {
 	Platform           *Platform
 	Config             config.AppConfigurer
 	command            func(string, ...string) *exec.Cmd
-	beforeExecuteCmd   func(*exec.Cmd)
 	getGlobalGitConfig func(string) (string, error)
 	getenv             func(string) string
 }
@@ -48,7 +47,6 @@ func NewOSCommand(log *logrus.Entry, config config.AppConfigurer) *OSCommand {
 		Platform:           getPlatform(),
 		Config:             config,
 		command:            exec.Command,
-		beforeExecuteCmd:   func(*exec.Cmd) {},
 		getGlobalGitConfig: gitconfig.Global,
 		getenv:             os.Getenv,
 	}
@@ -60,10 +58,6 @@ func (c *OSCommand) SetCommand(cmd func(string, ...string) *exec.Cmd) {
 	c.command = cmd
 }

-func (c *OSCommand) SetBeforeExecuteCmd(cmd func(*exec.Cmd)) {
-	c.beforeExecuteCmd = cmd
-}
-
 // RunCommandWithOutput wrapper around commands returning their output and error
 // NOTE: If you don't pass any formatArgs we'll just use the command directly,
 // however there's a bizarre compiler error/warning when you pass in a formatString
@@ -82,7 +76,6 @@ func (c *OSCommand) RunCommandWithOutput(formatString string, formatArgs ...inte

 // RunExecutableWithOutput runs an executable file and returns its output
 func (c *OSCommand) RunExecutableWithOutput(cmd *exec.Cmd) (string, error) {
-	c.beforeExecuteCmd(cmd)
 	return sanitisedCommandOutput(cmd.CombinedOutput())
 }

@@ -315,7 +308,6 @@ func (c *OSCommand) FileExists(path string) (bool, error) {
 // this is useful if you need to give your command some environment variables
 // before running it
 func (c *OSCommand) RunPreparedCommand(cmd *exec.Cmd) error {
-	c.beforeExecuteCmd(cmd)
 	out, err := cmd.CombinedOutput()
 	outString := string(out)
 	c.Log.Info(outString)
@@ -401,11 +393,3 @@ func (c *OSCommand) PipeCommands(commandStrings ...string) error {
 	}
 	return nil
 }
-
-func Kill(cmd *exec.Cmd) error {
-	if cmd.Process == nil {
-		// somebody got to it before we were able to, poor bastard
-		return nil
-	}
-	return cmd.Process.Kill()
-}
@@ -120,7 +120,7 @@ func coloredString(colorAttr color.Attribute, str string, selected bool, include
 	var cl *color.Color
 	attributes := []color.Attribute{colorAttr}
 	if selected {
-		attributes = append(attributes, theme.SelectedLineBgColor)
+		attributes = append(attributes, color.BgBlue)
 	}
 	cl = color.New(attributes...)
 	var clIncluded *color.Color
@@ -5,7 +5,6 @@ import (
 	"strings"

 	"github.com/go-errors/errors"
-	"github.com/jesseduffield/lazygit/pkg/config"
 )

 // Service is a service that repository is on (Github, Bitbucket, ...)
@@ -27,63 +26,27 @@ type RepoInformation struct {
 	Repository string
 }

-// NewService builds a Service based on the host type
-func NewService(typeName string, repositoryDomain string, siteDomain string) *Service {
-	var service *Service
-
-	switch typeName {
-	case "github":
-		service = &Service{
-			Name:           repositoryDomain,
-			PullRequestURL: fmt.Sprintf("https://%s%s", siteDomain, "/%s/%s/compare/%s?expand=1"),
-		}
-	case "bitbucket":
-		service = &Service{
-			Name:           repositoryDomain,
-			PullRequestURL: fmt.Sprintf("https://%s%s", siteDomain, "/%s/%s/pull-requests/new?source=%s&t=1"),
-		}
-	case "gitlab":
-		service = &Service{
-			Name:           repositoryDomain,
-			PullRequestURL: fmt.Sprintf("https://%s%s", siteDomain, "/%s/%s/merge_requests/new?merge_request[source_branch]=%s"),
-		}
+func getServices() []*Service {
+	return []*Service{
+		{
+			Name:           "github.com",
+			PullRequestURL: "https://github.com/%s/%s/compare/%s?expand=1",
+		},
+		{
+			Name:           "bitbucket.org",
+			PullRequestURL: "https://bitbucket.org/%s/%s/pull-requests/new?source=%s&t=1",
+		},
+		{
+			Name:           "gitlab.com",
+			PullRequestURL: "https://gitlab.com/%s/%s/merge_requests/new?merge_request[source_branch]=%s",
+		},
 	}
-
-	return service
-}
-
-func getServices(config config.AppConfigurer) []*Service {
-	services := []*Service{
-		NewService("github", "github.com", "github.com"),
-		NewService("bitbucket", "bitbucket.org", "bitbucket.org"),
-		NewService("gitlab", "gitlab.com", "gitlab.com"),
-	}
-
-	configServices := config.GetUserConfig().GetStringMapString("services")
-
-	for repoDomain, typeAndDomain := range configServices {
-		splitData := strings.Split(typeAndDomain, ":")
-		if len(splitData) != 2 {
-			// TODO log this misconfiguration
-			continue
-		}
-
-		service := NewService(splitData[0], repoDomain, splitData[1])
-		if service == nil {
-			// TODO log this unsupported service
-			continue
-		}
-
-		services = append(services, service)
-	}
-
-	return services
 }

 // NewPullRequest creates new instance of PullRequest
 func NewPullRequest(gitCommand *GitCommand) *PullRequest {
 	return &PullRequest{
-		GitServices: getServices(gitCommand.Config),
+		GitServices: getServices(),
 		GitCommand:  gitCommand,
 	}
 }
@@ -122,7 +85,7 @@ func getRepoInfoFromURL(url string) *RepoInformation {

 	if isHTTP {
 		splits := strings.Split(url, "/")
-		owner := strings.Join(splits[3:len(splits)-1], "/")
+		owner := splits[len(splits)-2]
 		repo := strings.TrimSuffix(splits[len(splits)-1], ".git")

 		return &RepoInformation{
@@ -133,8 +96,8 @@ func getRepoInfoFromURL(url string) *RepoInformation {

 	tmpSplit := strings.Split(url, ":")
 	splits := strings.Split(tmpSplit[1], "/")
-	owner := strings.Join(splits[0:len(splits)-1], "/")
-	repo := strings.TrimSuffix(splits[len(splits)-1], ".git")
+	owner := splits[0]
+	repo := strings.TrimSuffix(splits[1], ".git")

 	return &RepoInformation{
 		Owner:      owner,
@@ -147,13 +147,6 @@ func TestCreatePullRequest(t *testing.T) {
 			gitCommand := NewDummyGitCommand()
 			gitCommand.OSCommand.command = s.command
 			gitCommand.OSCommand.Config.GetUserConfig().Set("os.openLinkCommand", "open {{link}}")
-			gitCommand.Config.GetUserConfig().Set("services", map[string]string{
-				// valid configuration for a custom service URL
-				"git.work.com": "gitlab:code.work.com",
-				// invalid configurations for a custom service URL
-				"invalid.work.com":   "noservice:invalid.work.com",
-				"noservice.work.com": "noservice.work.com",
-			})
 			dummyPullRequest := NewPullRequest(gitCommand)
 			s.test(dummyPullRequest.Create(s.branch))
 		})
@@ -1,7 +1,19 @@
 package commands

+import (
+	"github.com/jesseduffield/lazygit/pkg/utils"
+)
+
 // Remote Branch : A git remote branch
 type RemoteBranch struct {
 	Name       string
+	Selected   bool
 	RemoteName string
 }
+
+// GetDisplayStrings returns the display string of branch
+func (b *RemoteBranch) GetDisplayStrings(isFocused bool) []string {
+	displayName := utils.ColoredString(b.Name, GetBranchColor(b.Name))
+
+	return []string{displayName}
+}
@@ -4,3 +4,8 @@ package commands
 type Tag struct {
 	Name string
 }
+
+// GetDisplayStrings returns the display string of a remote
+func (r *Tag) GetDisplayStrings(isFocused bool) []string {
+	return []string{r.Name}
+}
@@ -243,25 +243,18 @@ func GetDefaultConfig() []byte {
  scrollHeight: 2
  scrollPastBottom: true
  mouseEvents: true
-  skipUnstageLineWarning: false
-  sidePanelWidth: 0.3333
  theme:
    lightTheme: false
    activeBorderColor:
-      - green
+      - white
      - bold
    inactiveBorderColor:
      - white
    optionsTextColor:
      - blue
-    selectedLineBgColor:
-      - blue
  commitLength:
    show: true
 git:
-  paging:
-    colorArg: always
-    useConfig: false
  merging:
    manualCommit: false
  skipHookPrefix: 'WIP'
@@ -287,9 +280,6 @@ keybinding:
    nextBlock: '<right>'
    prevBlock-alt: 'h'
    nextBlock-alt: 'l'
-    nextMatch: 'n'
-    prevMatch: 'N'
-    startSearch: '/'
    optionMenu: 'x'
    optionMenu-alt1: '?'
    select: '<space>'
@@ -304,16 +294,14 @@ keybinding:
    scrollDownMain-alt1: 'J'
    scrollUpMain-alt2: '<c-u>'
    scrollDownMain-alt2: '<c-d>'
-    executeCustomCommand: ':'
+    executeCustomCommand: 'X'
    createRebaseOptionsMenu: 'm'
    pushFiles: 'P'
    pullFiles: 'p'
    refresh: 'R'
    createPatchOptionsMenu: '<c-p>'
-    nextTab: ']'
-    prevTab: '['
-    nextScreenMode: '+'
-    prevScreenMode: '_'
+    nextBranchTab: ']'
+    prevBranchTab: '['
  status:
    checkForUpdate: 'u'
    recentRepos: '<enter>'
@@ -334,7 +322,6 @@ keybinding:
    checkoutBranchByName: 'c'
    forceCheckoutBranch: 'F'
    rebaseBranch: 'r'
-    renameBranch: 'R'
    mergeIntoCurrentBranch: 'M'
    viewGitFlowOptions: 'i'
    fastForward: 'f'
@@ -358,9 +345,8 @@ keybinding:
    cherryPickCopyRange: 'C'
    pasteCommits: 'v'
    tagCommit: 'T'
-    toggleDiffCommit: 'i'
+    toggleDiffCommit: 'h'
    checkoutCommit: '<space>'
-    resetCherryPick: '<c-R>'
  stash:
    popStash: 'g'
  commitFiles:
@@ -1,8 +1,6 @@
 package gui

 import (
-	"time"
-
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )
@@ -51,24 +49,15 @@ func (m *statusManager) getStatusString() string {
 // WithWaitingStatus wraps a function and shows a waiting status while the function is still executing
 func (gui *Gui) WithWaitingStatus(name string, f func() error) error {
 	go func() {
-		gui.statusManager.addWaitingStatus(name)
+		gui.g.Update(func(g *gocui.Gui) error {
+			gui.statusManager.addWaitingStatus(name)
+			return nil
+		})

-		defer func() {
+		defer gui.g.Update(func(g *gocui.Gui) error {
 			gui.statusManager.removeStatus(name)
-		}()
-
-		go func() {
-			ticker := time.NewTicker(time.Millisecond * 50)
-			defer ticker.Stop()
-			for range ticker.C {
-				appStatus := gui.statusManager.getStatusString()
-				gui.Log.Warn(appStatus)
-				if appStatus == "" {
-					return
-				}
-				gui.renderString(gui.g, "appStatus", appStatus)
-			}
-		}()
+			return nil
+		})

 		if err := f(); err != nil {
 			gui.g.Update(func(g *gocui.Gui) error {
@@ -4,9 +4,9 @@ import (
 	"fmt"
 	"strings"

+	"github.com/fatih/color"
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )

@@ -37,20 +37,42 @@ func (gui *Gui) handleBranchSelect(g *gocui.Gui, v *gocui.View) error {

 	// This really shouldn't happen: there should always be a master branch
 	if len(gui.State.Branches) == 0 {
-		return gui.newStringTask("main", gui.Tr.SLocalize("NoBranchesThisRepo"))
+		return gui.renderString(g, "main", gui.Tr.SLocalize("NoBranchesThisRepo"))
 	}
 	branch := gui.getSelectedBranch()
-	v.FocusPoint(0, gui.State.Panels.Branches.SelectedLine)
-
-	cmd := gui.OSCommand.ExecutableFromString(
-		gui.GitCommand.GetBranchGraphCmdStr(branch.Name),
-	)
-	if err := gui.newCmdTask("main", cmd); err != nil {
-		gui.Log.Error(err)
+	if err := gui.focusPoint(0, gui.State.Panels.Branches.SelectedLine, len(gui.State.Branches), v); err != nil {
+		return err
 	}
+	go func() {
+		_ = gui.RenderSelectedBranchUpstreamDifferences()
+	}()
+	go func() {
+		upstream, _ := gui.GitCommand.GetUpstreamForBranch(branch.Name)
+		if strings.Contains(upstream, "no upstream configured for branch") || strings.Contains(upstream, "unknown revision or path not in the working tree") {
+			upstream = gui.Tr.SLocalize("notTrackingRemote")
+		}
+		graph, err := gui.GitCommand.GetBranchGraph(branch.Name)
+		if err != nil && strings.HasPrefix(graph, "fatal: ambiguous argument") {
+			graph = gui.Tr.SLocalize("NoTrackingThisBranch")
+		}
+		_ = gui.renderString(g, "main", fmt.Sprintf("%s → %s\n\n%s", utils.ColoredString(branch.Name, color.FgGreen), utils.ColoredString(upstream, color.FgRed), graph))
+	}()
 	return nil
 }

+func (gui *Gui) RenderSelectedBranchUpstreamDifferences() error {
+	// here we tell the selected branch that it is selected.
+	// this is necessary for showing stats on a branch that is selected, because
+	// the displaystring function doesn't have access to gui state to tell if it's selected
+	for i, branch := range gui.State.Branches {
+		branch.Selected = i == gui.State.Panels.Branches.SelectedLine
+	}
+
+	branch := gui.getSelectedBranch()
+	branch.Pushables, branch.Pullables = gui.GitCommand.GetBranchUpstreamDifferenceCount(branch.Name)
+	return gui.renderListPanel(gui.getBranchesView(), gui.State.Branches)
+}
+
 // gui.refreshStatus is called at the end of this because that's when we can
 // be sure there is a state.Branches array to pick the current branch from
 func (gui *Gui) refreshBranches(g *gocui.Gui) error {
@@ -71,7 +93,8 @@ func (gui *Gui) refreshBranches(g *gocui.Gui) error {

 		// TODO: if we're in the remotes view and we've just deleted a remote we need to refresh accordingly
 		if gui.getBranchesView().Context == "local-branches" {
-			if err := gui.renderLocalBranchesWithSelection(); err != nil {
+			gui.refreshSelectedLine(&gui.State.Panels.Branches.SelectedLine, len(gui.State.Branches))
+			if err := gui.RenderSelectedBranchUpstreamDifferences(); err != nil {
 				return err
 			}
 		}
@@ -85,12 +108,11 @@ func (gui *Gui) renderLocalBranchesWithSelection() error {
 	branchesView := gui.getBranchesView()

 	gui.refreshSelectedLine(&gui.State.Panels.Branches.SelectedLine, len(gui.State.Branches))
-	displayStrings := presentation.GetBranchListDisplayStrings(gui.State.Branches, gui.State.ScreenMode != SCREEN_NORMAL)
-	gui.renderDisplayStrings(branchesView, displayStrings)
-	if gui.g.CurrentView() == branchesView {
-		if err := gui.handleBranchSelect(gui.g, branchesView); err != nil {
-			return err
-		}
+	if err := gui.renderListPanel(branchesView, gui.State.Branches); err != nil {
+		return err
+	}
+	if err := gui.handleBranchSelect(gui.g, branchesView); err != nil {
+		return err
 	}

 	return nil
@@ -137,7 +159,7 @@ func (gui *Gui) handleForceCheckout(g *gocui.Gui, v *gocui.View) error {
 	title := gui.Tr.SLocalize("ForceCheckoutBranch")
 	return gui.createConfirmationPanel(g, v, true, title, message, func(g *gocui.Gui, v *gocui.View) error {
 		if err := gui.GitCommand.Checkout(branch.Name, true); err != nil {
-			_ = gui.createErrorPanel(g, err.Error())
+			gui.createErrorPanel(g, err.Error())
 		}
 		return gui.refreshSidePanels(g)
 	}, nil)
@@ -181,9 +203,10 @@ func (gui *Gui) handleCheckoutRef(ref string) error {
 }

 func (gui *Gui) handleCheckoutByName(g *gocui.Gui, v *gocui.View) error {
-	return gui.createPromptPanel(g, v, gui.Tr.SLocalize("BranchName")+":", "", func(g *gocui.Gui, v *gocui.View) error {
+	gui.createPromptPanel(g, v, gui.Tr.SLocalize("BranchName")+":", "", func(g *gocui.Gui, v *gocui.View) error {
 		return gui.handleCheckoutRef(gui.trimmedContent(v))
 	})
+	return nil
 }

 func (gui *Gui) getCheckedOutBranch() *commands.Branch {
@@ -195,31 +218,31 @@ func (gui *Gui) getCheckedOutBranch() *commands.Branch {
 }

 func (gui *Gui) handleNewBranch(g *gocui.Gui, v *gocui.View) error {
-	branch := gui.getSelectedBranch()
-	if branch == nil {
-		return nil
-	}
+	branch := gui.getCheckedOutBranch()
 	message := gui.Tr.TemplateLocalize(
 		"NewBranchNameBranchOff",
 		Teml{
 			"branchName": branch.Name,
 		},
 	)
-	return gui.createPromptPanel(g, v, message, "", func(g *gocui.Gui, v *gocui.View) error {
-		if err := gui.GitCommand.NewBranch(gui.trimmedContent(v), branch.Name); err != nil {
-			return gui.createErrorPanel(g, err.Error())
-		}
-		if err := gui.refreshSidePanels(g); err != nil {
+	gui.createPromptPanel(g, v, message, "", func(g *gocui.Gui, v *gocui.View) error {
+		if err := gui.GitCommand.NewBranch(gui.trimmedContent(v)); err != nil {
 			return gui.createErrorPanel(g, err.Error())
 		}
+		gui.refreshSidePanels(g)
 		return gui.handleBranchSelect(g, v)
 	})
+	return nil
 }

 func (gui *Gui) handleDeleteBranch(g *gocui.Gui, v *gocui.View) error {
 	return gui.deleteBranch(g, v, false)
 }

+func (gui *Gui) handleForceDeleteBranch(g *gocui.Gui, v *gocui.View) error {
+	return gui.deleteBranch(g, v, true)
+}
+
 func (gui *Gui) deleteBranch(g *gocui.Gui, v *gocui.View, force bool) error {
 	selectedBranch := gui.getSelectedBranch()
 	if selectedBranch == nil {
@@ -344,19 +367,12 @@ func (gui *Gui) handleFastForward(g *gocui.Gui, v *gocui.View) error {
 	go func() {
 		_ = gui.createLoaderPanel(gui.g, v, message)

-		if gui.State.Panels.Branches.SelectedLine == 0 {
-			if err := gui.GitCommand.PullWithoutPasswordCheck("--ff-only"); err != nil {
-				_ = gui.createErrorPanel(gui.g, err.Error())
-			}
-			_ = gui.refreshSidePanels(gui.g)
+		if err := gui.GitCommand.FastForward(branch.Name, remoteName, remoteBranchName); err != nil {
+			_ = gui.createErrorPanel(gui.g, err.Error())
 		} else {
-			if err := gui.GitCommand.FastForward(branch.Name, remoteName, remoteBranchName); err != nil {
-				_ = gui.createErrorPanel(gui.g, err.Error())
-			}
-			_ = gui.refreshBranches(gui.g)
+			_ = gui.closeConfirmationPrompt(gui.g, true)
+			_ = gui.RenderSelectedBranchUpstreamDifferences()
 		}
-
-		_ = gui.closeConfirmationPrompt(gui.g, true)
 	}()
 	return nil
 }
@@ -372,9 +388,6 @@ func (gui *Gui) onBranchesTabClick(tabIndex int) error {
 func (gui *Gui) switchBranchesPanelContext(context string) error {
 	branchesView := gui.getBranchesView()
 	branchesView.Context = context
-	if err := gui.onSearchEscape(); err != nil {
-		return err
-	}

 	contextTabIndexMap := map[string]int{
 		"local-branches":  0,
@@ -385,13 +398,7 @@ func (gui *Gui) switchBranchesPanelContext(context string) error {

 	branchesView.TabIndex = contextTabIndexMap[context]

-	return gui.refreshBranchesViewWithSelection()
-}
-
-func (gui *Gui) refreshBranchesViewWithSelection() error {
-	branchesView := gui.getBranchesView()
-
-	switch branchesView.Context {
+	switch context {
 	case "local-branches":
 		return gui.renderLocalBranchesWithSelection()
 	case "remotes":
@@ -416,66 +423,3 @@ func (gui *Gui) handlePrevBranchesTab(g *gocui.Gui, v *gocui.View) error {
 		utils.ModuloWithWrap(v.TabIndex-1, len(v.Tabs)),
 	)
 }
-
-func (gui *Gui) handleCreateResetToBranchMenu(g *gocui.Gui, v *gocui.View) error {
-	branch := gui.getSelectedBranch()
-	if branch == nil {
-		return nil
-	}
-
-	return gui.createResetMenu(branch.Name)
-}
-
-func (gui *Gui) onBranchesPanelSearchSelect(selectedLine int) error {
-	branchesView := gui.getBranchesView()
-	switch branchesView.Context {
-	case "local-branches":
-		gui.State.Panels.Branches.SelectedLine = selectedLine
-		return gui.handleBranchSelect(gui.g, branchesView)
-	case "remotes":
-		gui.State.Panels.Remotes.SelectedLine = selectedLine
-		return gui.handleRemoteSelect(gui.g, branchesView)
-	case "remote-branches":
-		gui.State.Panels.RemoteBranches.SelectedLine = selectedLine
-		return gui.handleRemoteBranchSelect(gui.g, branchesView)
-	}
-	return nil
-}
-
-func (gui *Gui) handleRenameBranch(g *gocui.Gui, v *gocui.View) error {
-	branch := gui.getSelectedBranch()
-	if branch == nil {
-		return nil
-	}
-
-	promptForNewName := func() error {
-		return gui.createPromptPanel(g, v, gui.Tr.SLocalize("NewBranchNamePrompt")+" "+branch.Name+":", "", func(g *gocui.Gui, v *gocui.View) error {
-			newName := gui.trimmedContent(v)
-			if err := gui.GitCommand.RenameBranch(branch.Name, newName); err != nil {
-				return gui.createErrorPanel(gui.g, err.Error())
-			}
-			// need to checkout so that the branch shows up in our reflog and therefore
-			// doesn't get lost among all the other branches when we switch to something else
-			if err := gui.GitCommand.Checkout(newName, false); err != nil {
-				return gui.createErrorPanel(gui.g, err.Error())
-			}
-
-			return gui.refreshBranches(gui.g)
-		})
-	}
-
-	// I could do an explicit check here for whether the branch is tracking a remote branch
-	// but if we've selected it we'll already know that via Pullables and Pullables.
-	// Bit of a hack but I'm lazy.
-	notTrackingRemote := branch.Pullables == "?"
-	if notTrackingRemote {
-		return promptForNewName()
-	}
-	return gui.createConfirmationPanel(gui.g, v, true, gui.Tr.SLocalize("renameBranch"), gui.Tr.SLocalize("RenameBranchWarning"), func(_g *gocui.Gui, _v *gocui.View) error {
-		return promptForNewName()
-	}, nil)
-}
-
-func (gui *Gui) currentBranch() *commands.Branch {
-	return gui.State.Branches[0]
-}
@@ -4,7 +4,6 @@ import (
 	"github.com/go-errors/errors"
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
 )

 func (gui *Gui) getSelectedCommitFile(g *gocui.Gui) *commands.CommitFile {
@@ -30,30 +29,25 @@ func (gui *Gui) handleCommitFileSelect(g *gocui.Gui, v *gocui.View) error {
 	}

 	gui.getMainView().Title = "Patch"
-	if gui.currentViewName() == "commitFiles" {
-		gui.handleEscapeLineByLinePanel()
-	}
+	gui.State.Panels.LineByLine = nil

 	commitFile := gui.getSelectedCommitFile(g)
 	if commitFile == nil {
-		gui.renderString(g, "commitFiles", gui.Tr.SLocalize("NoCommiteFiles"))
-		return nil
+		return gui.renderString(g, "commitFiles", gui.Tr.SLocalize("NoCommiteFiles"))
 	}

 	if err := gui.refreshSecondaryPatchPanel(); err != nil {
 		return err
 	}

-	v.FocusPoint(0, gui.State.Panels.CommitFiles.SelectedLine)
-
-	cmd := gui.OSCommand.ExecutableFromString(
-		gui.GitCommand.ShowCommitFileCmdStr(commitFile.Sha, commitFile.Name, false),
-	)
-	if err := gui.newPtyTask("main", cmd); err != nil {
-		gui.Log.Error(err)
+	if err := gui.focusPoint(0, gui.State.Panels.CommitFiles.SelectedLine, len(gui.State.CommitFiles), v); err != nil {
+		return err
 	}
-
-	return nil
+	commitText, err := gui.GitCommand.ShowCommitFile(commitFile.Sha, commitFile.Name, false)
+	if err != nil {
+		return err
+	}
+	return gui.renderString(g, "main", commitText)
 }

 func (gui *Gui) handleSwitchToCommitsPanel(g *gocui.Gui, v *gocui.View) error {
@@ -112,11 +106,11 @@ func (gui *Gui) refreshCommitFilesView() error {

 	gui.refreshSelectedLine(&gui.State.Panels.CommitFiles.SelectedLine, len(gui.State.CommitFiles))

-	commitsFileView := gui.getCommitFilesView()
-	displayStrings := presentation.GetCommitFileListDisplayStrings(gui.State.CommitFiles)
-	gui.renderDisplayStrings(commitsFileView, displayStrings)
+	if err := gui.renderListPanel(gui.getCommitFilesView(), gui.State.CommitFiles); err != nil {
+		return err
+	}

-	return gui.handleCommitFileSelect(gui.g, commitsFileView)
+	return gui.handleCommitFileSelect(gui.g, gui.getCommitFilesView())
 }

 func (gui *Gui) handleOpenOldCommitFile(g *gocui.Gui, v *gocui.View) error {
@@ -131,8 +125,7 @@ func (gui *Gui) handleToggleFileForPatch(g *gocui.Gui, v *gocui.View) error {

 	commitFile := gui.getSelectedCommitFile(g)
 	if commitFile == nil {
-		gui.renderString(g, "commitFiles", gui.Tr.SLocalize("NoCommiteFiles"))
-		return nil
+		return gui.renderString(g, "commitFiles", gui.Tr.SLocalize("NoCommiteFiles"))
 	}

 	toggleTheFile := func() error {
@@ -187,8 +180,7 @@ func (gui *Gui) enterCommitFile(selectedLineIdx int) error {

 	commitFile := gui.getSelectedCommitFile(gui.g)
 	if commitFile == nil {
-		gui.renderString(gui.g, "commitFiles", gui.Tr.SLocalize("NoCommiteFiles"))
-		return nil
+		return gui.renderString(gui.g, "commitFiles", gui.Tr.SLocalize("NoCommiteFiles"))
 	}

 	enterTheFile := func(selectedLineIdx int) error {
@@ -198,7 +190,9 @@ func (gui *Gui) enterCommitFile(selectedLineIdx int) error {
 			}
 		}

-		gui.changeMainViewsContext("patch-building")
+		if err := gui.changeMainViewsContext("patch-building"); err != nil {
+			return err
+		}
 		if err := gui.switchFocus(gui.g, gui.getCommitFilesView(), gui.getMainView()); err != nil {
 			return err
 		}
@@ -214,8 +208,3 @@ func (gui *Gui) enterCommitFile(selectedLineIdx int) error {

 	return enterTheFile(selectedLineIdx)
 }
-
-func (gui *Gui) onCommitFilesPanelSearchSelect(selectedLine int) error {
-	gui.State.Panels.CommitFiles.SelectedLine = selectedLine
-	return gui.handleCommitFileSelect(gui.g, gui.getCommitFilesView())
-}
@@ -52,7 +52,7 @@ func (gui *Gui) handleCommitConfirm(g *gocui.Gui, v *gocui.View) error {
 }

 func (gui *Gui) handleCommitClose(g *gocui.Gui, v *gocui.View) error {
-	_, _ = g.SetViewOnBottom("commitMessage")
+	g.SetViewOnBottom("commitMessage")
 	return gui.switchFocus(g, v, gui.getFilesView())
 }

@@ -68,8 +68,7 @@ func (gui *Gui) handleCommitFocused(g *gocui.Gui, v *gocui.View) error {
 			"keyBindConfirm": "enter",
 		},
 	)
-	gui.renderString(g, "options", message)
-	return nil
+	return gui.renderString(g, "options", message)
 }

 func (gui *Gui) getBufferLength(view *gocui.View) string {
@@ -1,11 +1,14 @@
 package gui

 import (
+	"fmt"
 	"strconv"

+	"github.com/fatih/color"
+	"github.com/go-errors/errors"
+
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )

@@ -34,58 +37,59 @@ func (gui *Gui) handleCommitSelect(g *gocui.Gui, v *gocui.View) error {
 		return err
 	}

-	state := gui.State.Panels.Commits
-	if state.SelectedLine > 20 && state.LimitCommits {
-		state.LimitCommits = false
-		go func() {
-			if err := gui.refreshCommitsWithLimit(); err != nil {
-				_ = gui.createErrorPanel(gui.g, err.Error())
-			}
-		}()
-	}
-
 	gui.getMainView().Title = "Patch"
 	gui.getSecondaryView().Title = "Custom Patch"
-	gui.handleEscapeLineByLinePanel()
+	gui.State.Panels.LineByLine = nil

 	commit := gui.getSelectedCommit(g)
 	if commit == nil {
-		return gui.newStringTask("main", gui.Tr.SLocalize("NoCommitsThisBranch"))
+		return gui.renderString(g, "main", gui.Tr.SLocalize("NoCommitsThisBranch"))
 	}

-	v.FocusPoint(0, gui.State.Panels.Commits.SelectedLine)
+	if err := gui.focusPoint(0, gui.State.Panels.Commits.SelectedLine, len(gui.State.Commits), v); err != nil {
+		return err
+	}

 	// if specific diff mode is on, don't show diff
 	if gui.State.Panels.Commits.SpecificDiffMode {
 		return nil
 	}

-	cmd := gui.OSCommand.ExecutableFromString(
-		gui.GitCommand.ShowCmdStr(commit.Sha),
-	)
-	if err := gui.newPtyTask("main", cmd); err != nil {
-		gui.Log.Error(err)
+	commitText, err := gui.GitCommand.Show(commit.Sha)
+	if err != nil {
+		return err
 	}
-
-	return nil
+	return gui.renderString(g, "main", commitText)
 }

 func (gui *Gui) refreshCommits(g *gocui.Gui) error {
 	g.Update(func(*gocui.Gui) error {
-		// I think this is here for the sake of some kind of rebasing thing
-		_ = gui.refreshStatus(g)
+		builder, err := commands.NewCommitListBuilder(gui.Log, gui.GitCommand, gui.OSCommand, gui.Tr, gui.State.CherryPickedCommits, gui.State.DiffEntries)
+		if err != nil {
+			return err
+		}
+		commits, err := builder.GetCommits()
+		if err != nil {
+			return err
+		}
+		gui.State.Commits = commits

-		if err := gui.refreshCommitsWithLimit(); err != nil {
+		gui.refreshSelectedLine(&gui.State.Panels.Commits.SelectedLine, len(gui.State.Commits))
+
+		isFocused := gui.g.CurrentView().Name() == "commits"
+		list, err := utils.RenderList(gui.State.Commits, isFocused)
+		if err != nil {
 			return err
 		}

-		// doing this async because it shouldn't hold anything up
-		go func() {
-			if err := gui.refreshReflogCommits(); err != nil {
-				_ = gui.createErrorPanel(gui.g, err.Error())
-			}
-		}()
+		v := gui.getCommitsView()
+		v.Clear()
+		fmt.Fprint(v, list)

+		gui.refreshStatus(g)
+		if g.CurrentView() == v {
+			gui.handleCommitSelect(g, v)
+		}
 		if g.CurrentView() == gui.getCommitFilesView() || (g.CurrentView() == gui.getMainView() || gui.State.MainContext == "patch-building") {
 			return gui.refreshCommitFilesView()
 		}
@@ -94,29 +98,30 @@ func (gui *Gui) refreshCommits(g *gocui.Gui) error {
 	return nil
 }

-func (gui *Gui) refreshCommitsWithLimit() error {
-	builder, err := commands.NewCommitListBuilder(gui.Log, gui.GitCommand, gui.OSCommand, gui.Tr, gui.State.CherryPickedCommits, gui.State.DiffEntries)
-	if err != nil {
-		return err
-	}
-
-	commits, err := builder.GetCommits(gui.State.Panels.Commits.LimitCommits)
-	if err != nil {
-		return err
-	}
-	gui.State.Commits = commits
-
-	if gui.getCommitsView().Context == "branch-commits" {
-		if err := gui.renderBranchCommitsWithSelection(); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
 // specific functions

+func (gui *Gui) handleResetToCommit(g *gocui.Gui, commitView *gocui.View) error {
+	return gui.createConfirmationPanel(g, commitView, true, gui.Tr.SLocalize("ResetToCommit"), gui.Tr.SLocalize("SureResetThisCommit"), func(g *gocui.Gui, v *gocui.View) error {
+		commit := gui.getSelectedCommit(g)
+		if commit == nil {
+			panic(errors.New(gui.Tr.SLocalize("NoCommitsThisBranch")))
+		}
+
+		if err := gui.GitCommand.ResetToCommit(commit.Sha, "mixed"); err != nil {
+			return gui.createErrorPanel(g, err.Error())
+		}
+		if err := gui.refreshCommits(g); err != nil {
+			panic(err)
+		}
+		if err := gui.refreshFiles(); err != nil {
+			panic(err)
+		}
+		gui.resetOrigin(commitView)
+		gui.State.Panels.Commits.SelectedLine = 0
+		return gui.handleCommitSelect(g, commitView)
+	}, nil)
+}
+
 func (gui *Gui) handleCommitSquashDown(g *gocui.Gui, v *gocui.View) error {
 	if len(gui.State.Commits) <= 1 {
 		return gui.createErrorPanel(g, gui.Tr.SLocalize("YouNoCommitsToSquash"))
@@ -130,12 +135,23 @@ func (gui *Gui) handleCommitSquashDown(g *gocui.Gui, v *gocui.View) error {
 		return nil
 	}

-	return gui.createConfirmationPanel(g, v, true, gui.Tr.SLocalize("Squash"), gui.Tr.SLocalize("SureSquashThisCommit"), func(g *gocui.Gui, v *gocui.View) error {
+	gui.createConfirmationPanel(g, v, true, gui.Tr.SLocalize("Squash"), gui.Tr.SLocalize("SureSquashThisCommit"), func(g *gocui.Gui, v *gocui.View) error {
 		return gui.WithWaitingStatus(gui.Tr.SLocalize("SquashingStatus"), func() error {
 			err := gui.GitCommand.InteractiveRebase(gui.State.Commits, gui.State.Panels.Commits.SelectedLine, "squash")
 			return gui.handleGenericMergeCommandResult(err)
 		})
 	}, nil)
+	return nil
+}
+
+// TODO: move to files panel
+func (gui *Gui) anyUnStagedChanges(files []*commands.File) bool {
+	for _, file := range files {
+		if file.Tracked && file.HasUnstagedChanges {
+			return true
+		}
+	}
+	return false
 }

 func (gui *Gui) handleCommitFixup(g *gocui.Gui, v *gocui.View) error {
@@ -151,12 +167,13 @@ func (gui *Gui) handleCommitFixup(g *gocui.Gui, v *gocui.View) error {
 		return nil
 	}

-	return gui.createConfirmationPanel(g, v, true, gui.Tr.SLocalize("Fixup"), gui.Tr.SLocalize("SureFixupThisCommit"), func(g *gocui.Gui, v *gocui.View) error {
+	gui.createConfirmationPanel(g, v, true, gui.Tr.SLocalize("Fixup"), gui.Tr.SLocalize("SureFixupThisCommit"), func(g *gocui.Gui, v *gocui.View) error {
 		return gui.WithWaitingStatus(gui.Tr.SLocalize("FixingStatus"), func() error {
 			err := gui.GitCommand.InteractiveRebase(gui.State.Commits, gui.State.Panels.Commits.SelectedLine, "fixup")
 			return gui.handleGenericMergeCommandResult(err)
 		})
 	}, nil)
+	return nil
 }

 func (gui *Gui) handleRenameCommit(g *gocui.Gui, v *gocui.View) error {
@@ -226,6 +243,21 @@ func (gui *Gui) handleMidRebaseCommand(action string) (bool, error) {
 	return true, gui.refreshCommits(gui.g)
 }

+// handleMoveTodoDown like handleMidRebaseCommand but for moving an item up in the todo list
+func (gui *Gui) handleMoveTodoDown(index int) (bool, error) {
+	selectedCommit := gui.State.Commits[index]
+	if selectedCommit.Status != "rebasing" {
+		return false, nil
+	}
+	if gui.State.Commits[index+1].Status != "rebasing" {
+		return true, nil
+	}
+	if err := gui.GitCommand.MoveTodoDown(index); err != nil {
+		return true, gui.createErrorPanel(gui.g, err.Error())
+	}
+	return true, gui.refreshCommits(gui.g)
+}
+
 func (gui *Gui) handleCommitDelete(g *gocui.Gui, v *gocui.View) error {
 	applied, err := gui.handleMidRebaseCommand("drop")
 	if err != nil {
@@ -412,7 +444,7 @@ func (gui *Gui) handleToggleDiffCommit(g *gocui.Gui, v *gocui.View) error {
 	// get selected commit
 	commit := gui.getSelectedCommit(g)
 	if commit == nil {
-		return gui.newStringTask("main", gui.Tr.SLocalize("NoCommitsThisBranch"))
+		return gui.renderString(g, "main", gui.Tr.SLocalize("NoCommitsThisBranch"))
 	}

 	// if already selected commit delete
@@ -435,7 +467,7 @@ func (gui *Gui) handleToggleDiffCommit(g *gocui.Gui, v *gocui.View) error {
 			return gui.createErrorPanel(gui.g, err.Error())
 		}

-		return gui.newStringTask("main", commitText)
+		return gui.renderString(g, "main", commitText)
 	}

 	return nil
@@ -451,7 +483,7 @@ func (gui *Gui) setDiffMode() {
 		v.Title = gui.Tr.SLocalize("CommitsTitle")
 	}

-	_ = gui.refreshCommits(gui.g)
+	gui.refreshCommits(gui.g)
 }

 func (gui *Gui) hasCommit(commits []*commands.Commit, target string) (int, bool) {
@@ -506,6 +538,53 @@ func (gui *Gui) handleSquashAllAboveFixupCommits(g *gocui.Gui, v *gocui.View) er
 	}, nil)
 }

+type resetOption struct {
+	description string
+	command     string
+}
+
+// GetDisplayStrings is a function.
+func (r *resetOption) GetDisplayStrings(isFocused bool) []string {
+	return []string{r.description, color.New(color.FgRed).Sprint(r.command)}
+}
+
+func (gui *Gui) handleCreateCommitResetMenu(g *gocui.Gui, v *gocui.View) error {
+	commit := gui.getSelectedCommit(g)
+	if commit == nil {
+		return gui.createErrorPanel(gui.g, gui.Tr.SLocalize("NoCommitsThisBranch"))
+	}
+
+	strengths := []string{"soft", "mixed", "hard"}
+	options := make([]*resetOption, len(strengths))
+	for i, strength := range strengths {
+		options[i] = &resetOption{
+			description: fmt.Sprintf("%s reset", strength),
+			command:     fmt.Sprintf("reset --%s %s", strength, commit.Sha),
+		}
+	}
+
+	handleMenuPress := func(index int) error {
+		if err := gui.GitCommand.ResetToCommit(commit.Sha, strengths[index]); err != nil {
+			return err
+		}
+
+		if err := gui.refreshCommits(g); err != nil {
+			return err
+		}
+		if err := gui.refreshFiles(); err != nil {
+			return err
+		}
+		if err := gui.resetOrigin(gui.getCommitsView()); err != nil {
+			return err
+		}
+
+		gui.State.Panels.Commits.SelectedLine = 0
+		return gui.handleCommitSelect(g, gui.getCommitsView())
+	}
+
+	return gui.createMenu(fmt.Sprintf("%s %s", gui.Tr.SLocalize("resetTo"), commit.Sha), options, len(options), handleMenuPress)
+}
+
 func (gui *Gui) handleTagCommit(g *gocui.Gui, v *gocui.View) error {
 	// TODO: bring up menu asking if you want to make a lightweight or annotated tag
 	// if annotated, switch to a subprocess to create the message
@@ -536,114 +615,10 @@ func (gui *Gui) handleCreateLightweightTag(commitSha string) error {
 func (gui *Gui) handleCheckoutCommit(g *gocui.Gui, v *gocui.View) error {
 	commit := gui.getSelectedCommit(g)
 	if commit == nil {
-		return nil
+		return gui.renderString(g, "main", gui.Tr.SLocalize("NoCommitsThisBranch"))
 	}

 	return gui.createConfirmationPanel(g, gui.getCommitsView(), true, gui.Tr.SLocalize("checkoutCommit"), gui.Tr.SLocalize("SureCheckoutThisCommit"), func(g *gocui.Gui, v *gocui.View) error {
 		return gui.handleCheckoutRef(commit.Sha)
 	}, nil)
 }
-
-func (gui *Gui) renderBranchCommitsWithSelection() error {
-	commitsView := gui.getCommitsView()
-
-	gui.refreshSelectedLine(&gui.State.Panels.Commits.SelectedLine, len(gui.State.Commits))
-	displayStrings := presentation.GetCommitListDisplayStrings(gui.State.Commits, gui.State.ScreenMode != SCREEN_NORMAL)
-	gui.renderDisplayStrings(commitsView, displayStrings)
-	if gui.g.CurrentView() == commitsView && commitsView.Context == "branch-commits" {
-		if err := gui.handleCommitSelect(gui.g, commitsView); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (gui *Gui) onCommitsTabClick(tabIndex int) error {
-	contexts := []string{"branch-commits", "reflog-commits"}
-	commitsView := gui.getCommitsView()
-	commitsView.TabIndex = tabIndex
-
-	return gui.switchCommitsPanelContext(contexts[tabIndex])
-}
-
-func (gui *Gui) switchCommitsPanelContext(context string) error {
-	commitsView := gui.getCommitsView()
-	commitsView.Context = context
-	if err := gui.onSearchEscape(); err != nil {
-		return err
-	}
-
-	contextTabIndexMap := map[string]int{
-		"branch-commits": 0,
-		"reflog-commits": 1,
-	}
-
-	commitsView.TabIndex = contextTabIndexMap[context]
-
-	return gui.refreshCommitsViewWithSelection()
-}
-
-func (gui *Gui) refreshCommitsViewWithSelection() error {
-	commitsView := gui.getCommitsView()
-
-	switch commitsView.Context {
-	case "branch-commits":
-		return gui.renderBranchCommitsWithSelection()
-	case "reflog-commits":
-		return gui.renderReflogCommitsWithSelection()
-	}
-
-	return nil
-}
-
-func (gui *Gui) handleNextCommitsTab(g *gocui.Gui, v *gocui.View) error {
-	return gui.onCommitsTabClick(
-		utils.ModuloWithWrap(v.TabIndex+1, len(v.Tabs)),
-	)
-}
-
-func (gui *Gui) handlePrevCommitsTab(g *gocui.Gui, v *gocui.View) error {
-	return gui.onCommitsTabClick(
-		utils.ModuloWithWrap(v.TabIndex-1, len(v.Tabs)),
-	)
-}
-
-func (gui *Gui) handleCreateCommitResetMenu(g *gocui.Gui, v *gocui.View) error {
-	commit := gui.getSelectedCommit(g)
-	if commit == nil {
-		return gui.createErrorPanel(gui.g, gui.Tr.SLocalize("NoCommitsThisBranch"))
-	}
-
-	return gui.createResetMenu(commit.Sha)
-}
-
-func (gui *Gui) onCommitsPanelSearchSelect(selectedLine int) error {
-	commitsView := gui.getCommitsView()
-	switch commitsView.Context {
-	case "branch-commits":
-		gui.State.Panels.Commits.SelectedLine = selectedLine
-		return gui.handleCommitSelect(gui.g, commitsView)
-	case "reflog-commits":
-		gui.State.Panels.ReflogCommits.SelectedLine = selectedLine
-		return gui.handleReflogCommitSelect(gui.g, commitsView)
-	}
-	return nil
-}
-
-func (gui *Gui) handleOpenSearchForCommitsPanel(g *gocui.Gui, v *gocui.View) error {
-	// we usually lazyload these commits but now that we're searching we need to load them now
-	if gui.State.Panels.Commits.LimitCommits {
-		gui.State.Panels.Commits.LimitCommits = false
-		if err := gui.refreshCommits(gui.g); err != nil {
-			return err
-		}
-	}
-
-	return gui.handleOpenSearch(gui.g, v)
-}
-
-func (gui *Gui) handleResetCherryPick(g *gocui.Gui, v *gocui.View) error {
-	gui.State.CherryPickedCommits = []*commands.Commit{}
-	return gui.refreshCommits(gui.g)
-}
@@ -75,9 +75,6 @@ func (gui *Gui) prepareConfirmationPanel(currentView *gocui.View, title, prompt
 			return nil, err
 		}
 		confirmationView.HasLoader = hasLoader
-		if hasLoader {
-			gui.g.StartTicking()
-		}
 		confirmationView.Title = title
 		confirmationView.Wrap = true
 		confirmationView.FgColor = theme.GocuiDefaultTextColor
@@ -122,7 +119,9 @@ func (gui *Gui) createPopupPanel(g *gocui.Gui, currentView *gocui.View, title, p
 			}()
 		}

-		gui.renderString(g, "confirmation", prompt)
+		if err := gui.renderString(g, "confirmation", prompt); err != nil {
+			return err
+		}
 		return gui.setKeyBindings(g, handleConfirm, handleClose, returnFocusOnClose)
 	})
 	return nil
@@ -149,13 +148,19 @@ func (gui *Gui) setKeyBindings(g *gocui.Gui, handleConfirm, handleClose func(*go
 			"keyBindConfirm": "enter",
 		},
 	)
-	gui.renderString(g, "options", actions)
+	if err := gui.renderString(g, "options", actions); err != nil {
+		return err
+	}
 	if err := g.SetKeybinding("confirmation", nil, gocui.KeyEnter, gocui.ModNone, gui.wrappedConfirmationFunction(handleConfirm, returnFocusOnClose)); err != nil {
 		return err
 	}
 	return g.SetKeybinding("confirmation", nil, gocui.KeyEsc, gocui.ModNone, gui.wrappedConfirmationFunction(handleClose, returnFocusOnClose))
 }

+func (gui *Gui) createMessagePanel(g *gocui.Gui, currentView *gocui.View, title, prompt string) error {
+	return gui.createPopupPanel(g, currentView, title, prompt, false, true, false, nil, nil)
+}
+
 // createSpecificErrorPanel allows you to create an error popup, specifying the
 //  view to be focused when the user closes the popup, and a boolean specifying
 // whether we will log the error. If the message may include a user password,
@@ -4,9 +4,9 @@ package gui
 // which currently just means a context that affects both the main and secondary views
 // other views can have their context changed directly but this function helps
 // keep the main and secondary views in sync
-func (gui *Gui) changeMainViewsContext(context string) {
+func (gui *Gui) changeMainViewsContext(context string) error {
 	if gui.State.MainContext == context {
-		return
+		return nil
 	}

 	switch context {
@@ -16,4 +16,5 @@ func (gui *Gui) changeMainViewsContext(context string) {
 	}

 	gui.State.MainContext = context
+	return nil
 }
@@ -82,8 +82,7 @@ func (gui *Gui) handleCredentialsViewFocused(g *gocui.Gui, v *gocui.View) error
 			"keyBindConfirm": "enter",
 		},
 	)
-	gui.renderString(g, "options", message)
-	return nil
+	return gui.renderString(g, "options", message)
 }

 // HandleCredentialsPopup handles the views after executing a command that might ask for credentials
@@ -1,42 +0,0 @@
-package gui
-
-import (
-	"github.com/jesseduffield/gocui"
-)
-
-func (gui *Gui) handleCreateDiscardMenu(g *gocui.Gui, v *gocui.View) error {
-	file, err := gui.getSelectedFile(g)
-	if err != nil {
-		if err != gui.Errors.ErrNoFiles {
-			return err
-		}
-		return nil
-	}
-
-	menuItems := []*menuItem{
-		{
-			displayString: gui.Tr.SLocalize("discardAllChanges"),
-			onPress: func() error {
-				if err := gui.GitCommand.DiscardAllFileChanges(file); err != nil {
-					return err
-				}
-				return gui.refreshFiles()
-			},
-		},
-	}
-
-	if file.HasStagedChanges && file.HasUnstagedChanges {
-		menuItems = append(menuItems, &menuItem{
-			displayString: gui.Tr.SLocalize("discardUnstagedChanges"),
-			onPress: func() error {
-				if err := gui.GitCommand.DiscardUnstagedFileChanges(file); err != nil {
-					return err
-				}
-
-				return gui.refreshFiles()
-			},
-		})
-	}
-
-	return gui.createMenu(file.Name, menuItems, createMenuOptions{showCancel: true})
-}
@@ -19,22 +19,13 @@ type fileWatcher struct {
 	Watcher          *fsnotify.Watcher
 	WatchedFilenames []string
 	Log              *logrus.Entry
-	Disabled         bool
 }

 func NewFileWatcher(log *logrus.Entry) *fileWatcher {
-	// TODO: get this going again, and ensure we don't see any crashes from it
-	return &fileWatcher{
-		Disabled: true,
-	}
-
 	watcher, err := fsnotify.NewWatcher()
-
 	if err != nil {
 		log.Error(err)
-		return &fileWatcher{
-			Disabled: true,
-		}
+		return nil
 	}

 	return &fileWatcher{
@@ -75,10 +66,6 @@ func (w *fileWatcher) watchFilename(filename string) {
 }

 func (w *fileWatcher) addFilesToFileWatcher(files []*commands.File) error {
-	if w.Disabled {
-		return nil
-	}
-
 	if len(files) == 0 {
 		return nil
 	}
@@ -118,7 +105,7 @@ func min(a int, b int) int {
 // TODO: consider watching the whole directory recursively (could be more expensive)
 func (gui *Gui) watchFilesForChanges() {
 	gui.fileWatcher = NewFileWatcher(gui.Log)
-	if gui.fileWatcher.Disabled {
+	if gui.fileWatcher == nil {
 		return
 	}
 	go func() {
@@ -12,7 +12,7 @@ import (

 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
+	"github.com/jesseduffield/lazygit/pkg/utils"
 )

 // list panel functions
@@ -32,12 +32,12 @@ func (gui *Gui) selectFile(alreadySelected bool) error {
 		if err != gui.Errors.ErrNoFiles {
 			return err
 		}
-		gui.State.SplitMainPanel = false
-		gui.getMainView().Title = ""
-		return gui.newStringTask("main", gui.Tr.SLocalize("NoChangedFiles"))
+		return gui.renderString(gui.g, "main", gui.Tr.SLocalize("NoChangedFiles"))
 	}

-	gui.getFilesView().FocusPoint(0, gui.State.Panels.Files.SelectedLine)
+	if err := gui.focusPoint(0, gui.State.Panels.Files.SelectedLine, len(gui.State.Files), gui.getFilesView()); err != nil {
+		return err
+	}

 	if file.HasInlineMergeConflicts {
 		gui.getMainView().Title = gui.Tr.SLocalize("MergeConflictsTitle")
@@ -45,40 +45,37 @@ func (gui *Gui) selectFile(alreadySelected bool) error {
 		return gui.refreshMergePanel()
 	}

-	if !alreadySelected {
-		if err := gui.resetOrigin(gui.getMainView()); err != nil {
-			return err
-		}
-		if err := gui.resetOrigin(gui.getSecondaryView()); err != nil {
-			return err
-		}
-	}
-
+	content := gui.GitCommand.Diff(file, false, false)
+	contentCached := gui.GitCommand.Diff(file, false, true)
+	leftContent := content
 	if file.HasStagedChanges && file.HasUnstagedChanges {
 		gui.State.SplitMainPanel = true
 		gui.getMainView().Title = gui.Tr.SLocalize("UnstagedChanges")
 		gui.getSecondaryView().Title = gui.Tr.SLocalize("StagedChanges")
-		cmdStr := gui.GitCommand.DiffCmdStr(file, false, true)
-		cmd := gui.OSCommand.ExecutableFromString(cmdStr)
-		if err := gui.newPtyTask("secondary", cmd); err != nil {
-			return err
-		}
 	} else {
 		gui.State.SplitMainPanel = false
 		if file.HasUnstagedChanges {
+			leftContent = content
 			gui.getMainView().Title = gui.Tr.SLocalize("UnstagedChanges")
 		} else {
+			leftContent = contentCached
 			gui.getMainView().Title = gui.Tr.SLocalize("StagedChanges")
 		}
 	}

-	cmdStr := gui.GitCommand.DiffCmdStr(file, false, !file.HasUnstagedChanges && file.HasStagedChanges)
-	cmd := gui.OSCommand.ExecutableFromString(cmdStr)
-	if err := gui.newPtyTask("main", cmd); err != nil {
+	if alreadySelected {
+		gui.g.Update(func(*gocui.Gui) error {
+			if err := gui.setViewContent(gui.g, gui.getSecondaryView(), contentCached); err != nil {
+				return err
+			}
+			return gui.setViewContent(gui.g, gui.getMainView(), leftContent)
+		})
+		return nil
+	}
+	if err := gui.renderString(gui.g, "secondary", contentCached); err != nil {
 		return err
 	}
-
-	return nil
+	return gui.renderString(gui.g, "main", leftContent)
 }

 func (gui *Gui) refreshFiles() error {
@@ -101,8 +98,14 @@ func (gui *Gui) refreshFiles() error {
 	}

 	gui.g.Update(func(g *gocui.Gui) error {
-		displayStrings := presentation.GetFileListDisplayStrings(gui.State.Files)
-		gui.renderDisplayStrings(filesView, displayStrings)
+
+		filesView.Clear()
+		isFocused := gui.g.CurrentView().Name() == "files"
+		list, err := utils.RenderList(gui.State.Files, isFocused)
+		if err != nil {
+			return err
+		}
+		fmt.Fprint(filesView, list)

 		if g.CurrentView() == filesView || (g.CurrentView() == gui.getMainView() && g.CurrentView().Context == "merging") {
 			newSelectedFile, _ := gui.getSelectedFile(gui.g)
@@ -165,7 +168,9 @@ func (gui *Gui) enterFile(forceSecondaryFocused bool, selectedLineIdx int) error
 	if file.HasMergeConflicts {
 		return gui.createErrorPanel(gui.g, gui.Tr.SLocalize("FileStagingRequirements"))
 	}
-	gui.changeMainViewsContext("staging")
+	if err := gui.changeMainViewsContext("staging"); err != nil {
+		return err
+	}
 	if err := gui.switchFocus(gui.g, gui.getFilesView(), gui.getMainView()); err != nil {
 		return err
 	}
@@ -186,12 +191,9 @@ func (gui *Gui) handleFilePress(g *gocui.Gui, v *gocui.View) error {
 	}

 	if file.HasUnstagedChanges {
-		err = gui.GitCommand.StageFile(file.Name)
+		gui.GitCommand.StageFile(file.Name)
 	} else {
-		err = gui.GitCommand.UnStageFile(file.Name, file.Tracked)
-	}
-	if err != nil {
-		return gui.createErrorPanel(gui.g, err.Error())
+		gui.GitCommand.UnStageFile(file.Name, file.Tracked)
 	}

 	if err := gui.refreshFiles(); err != nil {
@@ -237,29 +239,16 @@ func (gui *Gui) handleStageAll(g *gocui.Gui, v *gocui.View) error {
 }

 func (gui *Gui) handleIgnoreFile(g *gocui.Gui, v *gocui.View) error {
-	file, err := gui.getSelectedFile(gui.g)
+	file, err := gui.getSelectedFile(g)
 	if err != nil {
-		return gui.createErrorPanel(gui.g, err.Error())
+		return gui.createErrorPanel(g, err.Error())
 	}
-
 	if file.Tracked {
-		return gui.createConfirmationPanel(gui.g, gui.g.CurrentView(), true, gui.Tr.SLocalize("IgnoreTracked"), gui.Tr.SLocalize("IgnoreTrackedPrompt"),
-			// On confirmation
-			func(_ *gocui.Gui, _ *gocui.View) error {
-				if err := gui.GitCommand.Ignore(file.Name); err != nil {
-					return err
-				}
-				if err := gui.GitCommand.RemoveTrackedFiles(file.Name); err != nil {
-					return err
-				}
-				return gui.refreshFiles()
-			}, nil)
+		return gui.createErrorPanel(g, gui.Tr.SLocalize("CantIgnoreTrackFiles"))
 	}
-
 	if err := gui.GitCommand.Ignore(file.Name); err != nil {
-		return gui.createErrorPanel(gui.g, err.Error())
+		return gui.createErrorPanel(g, err.Error())
 	}
-
 	return gui.refreshFiles()
 }

@@ -269,7 +258,9 @@ func (gui *Gui) handleWIPCommitPress(g *gocui.Gui, filesView *gocui.View) error
 		return gui.createErrorPanel(gui.g, gui.Tr.SLocalize("SkipHookPrefixNotConfigured"))
 	}

-	gui.renderString(g, "commitMessage", skipHookPreifx)
+	if err := gui.renderString(g, "commitMessage", skipHookPreifx); err != nil {
+		return err
+	}
 	if err := gui.getCommitMessageView().SetCursor(len(skipHookPreifx), 0); err != nil {
 		return err
 	}
@@ -283,14 +274,8 @@ func (gui *Gui) handleCommitPress(g *gocui.Gui, filesView *gocui.View) error {
 	}
 	commitMessageView := gui.getCommitMessageView()
 	g.Update(func(g *gocui.Gui) error {
-		if _, err := g.SetViewOnTop("commitMessage"); err != nil {
-			return err
-		}
-
-		if err := gui.switchFocus(g, filesView, commitMessageView); err != nil {
-			return err
-		}
-
+		g.SetViewOnTop("commitMessage")
+		gui.switchFocus(g, filesView, commitMessageView)
 		gui.RenderCommitLength()
 		return nil
 	})
@@ -384,35 +369,28 @@ func (gui *Gui) catSelectedFile(g *gocui.Gui) (string, error) {
 		if err != gui.Errors.ErrNoFiles {
 			return "", err
 		}
-		return "", gui.newStringTask("main", gui.Tr.SLocalize("NoFilesDisplay"))
+		return "", gui.renderString(g, "main", gui.Tr.SLocalize("NoFilesDisplay"))
 	}
 	if item.Type != "file" {
-		return "", gui.newStringTask("main", gui.Tr.SLocalize("NotAFile"))
+		return "", gui.renderString(g, "main", gui.Tr.SLocalize("NotAFile"))
 	}
 	cat, err := gui.GitCommand.CatFile(item.Name)
 	if err != nil {
 		gui.Log.Error(err)
-		return "", gui.newStringTask("main", err.Error())
+		return "", gui.renderString(g, "main", err.Error())
 	}
 	return cat, nil
 }

 func (gui *Gui) handlePullFiles(g *gocui.Gui, v *gocui.View) error {
 	// if we have no upstream branch we need to set that first
-	currentBranch := gui.currentBranch()
-	if currentBranch.Pullables == "?" {
-		// see if we have this branch in our config with an upstream
-		conf, err := gui.GitCommand.Repo.Config()
-		if err != nil {
-			return gui.createErrorPanel(gui.g, err.Error())
-		}
-		for branchName, branch := range conf.Branches {
-			if branchName == currentBranch.Name {
-				return gui.pullFiles(v, fmt.Sprintf("%s %s", branch.Remote, branchName))
-			}
-		}
-
-		return gui.createPromptPanel(g, v, gui.Tr.SLocalize("EnterUpstream"), "origin/"+currentBranch.Name, func(g *gocui.Gui, v *gocui.View) error {
+	_, pullables := gui.GitCommand.GetCurrentBranchUpstreamDifferenceCount()
+	currentBranchName, err := gui.GitCommand.CurrentBranchName()
+	if err != nil {
+		return err
+	}
+	if pullables == "?" {
+		return gui.createPromptPanel(g, v, gui.Tr.SLocalize("EnterUpstream"), "origin/"+currentBranchName, func(g *gocui.Gui, v *gocui.View) error {
 			upstream := gui.trimmedContent(v)
 			if err := gui.GitCommand.SetUpstreamBranch(upstream); err != nil {
 				errorMessage := err.Error()
@@ -421,21 +399,21 @@ func (gui *Gui) handlePullFiles(g *gocui.Gui, v *gocui.View) error {
 				}
 				return gui.createErrorPanel(gui.g, errorMessage)
 			}
-			return gui.pullFiles(v, "")
+			return gui.pullFiles(v)
 		})
 	}

-	return gui.pullFiles(v, "")
+	return gui.pullFiles(v)
 }

-func (gui *Gui) pullFiles(v *gocui.View, args string) error {
+func (gui *Gui) pullFiles(v *gocui.View) error {
 	if err := gui.createLoaderPanel(gui.g, v, gui.Tr.SLocalize("PullWait")); err != nil {
 		return err
 	}

 	go func() {
 		unamePassOpend := false
-		err := gui.GitCommand.Pull(args, func(passOrUname string) string {
+		err := gui.GitCommand.Pull(func(passOrUname string) string {
 			unamePassOpend = true
 			return gui.waitForPassUname(gui.g, v, passOrUname)
 		})
@@ -445,14 +423,14 @@ func (gui *Gui) pullFiles(v *gocui.View, args string) error {
 	return nil
 }

-func (gui *Gui) pushWithForceFlag(g *gocui.Gui, v *gocui.View, force bool, upstream string, args string) error {
+func (gui *Gui) pushWithForceFlag(g *gocui.Gui, v *gocui.View, force bool, upstream string) error {
 	if err := gui.createLoaderPanel(gui.g, v, gui.Tr.SLocalize("PushWait")); err != nil {
 		return err
 	}
 	go func() {
 		unamePassOpend := false
 		branchName := gui.getCheckedOutBranch().Name
-		err := gui.GitCommand.Push(branchName, force, upstream, args, func(passOrUname string) string {
+		err := gui.GitCommand.Push(branchName, force, upstream, func(passOrUname string) string {
 			unamePassOpend = true
 			return gui.waitForPassUname(g, v, passOrUname)
 		})
@@ -463,28 +441,21 @@ func (gui *Gui) pushWithForceFlag(g *gocui.Gui, v *gocui.View, force bool, upstr

 func (gui *Gui) pushFiles(g *gocui.Gui, v *gocui.View) error {
 	// if we have pullables we'll ask if the user wants to force push
-	currentBranch := gui.currentBranch()
-
-	if currentBranch.Pullables == "?" {
-		// see if we have this branch in our config with an upstream
-		conf, err := gui.GitCommand.Repo.Config()
-		if err != nil {
-			return gui.createErrorPanel(gui.g, err.Error())
-		}
-		for branchName, branch := range conf.Branches {
-			if branchName == currentBranch.Name {
-				return gui.pushWithForceFlag(g, v, false, "", fmt.Sprintf("%s %s", branch.Remote, branchName))
-			}
-		}
-
-		return gui.createPromptPanel(g, v, gui.Tr.SLocalize("EnterUpstream"), "origin "+currentBranch.Name, func(g *gocui.Gui, v *gocui.View) error {
-			return gui.pushWithForceFlag(g, v, false, gui.trimmedContent(v), "")
-		})
-	} else if currentBranch.Pullables == "0" {
-		return gui.pushWithForceFlag(g, v, false, "", "")
+	_, pullables := gui.GitCommand.GetCurrentBranchUpstreamDifferenceCount()
+	currentBranchName, err := gui.GitCommand.CurrentBranchName()
+	if err != nil {
+		return err
 	}
-	return gui.createConfirmationPanel(g, v, true, gui.Tr.SLocalize("ForcePush"), gui.Tr.SLocalize("ForcePushPrompt"), func(g *gocui.Gui, v *gocui.View) error {
-		return gui.pushWithForceFlag(g, v, true, "", "")
+
+	if pullables == "?" {
+		return gui.createPromptPanel(g, v, gui.Tr.SLocalize("EnterUpstream"), "origin "+currentBranchName, func(g *gocui.Gui, v *gocui.View) error {
+			return gui.pushWithForceFlag(g, v, false, gui.trimmedContent(v))
+		})
+	} else if pullables == "0" {
+		return gui.pushWithForceFlag(g, v, false, "")
+	}
+	return gui.createConfirmationPanel(g, nil, true, gui.Tr.SLocalize("ForcePush"), gui.Tr.SLocalize("ForcePushPrompt"), func(g *gocui.Gui, v *gocui.View) error {
+		return gui.pushWithForceFlag(g, v, true, "")
 	}, nil)
 }

@@ -499,13 +470,24 @@ func (gui *Gui) handleSwitchToMerge(g *gocui.Gui, v *gocui.View) error {
 	if !file.HasInlineMergeConflicts {
 		return gui.createErrorPanel(g, gui.Tr.SLocalize("FileNoMergeCons"))
 	}
-	gui.changeMainViewsContext("merging")
+	if err := gui.changeMainViewsContext("merging"); err != nil {
+		return err
+	}
 	if err := gui.switchFocus(g, v, gui.getMainView()); err != nil {
 		return err
 	}
 	return gui.refreshMergePanel()
 }

+func (gui *Gui) handleAbortMerge(g *gocui.Gui, v *gocui.View) error {
+	if err := gui.GitCommand.AbortMerge(); err != nil {
+		return gui.createErrorPanel(g, err.Error())
+	}
+	gui.createMessagePanel(g, v, "", gui.Tr.SLocalize("MergeAborted"))
+	gui.refreshStatus(g)
+	return gui.refreshFiles()
+}
+
 func (gui *Gui) openFile(filename string) error {
 	if err := gui.OSCommand.OpenFile(filename); err != nil {
 		return gui.createErrorPanel(gui.g, err.Error())
@@ -522,6 +504,67 @@ func (gui *Gui) anyFilesWithMergeConflicts() bool {
 	return false
 }

+type discardOption struct {
+	handler     func(fileName *commands.File) error
+	description string
+}
+
+// GetDisplayStrings is a function.
+func (r *discardOption) GetDisplayStrings(isFocused bool) []string {
+	return []string{r.description}
+}
+
+func (gui *Gui) handleCreateDiscardMenu(g *gocui.Gui, v *gocui.View) error {
+	file, err := gui.getSelectedFile(g)
+	if err != nil {
+		if err != gui.Errors.ErrNoFiles {
+			return err
+		}
+		return nil
+	}
+
+	options := []*discardOption{
+		{
+			description: gui.Tr.SLocalize("discardAllChanges"),
+			handler: func(file *commands.File) error {
+				return gui.GitCommand.DiscardAllFileChanges(file)
+			},
+		},
+		{
+			description: gui.Tr.SLocalize("cancel"),
+			handler: func(file *commands.File) error {
+				return nil
+			},
+		},
+	}
+
+	if file.HasStagedChanges && file.HasUnstagedChanges {
+		discardUnstagedChanges := &discardOption{
+			description: gui.Tr.SLocalize("discardUnstagedChanges"),
+			handler: func(file *commands.File) error {
+				return gui.GitCommand.DiscardUnstagedFileChanges(file)
+			},
+		}
+
+		options = append(options[:1], append([]*discardOption{discardUnstagedChanges}, options[1:]...)...)
+	}
+
+	handleMenuPress := func(index int) error {
+		file, err := gui.getSelectedFile(g)
+		if err != nil {
+			return err
+		}
+
+		if err := options[index].handler(file); err != nil {
+			return err
+		}
+
+		return gui.refreshFiles()
+	}
+
+	return gui.createMenu(file.Name, options, len(options), handleMenuPress)
+}
+
 func (gui *Gui) handleCustomCommand(g *gocui.Gui, v *gocui.View) error {
 	return gui.createPromptPanel(g, v, gui.Tr.SLocalize("CustomCommand"), "", func(g *gocui.Gui, v *gocui.View) error {
 		command := gui.trimmedContent(v)
@@ -530,34 +573,45 @@ func (gui *Gui) handleCustomCommand(g *gocui.Gui, v *gocui.View) error {
 	})
 }

+type stashOption struct {
+	description string
+	handler     func() error
+}
+
+// GetDisplayStrings is a function.
+func (o *stashOption) GetDisplayStrings(isFocused bool) []string {
+	return []string{o.description}
+}
+
 func (gui *Gui) handleCreateStashMenu(g *gocui.Gui, v *gocui.View) error {
-	menuItems := []*menuItem{
+	options := []*stashOption{
 		{
-			displayString: gui.Tr.SLocalize("stashAllChanges"),
-			onPress: func() error {
+			description: gui.Tr.SLocalize("stashAllChanges"),
+			handler: func() error {
 				return gui.handleStashSave(gui.GitCommand.StashSave)
 			},
 		},
 		{
-			displayString: gui.Tr.SLocalize("stashStagedChanges"),
-			onPress: func() error {
+			description: gui.Tr.SLocalize("stashStagedChanges"),
+			handler: func() error {
 				return gui.handleStashSave(gui.GitCommand.StashSaveStagedChanges)
 			},
 		},
+		{
+			description: gui.Tr.SLocalize("cancel"),
+			handler: func() error {
+				return nil
+			},
+		},
 	}

-	return gui.createMenu(gui.Tr.SLocalize("stashOptions"), menuItems, createMenuOptions{showCancel: true})
+	handleMenuPress := func(index int) error {
+		return options[index].handler()
+	}
+
+	return gui.createMenu(gui.Tr.SLocalize("stashOptions"), options, len(options), handleMenuPress)
 }

 func (gui *Gui) handleStashChanges(g *gocui.Gui, v *gocui.View) error {
 	return gui.handleStashSave(gui.GitCommand.StashSave)
 }
-
-func (gui *Gui) handleCreateResetToUpstreamMenu(g *gocui.Gui, v *gocui.View) error {
-	return gui.createResetMenu("@{upstream}")
-}
-
-func (gui *Gui) onFilesPanelSearchSelect(selectedLine int) error {
-	gui.State.Panels.Files.SelectedLine = selectedLine
-	return gui.focusAndSelectFile(gui.g, gui.getFilesView())
-}
@@ -8,6 +8,11 @@ import (
 	"github.com/jesseduffield/gocui"
 )

+type gitFlowOption struct {
+	handler     func() error
+	description string
+}
+
 func (gui *Gui) gitFlowFinishBranch(gitFlowConfig string, branchName string) error {
 	// need to find out what kind of branch this is
 	prefix := strings.SplitAfterN(branchName, "/", 2)[0]
@@ -36,6 +41,11 @@ func (gui *Gui) gitFlowFinishBranch(gitFlowConfig string, branchName string) err
 	return gui.Errors.ErrSubProcess
 }

+// GetDisplayStrings is a function.
+func (r *gitFlowOption) GetDisplayStrings(isFocused bool) []string {
+	return []string{r.description}
+}
+
 func (gui *Gui) handleCreateGitFlowMenu(g *gocui.Gui, v *gocui.View) error {
 	branch := gui.getSelectedBranch()
 	if branch == nil {
@@ -60,27 +70,37 @@ func (gui *Gui) handleCreateGitFlowMenu(g *gocui.Gui, v *gocui.View) error {
 		}
 	}

-	menuItems := []*menuItem{
+	options := []*gitFlowOption{
 		{
 			// not localising here because it's one to one with the actual git flow commands
-			displayString: fmt.Sprintf("finish branch '%s'", branch.Name),
-			onPress: func() error {
+			description: fmt.Sprintf("finish branch '%s'", branch.Name),
+			handler: func() error {
 				return gui.gitFlowFinishBranch(gitFlowConfig, branch.Name)
 			},
 		},
 		{
-			displayString: "start feature",
-			onPress:       startHandler("feature"),
+			description: "start feature",
+			handler:     startHandler("feature"),
 		},
 		{
-			displayString: "start hotfix",
-			onPress:       startHandler("hotfix"),
+			description: "start hotfix",
+			handler:     startHandler("hotfix"),
 		},
 		{
-			displayString: "start release",
-			onPress:       startHandler("release"),
+			description: "start release",
+			handler:     startHandler("release"),
+		},
+		{
+			description: gui.Tr.SLocalize("cancel"),
+			handler: func() error {
+				return nil
+			},
 		},
 	}

-	return gui.createMenu("git flow", menuItems, createMenuOptions{})
+	handleMenuPress := func(index int) error {
+		return options[index].handler()
+	}
+
+	return gui.createMenu("git flow", options, len(options), handleMenuPress)
 }
@@ -25,7 +25,6 @@ import (
 	"github.com/jesseduffield/lazygit/pkg/commands"
 	"github.com/jesseduffield/lazygit/pkg/config"
 	"github.com/jesseduffield/lazygit/pkg/i18n"
-	"github.com/jesseduffield/lazygit/pkg/tasks"
 	"github.com/jesseduffield/lazygit/pkg/theme"
 	"github.com/jesseduffield/lazygit/pkg/updates"
 	"github.com/jesseduffield/lazygit/pkg/utils"
@@ -33,12 +32,6 @@ import (
 	"github.com/sirupsen/logrus"
 )

-const (
-	SCREEN_NORMAL int = iota
-	SCREEN_HALF
-	SCREEN_FULL
-)
-
 const StartupPopupVersion = 1

 // OverlappingEdges determines if panel edges overlap
@@ -75,22 +68,20 @@ type Teml i18n.Teml

 // Gui wraps the gocui Gui object which handles rendering and events
 type Gui struct {
-	g                    *gocui.Gui
-	Log                  *logrus.Entry
-	GitCommand           *commands.GitCommand
-	OSCommand            *commands.OSCommand
-	SubProcess           *exec.Cmd
-	State                *guiState
-	Config               config.AppConfigurer
-	Tr                   *i18n.Localizer
-	Errors               SentinelErrors
-	Updater              *updates.Updater
-	statusManager        *statusManager
-	credentials          credentials
-	waitForIntro         sync.WaitGroup
-	fileWatcher          *fileWatcher
-	viewBufferManagerMap map[string]*tasks.ViewBufferManager
-	stopChan             chan struct{}
+	g             *gocui.Gui
+	Log           *logrus.Entry
+	GitCommand    *commands.GitCommand
+	OSCommand     *commands.OSCommand
+	SubProcess    *exec.Cmd
+	State         guiState
+	Config        config.AppConfigurer
+	Tr            *i18n.Localizer
+	Errors        SentinelErrors
+	Updater       *updates.Updater
+	statusManager *statusManager
+	credentials   credentials
+	waitForIntro  sync.WaitGroup
+	fileWatcher   *fileWatcher
 }

 // for now the staging panel state, unlike the other panel states, is going to be
@@ -137,11 +128,6 @@ type tagsPanelState struct {
 type commitPanelState struct {
 	SelectedLine     int
 	SpecificDiffMode bool
-	LimitCommits     bool
-}
-
-type reflogCommitPanelState struct {
-	SelectedLine int
 }

 type stashPanelState struct {
@@ -169,7 +155,6 @@ type panelStates struct {
 	RemoteBranches *remoteBranchesState
 	Tags           *tagsPanelState
 	Commits        *commitPanelState
-	ReflogCommits  *reflogCommitPanelState
 	Stash          *stashPanelState
 	Menu           *menuPanelState
 	LineByLine     *lineByLinePanelState
@@ -178,19 +163,12 @@ type panelStates struct {
 	Status         *statusPanelState
 }

-type searchingState struct {
-	view         *gocui.View
-	isSearching  bool
-	searchString string
-}
-
 type guiState struct {
 	Files                []*commands.File
 	Branches             []*commands.Branch
 	Commits              []*commands.Commit
 	StashEntries         []*commands.StashEntry
 	CommitFiles          []*commands.CommitFile
-	ReflogCommits        []*commands.Commit
 	DiffEntries          []*commands.Commit
 	Remotes              []*commands.Remote
 	RemoteBranches       []*commands.RemoteBranch
@@ -207,13 +185,6 @@ type guiState struct {
 	RetainOriginalDir    bool
 	IsRefreshingFiles    bool
 	RefreshingFilesMutex sync.Mutex
-	Searching            searchingState
-	ScreenMode           int
-	SideView             *gocui.View
-	Ptmx                 *os.File
-	PrevMainWidth        int
-	PrevMainHeight       int
-	OldInformation       string
 }

 // for now the split view will always be on
@@ -221,7 +192,7 @@ type guiState struct {
 // NewGui builds a new gui handler
 func NewGui(log *logrus.Entry, gitCommand *commands.GitCommand, oSCommand *commands.OSCommand, tr *i18n.Localizer, config config.AppConfigurer, updater *updates.Updater) (*Gui, error) {

-	initialState := &guiState{
+	initialState := guiState{
 		Files:               make([]*commands.File, 0),
 		PreviousView:        "files",
 		Commits:             make([]*commands.Commit, 0),
@@ -235,8 +206,7 @@ func NewGui(log *logrus.Entry, gitCommand *commands.GitCommand, oSCommand *comma
 			Remotes:        &remotePanelState{SelectedLine: 0},
 			RemoteBranches: &remoteBranchesState{SelectedLine: -1},
 			Tags:           &tagsPanelState{SelectedLine: -1},
-			Commits:        &commitPanelState{SelectedLine: -1, LimitCommits: true},
-			ReflogCommits:  &reflogCommitPanelState{SelectedLine: 0}, // TODO: might need to make -1
+			Commits:        &commitPanelState{SelectedLine: -1},
 			CommitFiles:    &commitFilesPanelState{SelectedLine: -1},
 			Stash:          &stashPanelState{SelectedLine: -1},
 			Menu:           &menuPanelState{SelectedLine: 0},
@@ -248,21 +218,17 @@ func NewGui(log *logrus.Entry, gitCommand *commands.GitCommand, oSCommand *comma
 			},
 			Status: &statusPanelState{},
 		},
-		ScreenMode: SCREEN_NORMAL,
-		SideView:   nil,
-		Ptmx:       nil,
 	}

 	gui := &Gui{
-		Log:                  log,
-		GitCommand:           gitCommand,
-		OSCommand:            oSCommand,
-		State:                initialState,
-		Config:               config,
-		Tr:                   tr,
-		Updater:              updater,
-		statusManager:        &statusManager{},
-		viewBufferManagerMap: map[string]*tasks.ViewBufferManager{},
+		Log:           log,
+		GitCommand:    gitCommand,
+		OSCommand:     oSCommand,
+		State:         initialState,
+		Config:        config,
+		Tr:            tr,
+		Updater:       updater,
+		statusManager: &statusManager{},
 	}

 	gui.watchFilesForChanges()
@@ -272,34 +238,6 @@ func NewGui(log *logrus.Entry, gitCommand *commands.GitCommand, oSCommand *comma
 	return gui, nil
 }

-func (gui *Gui) nextScreenMode(g *gocui.Gui, v *gocui.View) error {
-	gui.State.ScreenMode = utils.NextIntInCycle([]int{SCREEN_NORMAL, SCREEN_HALF, SCREEN_FULL}, gui.State.ScreenMode)
-	// commits render differently depending on whether we're in fullscreen more or not
-	if err := gui.refreshCommitsViewWithSelection(); err != nil {
-		return err
-	}
-	// same with branches
-	if err := gui.refreshBranchesViewWithSelection(); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (gui *Gui) prevScreenMode(g *gocui.Gui, v *gocui.View) error {
-	gui.State.ScreenMode = utils.PrevIntInCycle([]int{SCREEN_NORMAL, SCREEN_HALF, SCREEN_FULL}, gui.State.ScreenMode)
-	// commits render differently depending on whether we're in fullscreen more or not
-	if err := gui.refreshCommitsViewWithSelection(); err != nil {
-		return err
-	}
-	// same with branches
-	if err := gui.refreshBranchesViewWithSelection(); err != nil {
-		return err
-	}
-
-	return nil
-}
-
 func (gui *Gui) scrollUpView(viewName string) error {
 	mainView, _ := gui.g.View(viewName)
 	ox, oy := mainView.Origin()
@@ -315,14 +253,8 @@ func (gui *Gui) scrollDownView(viewName string) error {
 		_, sy := mainView.Size()
 		y += sy
 	}
-	scrollHeight := gui.Config.GetUserConfig().GetInt("gui.scrollHeight")
-	if y < mainView.LinesHeight() {
-		if err := mainView.SetOrigin(ox, oy+scrollHeight); err != nil {
-			return err
-		}
-	}
-	if manager, ok := gui.viewBufferManagerMap[viewName]; ok {
-		manager.ReadLines(scrollHeight)
+	if y < len(mainView.BufferLines()) {
+		return mainView.SetOrigin(ox, oy+gui.Config.GetUserConfig().GetInt("gui.scrollHeight"))
 	}
 	return nil
 }
@@ -388,15 +320,20 @@ func (gui *Gui) onFocusLost(v *gocui.View, newView *gocui.View) error {
 	if v == nil {
 		return nil
 	}
-	if v.IsSearching() && newView.Name() != "search" {
-		if err := gui.onSearchEscape(); err != nil {
-			return err
-		}
-	}
 	switch v.Name() {
+	case "branches":
+		if v.Context == "local-branches" {
+			// This stops the branches panel from showing the upstream/downstream changes to the selected branch, when it loses focus
+			// inside renderListPanel it checks to see if the panel has focus
+			if err := gui.renderListPanel(gui.getBranchesView(), gui.State.Branches); err != nil {
+				return err
+			}
+		}
 	case "main":
 		// if we have lost focus to a first-class panel, we need to do some cleanup
-		gui.changeMainViewsContext("normal")
+		if err := gui.changeMainViewsContext("normal"); err != nil {
+			return err
+		}
 	case "commitFiles":
 		if gui.State.MainContext != "patch-building" {
 			if _, err := gui.g.SetViewOnBottom(v.Name()); err != nil {
@@ -416,75 +353,6 @@ func (gui *Gui) onFocus(v *gocui.View) error {
 	return nil
 }

-func (gui *Gui) getViewHeights() map[string]int {
-	currView := gui.g.CurrentView()
-	currentCyclebleView := gui.State.PreviousView
-	if currView != nil {
-		viewName := currView.Name()
-		usePreviousView := true
-		for _, view := range cyclableViews {
-			if view == viewName {
-				currentCyclebleView = viewName
-				usePreviousView = false
-				break
-			}
-		}
-		if usePreviousView {
-			currentCyclebleView = gui.State.PreviousView
-		}
-	}
-
-	// unfortunate result of the fact that these are separate views, have to map explicitly
-	if currentCyclebleView == "commitFiles" {
-		currentCyclebleView = "commits"
-	}
-
-	_, height := gui.g.Size()
-
-	if gui.State.ScreenMode == SCREEN_FULL || gui.State.ScreenMode == SCREEN_HALF {
-		vHeights := map[string]int{
-			"status":   0,
-			"files":    0,
-			"branches": 0,
-			"commits":  0,
-			"stash":    0,
-			"options":  0,
-		}
-		vHeights[currentCyclebleView] = height - 1
-		return vHeights
-	}
-
-	usableSpace := height - 7
-	extraSpace := usableSpace - (usableSpace/3)*3
-
-	if height >= 28 {
-		return map[string]int{
-			"status":   3,
-			"files":    (usableSpace / 3) + extraSpace,
-			"branches": usableSpace / 3,
-			"commits":  usableSpace / 3,
-			"stash":    3,
-			"options":  1,
-		}
-	}
-
-	defaultHeight := 3
-	if height < 21 {
-		defaultHeight = 1
-	}
-	vHeights := map[string]int{
-		"status":   defaultHeight,
-		"files":    defaultHeight,
-		"branches": defaultHeight,
-		"commits":  defaultHeight,
-		"stash":    defaultHeight,
-		"options":  defaultHeight,
-	}
-	vHeights[currentCyclebleView] = height - defaultHeight*4 - 1
-
-	return vHeights
-}
-
 // layout is called for every screen re-render e.g. when the screen is resized
 func (gui *Gui) layout(g *gocui.Gui) error {
 	g.Highlight = true
@@ -495,9 +363,6 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 		donate := color.New(color.FgMagenta, color.Underline).Sprint(gui.Tr.SLocalize("Donate"))
 		information = donate + " " + information
 	}
-	if len(gui.State.CherryPickedCommits) > 0 {
-		information = utils.ColoredString(fmt.Sprintf("%d commits copied", len(gui.State.CherryPickedCommits)), color.FgCyan)
-	}

 	minimumHeight := 9
 	minimumWidth := 10
@@ -514,7 +379,50 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 		return nil
 	}

-	vHeights := gui.getViewHeights()
+	currView := gui.g.CurrentView()
+	currentCyclebleView := gui.State.PreviousView
+	if currView != nil {
+		viewName := currView.Name()
+		usePreviouseView := true
+		for _, view := range cyclableViews {
+			if view == viewName {
+				currentCyclebleView = viewName
+				usePreviouseView = false
+				break
+			}
+		}
+		if usePreviouseView {
+			currentCyclebleView = gui.State.PreviousView
+		}
+	}
+
+	usableSpace := height - 7
+	extraSpace := usableSpace - (usableSpace/3)*3
+
+	vHeights := map[string]int{
+		"status":   3,
+		"files":    (usableSpace / 3) + extraSpace,
+		"branches": usableSpace / 3,
+		"commits":  usableSpace / 3,
+		"stash":    3,
+		"options":  1,
+	}
+
+	if height < 28 {
+		defaultHeight := 3
+		if height < 21 {
+			defaultHeight = 1
+		}
+		vHeights = map[string]int{
+			"status":   defaultHeight,
+			"files":    defaultHeight,
+			"branches": defaultHeight,
+			"commits":  defaultHeight,
+			"stash":    defaultHeight,
+			"options":  defaultHeight,
+		}
+		vHeights[currentCyclebleView] = height - defaultHeight*4 - 1
+	}

 	optionsVersionBoundary := width - max(len(utils.Decolorise(information)), 1)

@@ -524,50 +432,21 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 		appStatusOptionsBoundary = len(appStatus) + 2
 	}

-	_, _ = g.SetViewOnBottom("limit")
-	_ = g.DeleteView("limit")
-
-	sidePanelWidthRatio := gui.Config.GetUserConfig().GetFloat64("gui.sidePanelWidth")
-
-	textColor := theme.GocuiDefaultTextColor
-	var leftSideWidth int
-	switch gui.State.ScreenMode {
-	case SCREEN_NORMAL:
-		leftSideWidth = int(float64(width) * sidePanelWidthRatio)
-	case SCREEN_HALF:
-		leftSideWidth = width / 2
-	case SCREEN_FULL:
-		currentView := gui.g.CurrentView()
-		if currentView != nil && currentView.Name() == "main" {
-			leftSideWidth = 0
-		} else {
-			leftSideWidth = width - 1
-		}
+	panelSpacing := 1
+	if OverlappingEdges {
+		panelSpacing = 0
 	}

-	mainPanelLeft := leftSideWidth + 1
-	mainPanelRight := width - 1
-	secondaryPanelLeft := width - 1
-	secondaryPanelTop := 0
-	mainPanelBottom := height - 2
+	_, _ = g.SetViewOnBottom("limit")
+	g.DeleteView("limit")
+
+	textColor := theme.GocuiDefaultTextColor
+	leftSideWidth := width / 3
+	panelSplitX := width - 1
 	if gui.State.SplitMainPanel {
-		if gui.State.ScreenMode == SCREEN_FULL {
-			mainPanelLeft = 0
-			panelSplitX := width/2 - 4
-			mainPanelRight = panelSplitX
-			secondaryPanelLeft = panelSplitX + 1
-		} else if width < 220 {
-			mainPanelBottom = height/2 - 1
-			secondaryPanelTop = mainPanelBottom + 1
-			secondaryPanelLeft = leftSideWidth + 1
-		} else {
-			units := 5
-			leftSideWidth = width / units
-			mainPanelLeft = leftSideWidth + 1
-			panelSplitX := (1 + ((units - 1) / 2)) * width / units
-			mainPanelRight = panelSplitX
-			secondaryPanelLeft = panelSplitX + 1
-		}
+		units := 7
+		leftSideWidth = width / units
+		panelSplitX = (1 + ((units - 1) / 2)) * width / units
 	}

 	main := "main"
@@ -578,22 +457,7 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 		secondary = "main"
 	}

-	// reading more lines into main view buffers upon resize
-	prevMainView, err := gui.g.View("main")
-	if err == nil {
-		_, prevMainHeight := prevMainView.Size()
-		heightDiff := mainPanelBottom - prevMainHeight - 1
-		if heightDiff > 0 {
-			if manager, ok := gui.viewBufferManagerMap["main"]; ok {
-				manager.ReadLines(heightDiff)
-			}
-			if manager, ok := gui.viewBufferManagerMap["secondary"]; ok {
-				manager.ReadLines(heightDiff)
-			}
-		}
-	}
-
-	v, err := g.SetView(main, mainPanelLeft, 0, mainPanelRight, mainPanelBottom, gocui.LEFT)
+	v, err := g.SetView(main, leftSideWidth+panelSpacing, 0, panelSplitX, height-2, gocui.LEFT)
 	if err != nil {
 		if err.Error() != "unknown view" {
 			return err
@@ -601,16 +465,13 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 		v.Title = gui.Tr.SLocalize("DiffTitle")
 		v.Wrap = true
 		v.FgColor = textColor
-		v.IgnoreCarriageReturns = true
 	}

-	hiddenViewOffset := 9999
-
-	hiddenSecondaryPanelOffset := 0
+	hiddenViewOffset := 0
 	if !gui.State.SplitMainPanel {
-		hiddenSecondaryPanelOffset = hiddenViewOffset
+		hiddenViewOffset = 9999
 	}
-	secondaryView, err := g.SetView(secondary, secondaryPanelLeft+hiddenSecondaryPanelOffset, hiddenSecondaryPanelOffset+secondaryPanelTop, width-1+hiddenSecondaryPanelOffset, height-2+hiddenSecondaryPanelOffset, gocui.LEFT)
+	secondaryView, err := g.SetView(secondary, panelSplitX+1+hiddenViewOffset, hiddenViewOffset, width-1+hiddenViewOffset, height-2+hiddenViewOffset, gocui.LEFT)
 	if err != nil {
 		if err.Error() != "unknown view" {
 			return err
@@ -618,7 +479,6 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 		secondaryView.Title = gui.Tr.SLocalize("DiffTitle")
 		secondaryView.Wrap = true
 		secondaryView.FgColor = gocui.ColorWhite
-		secondaryView.IgnoreCarriageReturns = true
 	}

 	if v, err := g.SetView("status", 0, 0, leftSideWidth, vHeights["status"]-1, gocui.BOTTOM|gocui.RIGHT); err != nil {
@@ -636,8 +496,7 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 		}
 		filesView.Highlight = true
 		filesView.Title = gui.Tr.SLocalize("FilesTitle")
-		filesView.SetOnSelectItem(gui.onSelectItemWrapper(gui.onFilesPanelSearchSelect))
-		filesView.ContainsList = true
+		v.FgColor = textColor
 	}

 	branchesView, err := g.SetViewBeneath("branches", "files", vHeights["branches"])
@@ -648,8 +507,6 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 		branchesView.Title = gui.Tr.SLocalize("BranchesTitle")
 		branchesView.Tabs = []string{"Local Branches", "Remotes", "Tags"}
 		branchesView.FgColor = textColor
-		branchesView.SetOnSelectItem(gui.onSelectItemWrapper(gui.onBranchesPanelSearchSelect))
-		branchesView.ContainsList = true
 	}

 	if v, err := g.SetViewBeneath("commitFiles", "branches", vHeights["commits"]); err != nil {
@@ -658,8 +515,6 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 		}
 		v.Title = gui.Tr.SLocalize("CommitFiles")
 		v.FgColor = textColor
-		v.SetOnSelectItem(gui.onSelectItemWrapper(gui.onCommitFilesPanelSearchSelect))
-		v.ContainsList = true
 	}

 	commitsView, err := g.SetViewBeneath("commits", "branches", vHeights["commits"])
@@ -668,10 +523,7 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 			return err
 		}
 		commitsView.Title = gui.Tr.SLocalize("CommitsTitle")
-		commitsView.Tabs = []string{"Commits", "Reflog"}
 		commitsView.FgColor = textColor
-		commitsView.SetOnSelectItem(gui.onSelectItemWrapper(gui.onCommitsPanelSearchSelect))
-		commitsView.ContainsList = true
 	}

 	stashView, err := g.SetViewBeneath("stash", "commits", vHeights["stash"])
@@ -681,8 +533,6 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 		}
 		stashView.Title = gui.Tr.SLocalize("StashTitle")
 		stashView.FgColor = textColor
-		stashView.SetOnSelectItem(gui.onSelectItemWrapper(gui.onStashPanelSearchSelect))
-		stashView.ContainsList = true
 	}

 	if v, err := g.SetView("options", appStatusOptionsBoundary-1, height-2, optionsVersionBoundary-1, height, 0); err != nil {
@@ -690,16 +540,17 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 			return err
 		}
 		v.Frame = false
-		v.FgColor = theme.OptionsColor
+		userConfig := gui.Config.GetUserConfig()
+		v.FgColor = theme.GetColor(userConfig.GetStringSlice("gui.theme.optionsTextColor"))
 	}

 	if gui.getCommitMessageView() == nil {
 		// doesn't matter where this view starts because it will be hidden
-		if commitMessageView, err := g.SetView("commitMessage", hiddenViewOffset, hiddenViewOffset, hiddenViewOffset+10, hiddenViewOffset+10, 0); err != nil {
+		if commitMessageView, err := g.SetView("commitMessage", width, height, width*2, height*2, 0); err != nil {
 			if err.Error() != "unknown view" {
 				return err
 			}
-			_, _ = g.SetViewOnBottom("commitMessage")
+			g.SetViewOnBottom("commitMessage")
 			commitMessageView.Title = gui.Tr.SLocalize("CommitMessage")
 			commitMessageView.FgColor = textColor
 			commitMessageView.Editable = true
@@ -709,7 +560,7 @@ func (gui *Gui) layout(g *gocui.Gui) error {

 	if check, _ := g.View("credentials"); check == nil {
 		// doesn't matter where this view starts because it will be hidden
-		if credentialsView, err := g.SetView("credentials", hiddenViewOffset, hiddenViewOffset, hiddenViewOffset+10, hiddenViewOffset+10, 0); err != nil {
+		if credentialsView, err := g.SetView("credentials", width, height, width*2, height*2, 0); err != nil {
 			if err.Error() != "unknown view" {
 				return err
 			}
@@ -723,35 +574,6 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 		}
 	}

-	searchViewOffset := hiddenViewOffset
-	if gui.State.Searching.isSearching {
-		searchViewOffset = 0
-	}
-
-	// this view takes up one character. Its only purpose is to show the slash when searching
-	searchPrefix := "search: "
-	if searchPrefixView, err := g.SetView("searchPrefix", appStatusOptionsBoundary-1+searchViewOffset, height-2+searchViewOffset, len(searchPrefix)+searchViewOffset, height+searchViewOffset, 0); err != nil {
-		if err.Error() != "unknown view" {
-			return err
-		}
-
-		searchPrefixView.BgColor = gocui.ColorDefault
-		searchPrefixView.FgColor = gocui.ColorGreen
-		searchPrefixView.Frame = false
-		gui.setViewContent(gui.g, searchPrefixView, searchPrefix)
-	}
-
-	if searchView, err := g.SetView("search", appStatusOptionsBoundary-1+searchViewOffset+len(searchPrefix), height-2+searchViewOffset, optionsVersionBoundary+searchViewOffset, height+searchViewOffset, 0); err != nil {
-		if err.Error() != "unknown view" {
-			return err
-		}
-
-		searchView.BgColor = gocui.ColorDefault
-		searchView.FgColor = gocui.ColorGreen
-		searchView.Frame = false
-		searchView.Editable = true
-	}
-
 	if appStatusView, err := g.SetView("appStatus", -1, height-2, width, height, 0); err != nil {
 		if err.Error() != "unknown view" {
 			return err
@@ -764,25 +586,22 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 		}
 	}

-	informationView, err := g.SetView("information", optionsVersionBoundary-1, height-2, width, height, 0)
-	if err != nil {
+	if v, err := g.SetView("information", optionsVersionBoundary-1, height-2, width, height, 0); err != nil {
 		if err.Error() != "unknown view" {
 			return err
 		}
-		informationView.BgColor = gocui.ColorDefault
-		informationView.FgColor = gocui.ColorGreen
-		informationView.Frame = false
-		gui.renderString(g, "information", information)
+		v.BgColor = gocui.ColorDefault
+		v.FgColor = gocui.ColorGreen
+		v.Frame = false
+		if err := gui.renderString(g, "information", information); err != nil {
+			return err
+		}

 		// doing this here because it'll only happen once
 		if err := gui.onInitialViewsCreation(); err != nil {
 			return err
 		}
 	}
-	if gui.State.OldInformation != information {
-		gui.setViewContent(g, informationView, information)
-		gui.State.OldInformation = information
-	}

 	if gui.g.CurrentView() == nil {
 		if _, err := gui.g.SetCurrentView(gui.getFilesView().Name()); err != nil {
@@ -806,8 +625,7 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 		{view: branchesView, context: "local-branches", selectedLine: gui.State.Panels.Branches.SelectedLine, lineCount: len(gui.State.Branches)},
 		{view: branchesView, context: "remotes", selectedLine: gui.State.Panels.Remotes.SelectedLine, lineCount: len(gui.State.Remotes)},
 		{view: branchesView, context: "remote-branches", selectedLine: gui.State.Panels.RemoteBranches.SelectedLine, lineCount: len(gui.State.Remotes)},
-		{view: commitsView, context: "branch-commits", selectedLine: gui.State.Panels.Commits.SelectedLine, lineCount: len(gui.State.Commits)},
-		{view: commitsView, context: "reflog-commits", selectedLine: gui.State.Panels.ReflogCommits.SelectedLine, lineCount: len(gui.State.ReflogCommits)},
+		{view: commitsView, context: "", selectedLine: gui.State.Panels.Commits.SelectedLine, lineCount: len(gui.State.Commits)},
 		{view: stashView, context: "", selectedLine: gui.State.Panels.Stash.SelectedLine, lineCount: len(gui.State.StashEntries)},
 	}

@@ -821,14 +639,7 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 			continue
 		}
 		// check if the selected line is now out of view and if so refocus it
-		listView.view.FocusPoint(0, listView.selectedLine)
-	}
-
-	mainViewWidth, mainViewHeight := gui.getMainView().Size()
-	if mainViewWidth != gui.State.PrevMainWidth || mainViewHeight != gui.State.PrevMainHeight {
-		gui.State.PrevMainWidth = mainViewWidth
-		gui.State.PrevMainHeight = mainViewHeight
-		if err := gui.onResize(); err != nil {
+		if err := gui.focusPoint(0, listView.selectedLine, listView.lineCount, listView.view); err != nil {
 			return err
 		}
 	}
@@ -841,10 +652,11 @@ func (gui *Gui) layout(g *gocui.Gui) error {
 }

 func (gui *Gui) onInitialViewsCreation() error {
-	gui.changeMainViewsContext("normal")
+	if err := gui.changeMainViewsContext("normal"); err != nil {
+		return err
+	}

 	gui.getBranchesView().Context = "local-branches"
-	gui.getCommitsView().Context = "branch-commits"

 	return gui.loadNewRepo()
 }
@@ -916,32 +728,32 @@ func (gui *Gui) fetch(g *gocui.Gui, v *gocui.View, canAskForCredentials bool) (u
 		_ = gui.createConfirmationPanel(g, v, true, gui.Tr.SLocalize("Error"), coloredMessage, close, close)
 	}

-	_ = gui.refreshStatus(g)
-
+	gui.refreshStatus(g)
 	return unamePassOpend, err
 }

+func (gui *Gui) renderAppStatus() error {
+	appStatus := gui.statusManager.getStatusString()
+	if appStatus != "" {
+		return gui.renderString(gui.g, "appStatus", appStatus)
+	}
+	return nil
+}
+
 func (gui *Gui) renderGlobalOptions() error {
 	return gui.renderOptionsMap(map[string]string{
 		fmt.Sprintf("%s/%s", gui.getKeyDisplay("universal.scrollUpMain"), gui.getKeyDisplay("universal.scrollDownMain")):                                                                                 gui.Tr.SLocalize("scroll"),
 		fmt.Sprintf("%s %s %s %s", gui.getKeyDisplay("universal.prevBlock"), gui.getKeyDisplay("universal.nextBlock"), gui.getKeyDisplay("universal.prevItem"), gui.getKeyDisplay("universal.nextItem")): gui.Tr.SLocalize("navigate"),
 		fmt.Sprintf("%s/%s", gui.getKeyDisplay("universal.return"), gui.getKeyDisplay("universal.quit")):                                                                                                 gui.Tr.SLocalize("close"),
-		gui.getKeyDisplay("universal.optionMenu"): gui.Tr.SLocalize("menu"),
+		fmt.Sprintf("%s", gui.getKeyDisplay("universal.optionMenu")):                                                                                                                                     gui.Tr.SLocalize("menu"),
 		"1-5": gui.Tr.SLocalize("jump"),
 	})
 }

-func (gui *Gui) goEvery(interval time.Duration, stop chan struct{}, function func() error) {
+func (gui *Gui) goEvery(interval time.Duration, function func() error) {
 	go func() {
-		ticker := time.NewTicker(interval)
-		defer ticker.Stop()
-		for {
-			select {
-			case <-ticker.C:
-				_ = function()
-			case <-stop:
-				return
-			}
+		for range time.Tick(interval) {
+			_ = function()
 		}
 	}()
 }
@@ -956,7 +768,7 @@ func (gui *Gui) startBackgroundFetch() {
 	if err != nil && strings.Contains(err.Error(), "exit status 128") && isNew {
 		_ = gui.createConfirmationPanel(gui.g, gui.g.CurrentView(), true, gui.Tr.SLocalize("NoAutomaticGitFetchTitle"), gui.Tr.SLocalize("NoAutomaticGitFetchBody"), nil, nil)
 	} else {
-		gui.goEvery(time.Second*60, gui.stopChan, func() error {
+		gui.goEvery(time.Second*60, func() error {
 			_, err := gui.fetch(gui.g, gui.g.CurrentView(), false)
 			return err
 		})
@@ -965,19 +777,12 @@ func (gui *Gui) startBackgroundFetch() {

 // Run setup the gui with keybindings and start the mainloop
 func (gui *Gui) Run() error {
-	g, err := gocui.NewGui(gocui.Output256, OverlappingEdges)
+	g, err := gocui.NewGui(gocui.OutputNormal, OverlappingEdges)
 	if err != nil {
 		return err
 	}
 	defer g.Close()

-	g.OnSearchEscape = gui.onSearchEscape
-	g.SearchEscapeKey = gui.getKey("universal.return")
-	g.NextSearchMatchKey = gui.getKey("universal.nextMatch")
-	g.PrevSearchMatchKey = gui.getKey("universal.prevMatch")
-
-	gui.stopChan = make(chan struct{})
-
 	g.ASCII = runtime.GOOS == "windows" && runewidth.IsEastAsian()

 	if gui.Config.GetUserConfig().GetBool("gui.mouseEvents") {
@@ -1006,7 +811,8 @@ func (gui *Gui) Run() error {
 		go gui.startBackgroundFetch()
 	}

-	gui.goEvery(time.Second*10, gui.stopChan, gui.refreshFiles)
+	gui.goEvery(time.Second*10, gui.refreshFiles)
+	gui.goEvery(time.Millisecond*50, gui.renderAppStatus)

 	g.SetManager(gocui.ManagerFunc(gui.layout), gocui.ManagerFunc(gui.getFocusLayout()))

@@ -1026,17 +832,6 @@ func (gui *Gui) Run() error {
 func (gui *Gui) RunWithSubprocesses() error {
 	for {
 		if err := gui.Run(); err != nil {
-			for _, manager := range gui.viewBufferManagerMap {
-				manager.Close()
-			}
-			gui.viewBufferManagerMap = map[string]*tasks.ViewBufferManager{}
-
-			if !gui.fileWatcher.Disabled {
-				gui.fileWatcher.Watcher.Close()
-			}
-
-			close(gui.stopChan)
-
 			if err == gocui.ErrQuit {
 				if !gui.State.RetainOriginalDir {
 					if err := gui.recordCurrentDirectory(); err != nil {
@@ -1044,6 +839,8 @@ func (gui *Gui) RunWithSubprocesses() error {
 					}
 				}

+				gui.fileWatcher.Watcher.Close()
+
 				break
 			} else if err == gui.Errors.ErrSwitchRepo {
 				continue
@@ -162,15 +162,15 @@ func (gui *Gui) getKeyDisplay(name string) string {
 func GetKeyDisplay(key interface{}) string {
 	keyInt := 0

-	switch key := key.(type) {
+	switch key.(type) {
 	case rune:
-		keyInt = int(key)
+		keyInt = int(key.(rune))
 	case gocui.Key:
-		value, ok := keyMapReversed[key]
+		value, ok := keyMapReversed[key.(gocui.Key)]
 		if ok {
 			return value
 		}
-		keyInt = int(key)
+		keyInt = int(key.(gocui.Key))
 	}

 	return string(keyInt)
@@ -225,7 +225,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 			Modifier:    gocui.ModNone,
 			Handler:     gui.scrollUpMain,
 			Alternative: "fn+up",
-			Description: gui.Tr.SLocalize("scrollUpMainPanel"),
 		},
 		{
 			ViewName:    "",
@@ -233,7 +232,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 			Modifier:    gocui.ModNone,
 			Handler:     gui.scrollDownMain,
 			Alternative: "fn+down",
-			Description: gui.Tr.SLocalize("scrollDownMainPanel"),
 		},
 		{
 			ViewName: "",
@@ -295,11 +293,10 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 			Description: gui.Tr.SLocalize("refresh"),
 		},
 		{
-			ViewName:    "",
-			Key:         gui.getKey("universal.optionMenu"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCreateOptionsMenu,
-			Description: gui.Tr.SLocalize("openMenu"),
+			ViewName: "",
+			Key:      gui.getKey("universal.optionMenu"),
+			Modifier: gocui.ModNone,
+			Handler:  gui.handleCreateOptionsMenu,
 		},
 		{
 			ViewName: "",
@@ -320,20 +317,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 			Handler:     gui.handleEditConfig,
 			Description: gui.Tr.SLocalize("EditConfig"),
 		},
-		{
-			ViewName:    "",
-			Key:         gui.getKey("universal.nextScreenMode"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.nextScreenMode,
-			Description: gui.Tr.SLocalize("nextScreenMode"),
-		},
-		{
-			ViewName:    "",
-			Key:         gui.getKey("universal.prevScreenMode"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.prevScreenMode,
-			Description: gui.Tr.SLocalize("prevScreenMode"),
-		},
 		{
 			ViewName:    "status",
 			Key:         gui.getKey("universal.openFile"),
@@ -468,19 +451,12 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 			Description: gui.Tr.SLocalize("fetch"),
 		},
 		{
-			ViewName:    "",
+			ViewName:    "files",
 			Key:         gui.getKey("universal.executeCustomCommand"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleCustomCommand,
 			Description: gui.Tr.SLocalize("executeCustomCommand"),
 		},
-		{
-			ViewName:    "files",
-			Key:         gui.getKey("commits.viewResetOptions"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCreateResetToUpstreamMenu,
-			Description: gui.Tr.SLocalize("viewResetToUpstreamOptions"),
-		},
 		{
 			ViewName:    "branches",
 			Contexts:    []string{"local-branches"},
@@ -561,22 +537,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 			Handler:     gui.handleFastForward,
 			Description: gui.Tr.SLocalize("FastForward"),
 		},
-		{
-			ViewName:    "branches",
-			Contexts:    []string{"local-branches"},
-			Key:         gui.getKey("commits.viewResetOptions"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCreateResetToBranchMenu,
-			Description: gui.Tr.SLocalize("viewResetOptions"),
-		},
-		{
-			ViewName:    "branches",
-			Contexts:    []string{"local-branches"},
-			Key:         gui.getKey("branches.renameBranch"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleRenameBranch,
-			Description: gui.Tr.SLocalize("renameBranch"),
-		},
 		{
 			ViewName:    "branches",
 			Contexts:    []string{"tags"},
@@ -610,26 +570,16 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 			Description: gui.Tr.SLocalize("createTag"),
 		},
 		{
-			ViewName:    "branches",
-			Contexts:    []string{"tags"},
-			Key:         gui.getKey("commits.viewResetOptions"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCreateResetToTagMenu,
-			Description: gui.Tr.SLocalize("viewResetOptions"),
+			ViewName: "branches",
+			Key:      gui.getKey("universal.nextBranchTab"),
+			Modifier: gocui.ModNone,
+			Handler:  gui.handleNextBranchesTab,
 		},
 		{
-			ViewName:    "branches",
-			Key:         gui.getKey("universal.nextTab"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleNextBranchesTab,
-			Description: gui.Tr.SLocalize("nextTab"),
-		},
-		{
-			ViewName:    "branches",
-			Key:         gui.getKey("universal.prevTab"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handlePrevBranchesTab,
-			Description: gui.Tr.SLocalize("prevTab"),
+			ViewName: "branches",
+			Key:      gui.getKey("universal.prevBranchTab"),
+			Modifier: gocui.ModNone,
+			Handler:  gui.handlePrevBranchesTab,
 		},
 		{
 			ViewName:    "branches",
@@ -639,14 +589,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 			Handler:     gui.handleRemoteBranchesEscape,
 			Description: gui.Tr.SLocalize("ReturnToRemotesList"),
 		},
-		{
-			ViewName:    "branches",
-			Contexts:    []string{"remote-branches"},
-			Key:         gui.getKey("commits.viewResetOptions"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCreateResetToRemoteBranchMenu,
-			Description: gui.Tr.SLocalize("viewResetOptions"),
-		},
 		{
 			ViewName:    "branches",
 			Contexts:    []string{"remotes"},
@@ -657,28 +599,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Key:         gui.getKey("universal.nextTab"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleNextCommitsTab,
-			Description: gui.Tr.SLocalize("nextTab"),
-		},
-		{
-			ViewName:    "commits",
-			Key:         gui.getKey("universal.prevTab"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handlePrevCommitsTab,
-			Description: gui.Tr.SLocalize("prevTab"),
-		},
-		{
-			ViewName:    "commits",
-			Key:         gui.getKey("universal.startSearch"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleOpenSearchForCommitsPanel,
-			Description: gui.Tr.SLocalize("startSearch"),
-		},
-		{
-			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("commits.squashDown"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleCommitSquashDown,
@@ -686,7 +606,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("commits.renameCommit"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleRenameCommit,
@@ -694,7 +613,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("commits.renameCommitWithEditor"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleRenameCommitEditor,
@@ -702,7 +620,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("commits.viewResetOptions"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleCreateCommitResetMenu,
@@ -710,7 +627,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("commits.markCommitAsFixup"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleCommitFixup,
@@ -718,7 +634,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("commits.createFixupCommit"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleCreateFixupCommit,
@@ -726,7 +641,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("commits.squashAboveCommits"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleSquashAllAboveFixupCommits,
@@ -734,7 +648,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("universal.remove"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleCommitDelete,
@@ -742,7 +655,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("commits.moveDownCommit"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleCommitMoveDown,
@@ -750,7 +662,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("commits.moveUpCommit"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleCommitMoveUp,
@@ -758,7 +669,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("universal.edit"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleCommitEdit,
@@ -766,7 +676,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("commits.amendToCommit"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleCommitAmendTo,
@@ -774,7 +683,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("commits.pickCommit"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleCommitPick,
@@ -782,7 +690,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("commits.revertCommit"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleCommitRevert,
@@ -790,7 +697,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("commits.cherryPickCopy"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleCopyCommit,
@@ -798,7 +704,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("commits.cherryPickCopyRange"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleCopyCommitRange,
@@ -806,7 +711,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("commits.pasteCommits"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.HandlePasteCommits,
@@ -814,7 +718,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("universal.goInto"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleSwitchToCommitFilesPanel,
@@ -822,7 +725,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("commits.checkoutCommit"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleCheckoutCommit,
@@ -830,7 +732,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("commits.toggleDiffCommit"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleToggleDiffCommit,
@@ -838,36 +739,11 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 		},
 		{
 			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
 			Key:         gui.getKey("commits.tagCommit"),
 			Modifier:    gocui.ModNone,
 			Handler:     gui.handleTagCommit,
 			Description: gui.Tr.SLocalize("tagCommit"),
 		},
-		{
-			ViewName:    "commits",
-			Contexts:    []string{"branch-commits"},
-			Key:         gui.getKey("commits.resetCherryPick"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleResetCherryPick,
-			Description: gui.Tr.SLocalize("resetCherryPick"),
-		},
-		{
-			ViewName:    "commits",
-			Contexts:    []string{"reflog-commits"},
-			Key:         gui.getKey("universal.select"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCheckoutReflogCommit,
-			Description: gui.Tr.SLocalize("checkoutCommit"),
-		},
-		{
-			ViewName:    "commits",
-			Contexts:    []string{"reflog-commits"},
-			Key:         gui.getKey("commits.viewResetOptions"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCreateReflogResetMenu,
-			Description: gui.Tr.SLocalize("viewResetOptions"),
-		},
 		{
 			ViewName:    "stash",
 			Key:         gui.getKey("universal.select"),
@@ -914,18 +790,16 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 			Handler:  gui.handleCloseCredentialsView,
 		},
 		{
-			ViewName:    "menu",
-			Key:         gui.getKey("universal.return"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleMenuClose,
-			Description: gui.Tr.SLocalize("closeMenu"),
+			ViewName: "menu",
+			Key:      gui.getKey("universal.return"),
+			Modifier: gocui.ModNone,
+			Handler:  gui.handleMenuClose,
 		},
 		{
-			ViewName:    "menu",
-			Key:         gui.getKey("universal.quit"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleMenuClose,
-			Description: gui.Tr.SLocalize("closeMenu"),
+			ViewName: "menu",
+			Key:      gui.getKey("universal.quit"),
+			Modifier: gocui.ModNone,
+			Handler:  gui.handleMenuClose,
 		},
 		{
 			ViewName: "information",
@@ -1039,7 +913,7 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 			Contexts:    []string{"staging"},
 			Key:         gui.getKey("universal.select"),
 			Modifier:    gocui.ModNone,
-			Handler:     gui.handleToggleStagedSelection,
+			Handler:     gui.handleStageSelection,
 			Description: gui.Tr.SLocalize("StageSelection"),
 		},
 		{
@@ -1161,8 +1035,16 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 			Contexts:    []string{"patch-building"},
 			Key:         gui.getKey("universal.select"),
 			Modifier:    gocui.ModNone,
-			Handler:     gui.handleToggleSelectionForPatch,
-			Description: gui.Tr.SLocalize("ToggleSelectionForPatch"),
+			Handler:     gui.handleAddSelectionToPatch,
+			Description: gui.Tr.SLocalize("StageSelection"),
+		},
+		{
+			ViewName:    "main",
+			Contexts:    []string{"patch-building"},
+			Key:         gui.getKey("universal.remove"),
+			Modifier:    gocui.ModNone,
+			Handler:     gui.handleRemoveSelectionFromPatch,
+			Description: gui.Tr.SLocalize("ResetSelection"),
 		},
 		{
 			ViewName:    "main",
@@ -1217,30 +1099,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 			Modifier: gocui.ModNone,
 			Handler:  gui.handleMouseScrollDown,
 		},
-		{
-			ViewName:    "main",
-			Contexts:    []string{"staging"},
-			Key:         gui.getKey("files.commitChanges"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCommitPress,
-			Description: gui.Tr.SLocalize("CommitChanges"),
-		},
-		{
-			ViewName:    "main",
-			Contexts:    []string{"staging"},
-			Key:         gui.getKey("files.commitChangesWithoutHook"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleWIPCommitPress,
-			Description: gui.Tr.SLocalize("commitChangesWithoutHook"),
-		},
-		{
-			ViewName:    "main",
-			Contexts:    []string{"staging"},
-			Key:         gui.getKey("files.commitChangesWithEditor"),
-			Modifier:    gocui.ModNone,
-			Handler:     gui.handleCommitEditorPress,
-			Description: gui.Tr.SLocalize("CommitChangesWithEditor"),
-		},
 		{
 			ViewName:    "main",
 			Contexts:    []string{"merging"},
@@ -1436,18 +1294,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 			Modifier: gocui.ModNone,
 			Handler:  gui.handleCommitFilesClick,
 		},
-		{
-			ViewName: "search",
-			Key:      gocui.KeyEnter,
-			Modifier: gocui.ModNone,
-			Handler:  gui.handleSearch,
-		},
-		{
-			ViewName: "search",
-			Key:      gui.getKey("universal.return"),
-			Modifier: gocui.ModNone,
-			Handler:  gui.handleSearchEscape,
-		},
 	}

 	for _, viewName := range []string{"status", "branches", "files", "commits", "commitFiles", "stash", "menu"} {
@@ -1475,18 +1321,6 @@ func (gui *Gui) GetInitialKeybindings() []*Binding {
 			{ViewName: listView.viewName, Contexts: []string{listView.context}, Key: gocui.MouseWheelDown, Modifier: gocui.ModNone, Handler: listView.handleNextLine},
 			{ViewName: listView.viewName, Contexts: []string{listView.context}, Key: gocui.MouseLeft, Modifier: gocui.ModNone, Handler: listView.handleClick},
 		}...)
-
-		// we need a specific keybinding for the commits panel beacuse it usually lazyloads commits
-		if listView.viewName != "commits" {
-			bindings = append(bindings, &Binding{
-				ViewName:    listView.viewName,
-				Contexts:    []string{listView.context},
-				Key:         gui.getKey("universal.startSearch"),
-				Modifier:    gocui.ModNone,
-				Handler:     gui.handleOpenSearch,
-				Description: gui.Tr.SLocalize("startSearch"),
-			})
-		}
 	}

 	return bindings
@@ -1501,15 +1335,8 @@ func (gui *Gui) keybindings(g *gocui.Gui) error {
 		}
 	}

-	tabClickBindings := map[string]func(int) error{
-		"branches": gui.onBranchesTabClick,
-		"commits":  gui.onCommitsTabClick,
-	}
-
-	for viewName, binding := range tabClickBindings {
-		if err := g.SetTabClickBinding(viewName, binding); err != nil {
-			return err
-		}
+	if err := g.SetTabClickBinding("branches", gui.onBranchesTabClick); err != nil {
+		return err
 	}

 	return nil
@@ -88,8 +88,7 @@ func (gui *Gui) refreshLineByLinePanel(diff string, secondaryDiff string, second
 	}

 	gui.g.Update(func(*gocui.Gui) error {
-		gui.setViewContent(gui.g, gui.getSecondaryView(), secondaryPatchParser.Render(-1, -1, nil))
-		return nil
+		return gui.setViewContent(gui.g, gui.getSecondaryView(), secondaryPatchParser.Render(-1, -1, nil))
 	})

 	return false, nil
@@ -221,10 +220,6 @@ func (gui *Gui) handleMouseScrollDown(g *gocui.Gui, v *gocui.View) error {
 	return gui.handleCycleLine(1)
 }

-func (gui *Gui) getSelectedCommitFileName() string {
-	return gui.State.CommitFiles[gui.State.Panels.CommitFiles.SelectedLine].Name
-}
-
 func (gui *Gui) refreshMainView() error {
 	state := gui.State.Panels.LineByLine

@@ -232,7 +227,7 @@ func (gui *Gui) refreshMainView() error {
 	// I'd prefer not to have knowledge of contexts using this file but I'm not sure
 	// how to get around this
 	if gui.State.MainContext == "patch-building" {
-		filename := gui.getSelectedCommitFileName()
+		filename := gui.State.CommitFiles[gui.State.Panels.CommitFiles.SelectedLine].Name
 		includedLineIndices = gui.GitCommand.PatchManager.GetFileIncLineIndices(filename)
 	}
 	colorDiff := state.PatchParser.Render(state.FirstLineIdx, state.LastLineIdx, includedLineIndices)
@@ -242,8 +237,7 @@ func (gui *Gui) refreshMainView() error {
 	mainView.Wrap = false

 	gui.g.Update(func(*gocui.Gui) error {
-		gui.setViewContent(gui.g, gui.getMainView(), colorDiff)
-		return nil
+		return gui.setViewContent(gui.g, gui.getMainView(), colorDiff)
 	})

 	return nil
@@ -320,8 +314,3 @@ func (gui *Gui) handleToggleSelectHunk(g *gocui.Gui, v *gocui.View) error {

 	return gui.focusSelection(state.SelectMode == HUNK)
 }
-
-func (gui *Gui) handleEscapeLineByLinePanel() {
-	gui.changeMainViewsContext("normal")
-	gui.State.Panels.LineByLine = nil
-}
@@ -34,7 +34,6 @@ func (lv *listView) handleLineChange(change int) error {
 			return err
 		}
 	}
-
 	view, err := lv.gui.g.View(lv.viewName)
 	if err != nil {
 		return err
@@ -57,14 +56,7 @@ func (lv *listView) handleClick(g *gocui.Gui, v *gocui.View) error {

 	*selectedLineIdxPtr = newSelectedLineIdx

-	if lv.rendersToMainView {
-		if err := lv.gui.resetOrigin(lv.gui.getMainView()); err != nil {
-			return err
-		}
-	}
-
-	prevViewName := lv.gui.currentViewName()
-	if prevSelectedLineIdx == newSelectedLineIdx && prevViewName == lv.viewName && lv.handleClickSelectedItem != nil {
+	if prevSelectedLineIdx == newSelectedLineIdx && lv.gui.currentViewName() == lv.viewName && lv.handleClickSelectedItem != nil {
 		return lv.handleClickSelectedItem(lv.gui.g, v)
 	}
 	return lv.handleItemSelect(lv.gui.g, v)
@@ -134,10 +126,8 @@ func (gui *Gui) getListViews() []*listView {
 			gui:                   gui,
 			rendersToMainView:     true,
 		},
-
 		{
 			viewName:                "commits",
-			context:                 "branch-commits",
 			getItemsLength:          func() int { return len(gui.State.Commits) },
 			getSelectedLineIdxPtr:   func() *int { return &gui.State.Panels.Commits.SelectedLine },
 			handleFocus:             gui.handleCommitSelect,
@@ -146,16 +136,6 @@ func (gui *Gui) getListViews() []*listView {
 			gui:                     gui,
 			rendersToMainView:       true,
 		},
-		{
-			viewName:              "commits",
-			context:               "reflog-commits",
-			getItemsLength:        func() int { return len(gui.State.ReflogCommits) },
-			getSelectedLineIdxPtr: func() *int { return &gui.State.Panels.ReflogCommits.SelectedLine },
-			handleFocus:           gui.handleReflogCommitSelect,
-			handleItemSelect:      gui.handleReflogCommitSelect,
-			gui:                   gui,
-			rendersToMainView:     true,
-		},
 		{
 			viewName:              "stash",
 			getItemsLength:        func() int { return len(gui.State.StashEntries) },
@@ -8,17 +8,10 @@ import (
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )

-type menuItem struct {
-	displayString  string
-	displayStrings []string
-	onPress        func() error
-}
-
 // list panel functions

 func (gui *Gui) handleMenuSelect(g *gocui.Gui, v *gocui.View) error {
-	v.FocusPoint(0, gui.State.Panels.Menu.SelectedLine)
-	return nil
+	return gui.focusPoint(0, gui.State.Panels.Menu.SelectedLine, gui.State.MenuItemCount, v)
 }

 // specific functions
@@ -45,49 +38,27 @@ func (gui *Gui) handleMenuClose(g *gocui.Gui, v *gocui.View) error {
 	return gui.returnFocus(g, v)
 }

-type createMenuOptions struct {
-	showCancel bool
-}
-
-func (gui *Gui) createMenu(title string, items []*menuItem, createMenuOptions createMenuOptions) error {
-	if createMenuOptions.showCancel {
-		// this is mutative but I'm okay with that for now
-		items = append(items, &menuItem{
-			displayStrings: []string{gui.Tr.SLocalize("cancel")},
-			onPress: func() error {
-				return nil
-			},
-		})
+func (gui *Gui) createMenu(title string, items interface{}, itemCount int, handlePress func(int) error) error {
+	isFocused := gui.g.CurrentView().Name() == "menu"
+	gui.State.MenuItemCount = itemCount
+	list, err := utils.RenderList(items, isFocused)
+	if err != nil {
+		return err
 	}

-	gui.State.MenuItemCount = len(items)
-
-	stringArrays := make([][]string, len(items))
-	for i, item := range items {
-		if item.displayStrings == nil {
-			stringArrays[i] = []string{item.displayString}
-		} else {
-			stringArrays[i] = item.displayStrings
-		}
-	}
-
-	list := utils.RenderDisplayStrings(stringArrays)
-
 	x0, y0, x1, y1 := gui.getConfirmationPanelDimensions(gui.g, false, list)
 	menuView, _ := gui.g.SetView("menu", x0, y0, x1, y1, 0)
 	menuView.Title = title
 	menuView.FgColor = theme.GocuiDefaultTextColor
-	menuView.ContainsList = true
 	menuView.Clear()
 	fmt.Fprint(menuView, list)
 	gui.State.Panels.Menu.SelectedLine = 0

 	wrappedHandlePress := func(g *gocui.Gui, v *gocui.View) error {
 		selectedLine := gui.State.Panels.Menu.SelectedLine
-		if err := items[selectedLine].onPress(); err != nil {
+		if err := handlePress(selectedLine); err != nil {
 			return err
 		}
-
 		if _, err := gui.g.View("menu"); err == nil {
 			if _, err := gui.g.SetViewOnBottom("menu"); err != nil {
 				return err
@@ -151,19 +151,13 @@ func (gui *Gui) handlePopFileSnapshot(g *gocui.Gui, v *gocui.View) error {
 	if err != nil {
 		return err
 	}
-	if err := ioutil.WriteFile(gitFile.Name, []byte(prevContent), 0644); err != nil {
-		return err
-	}
-
+	ioutil.WriteFile(gitFile.Name, []byte(prevContent), 0644)
 	return gui.refreshMergePanel()
 }

 func (gui *Gui) handlePickHunk(g *gocui.Gui, v *gocui.View) error {
 	conflict := gui.State.Panels.Merging.Conflicts[gui.State.Panels.Merging.ConflictIndex]
-	if err := gui.pushFileSnapshot(g); err != nil {
-		return err
-	}
-
+	gui.pushFileSnapshot(g)
 	pick := "bottom"
 	if gui.State.Panels.Merging.ConflictTop {
 		pick = "top"
@@ -184,9 +178,7 @@ func (gui *Gui) handlePickHunk(g *gocui.Gui, v *gocui.View) error {

 func (gui *Gui) handlePickBothHunks(g *gocui.Gui, v *gocui.View) error {
 	conflict := gui.State.Panels.Merging.Conflicts[gui.State.Panels.Merging.ConflictIndex]
-	if err := gui.pushFileSnapshot(g); err != nil {
-		return err
-	}
+	gui.pushFileSnapshot(g)
 	err := gui.resolveConflict(g, conflict, "both")
 	if err != nil {
 		panic(err)
@@ -220,15 +212,16 @@ func (gui *Gui) refreshMergePanel() error {
 	if err != nil {
 		return err
 	}
-
-	mainView := gui.getMainView()
-	mainView.Wrap = false
-	gui.setViewContent(gui.g, mainView, content)
-	gui.Log.Warn("scrolling to conflict")
+	if err := gui.renderString(gui.g, "main", content); err != nil {
+		return err
+	}
 	if err := gui.scrollToConflict(gui.g); err != nil {
 		return err
 	}

+	mainView := gui.getMainView()
+	mainView.Wrap = false
+
 	return nil
 }

@@ -3,6 +3,8 @@ package gui
 import (
 	"strings"

+	"github.com/go-errors/errors"
+
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )
@@ -36,23 +38,19 @@ func (gui *Gui) getBindings(v *gocui.View) []*Binding {
 func (gui *Gui) handleCreateOptionsMenu(g *gocui.Gui, v *gocui.View) error {
 	bindings := gui.getBindings(v)

-	menuItems := make([]*menuItem, len(bindings))
-
-	for i, binding := range bindings {
-		innerBinding := binding // note to self, never close over loop variables
-		menuItems[i] = &menuItem{
-			displayStrings: []string{GetKeyDisplay(innerBinding.Key), innerBinding.Description},
-			onPress: func() error {
-				if innerBinding.Key == nil {
-					return nil
-				}
-				if err := gui.handleMenuClose(g, v); err != nil {
-					return err
-				}
-				return innerBinding.Handler(g, v)
-			},
+	handleMenuPress := func(index int) error {
+		if bindings[index].Key == nil {
+			return nil
 		}
+		if index >= len(bindings) {
+			return errors.New("Index is greater than size of bindings")
+		}
+		err := gui.handleMenuClose(g, v)
+		if err != nil {
+			return err
+		}
+		return bindings[index].Handler(g, v)
 	}

-	return gui.createMenu(strings.Title(gui.Tr.SLocalize("menu")), menuItems, createMenuOptions{})
+	return gui.createMenu(strings.Title(gui.Tr.SLocalize("menu")), bindings, len(bindings), handleMenuPress)
 }
@@ -2,7 +2,6 @@ package gui

 import (
 	"github.com/jesseduffield/gocui"
-	"github.com/jesseduffield/lazygit/pkg/utils"
 )

 func (gui *Gui) refreshPatchBuildingPanel(selectedLineIdx int) error {
@@ -18,8 +17,7 @@ func (gui *Gui) refreshPatchBuildingPanel(selectedLineIdx int) error {
 	// get diff from commit file that's currently selected
 	commitFile := gui.getSelectedCommitFile(gui.g)
 	if commitFile == nil {
-		gui.renderString(gui.g, "commitFiles", gui.Tr.SLocalize("NoCommiteFiles"))
-		return nil
+		return gui.renderString(gui.g, "commitFiles", gui.Tr.SLocalize("NoCommiteFiles"))
 	}

 	diff, err := gui.GitCommand.ShowCommitFile(commitFile.Sha, commitFile.Name, true)
@@ -44,25 +42,38 @@ func (gui *Gui) refreshPatchBuildingPanel(selectedLineIdx int) error {
 	return nil
 }

-func (gui *Gui) handleToggleSelectionForPatch(g *gocui.Gui, v *gocui.View) error {
+func (gui *Gui) handleAddSelectionToPatch(g *gocui.Gui, v *gocui.View) error {
 	state := gui.State.Panels.LineByLine

-	toggleFunc := gui.GitCommand.PatchManager.AddFileLineRange
-	filename := gui.getSelectedCommitFileName()
-	includedLineIndices := gui.GitCommand.PatchManager.GetFileIncLineIndices(filename)
-	currentLineIsStaged := utils.IncludesInt(includedLineIndices, state.SelectedLineIdx)
-	if currentLineIsStaged {
-		toggleFunc = gui.GitCommand.PatchManager.RemoveFileLineRange
-	}
-
 	// add range of lines to those set for the file
 	commitFile := gui.getSelectedCommitFile(gui.g)
 	if commitFile == nil {
-		gui.renderString(gui.g, "commitFiles", gui.Tr.SLocalize("NoCommiteFiles"))
-		return nil
+		return gui.renderString(gui.g, "commitFiles", gui.Tr.SLocalize("NoCommiteFiles"))
 	}

-	toggleFunc(commitFile.Name, state.FirstLineIdx, state.LastLineIdx)
+	gui.GitCommand.PatchManager.AddFileLineRange(commitFile.Name, state.FirstLineIdx, state.LastLineIdx)
+
+	if err := gui.refreshCommitFilesView(); err != nil {
+		return err
+	}
+
+	if err := gui.refreshPatchBuildingPanel(-1); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (gui *Gui) handleRemoveSelectionFromPatch(g *gocui.Gui, v *gocui.View) error {
+	state := gui.State.Panels.LineByLine
+
+	// add range of lines to those set for the file
+	commitFile := gui.getSelectedCommitFile(gui.g)
+	if commitFile == nil {
+		return gui.renderString(gui.g, "commitFiles", gui.Tr.SLocalize("NoCommiteFiles"))
+	}
+
+	gui.GitCommand.PatchManager.RemoveFileLineRange(commitFile.Name, state.FirstLineIdx, state.LastLineIdx)

 	if err := gui.refreshCommitFilesView(); err != nil {
 		return err
@@ -76,7 +87,8 @@ func (gui *Gui) handleToggleSelectionForPatch(g *gocui.Gui, v *gocui.View) error
 }

 func (gui *Gui) handleEscapePatchBuildingPanel(g *gocui.Gui, v *gocui.View) error {
-	gui.handleEscapeLineByLinePanel()
+	gui.State.Panels.LineByLine = nil
+	gui.changeMainViewsContext("normal")

 	if gui.GitCommand.PatchManager.IsEmpty() {
 		gui.GitCommand.PatchManager.Reset()
@@ -94,8 +106,7 @@ func (gui *Gui) refreshSecondaryPatchPanel() error {
 		secondaryView.Wrap = false

 		gui.g.Update(func(*gocui.Gui) error {
-			gui.setViewContent(gui.g, gui.getSecondaryView(), gui.GitCommand.PatchManager.RenderAggregatedPatchColored(false))
-			return nil
+			return gui.setViewContent(gui.g, gui.getSecondaryView(), gui.GitCommand.PatchManager.RenderAggregatedPatchColored(false))
 		})
 	} else {
 		gui.State.SplitMainPanel = false
@@ -6,43 +6,48 @@ import (
 	"github.com/jesseduffield/gocui"
 )

+type patchMenuOption struct {
+	displayName string
+	function    func() error
+}
+
+// GetDisplayStrings is a function.
+func (o *patchMenuOption) GetDisplayStrings(isFocused bool) []string {
+	return []string{o.displayName}
+}
+
 func (gui *Gui) handleCreatePatchOptionsMenu(g *gocui.Gui, v *gocui.View) error {
 	if !gui.GitCommand.PatchManager.CommitSelected() {
 		return gui.createErrorPanel(gui.g, gui.Tr.SLocalize("NoPatchError"))
 	}

-	menuItems := []*menuItem{
-		{
-			displayString: fmt.Sprintf("remove patch from original commit (%s)", gui.GitCommand.PatchManager.CommitSha),
-			onPress:       gui.handleDeletePatchFromCommit,
-		},
-		{
-			displayString: "pull patch out into index",
-			onPress:       gui.handlePullPatchIntoWorkingTree,
-		},
-		{
-			displayString: "reset patch",
-			onPress:       gui.handleResetPatch,
-		},
+	options := []*patchMenuOption{
+		{displayName: fmt.Sprintf("remove patch from original commit (%s)", gui.GitCommand.PatchManager.CommitSha), function: gui.handleDeletePatchFromCommit},
+		{displayName: "pull patch out into index", function: gui.handlePullPatchIntoWorkingTree},
+		{displayName: "reset patch", function: gui.handleResetPatch},
 	}

 	selectedCommit := gui.getSelectedCommit(gui.g)
 	if selectedCommit != nil && gui.GitCommand.PatchManager.CommitSha != selectedCommit.Sha {
 		// adding this option to index 1
-		menuItems = append(
-			menuItems[:1],
+		options = append(
+			options[:1],
 			append(
-				[]*menuItem{
+				[]*patchMenuOption{
 					{
-						displayString: fmt.Sprintf("move patch to selected commit (%s)", selectedCommit.Sha),
-						onPress:       gui.handleMovePatchToSelectedCommit,
+						displayName: fmt.Sprintf("move patch to selected commit (%s)", selectedCommit.Sha),
+						function:    gui.handleMovePatchToSelectedCommit,
 					},
-				}, menuItems[1:]...,
+				}, options[1:]...,
 			)...,
 		)
 	}

-	return gui.createMenu(gui.Tr.SLocalize("PatchOptionsTitle"), menuItems, createMenuOptions{showCancel: true})
+	handleMenuPress := func(index int) error {
+		return options[index].function()
+	}
+
+	return gui.createMenu(gui.Tr.SLocalize("PatchOptionsTitle"), options, len(options), handleMenuPress)
 }

 func (gui *Gui) getPatchCommitIndex() int {
@@ -1,61 +0,0 @@
-package presentation
-
-import (
-	"fmt"
-	"strings"
-
-	"github.com/fatih/color"
-	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/theme"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-func GetBranchListDisplayStrings(branches []*commands.Branch, fullDescription bool) [][]string {
-	lines := make([][]string, len(branches))
-
-	for i := range branches {
-		lines[i] = getBranchDisplayStrings(branches[i], fullDescription)
-	}
-
-	return lines
-}
-
-// getBranchDisplayStrings returns the display string of branch
-func getBranchDisplayStrings(b *commands.Branch, fullDescription bool) []string {
-	displayName := utils.ColoredString(b.Name, GetBranchColor(b.Name))
-	if b.Pushables != "" && b.Pullables != "" && b.Pushables != "?" && b.Pullables != "?" {
-		trackColor := color.FgYellow
-		if b.Pushables == "0" && b.Pullables == "0" {
-			trackColor = color.FgGreen
-		}
-		track := utils.ColoredString(fmt.Sprintf("↑%s↓%s", b.Pushables, b.Pullables), trackColor)
-		displayName = fmt.Sprintf("%s %s", displayName, track)
-	}
-
-	recencyColor := color.FgCyan
-	if b.Recency == "  *" {
-		recencyColor = color.FgGreen
-	}
-
-	if fullDescription {
-		return []string{utils.ColoredString(b.Recency, recencyColor), displayName, utils.ColoredString(b.UpstreamName, color.FgYellow)}
-	}
-
-	return []string{utils.ColoredString(b.Recency, recencyColor), displayName}
-}
-
-// GetBranchColor branch color
-func GetBranchColor(name string) color.Attribute {
-	branchType := strings.Split(name, "/")[0]
-
-	switch branchType {
-	case "feature":
-		return color.FgGreen
-	case "bugfix":
-		return color.FgYellow
-	case "hotfix":
-		return color.FgRed
-	default:
-		return theme.DefaultTextColor
-	}
-}
@@ -1,35 +0,0 @@
-package presentation
-
-import (
-	"github.com/fatih/color"
-	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/theme"
-)
-
-func GetCommitFileListDisplayStrings(branches []*commands.CommitFile) [][]string {
-	lines := make([][]string, len(branches))
-
-	for i := range branches {
-		lines[i] = getCommitFileDisplayStrings(branches[i])
-	}
-
-	return lines
-}
-
-// getCommitFileDisplayStrings returns the display string of branch
-func getCommitFileDisplayStrings(f *commands.CommitFile) []string {
-	yellow := color.New(color.FgYellow)
-	green := color.New(color.FgGreen)
-	defaultColor := color.New(theme.DefaultTextColor)
-
-	var colour *color.Color
-	switch f.Status {
-	case commands.UNSELECTED:
-		colour = defaultColor
-	case commands.WHOLE:
-		colour = green
-	case commands.PART:
-		colour = yellow
-	}
-	return []string{colour.Sprint(f.DisplayString)}
-}
@@ -1,126 +0,0 @@
-package presentation
-
-import (
-	"strings"
-
-	"github.com/fatih/color"
-	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/theme"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-func GetCommitListDisplayStrings(commits []*commands.Commit, fullDescription bool) [][]string {
-	lines := make([][]string, len(commits))
-
-	var displayFunc func(*commands.Commit) []string
-	if fullDescription {
-		displayFunc = getFullDescriptionDisplayStringsForCommit
-	} else {
-		displayFunc = getDisplayStringsForCommit
-	}
-
-	for i := range commits {
-		lines[i] = displayFunc(commits[i])
-	}
-
-	return lines
-}
-
-func getFullDescriptionDisplayStringsForCommit(c *commands.Commit) []string {
-	red := color.New(color.FgRed)
-	yellow := color.New(color.FgYellow)
-	green := color.New(color.FgGreen)
-	blue := color.New(color.FgBlue)
-	cyan := color.New(color.FgCyan)
-	defaultColor := color.New(theme.DefaultTextColor)
-	magenta := color.New(color.FgMagenta)
-
-	// for some reason, setting the background to blue pads out the other commits
-	// horizontally. For the sake of accessibility I'm considering this a feature,
-	// not a bug
-	copied := color.New(color.FgCyan, color.BgBlue)
-
-	var shaColor *color.Color
-	switch c.Status {
-	case "unpushed":
-		shaColor = red
-	case "pushed":
-		shaColor = yellow
-	case "merged":
-		shaColor = green
-	case "rebasing":
-		shaColor = blue
-	case "reflog":
-		shaColor = blue
-	case "selected":
-		shaColor = magenta
-	default:
-		shaColor = defaultColor
-	}
-
-	if c.Copied {
-		shaColor = copied
-	}
-
-	tagString := ""
-	truncatedDate := utils.TruncateWithEllipsis(c.Date, 15)
-	secondColumnString := blue.Sprint(truncatedDate)
-	if c.Action != "" {
-		secondColumnString = cyan.Sprint(c.Action)
-	} else if c.ExtraInfo != "" {
-		tagColor := color.New(color.FgMagenta, color.Bold)
-		tagString = utils.ColoredStringDirect(c.ExtraInfo, tagColor) + " "
-	}
-
-	truncatedAuthor := utils.TruncateWithEllipsis(c.Author, 17)
-
-	return []string{shaColor.Sprint(c.Sha[:8]), secondColumnString, yellow.Sprint(truncatedAuthor), tagString + defaultColor.Sprint(c.Name)}
-}
-
-func getDisplayStringsForCommit(c *commands.Commit) []string {
-	red := color.New(color.FgRed)
-	yellow := color.New(color.FgYellow)
-	green := color.New(color.FgGreen)
-	blue := color.New(color.FgBlue)
-	cyan := color.New(color.FgCyan)
-	defaultColor := color.New(theme.DefaultTextColor)
-	magenta := color.New(color.FgMagenta)
-
-	// for some reason, setting the background to blue pads out the other commits
-	// horizontally. For the sake of accessibility I'm considering this a feature,
-	// not a bug
-	copied := color.New(color.FgCyan, color.BgBlue)
-
-	var shaColor *color.Color
-	switch c.Status {
-	case "unpushed":
-		shaColor = red
-	case "pushed":
-		shaColor = yellow
-	case "merged":
-		shaColor = green
-	case "rebasing":
-		shaColor = blue
-	case "reflog":
-		shaColor = blue
-	case "selected":
-		shaColor = magenta
-	default:
-		shaColor = defaultColor
-	}
-
-	if c.Copied {
-		shaColor = copied
-	}
-
-	actionString := ""
-	tagString := ""
-	if c.Action != "" {
-		actionString = cyan.Sprint(utils.WithPadding(c.Action, 7)) + " "
-	} else if len(c.Tags) > 0 {
-		tagColor := color.New(color.FgMagenta, color.Bold)
-		tagString = utils.ColoredStringDirect(strings.Join(c.Tags, " "), tagColor) + " "
-	}
-
-	return []string{shaColor.Sprint(c.Sha[:8]), actionString + tagString + defaultColor.Sprint(c.Name)}
-}
@@ -1,36 +0,0 @@
-package presentation
-
-import (
-	"github.com/fatih/color"
-	"github.com/jesseduffield/lazygit/pkg/commands"
-)
-
-func GetFileListDisplayStrings(files []*commands.File) [][]string {
-	lines := make([][]string, len(files))
-
-	for i := range files {
-		lines[i] = getFileDisplayStrings(files[i])
-	}
-
-	return lines
-}
-
-// getFileDisplayStrings returns the display string of branch
-func getFileDisplayStrings(f *commands.File) []string {
-	// potentially inefficient to be instantiating these color
-	// objects with each render
-	red := color.New(color.FgRed)
-	green := color.New(color.FgGreen)
-	if !f.Tracked && !f.HasStagedChanges {
-		return []string{red.Sprint(f.DisplayString)}
-	}
-
-	output := green.Sprint(f.DisplayString[0:1])
-	output += red.Sprint(f.DisplayString[1:3])
-	if f.HasUnstagedChanges {
-		output += red.Sprint(f.Name)
-	} else {
-		output += green.Sprint(f.Name)
-	}
-	return []string{output}
-}
@@ -1,23 +0,0 @@
-package presentation
-
-import (
-	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-func GetRemoteBranchListDisplayStrings(branches []*commands.RemoteBranch) [][]string {
-	lines := make([][]string, len(branches))
-
-	for i := range branches {
-		lines[i] = getRemoteBranchDisplayStrings(branches[i])
-	}
-
-	return lines
-}
-
-// getRemoteBranchDisplayStrings returns the display string of branch
-func getRemoteBranchDisplayStrings(b *commands.RemoteBranch) []string {
-	displayName := utils.ColoredString(b.Name, GetBranchColor(b.Name))
-
-	return []string{displayName}
-}
@@ -1,20 +0,0 @@
-package presentation
-
-import (
-	"github.com/jesseduffield/lazygit/pkg/commands"
-)
-
-func GetRemoteListDisplayStrings(remotes []*commands.Remote) [][]string {
-	lines := make([][]string, len(remotes))
-
-	for i := range remotes {
-		lines[i] = getRemoteDisplayStrings(remotes[i])
-	}
-
-	return lines
-}
-
-// getRemoteDisplayStrings returns the display string of branch
-func getRemoteDisplayStrings(r *commands.Remote) []string {
-	return []string{r.Name}
-}
@@ -1,20 +0,0 @@
-package presentation
-
-import (
-	"github.com/jesseduffield/lazygit/pkg/commands"
-)
-
-func GetStashEntryListDisplayStrings(stashEntries []*commands.StashEntry) [][]string {
-	lines := make([][]string, len(stashEntries))
-
-	for i := range stashEntries {
-		lines[i] = getStashEntryDisplayStrings(stashEntries[i])
-	}
-
-	return lines
-}
-
-// getStashEntryDisplayStrings returns the display string of branch
-func getStashEntryDisplayStrings(s *commands.StashEntry) []string {
-	return []string{s.DisplayString}
-}
@@ -1,20 +0,0 @@
-package presentation
-
-import (
-	"github.com/jesseduffield/lazygit/pkg/commands"
-)
-
-func GetTagListDisplayStrings(tags []*commands.Tag) [][]string {
-	lines := make([][]string, len(tags))
-
-	for i := range tags {
-		lines[i] = getTagDisplayStrings(tags[i])
-	}
-
-	return lines
-}
-
-// getTagDisplayStrings returns the display string of branch
-func getTagDisplayStrings(t *commands.Tag) []string {
-	return []string{t.Name}
-}
@@ -1,74 +0,0 @@
-// +build !windows
-
-package gui
-
-import (
-	"os/exec"
-
-	"github.com/jesseduffield/pty"
-)
-
-func (gui *Gui) onResize() error {
-	if gui.State.Ptmx == nil {
-		return nil
-	}
-	mainView := gui.getMainView()
-	width, height := mainView.Size()
-
-	if err := pty.Setsize(gui.State.Ptmx, &pty.Winsize{Cols: uint16(width), Rows: uint16(height)}); err != nil {
-		return err
-	}
-
-	// TODO: handle resizing properly
-
-	return nil
-}
-
-// Some commands need to output for a terminal to active certain behaviour.
-// For example,  git won't invoke the GIT_PAGER env var unless it thinks it's
-// talking to a terminal. We typically write cmd outputs straight to a view,
-// which is just an io.Reader. the pty package lets us wrap a command in a
-// pseudo-terminal meaning we'll get the behaviour we want from the underlying
-// command.
-func (gui *Gui) newPtyTask(viewName string, cmd *exec.Cmd) error {
-	width, _ := gui.getMainView().Size()
-	pager := gui.GitCommand.GetPager(width)
-
-	if pager == "" {
-		// if we're not using a custom pager we don't need to use a pty
-		return gui.newCmdTask(viewName, cmd)
-	}
-
-	cmd.Env = append(cmd.Env, "GIT_PAGER="+pager)
-
-	view, err := gui.g.View(viewName)
-	if err != nil {
-		return nil // swallowing for now
-	}
-
-	_, height := view.Size()
-	_, oy := view.Origin()
-
-	manager := gui.getManager(view)
-
-	ptmx, err := pty.Start(cmd)
-	if err != nil {
-		return err
-	}
-
-	gui.State.Ptmx = ptmx
-	onClose := func() {
-		ptmx.Close()
-		gui.State.Ptmx = nil
-	}
-
-	if err := gui.onResize(); err != nil {
-		return err
-	}
-
-	if err := manager.NewTask(manager.NewCmdTask(ptmx, cmd, height+oy+10, onClose)); err != nil {
-		return err
-	}
-
-	return nil
-}
@@ -1,13 +0,0 @@
-// +build windows
-
-package gui
-
-import "os/exec"
-
-func (gui *Gui) onResize() error {
-	return nil
-}
-
-func (gui *Gui) newPtyTask(viewName string, cmd *exec.Cmd) error {
-	return gui.newCmdTask(viewName, cmd)
-}
@@ -7,23 +7,33 @@ import (
 	"github.com/jesseduffield/gocui"
 )

-func (gui *Gui) handleCreateRebaseOptionsMenu(g *gocui.Gui, v *gocui.View) error {
-	options := []string{"continue", "abort"}
+type option struct {
+	value string
+}

-	if gui.State.WorkingTreeState == "rebasing" {
-		options = append(options, "skip")
+// GetDisplayStrings is a function.
+func (r *option) GetDisplayStrings(isFocused bool) []string {
+	return []string{r.value}
+}
+
+func (gui *Gui) handleCreateRebaseOptionsMenu(g *gocui.Gui, v *gocui.View) error {
+	options := []*option{
+		{value: "continue"},
+		{value: "abort"},
 	}

-	menuItems := make([]*menuItem, len(options))
-	for i, option := range options {
-		// note to self. Never, EVER, close over loop variables in a function
-		option := option
-		menuItems[i] = &menuItem{
-			displayString: option,
-			onPress: func() error {
-				return gui.genericMergeCommand(option)
-			},
+	if gui.State.WorkingTreeState == "rebasing" {
+		options = append(options, &option{value: "skip"})
+	}
+
+	options = append(options, &option{value: "cancel"})
+
+	handleMenuPress := func(index int) error {
+		command := options[index].value
+		if command == "cancel" {
+			return nil
 		}
+		return gui.genericMergeCommand(command)
 	}

 	var title string
@@ -33,7 +43,7 @@ func (gui *Gui) handleCreateRebaseOptionsMenu(g *gocui.Gui, v *gocui.View) error
 		title = gui.Tr.SLocalize("RebaseOptionsTitle")
 	}

-	return gui.createMenu(title, menuItems, createMenuOptions{showCancel: true})
+	return gui.createMenu(title, options, len(options), handleMenuPress)
 }

 func (gui *Gui) genericMergeCommand(command string) error {
@@ -10,34 +10,41 @@ import (
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )

+type recentRepo struct {
+	path string
+}
+
+// GetDisplayStrings returns the path from a recent repo.
+func (r *recentRepo) GetDisplayStrings(isFocused bool) []string {
+	yellow := color.New(color.FgMagenta)
+	base := filepath.Base(r.path)
+	path := yellow.Sprint(r.path)
+	return []string{base, path}
+}
+
 func (gui *Gui) handleCreateRecentReposMenu(g *gocui.Gui, v *gocui.View) error {
 	recentRepoPaths := gui.Config.GetAppState().RecentRepos
 	reposCount := utils.Min(len(recentRepoPaths), 20)
-	yellow := color.New(color.FgMagenta)
 	// we won't show the current repo hence the -1
-	menuItems := make([]*menuItem, reposCount-1)
+	recentRepos := make([]*recentRepo, reposCount-1)
 	for i, path := range recentRepoPaths[1:reposCount] {
-		innerPath := path
-		menuItems[i] = &menuItem{
-			displayStrings: []string{
-				filepath.Base(innerPath),
-				yellow.Sprint(innerPath),
-			},
-			onPress: func() error {
-				if err := os.Chdir(innerPath); err != nil {
-					return err
-				}
-				newGitCommand, err := commands.NewGitCommand(gui.Log, gui.OSCommand, gui.Tr, gui.Config)
-				if err != nil {
-					return err
-				}
-				gui.GitCommand = newGitCommand
-				return gui.Errors.ErrSwitchRepo
-			},
-		}
+		recentRepos[i] = &recentRepo{path: path}
 	}

-	return gui.createMenu(gui.Tr.SLocalize("RecentRepos"), menuItems, createMenuOptions{showCancel: true})
+	handleMenuPress := func(index int) error {
+		repo := recentRepos[index]
+		if err := os.Chdir(repo.path); err != nil {
+			return err
+		}
+		newGitCommand, err := commands.NewGitCommand(gui.Log, gui.OSCommand, gui.Tr, gui.Config)
+		if err != nil {
+			return err
+		}
+		gui.GitCommand = newGitCommand
+		return gui.Errors.ErrSwitchRepo
+	}
+
+	return gui.createMenu(gui.Tr.SLocalize("RecentRepos"), recentRepos, len(recentRepos), handleMenuPress)
 }

 // updateRecentRepoList registers the fact that we opened lazygit in this repo,
@@ -1,101 +0,0 @@
-package gui
-
-import (
-	"github.com/jesseduffield/gocui"
-	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
-)
-
-// list panel functions
-
-func (gui *Gui) getSelectedReflogCommit() *commands.Commit {
-	selectedLine := gui.State.Panels.ReflogCommits.SelectedLine
-	if selectedLine == -1 || len(gui.State.ReflogCommits) == 0 {
-		return nil
-	}
-
-	return gui.State.ReflogCommits[selectedLine]
-}
-
-func (gui *Gui) handleReflogCommitSelect(g *gocui.Gui, v *gocui.View) error {
-	if gui.popupPanelFocused() {
-		return nil
-	}
-
-	gui.State.SplitMainPanel = false
-
-	if _, err := gui.g.SetCurrentView(v.Name()); err != nil {
-		return err
-	}
-
-	gui.getMainView().Title = "Reflog Entry"
-
-	commit := gui.getSelectedReflogCommit()
-	if commit == nil {
-		return gui.newStringTask("main", "No reflog history")
-	}
-	v.FocusPoint(0, gui.State.Panels.ReflogCommits.SelectedLine)
-
-	cmd := gui.OSCommand.ExecutableFromString(
-		gui.GitCommand.ShowCmdStr(commit.Sha),
-	)
-	if err := gui.newPtyTask("main", cmd); err != nil {
-		gui.Log.Error(err)
-	}
-
-	return nil
-}
-
-func (gui *Gui) refreshReflogCommits() error {
-	commits, err := gui.GitCommand.GetReflogCommits()
-	if err != nil {
-		return gui.createErrorPanel(gui.g, err.Error())
-	}
-
-	gui.State.ReflogCommits = commits
-
-	if gui.getCommitsView().Context == "reflog-commits" {
-		return gui.renderReflogCommitsWithSelection()
-	}
-
-	return nil
-}
-
-func (gui *Gui) renderReflogCommitsWithSelection() error {
-	commitsView := gui.getCommitsView()
-
-	gui.refreshSelectedLine(&gui.State.Panels.ReflogCommits.SelectedLine, len(gui.State.ReflogCommits))
-	displayStrings := presentation.GetCommitListDisplayStrings(gui.State.ReflogCommits, gui.State.ScreenMode != SCREEN_NORMAL)
-	gui.renderDisplayStrings(commitsView, displayStrings)
-	if gui.g.CurrentView() == commitsView && commitsView.Context == "reflog-commits" {
-		if err := gui.handleReflogCommitSelect(gui.g, commitsView); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (gui *Gui) handleCheckoutReflogCommit(g *gocui.Gui, v *gocui.View) error {
-	commit := gui.getSelectedReflogCommit()
-	if commit == nil {
-		return nil
-	}
-
-	err := gui.createConfirmationPanel(g, gui.getCommitsView(), true, gui.Tr.SLocalize("checkoutCommit"), gui.Tr.SLocalize("SureCheckoutThisCommit"), func(g *gocui.Gui, v *gocui.View) error {
-		return gui.handleCheckoutRef(commit.Sha)
-	}, nil)
-	if err != nil {
-		return err
-	}
-
-	gui.State.Panels.ReflogCommits.SelectedLine = 0
-
-	return nil
-}
-
-func (gui *Gui) handleCreateReflogResetMenu(g *gocui.Gui, v *gocui.View) error {
-	commit := gui.getSelectedReflogCommit()
-
-	return gui.createResetMenu(commit.Sha)
-}
@@ -2,10 +2,12 @@ package gui

 import (
 	"fmt"
+	"strings"

+	"github.com/fatih/color"
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
+	"github.com/jesseduffield/lazygit/pkg/utils"
 )

 // list panel functions
@@ -35,20 +37,22 @@ func (gui *Gui) handleRemoteBranchSelect(g *gocui.Gui, v *gocui.View) error {
 	remote := gui.getSelectedRemote()
 	remoteBranch := gui.getSelectedRemoteBranch()
 	if remoteBranch == nil {
-		return gui.newStringTask("main", "No branches for this remote")
+		return gui.renderString(g, "main", "No branches for this remote")
 	}

-	v.FocusPoint(0, gui.State.Panels.RemoteBranches.SelectedLine)
-
-	branchName := fmt.Sprintf("%s/%s", remote.Name, remoteBranch.Name)
-
-	cmd := gui.OSCommand.ExecutableFromString(
-		gui.GitCommand.GetBranchGraphCmdStr(branchName),
-	)
-	if err := gui.newCmdTask("main", cmd); err != nil {
-		gui.Log.Error(err)
+	gui.focusPoint(0, gui.State.Panels.Menu.SelectedLine, gui.State.MenuItemCount, v)
+	if err := gui.focusPoint(0, gui.State.Panels.RemoteBranches.SelectedLine, len(gui.State.RemoteBranches), v); err != nil {
+		return err
 	}

+	go func() {
+		graph, err := gui.GitCommand.GetBranchGraph(fmt.Sprintf("%s/%s", remote.Name, remoteBranch.Name))
+		if err != nil && strings.HasPrefix(graph, "fatal: ambiguous argument") {
+			graph = gui.Tr.SLocalize("NoTrackingThisBranch")
+		}
+		_ = gui.renderString(g, "main", fmt.Sprintf("%s/%s\n\n%s", utils.ColoredString(remote.Name, color.FgRed), utils.ColoredString(remoteBranch.Name, color.FgGreen), graph))
+	}()
+
 	return nil
 }

@@ -60,12 +64,11 @@ func (gui *Gui) renderRemoteBranchesWithSelection() error {
 	branchesView := gui.getBranchesView()

 	gui.refreshSelectedLine(&gui.State.Panels.RemoteBranches.SelectedLine, len(gui.State.RemoteBranches))
-	displayStrings := presentation.GetRemoteBranchListDisplayStrings(gui.State.RemoteBranches)
-	gui.renderDisplayStrings(branchesView, displayStrings)
-	if gui.g.CurrentView() == branchesView && branchesView.Context == "remote-branches" {
-		if err := gui.handleRemoteBranchSelect(gui.g, branchesView); err != nil {
-			return err
-		}
+	if err := gui.renderListPanel(branchesView, gui.State.RemoteBranches); err != nil {
+		return err
+	}
+	if err := gui.handleRemoteBranchSelect(gui.g, branchesView); err != nil {
+		return err
 	}

 	return nil
@@ -129,12 +132,3 @@ func (gui *Gui) handleSetBranchUpstream(g *gocui.Gui, v *gocui.View) error {
 		return gui.refreshSidePanels(gui.g)
 	}, nil)
 }
-
-func (gui *Gui) handleCreateResetToRemoteBranchMenu(g *gocui.Gui, v *gocui.View) error {
-	selectedBranch := gui.getSelectedRemoteBranch()
-	if selectedBranch == nil {
-		return nil
-	}
-
-	return gui.createResetMenu(fmt.Sprintf("%s/%s", selectedBranch.RemoteName, selectedBranch.Name))
-}
@@ -7,7 +7,6 @@ import (
 	"github.com/fatih/color"
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )

@@ -37,11 +36,13 @@ func (gui *Gui) handleRemoteSelect(g *gocui.Gui, v *gocui.View) error {

 	remote := gui.getSelectedRemote()
 	if remote == nil {
-		return gui.newStringTask("main", "No remotes")
+		return gui.renderString(g, "main", "No remotes")
+	}
+	if err := gui.focusPoint(0, gui.State.Panels.Remotes.SelectedLine, len(gui.State.Remotes), v); err != nil {
+		return err
 	}
-	v.FocusPoint(0, gui.State.Panels.Remotes.SelectedLine)

-	return gui.newStringTask("main", fmt.Sprintf("%s\nUrls:\n%s", utils.ColoredString(remote.Name, color.FgGreen), strings.Join(remote.Urls, "\n")))
+	return gui.renderString(g, "main", fmt.Sprintf("%s\nUrls:\n%s", utils.ColoredString(remote.Name, color.FgGreen), strings.Join(remote.Urls, "\n")))
 }

 func (gui *Gui) refreshRemotes() error {
@@ -79,14 +80,11 @@ func (gui *Gui) renderRemotesWithSelection() error {
 	branchesView := gui.getBranchesView()

 	gui.refreshSelectedLine(&gui.State.Panels.Remotes.SelectedLine, len(gui.State.Remotes))
-
-	displayStrings := presentation.GetRemoteListDisplayStrings(gui.State.Remotes)
-	gui.renderDisplayStrings(branchesView, displayStrings)
-
-	if gui.g.CurrentView() == branchesView && branchesView.Context == "remotes" {
-		if err := gui.handleRemoteSelect(gui.g, branchesView); err != nil {
-			return err
-		}
+	if err := gui.renderListPanel(branchesView, gui.State.Remotes); err != nil {
+		return err
+	}
+	if err := gui.handleRemoteSelect(gui.g, branchesView); err != nil {
+		return err
 	}

 	return nil
@@ -1,52 +0,0 @@
-package gui
-
-import (
-	"fmt"
-
-	"github.com/fatih/color"
-)
-
-func (gui *Gui) createResetMenu(ref string) error {
-	strengths := []string{"soft", "mixed", "hard"}
-	menuItems := make([]*menuItem, len(strengths))
-	for i, strength := range strengths {
-		innerStrength := strength
-		menuItems[i] = &menuItem{
-			displayStrings: []string{
-				fmt.Sprintf("%s reset", strength),
-				color.New(color.FgRed).Sprint(
-					fmt.Sprintf("reset --%s %s", strength, ref),
-				),
-			},
-			onPress: func() error {
-				if err := gui.GitCommand.ResetToCommit(ref, innerStrength); err != nil {
-					return gui.createErrorPanel(gui.g, err.Error())
-				}
-
-				if err := gui.switchCommitsPanelContext("branch-commits"); err != nil {
-					return err
-				}
-
-				gui.State.Panels.Commits.SelectedLine = 0
-				gui.State.Panels.ReflogCommits.SelectedLine = 0
-
-				if err := gui.refreshCommits(gui.g); err != nil {
-					return err
-				}
-				if err := gui.refreshFiles(); err != nil {
-					return err
-				}
-				if err := gui.refreshBranches(gui.g); err != nil {
-					return err
-				}
-				if err := gui.resetOrigin(gui.getCommitsView()); err != nil {
-					return err
-				}
-
-				return gui.handleCommitSelect(gui.g, gui.getCommitsView())
-			},
-		}
-	}
-
-	return gui.createMenu(fmt.Sprintf("%s %s", gui.Tr.SLocalize("resetTo"), ref), menuItems, createMenuOptions{showCancel: true})
-}
@@ -1,94 +0,0 @@
-package gui
-
-import (
-	"fmt"
-
-	"github.com/jesseduffield/gocui"
-	"github.com/jesseduffield/lazygit/pkg/theme"
-	"github.com/jesseduffield/lazygit/pkg/utils"
-)
-
-func (gui *Gui) handleOpenSearch(g *gocui.Gui, v *gocui.View) error {
-	gui.State.Searching.isSearching = true
-	gui.State.Searching.view = v
-	gui.renderString(gui.g, "search", "")
-	if err := gui.switchFocus(gui.g, v, gui.getSearchView()); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (gui *Gui) handleSearch(g *gocui.Gui, v *gocui.View) error {
-	gui.State.Searching.searchString = gui.getSearchView().Buffer()
-	if err := gui.switchFocus(gui.g, nil, gui.State.Searching.view); err != nil {
-		return err
-	}
-
-	if err := gui.State.Searching.view.Search(gui.State.Searching.searchString); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (gui *Gui) onSelectItemWrapper(innerFunc func(int) error) func(int, int, int) error {
-	return func(y int, index int, total int) error {
-		if total == 0 {
-			gui.renderString(
-				gui.g,
-				"search",
-				fmt.Sprintf(
-					"no matches for '%s' %s",
-					gui.State.Searching.searchString,
-					utils.ColoredString(
-						fmt.Sprintf("%s: exit search mode", gui.getKeyDisplay("universal.return")),
-						theme.OptionsFgColor,
-					),
-				),
-			)
-			return nil
-		}
-		gui.renderString(
-			gui.g,
-			"search",
-			fmt.Sprintf(
-				"matches for '%s' (%d of %d) %s",
-				gui.State.Searching.searchString,
-				index+1,
-				total,
-				utils.ColoredString(
-					fmt.Sprintf(
-						"%s: next match, %s: previous match, %s: exit search mode",
-						gui.getKeyDisplay("universal.nextMatch"),
-						gui.getKeyDisplay("universal.prevMatch"),
-						gui.getKeyDisplay("universal.return"),
-					),
-					theme.OptionsFgColor,
-				),
-			),
-		)
-		if err := innerFunc(y); err != nil {
-			return err
-		}
-		return nil
-	}
-}
-
-func (gui *Gui) onSearchEscape() error {
-	gui.State.Searching.isSearching = false
-	if gui.State.Searching.view != nil {
-		gui.State.Searching.view.ClearSearch()
-		gui.State.Searching.view = nil
-	}
-
-	return nil
-}
-
-func (gui *Gui) handleSearchEscape(g *gocui.Gui, v *gocui.View) error {
-	if err := gui.switchFocus(gui.g, nil, gui.State.Searching.view); err != nil {
-		return err
-	}
-
-	return gui.onSearchEscape()
-}
@@ -12,13 +12,6 @@ func (gui *Gui) refreshStagingPanel(forceSecondaryFocused bool, selectedLineIdx

 	state := gui.State.Panels.LineByLine

-	// We need to force focus here because the confirmation panel for safely staging lines does not return focus automatically.
-	// This is because if we tell it to return focus it will unconditionally return it to the main panel which may not be what we want
-	// e.g. in the event that there's nothing left to stage.
-	if err := gui.switchFocus(gui.g, nil, gui.getMainView()); err != nil {
-		return err
-	}
-
 	file, err := gui.getSelectedFile(gui.g)
 	if err != nil {
 		if err != gui.Errors.ErrNoFiles {
@@ -94,37 +87,26 @@ func (gui *Gui) handleTogglePanel(g *gocui.Gui, v *gocui.View) error {
 }

 func (gui *Gui) handleStagingEscape(g *gocui.Gui, v *gocui.View) error {
-	gui.handleEscapeLineByLinePanel()
+	gui.State.Panels.LineByLine = nil

 	return gui.switchFocus(gui.g, nil, gui.getFilesView())
 }

-func (gui *Gui) handleToggleStagedSelection(g *gocui.Gui, v *gocui.View) error {
-	state := gui.State.Panels.LineByLine
-
-	return gui.applySelection(state.SecondaryFocused)
+func (gui *Gui) handleStageSelection(g *gocui.Gui, v *gocui.View) error {
+	return gui.applySelection(false)
 }

 func (gui *Gui) handleResetSelection(g *gocui.Gui, v *gocui.View) error {
-	state := gui.State.Panels.LineByLine
-
-	if state.SecondaryFocused {
-		// for backwards compatibility
-		return gui.applySelection(true)
-	}
-
-	if gui.Config.GetUserConfig().GetBool("gui.skipUnstageLineWarning") {
-		return gui.createConfirmationPanel(gui.g, gui.getMainView(), false, "unstage lines", "Are you sure you want to delete the selected lines (git reset)? It is irreversible.\nTo disable this dialogue set the config key of 'gui.skipUnstageLineWarning' to true", func(*gocui.Gui, *gocui.View) error {
-			return gui.applySelection(true)
-		}, nil)
-	} else {
-		return gui.applySelection(true)
-	}
+	return gui.applySelection(true)
 }

 func (gui *Gui) applySelection(reverse bool) error {
 	state := gui.State.Panels.LineByLine

+	if !reverse && state.SecondaryFocused {
+		return gui.createErrorPanel(gui.g, gui.Tr.SLocalize("CantStageStaged"))
+	}
+
 	file, err := gui.getSelectedFile(gui.g)
 	if err != nil {
 		return err
@@ -159,3 +141,11 @@ func (gui *Gui) applySelection(reverse bool) error {
 	}
 	return nil
 }
+
+func (gui *Gui) handleMouseDownSecondaryWhileStaging(g *gocui.Gui, v *gocui.View) error {
+	state := gui.State.Panels.LineByLine
+
+	state.SecondaryFocused = !state.SecondaryFocused
+
+	return gui.refreshStagingPanel(false, -1)
+}
@@ -1,9 +1,11 @@
 package gui

 import (
+	"fmt"
+
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
+	"github.com/jesseduffield/lazygit/pkg/utils"
 )

 // list panel functions
@@ -32,17 +34,16 @@ func (gui *Gui) handleStashEntrySelect(g *gocui.Gui, v *gocui.View) error {

 	stashEntry := gui.getSelectedStashEntry(v)
 	if stashEntry == nil {
-		return gui.newStringTask("main", gui.Tr.SLocalize("NoStashEntries"))
+		return gui.renderString(g, "main", gui.Tr.SLocalize("NoStashEntries"))
 	}
-	v.FocusPoint(0, gui.State.Panels.Stash.SelectedLine)
-
-	cmd := gui.OSCommand.ExecutableFromString(
-		gui.GitCommand.ShowStashEntryCmdStr(stashEntry.Index),
-	)
-	if err := gui.newPtyTask("main", cmd); err != nil {
-		gui.Log.Error(err)
+	if err := gui.focusPoint(0, gui.State.Panels.Stash.SelectedLine, len(gui.State.StashEntries), v); err != nil {
+		return err
 	}
-
+	go func() {
+		// doing this asynchronously cos it can take time
+		diff, _ := gui.GitCommand.GetStashEntryDiff(stashEntry.Index)
+		_ = gui.renderString(g, "main", diff)
+	}()
 	return nil
 }

@@ -52,12 +53,17 @@ func (gui *Gui) refreshStashEntries(g *gocui.Gui) error {

 		gui.refreshSelectedLine(&gui.State.Panels.Stash.SelectedLine, len(gui.State.StashEntries))

-		stashView := gui.getStashView()
+		isFocused := gui.g.CurrentView().Name() == "stash"
+		list, err := utils.RenderList(gui.State.StashEntries, isFocused)
+		if err != nil {
+			return err
+		}

-		displayStrings := presentation.GetStashEntryListDisplayStrings(gui.State.StashEntries)
-		gui.renderDisplayStrings(stashView, displayStrings)
+		v := gui.getStashView()
+		v.Clear()
+		fmt.Fprint(v, list)

-		if err := gui.resetOrigin(stashView); err != nil {
+		if err := gui.resetOrigin(v); err != nil {
 			return err
 		}
 		return nil
@@ -95,11 +101,9 @@ func (gui *Gui) stashDo(g *gocui.Gui, v *gocui.View, method string) error {
 		return gui.createErrorPanel(g, errorMessage)
 	}
 	if err := gui.GitCommand.StashDo(stashEntry.Index, method); err != nil {
-		return gui.createErrorPanel(g, err.Error())
-	}
-	if err := gui.refreshStashEntries(g); err != nil {
-		return gui.createErrorPanel(g, err.Error())
+		gui.createErrorPanel(g, err.Error())
 	}
+	gui.refreshStashEntries(g)
 	return gui.refreshFiles()
 }

@@ -109,16 +113,9 @@ func (gui *Gui) handleStashSave(stashFunc func(message string) error) error {
 	}
 	return gui.createPromptPanel(gui.g, gui.getFilesView(), gui.Tr.SLocalize("StashChanges"), "", func(g *gocui.Gui, v *gocui.View) error {
 		if err := stashFunc(gui.trimmedContent(v)); err != nil {
-			return gui.createErrorPanel(g, err.Error())
-		}
-		if err := gui.refreshStashEntries(g); err != nil {
-			return gui.createErrorPanel(g, err.Error())
+			gui.createErrorPanel(g, err.Error())
 		}
+		gui.refreshStashEntries(g)
 		return gui.refreshFiles()
 	})
 }
-
-func (gui *Gui) onStashPanelSearchSelect(selectedLine int) error {
-	gui.State.Panels.Stash.SelectedLine = selectedLine
-	return gui.handleStashEntrySelect(gui.g, gui.getStashView())
-}
@@ -6,7 +6,7 @@ import (

 	"github.com/fatih/color"
 	"github.com/jesseduffield/gocui"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
+	"github.com/jesseduffield/lazygit/pkg/commands"
 	"github.com/jesseduffield/lazygit/pkg/utils"
 )

@@ -22,20 +22,11 @@ func (gui *Gui) refreshStatus(g *gocui.Gui) error {
 	// contents end up cleared
 	g.Update(func(*gocui.Gui) error {
 		v.Clear()
-		// TODO: base this off of the current branch
 		state.pushables, state.pullables = gui.GitCommand.GetCurrentBranchUpstreamDifferenceCount()
 		if err := gui.updateWorkTreeState(); err != nil {
 			return err
 		}
-
-		trackColor := color.FgYellow
-		if state.pushables == "0" && state.pullables == "0" {
-			trackColor = color.FgGreen
-		} else if state.pushables == "?" && state.pullables == "?" {
-			trackColor = color.FgRed
-		}
-
-		status := utils.ColoredString(fmt.Sprintf("↑%s↓%s", state.pushables, state.pullables), trackColor)
+		status := fmt.Sprintf("↑%s↓%s", state.pushables, state.pullables)
 		branches := gui.State.Branches

 		if gui.State.WorkingTreeState != "normal" {
@@ -44,7 +35,7 @@ func (gui *Gui) refreshStatus(g *gocui.Gui) error {

 		if len(branches) > 0 {
 			branch := branches[0]
-			name := utils.ColoredString(branch.Name, presentation.GetBranchColor(branch.Name))
+			name := utils.ColoredString(branch.Name, commands.GetBranchColor(branch.Name))
 			repoName := utils.GetCurrentRepoName()
 			status += fmt.Sprintf(" %s → %s", repoName, name)
 		}
@@ -120,7 +111,7 @@ func (gui *Gui) handleStatusSelect(g *gocui.Gui, v *gocui.View) error {
 			magenta.Sprint("Become a sponsor (github is matching all donations for 12 months): https://github.com/sponsors/jesseduffield"), // caffeine ain't free
 		}, "\n\n")

-	return gui.newStringTask("main", dashboardString)
+	return gui.renderString(g, "main", dashboardString)
 }

 func (gui *Gui) handleOpenConfig(g *gocui.Gui, v *gocui.View) error {
@@ -145,14 +136,6 @@ func lazygitTitle() string {
 }

 func (gui *Gui) updateWorkTreeState() error {
-	rebaseMode, err := gui.GitCommand.RebaseMode()
-	if err != nil {
-		return err
-	}
-	if rebaseMode != "" {
-		gui.State.WorkingTreeState = "rebasing"
-		return nil
-	}
 	merging, err := gui.GitCommand.IsInMergeState()
 	if err != nil {
 		return err
@@ -161,6 +144,14 @@ func (gui *Gui) updateWorkTreeState() error {
 		gui.State.WorkingTreeState = "merging"
 		return nil
 	}
+	rebaseMode, err := gui.GitCommand.RebaseMode()
+	if err != nil {
+		return err
+	}
+	if rebaseMode != "" {
+		gui.State.WorkingTreeState = "rebasing"
+		return nil
+	}
 	gui.State.WorkingTreeState = "normal"
 	return nil
 }
@@ -1,9 +1,10 @@
 package gui

 import (
+	"fmt"
+
 	"github.com/jesseduffield/gocui"
 	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
 )

 // list panel functions
@@ -32,16 +33,25 @@ func (gui *Gui) handleTagSelect(g *gocui.Gui, v *gocui.View) error {

 	tag := gui.getSelectedTag()
 	if tag == nil {
-		return gui.newStringTask("main", "No tags")
+		return gui.renderString(g, "main", "No tags")
+	}
+	if err := gui.focusPoint(0, gui.State.Panels.Tags.SelectedLine, len(gui.State.Tags), v); err != nil {
+		return err
 	}
-	v.FocusPoint(0, gui.State.Panels.Tags.SelectedLine)

-	cmd := gui.OSCommand.ExecutableFromString(
-		gui.GitCommand.GetBranchGraphCmdStr(tag.Name),
-	)
-	if err := gui.newCmdTask("main", cmd); err != nil {
-		gui.Log.Error(err)
-	}
+	go func() {
+		show, err := gui.GitCommand.ShowTag(tag.Name)
+		if err != nil {
+			show = ""
+		}
+
+		graph, err := gui.GitCommand.GetBranchGraph(tag.Name)
+		if err != nil {
+			graph = "No graph for tag " + tag.Name
+		}
+
+		_ = gui.renderString(g, "main", fmt.Sprintf("%s\n%s", show, graph))
+	}()

 	return nil
 }
@@ -55,7 +65,7 @@ func (gui *Gui) refreshTags() error {
 	gui.State.Tags = tags

 	if gui.getBranchesView().Context == "tags" {
-		return gui.renderTagsWithSelection()
+		gui.renderTagsWithSelection()
 	}

 	return nil
@@ -65,12 +75,11 @@ func (gui *Gui) renderTagsWithSelection() error {
 	branchesView := gui.getBranchesView()

 	gui.refreshSelectedLine(&gui.State.Panels.Tags.SelectedLine, len(gui.State.Tags))
-	displayStrings := presentation.GetTagListDisplayStrings(gui.State.Tags)
-	gui.renderDisplayStrings(branchesView, displayStrings)
-	if gui.g.CurrentView() == branchesView && branchesView.Context == "tags" {
-		if err := gui.handleTagSelect(gui.g, branchesView); err != nil {
-			return err
-		}
+	if err := gui.renderListPanel(branchesView, gui.State.Tags); err != nil {
+		return err
+	}
+	if err := gui.handleTagSelect(gui.g, branchesView); err != nil {
+		return err
 	}

 	return nil
@@ -104,13 +113,7 @@ func (gui *Gui) handleDeleteTag(g *gocui.Gui, v *gocui.View) error {
 		if err := gui.GitCommand.DeleteTag(tag.Name); err != nil {
 			return gui.createErrorPanel(gui.g, err.Error())
 		}
-		if err := gui.refreshCommits(g); err != nil {
-			return gui.createErrorPanel(g, err.Error())
-		}
-		if err := gui.refreshTags(); err != nil {
-			return gui.createErrorPanel(g, err.Error())
-		}
-		return nil
+		return gui.refreshTags()
 	}, nil)
 }

@@ -141,21 +144,6 @@ func (gui *Gui) handleCreateTag(g *gocui.Gui, v *gocui.View) error {
 		if err := gui.GitCommand.CreateLightweightTag(v.Buffer(), ""); err != nil {
 			return gui.createErrorPanel(gui.g, err.Error())
 		}
-		if err := gui.refreshCommits(g); err != nil {
-			return gui.createErrorPanel(g, err.Error())
-		}
-		if err := gui.refreshTags(); err != nil {
-			return gui.createErrorPanel(g, err.Error())
-		}
-		return nil
+		return gui.refreshTags()
 	})
 }
-
-func (gui *Gui) handleCreateResetToTagMenu(g *gocui.Gui, v *gocui.View) error {
-	tag := gui.getSelectedTag()
-	if tag == nil {
-		return nil
-	}
-
-	return gui.createResetMenu(tag.Name)
-}
@@ -1,92 +0,0 @@
-package gui
-
-import (
-	"os/exec"
-
-	"github.com/jesseduffield/gocui"
-	"github.com/jesseduffield/lazygit/pkg/tasks"
-)
-
-func (gui *Gui) newCmdTask(viewName string, cmd *exec.Cmd) error {
-	view, err := gui.g.View(viewName)
-	if err != nil {
-		return nil // swallowing for now
-	}
-
-	_, height := view.Size()
-	_, oy := view.Origin()
-
-	manager := gui.getManager(view)
-
-	r, err := cmd.StdoutPipe()
-	if err != nil {
-		return err
-	}
-	cmd.Stderr = cmd.Stdout
-
-	if err := cmd.Start(); err != nil {
-		return err
-	}
-
-	if err := manager.NewTask(manager.NewCmdTask(r, cmd, height+oy+10, nil)); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (gui *Gui) newTask(viewName string, f func(chan struct{}) error) error {
-	view, err := gui.g.View(viewName)
-	if err != nil {
-		return nil // swallowing for now
-	}
-
-	manager := gui.getManager(view)
-
-	if err := manager.NewTask(f); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (gui *Gui) newStringTask(viewName string, str string) error {
-	view, err := gui.g.View(viewName)
-	if err != nil {
-		return nil // swallowing for now
-	}
-
-	manager := gui.getManager(view)
-
-	f := func(stop chan struct{}) error {
-		gui.renderString(gui.g, viewName, str)
-		return nil
-	}
-
-	if err := manager.NewTask(f); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (gui *Gui) getManager(view *gocui.View) *tasks.ViewBufferManager {
-	manager, ok := gui.viewBufferManagerMap[view.Name()]
-	if !ok {
-		manager = tasks.NewViewBufferManager(
-			gui.Log,
-			view,
-			func() {
-				view.Clear()
-			},
-			func() {
-				gui.g.Update(func(*gocui.Gui) error {
-					gui.Log.Warn("updating view")
-					return nil
-				})
-			})
-		gui.viewBufferManagerMap[view.Name()] = manager
-	}
-
-	return manager
-}
@@ -47,7 +47,9 @@ func (gui *Gui) startUpdating(newVersion string) {
 func (gui *Gui) onUpdateFinish(err error) error {
 	gui.State.Updating = false
 	gui.statusManager.removeStatus("updating")
-	gui.renderString(gui.g, "appStatus", "")
+	if err := gui.renderString(gui.g, "appStatus", ""); err != nil {
+		return err
+	}
 	if err != nil {
 		return gui.createErrorPanel(gui.g, "Update failed: "+err.Error())
 	}
@@ -135,8 +135,6 @@ func (gui *Gui) newLineFocused(g *gocui.Gui, v *gocui.View) error {
 		}
 		v.Highlight = false
 		return nil
-	case "search":
-		return nil
 	default:
 		panic(gui.Tr.SLocalize("NoViewMachingNewLineFocusedSwitchStatement"))
 	}
@@ -218,18 +216,50 @@ func (gui *Gui) resetOrigin(v *gocui.View) error {
 	return v.SetOrigin(0, 0)
 }

+// if the cursor down past the last item, move it to the last line
+func (gui *Gui) focusPoint(cx int, cy int, lineCount int, v *gocui.View) error {
+	if cy < 0 || cy > lineCount {
+		return nil
+	}
+	ox, oy := v.Origin()
+	_, height := v.Size()
+
+	ly := height - 1
+	if ly == -1 {
+		ly = 0
+	}
+
+	// if line is above origin, move origin and set cursor to zero
+	// if line is below origin + height, move origin and set cursor to max
+	// otherwise set cursor to value - origin
+	if ly > lineCount {
+		_ = v.SetCursor(cx, cy)
+		_ = v.SetOrigin(ox, 0)
+	} else if cy < oy {
+		_ = v.SetCursor(cx, 0)
+		_ = v.SetOrigin(ox, cy)
+	} else if cy > oy+ly {
+		_ = v.SetCursor(cx, ly)
+		_ = v.SetOrigin(ox, cy-ly)
+	} else {
+		_ = v.SetCursor(cx, cy-oy)
+	}
+	return nil
+}
+
 func (gui *Gui) cleanString(s string) string {
 	output := string(bom.Clean([]byte(s)))
 	return utils.NormalizeLinefeeds(output)
 }

-func (gui *Gui) setViewContent(g *gocui.Gui, v *gocui.View, s string) {
+func (gui *Gui) setViewContent(g *gocui.Gui, v *gocui.View, s string) error {
 	v.Clear()
 	fmt.Fprint(v, gui.cleanString(s))
+	return nil
 }

 // renderString resets the origin of a view and sets its content
-func (gui *Gui) renderString(g *gocui.Gui, viewName, s string) {
+func (gui *Gui) renderString(g *gocui.Gui, viewName, s string) error {
 	g.Update(func(*gocui.Gui) error {
 		v, err := g.View(viewName)
 		if err != nil {
@@ -238,12 +268,9 @@ func (gui *Gui) renderString(g *gocui.Gui, viewName, s string) {
 		if err := v.SetOrigin(0, 0); err != nil {
 			return err
 		}
-		if err := v.SetCursor(0, 0); err != nil {
-			return err
-		}
-		gui.setViewContent(gui.g, v, s)
-		return nil
+		return gui.setViewContent(gui.g, v, s)
 	})
+	return nil
 }

 func (gui *Gui) optionsMapToString(optionsMap map[string]string) string {
@@ -256,8 +283,7 @@ func (gui *Gui) optionsMapToString(optionsMap map[string]string) string {
 }

 func (gui *Gui) renderOptionsMap(optionsMap map[string]string) error {
-	gui.renderString(gui.g, "options", gui.optionsMapToString(optionsMap))
-	return nil
+	return gui.renderString(gui.g, "options", gui.optionsMapToString(optionsMap))
 }

 // TODO: refactor properly
@@ -307,11 +333,6 @@ func (gui *Gui) getMenuView() *gocui.View {
 	return v
 }

-func (gui *Gui) getSearchView() *gocui.View {
-	v, _ := gui.g.View("search")
-	return v
-}
-
 func (gui *Gui) trimmedContent(v *gocui.View) string {
 	return strings.TrimSpace(v.Buffer())
 }
@@ -343,6 +364,22 @@ func (gui *Gui) resizePopupPanel(g *gocui.Gui, v *gocui.View) error {
 	return err
 }

+// generalFocusLine takes a lineNumber to focus, and a bottomLine to ensure we can see
+func (gui *Gui) generalFocusLine(lineNumber int, bottomLine int, v *gocui.View) error {
+	_, height := v.Size()
+	overScroll := bottomLine - height + 1
+	if overScroll < 0 {
+		overScroll = 0
+	}
+	if err := v.SetOrigin(0, overScroll); err != nil {
+		return err
+	}
+	if err := v.SetCursor(0, lineNumber-overScroll); err != nil {
+		return err
+	}
+	return nil
+}
+
 func (gui *Gui) changeSelectedLine(line *int, total int, change int) {
 	// TODO: find out why we're doing this
 	if *line == -1 {
@@ -365,13 +402,18 @@ func (gui *Gui) refreshSelectedLine(line *int, total int) {
 	}
 }

-func (gui *Gui) renderDisplayStrings(v *gocui.View, displayStrings [][]string) {
+func (gui *Gui) renderListPanel(v *gocui.View, items interface{}) error {
 	gui.g.Update(func(g *gocui.Gui) error {
-		list := utils.RenderDisplayStrings(displayStrings)
+		isFocused := gui.g.CurrentView().Name() == v.Name()
+		list, err := utils.RenderList(items, isFocused)
+		if err != nil {
+			return gui.createErrorPanel(gui.g, err.Error())
+		}
 		v.Clear()
 		fmt.Fprint(v, list)
 		return nil
 	})
+	return nil
 }

 func (gui *Gui) renderPanelOptions() error {
@@ -387,6 +429,11 @@ func (gui *Gui) renderPanelOptions() error {
 	return gui.renderGlobalOptions()
 }

+func (gui *Gui) handleFocusView(g *gocui.Gui, v *gocui.View) error {
+	_, err := gui.g.SetCurrentView(v.Name())
+	return err
+}
+
 func (gui *Gui) isPopupPanel(viewName string) bool {
 	return viewName == "commitMessage" || viewName == "credentials" || viewName == "confirmation" || viewName == "menu"
 }
@@ -5,16 +5,23 @@ import (
 	"github.com/jesseduffield/gocui"
 )

-func (gui *Gui) handleCreateResetMenu(g *gocui.Gui, v *gocui.View) error {
-	red := color.New(color.FgRed)
+type workspaceResetOption struct {
+	handler     func() error
+	description string
+	command     string
+}

-	menuItems := []*menuItem{
+// GetDisplayStrings is a function.
+func (r *workspaceResetOption) GetDisplayStrings(isFocused bool) []string {
+	return []string{r.description, color.New(color.FgRed).Sprint(r.command)}
+}
+
+func (gui *Gui) handleCreateResetMenu(g *gocui.Gui, v *gocui.View) error {
+	options := []*workspaceResetOption{
 		{
-			displayStrings: []string{
-				gui.Tr.SLocalize("discardAllChangesToAllFiles"),
-				red.Sprint("reset --hard HEAD && git clean -fd"),
-			},
-			onPress: func() error {
+			description: gui.Tr.SLocalize("discardAllChangesToAllFiles"),
+			command:     "reset --hard HEAD && git clean -fd",
+			handler: func() error {
 				if err := gui.GitCommand.ResetAndClean(); err != nil {
 					return gui.createErrorPanel(gui.g, err.Error())
 				}
@@ -23,11 +30,9 @@ func (gui *Gui) handleCreateResetMenu(g *gocui.Gui, v *gocui.View) error {
 			},
 		},
 		{
-			displayStrings: []string{
-				gui.Tr.SLocalize("discardAnyUnstagedChanges"),
-				red.Sprint("git checkout -- ."),
-			},
-			onPress: func() error {
+			description: gui.Tr.SLocalize("discardAnyUnstagedChanges"),
+			command:     "git checkout -- .",
+			handler: func() error {
 				if err := gui.GitCommand.DiscardAnyUnstagedFileChanges(); err != nil {
 					return gui.createErrorPanel(gui.g, err.Error())
 				}
@@ -36,11 +41,9 @@ func (gui *Gui) handleCreateResetMenu(g *gocui.Gui, v *gocui.View) error {
 			},
 		},
 		{
-			displayStrings: []string{
-				gui.Tr.SLocalize("discardUntrackedFiles"),
-				red.Sprint("git clean -fd"),
-			},
-			onPress: func() error {
+			description: gui.Tr.SLocalize("discardUntrackedFiles"),
+			command:     "git clean -fd",
+			handler: func() error {
 				if err := gui.GitCommand.RemoveUntrackedFiles(); err != nil {
 					return gui.createErrorPanel(gui.g, err.Error())
 				}
@@ -49,11 +52,9 @@ func (gui *Gui) handleCreateResetMenu(g *gocui.Gui, v *gocui.View) error {
 			},
 		},
 		{
-			displayStrings: []string{
-				gui.Tr.SLocalize("softReset"),
-				red.Sprint("git reset --soft HEAD"),
-			},
-			onPress: func() error {
+			description: gui.Tr.SLocalize("softReset"),
+			command:     "git reset --soft HEAD",
+			handler: func() error {
 				if err := gui.GitCommand.ResetSoft("HEAD"); err != nil {
 					return gui.createErrorPanel(gui.g, err.Error())
 				}
@@ -62,24 +63,9 @@ func (gui *Gui) handleCreateResetMenu(g *gocui.Gui, v *gocui.View) error {
 			},
 		},
 		{
-			displayStrings: []string{
-				"mixed reset",
-				red.Sprint("git reset --mixed HEAD"),
-			},
-			onPress: func() error {
-				if err := gui.GitCommand.ResetSoft("HEAD"); err != nil {
-					return gui.createErrorPanel(gui.g, err.Error())
-				}
-
-				return gui.refreshFiles()
-			},
-		},
-		{
-			displayStrings: []string{
-				gui.Tr.SLocalize("hardReset"),
-				red.Sprint("git reset --hard HEAD"),
-			},
-			onPress: func() error {
+			description: gui.Tr.SLocalize("hardReset"),
+			command:     "git reset --hard HEAD",
+			handler: func() error {
 				if err := gui.GitCommand.ResetHard("HEAD"); err != nil {
 					return gui.createErrorPanel(gui.g, err.Error())
 				}
@@ -87,7 +73,28 @@ func (gui *Gui) handleCreateResetMenu(g *gocui.Gui, v *gocui.View) error {
 				return gui.refreshFiles()
 			},
 		},
+		{
+			description: gui.Tr.SLocalize("hardResetUpstream"),
+			command:     "git reset --hard @{upstream}",
+			handler: func() error {
+				if err := gui.GitCommand.ResetHard("@{upstream}"); err != nil {
+					return gui.createErrorPanel(gui.g, err.Error())
+				}
+
+				return gui.refreshSidePanels(gui.g)
+			},
+		},
+		{
+			description: gui.Tr.SLocalize("cancel"),
+			handler: func() error {
+				return nil
+			},
+		},
 	}

-	return gui.createMenu("", menuItems, createMenuOptions{showCancel: true})
+	handleMenuPress := func(index int) error {
+		return options[index].handler()
+	}
+
+	return gui.createMenu("", options, len(options), handleMenuPress)
 }
@@ -136,6 +136,9 @@ func addDutch(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "CannotGitAdd",
 			Other: "Kan commando niet uitvoeren git add --path untracked files",
+		}, &i18n.Message{
+			ID:    "CantIgnoreTrackFiles",
+			Other: "Kan gevolgde bestanden niet negeren",
 		}, &i18n.Message{
 			ID:    "NoStagedFilesToCommit",
 			Other: "Er zijn geen staged bestanden om te commiten",
@@ -757,12 +760,6 @@ func addDutch(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "ReturnToRemotesList",
 			Other: `return to remotes list`,
-		}, &i18n.Message{
-			ID:    "IgnoreTracked",
-			Other: "Ignore tracked file",
-		}, &i18n.Message{
-			ID:    "IgnoreTrackedPrompt",
-			Other: "Are you sure you want to ignore a tracked file?",
 		},
 	)
 }
@@ -162,6 +162,9 @@ func addEnglish(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "CannotGitAdd",
 			Other: "Cannot git add --patch untracked files",
+		}, &i18n.Message{
+			ID:    "CantIgnoreTrackFiles",
+			Other: "Cannot ignore tracked files",
 		}, &i18n.Message{
 			ID:    "NoStagedFilesToCommit",
 			Other: "There are no staged files to commit",
@@ -501,19 +504,16 @@ func addEnglish(i18nObject *i18n.Bundle) error {
 			Other: `select hunk`,
 		}, &i18n.Message{
 			ID:    "StageSelection",
-			Other: `toggle line staged / unstaged`,
+			Other: `stage selection`,
 		}, &i18n.Message{
 			ID:    "ResetSelection",
-			Other: `delete change (git reset)`,
+			Other: `reset selection`,
 		}, &i18n.Message{
 			ID:    "ToggleDragSelect",
 			Other: `toggle drag select`,
 		}, &i18n.Message{
 			ID:    "ToggleSelectHunk",
 			Other: `toggle select hunk`,
-		}, &i18n.Message{
-			ID:    "ToggleSelectionForPatch",
-			Other: `add/remove line(s) to patch`,
 		},
 		&i18n.Message{
 			ID:    "TogglePanel",
@@ -567,54 +567,6 @@ func addEnglish(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "RebaseOptionsTitle",
 			Other: "Rebase Options",
-		}, &i18n.Message{
-			ID:    "CommitMessageTitle",
-			Other: "Commit Message",
-		}, &i18n.Message{
-			ID:    "Local-BranchesTitle",
-			Other: "Branches Tab",
-		}, &i18n.Message{
-			ID:    "SearchTitle",
-			Other: "Search",
-		}, &i18n.Message{
-			ID:    "TagsTitle",
-			Other: "Tags Tab",
-		}, &i18n.Message{
-			ID:    "Branch-CommitsTitle",
-			Other: "Commits Tab",
-		}, &i18n.Message{
-			ID:    "MenuTitle",
-			Other: "Menu",
-		}, &i18n.Message{
-			ID:    "RemotesTitle",
-			Other: "Remotes Tab",
-		}, &i18n.Message{
-			ID:    "CredentialsTitle",
-			Other: "Credentials",
-		}, &i18n.Message{
-			ID:    "Remote-BranchesTitle",
-			Other: "Remote Branches (in Remotes tab)",
-		}, &i18n.Message{
-			ID:    "Patch-BuildingTitle",
-			Other: "Patch Building",
-		}, &i18n.Message{
-			ID:    "InformationTitle",
-			Other: "Information",
-		}, &i18n.Message{
-			ID:    "SecondaryTitle",
-			Other: "Secondary",
-		}, &i18n.Message{
-			ID:    "Reflog-CommitsTitle",
-			Other: "Reflog Tab",
-		}, &i18n.Message{
-			ID:    "Title",
-			Other: "Title",
-		}, &i18n.Message{
-			ID:    "GlobalTitle",
-			Other: "Global Keybindings",
-		}, &i18n.Message{
-			ID:    "MerginTitle",
-			Other: "Mergin",
 		}, &i18n.Message{
 			ID:    "ConflictsResolved",
 			Other: "all merge conflicts resolved. Continue?",
@@ -702,12 +654,6 @@ func addEnglish(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "ScrollUp",
 			Other: "scroll up",
-		}, &i18n.Message{
-			ID:    "scrollUpMainPanel",
-			Other: "scroll up main panel",
-		}, &i18n.Message{
-			ID:    "scrollDownMainPanel",
-			Other: "scroll down main panel",
 		}, &i18n.Message{
 			ID:    "AmendCommitTitle",
 			Other: "Amend Commit",
@@ -749,7 +695,7 @@ func addEnglish(i18nObject *i18n.Bundle) error {
 			Other: "view commit's files",
 		}, &i18n.Message{
 			ID:    "CommitFilesTitle",
-			Other: "Commit Files",
+			Other: "Commit files",
 		}, &i18n.Message{
 			ID:    "goBack",
 			Other: "go back",
@@ -993,54 +939,6 @@ func addEnglish(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "NewBranchNamePrompt",
 			Other: "new {{.branchType}} name:",
-		}, &i18n.Message{
-			ID:    "IgnoreTracked",
-			Other: "Ignore tracked file",
-		}, &i18n.Message{
-			ID:    "IgnoreTrackedPrompt",
-			Other: "Are you sure you want to ignore a tracked file?",
-		}, &i18n.Message{
-			ID:    "viewResetToUpstreamOptions",
-			Other: "view upstream reset options",
-		}, &i18n.Message{
-			ID:    "nextScreenMode",
-			Other: "next screen mode (normal/half/fullscreen)",
-		}, &i18n.Message{
-			ID:    "prevScreenMode",
-			Other: "prev screen mode",
-		}, &i18n.Message{
-			ID:    "startSearch",
-			Other: "start search",
-		}, &i18n.Message{
-			ID:    "Panel",
-			Other: "Panel",
-		}, &i18n.Message{
-			ID:    "Keybindings",
-			Other: "Keybindings",
-		}, &i18n.Message{
-			ID:    "renameBranch",
-			Other: "rename branch",
-		}, &i18n.Message{
-			ID:    "NewBranchNamePrompt",
-			Other: "Enter new branch name for branch",
-		}, &i18n.Message{
-			ID:    "RenameBranchWarning",
-			Other: "This branch is tracking a remote. This action will only rename the local branch name, not the name of the remote branch. Continue?",
-		}, &i18n.Message{
-			ID:    "openMenu",
-			Other: "open menu",
-		}, &i18n.Message{
-			ID:    "closeMenu",
-			Other: "close menu",
-		}, &i18n.Message{
-			ID:    "resetCherryPick",
-			Other: "reset cherry-picked (copied) commits selection",
-		}, &i18n.Message{
-			ID:    "nextTab",
-			Other: "next tab",
-		}, &i18n.Message{
-			ID:    "prevTab",
-			Other: "previous tab",
 		},
 	)
 }
@@ -128,6 +128,9 @@ func addPolish(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "CannotGitAdd",
 			Other: "Nie można git add --patch nieśledzonych plików",
+		}, &i18n.Message{
+			ID:    "CantIgnoreTrackFiles",
+			Other: "Nie można zignorować nieśledzonych plików",
 		}, &i18n.Message{
 			ID:    "NoStagedFilesToCommit",
 			Other: "Brak zatwierdzonych plików do commita",
@@ -740,12 +743,6 @@ func addPolish(i18nObject *i18n.Bundle) error {
 		}, &i18n.Message{
 			ID:    "ReturnToRemotesList",
 			Other: `return to remotes list`,
-		}, &i18n.Message{
-			ID:    "IgnoreTracked",
-			Other: "Ignore tracked file",
-		}, &i18n.Message{
-			ID:    "IgnoreTrackedPrompt",
-			Other: "Are you sure you want to ignore a tracked file?",
 		},
 	)
 }
@@ -1,225 +0,0 @@
-package tasks
-
-import (
-	"bufio"
-	"fmt"
-	"io"
-	"os/exec"
-	"sync"
-	"time"
-
-	"github.com/jesseduffield/lazygit/pkg/commands"
-	"github.com/sirupsen/logrus"
-)
-
-type Task struct {
-	stop          chan struct{}
-	stopped       bool
-	stopMutex     sync.Mutex
-	notifyStopped chan struct{}
-	Log           *logrus.Entry
-	f             func(chan struct{}) error
-}
-
-type ViewBufferManager struct {
-	writer       io.Writer
-	currentTask  *Task
-	waitingMutex sync.Mutex
-	taskIDMutex  sync.Mutex
-	Log          *logrus.Entry
-	newTaskId    int
-	readLines    chan int
-
-	// beforeStart is the function that is called before starting a new task
-	beforeStart func()
-	refreshView func()
-}
-
-func NewViewBufferManager(log *logrus.Entry, writer io.Writer, beforeStart func(), refreshView func()) *ViewBufferManager {
-	return &ViewBufferManager{Log: log, writer: writer, beforeStart: beforeStart, refreshView: refreshView, readLines: make(chan int, 1024)}
-}
-
-func (m *ViewBufferManager) ReadLines(n int) {
-	go func() {
-		m.readLines <- n
-	}()
-}
-
-func (m *ViewBufferManager) NewCmdTask(r io.Reader, cmd *exec.Cmd, linesToRead int, onDone func()) func(chan struct{}) error {
-	return func(stop chan struct{}) error {
-		go func() {
-			<-stop
-			if err := commands.Kill(cmd); err != nil {
-				m.Log.Warn(err)
-			}
-			if onDone != nil {
-				onDone()
-			}
-		}()
-
-		loadingMutex := sync.Mutex{}
-
-		// not sure if it's the right move to redefine this or not
-		m.readLines = make(chan int, 1024)
-
-		done := make(chan struct{})
-
-		go func() {
-			scanner := bufio.NewScanner(r)
-			scanner.Split(bufio.ScanLines)
-
-			loaded := false
-
-			go func() {
-				ticker := time.NewTicker(time.Millisecond * 100)
-				defer ticker.Stop()
-				select {
-				case <-ticker.C:
-					loadingMutex.Lock()
-					if !loaded {
-						m.beforeStart()
-						_, _ = m.writer.Write([]byte("loading..."))
-						m.refreshView()
-					}
-					loadingMutex.Unlock()
-				case <-stop:
-					return
-				}
-			}()
-
-		outer:
-			for {
-				select {
-				case linesToRead := <-m.readLines:
-					for i := 0; i < linesToRead; i++ {
-						ok := scanner.Scan()
-						loadingMutex.Lock()
-						if !loaded {
-							m.beforeStart()
-							loaded = true
-						}
-						loadingMutex.Unlock()
-
-						select {
-						case <-stop:
-							m.refreshView()
-							break outer
-						default:
-						}
-						if !ok {
-							m.refreshView()
-							break outer
-						}
-						_, _ = m.writer.Write(append(scanner.Bytes(), []byte("\n")...))
-					}
-					m.refreshView()
-				case <-stop:
-					m.refreshView()
-					break outer
-				}
-			}
-
-			if err := cmd.Wait(); err != nil {
-				m.Log.Warn(err)
-			}
-
-			m.refreshView()
-
-			if onDone != nil {
-				onDone()
-			}
-
-			close(done)
-		}()
-
-		m.readLines <- linesToRead
-
-		<-done
-
-		return nil
-	}
-}
-
-// Close closes the task manager, killing whatever task may currently be running
-func (t *ViewBufferManager) Close() {
-	if t.currentTask == nil {
-		return
-	}
-
-	c := make(chan struct{})
-
-	go func() {
-		t.currentTask.Stop()
-		c <- struct{}{}
-	}()
-
-	select {
-	case <-c:
-		return
-	case <-time.After(3 * time.Second):
-		fmt.Println("cannot kill child process")
-	}
-}
-
-// different kinds of tasks:
-// 1) command based, where the manager can be asked to read more lines,  but the command can be killed
-// 2) string based, where the manager can also be asked to read more lines
-
-func (m *ViewBufferManager) NewTask(f func(stop chan struct{}) error) error {
-	go func() {
-		m.taskIDMutex.Lock()
-		m.newTaskId++
-		taskID := m.newTaskId
-		m.Log.Infof("starting task %d", taskID)
-		m.taskIDMutex.Unlock()
-
-		m.waitingMutex.Lock()
-		defer m.waitingMutex.Unlock()
-
-		m.Log.Infof("done waiting")
-		if taskID < m.newTaskId {
-			m.Log.Infof("returning cos the task is obsolete")
-			return
-		}
-
-		stop := make(chan struct{})
-		notifyStopped := make(chan struct{})
-
-		if m.currentTask != nil {
-			m.Log.Info("asking task to stop")
-			m.currentTask.Stop()
-			m.Log.Info("task stopped")
-		}
-
-		m.currentTask = &Task{
-			stop:          stop,
-			notifyStopped: notifyStopped,
-			Log:           m.Log,
-			f:             f,
-		}
-
-		go func() {
-			if err := f(stop); err != nil {
-				m.Log.Error(err) // might need an onError callback
-			}
-
-			m.Log.Infof("returning from task %d", taskID)
-			close(notifyStopped)
-		}()
-	}()
-
-	return nil
-}
-
-func (t *Task) Stop() {
-	t.stopMutex.Lock()
-	defer t.stopMutex.Unlock()
-	if t.stopped {
-		return
-	}
-	close(t.stop)
-	t.Log.Info("closed stop channel, waiting for notifyStopped message")
-	<-t.notifyStopped
-	t.Log.Info("received notifystopped message")
-	t.stopped = true
-}
@@ -3,7 +3,6 @@ package test
 import (
 	"fmt"
 	"os/exec"
-	"regexp"
 	"strings"
 	"testing"

@@ -44,15 +43,3 @@ func CreateMockCommand(t *testing.T, swappers []*CommandSwapper) func(cmd string
 		return command
 	}
 }
-
-func AssertContainsMatch(t *testing.T, strs []string, pattern *regexp.Regexp, message string) {
-	t.Helper()
-
-	for _, str := range strs {
-		if pattern.Match([]byte(str)) {
-			return
-		}
-	}
-
-	assert.Fail(t, message)
-}
@@ -20,22 +20,12 @@ var (

 	// InactiveBorderColor is the border color of the inactive active frames
 	InactiveBorderColor gocui.Attribute
-
-	// SelectedLineBgColor is the background color for the selected line
-	SelectedLineBgColor color.Attribute
-
-	OptionsFgColor color.Attribute
-
-	OptionsColor gocui.Attribute
 )

 // UpdateTheme updates all theme variables
 func UpdateTheme(userConfig *viper.Viper) {
-	ActiveBorderColor = GetGocuiColor(userConfig.GetStringSlice("gui.theme.activeBorderColor"))
-	InactiveBorderColor = GetGocuiColor(userConfig.GetStringSlice("gui.theme.inactiveBorderColor"))
-	SelectedLineBgColor = GetBgColor(userConfig.GetStringSlice("gui.theme.selectedLineBgColor"))
-	OptionsColor = GetGocuiColor(userConfig.GetStringSlice("gui.theme.optionsTextColor"))
-	OptionsFgColor = GetFgColor(userConfig.GetStringSlice("gui.theme.optionsTextColor"))
+	ActiveBorderColor = getColor(userConfig.GetStringSlice("gui.theme.activeBorderColor"))
+	InactiveBorderColor = getColor(userConfig.GetStringSlice("gui.theme.inactiveBorderColor"))

 	isLightTheme := userConfig.GetBool("gui.theme.lightTheme")
 	if isLightTheme {
@@ -49,8 +39,8 @@ func UpdateTheme(userConfig *viper.Viper) {
 	}
 }

-// GetAttribute gets the gocui color attribute from the string
-func GetGocuiAttribute(key string) gocui.Attribute {
+// getAttribute gets the gocui color attribute from the string
+func getAttribute(key string) gocui.Attribute {
 	colorMap := map[string]gocui.Attribute{
 		"default":   gocui.ColorDefault,
 		"black":     gocui.ColorBlack,
@@ -72,75 +62,43 @@ func GetGocuiAttribute(key string) gocui.Attribute {
 	return gocui.ColorWhite
 }

-// GetFgAttribute gets the color foreground attribute from the string
-func GetFgAttribute(key string) color.Attribute {
-	colorMap := map[string]color.Attribute{
-		"default":   color.FgWhite,
-		"black":     color.FgBlack,
-		"red":       color.FgRed,
-		"green":     color.FgGreen,
-		"yellow":    color.FgYellow,
-		"blue":      color.FgBlue,
-		"magenta":   color.FgMagenta,
-		"cyan":      color.FgCyan,
-		"white":     color.FgWhite,
-		"bold":      color.Bold,
-		"reverse":   color.ReverseVideo,
-		"underline": color.Underline,
-	}
-	value, present := colorMap[key]
-	if present {
-		return value
-	}
-	return color.FgWhite
-}
-
-// GetBgAttribute gets the color background attribute from the string
-func GetBgAttribute(key string) color.Attribute {
-	colorMap := map[string]color.Attribute{
-		"default":   color.BgWhite,
-		"black":     color.BgBlack,
-		"red":       color.BgRed,
-		"green":     color.BgGreen,
-		"yellow":    color.BgYellow,
-		"blue":      color.BgBlue,
-		"magenta":   color.BgMagenta,
-		"cyan":      color.BgCyan,
-		"white":     color.BgWhite,
-		"bold":      color.Bold,
-		"reverse":   color.ReverseVideo,
-		"underline": color.Underline,
-	}
-	value, present := colorMap[key]
-	if present {
-		return value
-	}
-	return color.FgWhite
-}
-
-// GetGocuiColor bitwise OR's a list of attributes obtained via the given keys
-func GetGocuiColor(keys []string) gocui.Attribute {
+// getColor bitwise OR's a list of attributes obtained via the given keys
+func getColor(keys []string) gocui.Attribute {
 	var attribute gocui.Attribute
 	for _, key := range keys {
-		attribute |= GetGocuiAttribute(key)
+		attribute |= getAttribute(key)
 	}
 	return attribute
 }

-// GetColor bitwise OR's a list of attributes obtained via the given keys
-func GetBgColor(keys []string) color.Attribute {
-	var attribute color.Attribute
-	for _, key := range keys {
-		attribute |= GetBgAttribute(key)
+// GetAttribute gets the gocui color attribute from the string
+func GetAttribute(key string) gocui.Attribute {
+	colorMap := map[string]gocui.Attribute{
+		"default":   gocui.ColorDefault,
+		"black":     gocui.ColorBlack,
+		"red":       gocui.ColorRed,
+		"green":     gocui.ColorGreen,
+		"yellow":    gocui.ColorYellow,
+		"blue":      gocui.ColorBlue,
+		"magenta":   gocui.ColorMagenta,
+		"cyan":      gocui.ColorCyan,
+		"white":     gocui.ColorWhite,
+		"bold":      gocui.AttrBold,
+		"reverse":   gocui.AttrReverse,
+		"underline": gocui.AttrUnderline,
 	}
-	return attribute
+	value, present := colorMap[key]
+	if present {
+		return value
+	}
+	return gocui.ColorWhite
 }

 // GetColor bitwise OR's a list of attributes obtained via the given keys
-func GetFgColor(keys []string) color.Attribute {
-	var attribute color.Attribute
+func GetColor(keys []string) gocui.Attribute {
+	var attribute gocui.Attribute
 	for _, key := range keys {
-		attribute |= GetFgAttribute(key)
+		attribute |= GetAttribute(key)
 	}
 	return attribute
 }
@@ -6,10 +6,13 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+	"reflect"
 	"regexp"
 	"strings"
 	"time"

+	"github.com/go-errors/errors"
+
 	"github.com/fatih/color"
 )

@@ -111,11 +114,51 @@ func Min(x, y int) int {
 	return y
 }

-func RenderDisplayStrings(displayStringsArr [][]string) string {
-	padWidths := getPadWidths(displayStringsArr)
-	paddedDisplayStrings := getPaddedDisplayStrings(displayStringsArr, padWidths)
+type Displayable interface {
+	GetDisplayStrings(bool) []string
+}

-	return strings.Join(paddedDisplayStrings, "\n")
+// RenderList takes a slice of items, confirms they implement the Displayable
+// interface, then generates a list of their displaystrings to write to a panel's
+// buffer
+func RenderList(slice interface{}, isFocused bool) (string, error) {
+	s := reflect.ValueOf(slice)
+	if s.Kind() != reflect.Slice {
+		return "", errors.New("RenderList given a non-slice type")
+	}
+
+	displayables := make([]Displayable, s.Len())
+
+	for i := 0; i < s.Len(); i++ {
+		value, ok := s.Index(i).Interface().(Displayable)
+		if !ok {
+			return "", errors.New("item does not implement the Displayable interface")
+		}
+		displayables[i] = value
+	}
+
+	return renderDisplayableList(displayables, isFocused)
+}
+
+// renderDisplayableList takes a list of displayable items, obtains their display
+// strings via GetDisplayStrings() and then returns a single string containing
+// each item's string representation on its own line, with appropriate horizontal
+// padding between the item's own strings
+func renderDisplayableList(items []Displayable, isFocused bool) (string, error) {
+	if len(items) == 0 {
+		return "", nil
+	}
+
+	stringArrays := getDisplayStringArrays(items, isFocused)
+
+	if !displayArraysAligned(stringArrays) {
+		return "", errors.New("Each item must return the same number of strings to display")
+	}
+
+	padWidths := getPadWidths(stringArrays)
+	paddedDisplayStrings := getPaddedDisplayStrings(stringArrays, padWidths)
+
+	return strings.Join(paddedDisplayStrings, "\n"), nil
 }

 // Decolorise strips a string of color
@@ -125,16 +168,10 @@ func Decolorise(str string) string {
 }

 func getPadWidths(stringArrays [][]string) []int {
-	maxWidth := 0
-	for _, stringArray := range stringArrays {
-		if len(stringArray) > maxWidth {
-			maxWidth = len(stringArray)
-		}
-	}
-	if maxWidth-1 < 0 {
+	if len(stringArrays[0]) <= 1 {
 		return []int{}
 	}
-	padWidths := make([]int, maxWidth-1)
+	padWidths := make([]int, len(stringArrays[0])-1)
 	for i := range padWidths {
 		for _, strings := range stringArrays {
 			uncoloredString := Decolorise(strings[i])
@@ -153,14 +190,8 @@ func getPaddedDisplayStrings(stringArrays [][]string, padWidths []int) []string
 			continue
 		}
 		for j, padWidth := range padWidths {
-			if len(stringArray)-1 < j {
-				continue
-			}
 			paddedDisplayStrings[i] += WithPadding(stringArray[j], padWidth) + " "
 		}
-		if len(stringArray)-1 < len(padWidths) {
-			continue
-		}
 		paddedDisplayStrings[i] += stringArray[len(padWidths)]
 	}
 	return paddedDisplayStrings
@@ -177,6 +208,14 @@ func displayArraysAligned(stringArrays [][]string) bool {
 	return true
 }

+func getDisplayStringArrays(displayables []Displayable, isFocused bool) [][]string {
+	stringArrays := make([][]string, len(displayables))
+	for i, item := range displayables {
+		stringArrays[i] = item.GetDisplayStrings(isFocused)
+	}
+	return stringArrays
+}
+
 // IncludesString if the list contains the string
 func IncludesString(list []string, a string) bool {
 	for _, b := range list {
@@ -271,48 +310,3 @@ func ModuloWithWrap(n, max int) int {
 		return n
 	}
 }
-
-// NextIntInCycle returns the next int in a slice, returning to the first index if we've reached the end
-func NextIntInCycle(sl []int, current int) int {
-	for i, val := range sl {
-		if val == current {
-			if i == len(sl)-1 {
-				return sl[0]
-			}
-			return sl[i+1]
-		}
-	}
-	return sl[0]
-}
-
-// PrevIntInCycle returns the prev int in a slice, returning to the first index if we've reached the end
-func PrevIntInCycle(sl []int, current int) int {
-	for i, val := range sl {
-		if val == current {
-			if i > 0 {
-				return sl[i-1]
-			}
-			return sl[len(sl)-1]
-		}
-	}
-	return sl[len(sl)-1]
-}
-
-// TruncateWithEllipsis returns a string, truncated to a certain length, with an ellipsis
-func TruncateWithEllipsis(str string, limit int) string {
-	if limit == 1 && len(str) > 1 {
-		return "."
-	}
-
-	if limit == 2 && len(str) > 2 {
-		return ".."
-	}
-
-	ellipsis := "..."
-	if len(str) <= limit {
-		return str
-	}
-
-	remainingLength := limit - len(ellipsis)
-	return str[0:remainingLength] + "..."
-}
@@ -196,6 +196,166 @@ func TestDisplayArraysAligned(t *testing.T) {
 	}
 }

+type myDisplayable struct {
+	strings []string
+}
+
+type myStruct struct{}
+
+// GetDisplayStrings is a function.
+func (d *myDisplayable) GetDisplayStrings(isFocused bool) []string {
+	if isFocused {
+		return append(d.strings, "blah")
+	}
+	return d.strings
+}
+
+// TestGetDisplayStringArrays is a function.
+func TestGetDisplayStringArrays(t *testing.T) {
+	type scenario struct {
+		input     []Displayable
+		isFocused bool
+		expected  [][]string
+	}
+
+	scenarios := []scenario{
+		{
+			[]Displayable{
+				Displayable(&myDisplayable{[]string{"a", "b"}}),
+				Displayable(&myDisplayable{[]string{"c", "d"}}),
+			},
+			false,
+			[][]string{{"a", "b"}, {"c", "d"}},
+		},
+		{
+			[]Displayable{
+				Displayable(&myDisplayable{[]string{"a", "b"}}),
+				Displayable(&myDisplayable{[]string{"c", "d"}}),
+			},
+			true,
+			[][]string{{"a", "b", "blah"}, {"c", "d", "blah"}},
+		},
+	}
+
+	for _, s := range scenarios {
+		assert.EqualValues(t, s.expected, getDisplayStringArrays(s.input, s.isFocused))
+	}
+}
+
+// TestRenderDisplayableList is a function.
+func TestRenderDisplayableList(t *testing.T) {
+	type scenario struct {
+		input                []Displayable
+		isFocused            bool
+		expectedString       string
+		expectedErrorMessage string
+	}
+
+	scenarios := []scenario{
+		{
+			[]Displayable{
+				Displayable(&myDisplayable{[]string{}}),
+				Displayable(&myDisplayable{[]string{}}),
+			},
+			false,
+			"\n",
+			"",
+		},
+		{
+			[]Displayable{
+				Displayable(&myDisplayable{[]string{"aa", "b"}}),
+				Displayable(&myDisplayable{[]string{"c", "d"}}),
+			},
+			false,
+			"aa b\nc  d",
+			"",
+		},
+		{
+			[]Displayable{
+				Displayable(&myDisplayable{[]string{"a"}}),
+				Displayable(&myDisplayable{[]string{"b", "c"}}),
+			},
+			false,
+			"",
+			"Each item must return the same number of strings to display",
+		},
+		{
+			[]Displayable{
+				Displayable(&myDisplayable{[]string{"a"}}),
+				Displayable(&myDisplayable{[]string{"b"}}),
+			},
+			true,
+			"a blah\nb blah",
+			"",
+		},
+	}
+
+	for _, s := range scenarios {
+		str, err := renderDisplayableList(s.input, s.isFocused)
+		assert.EqualValues(t, s.expectedString, str)
+		if s.expectedErrorMessage != "" {
+			assert.EqualError(t, err, s.expectedErrorMessage)
+		} else {
+			assert.NoError(t, err)
+		}
+	}
+}
+
+// TestRenderList is a function.
+func TestRenderList(t *testing.T) {
+	type scenario struct {
+		input                interface{}
+		isFocused            bool
+		expectedString       string
+		expectedErrorMessage string
+	}
+
+	scenarios := []scenario{
+		{
+			[]*myDisplayable{
+				{[]string{"aa", "b"}},
+				{[]string{"c", "d"}},
+			},
+			false,
+			"aa b\nc  d",
+			"",
+		},
+		{
+			[]*myStruct{
+				{},
+				{},
+			},
+			false,
+			"",
+			"item does not implement the Displayable interface",
+		},
+		{
+			&myStruct{},
+			false,
+			"",
+			"RenderList given a non-slice type",
+		},
+		{
+			[]*myDisplayable{
+				{[]string{"a"}},
+			},
+			true,
+			"a blah",
+			"",
+		},
+	}
+
+	for _, s := range scenarios {
+		str, err := RenderList(s.input, s.isFocused)
+		assert.EqualValues(t, s.expectedString, str)
+		if s.expectedErrorMessage != "" {
+			assert.EqualError(t, err, s.expectedErrorMessage)
+		} else {
+			assert.NoError(t, err)
+		}
+	}
+}
+
 // TestGetPaddedDisplayStrings is a function.
 func TestGetPaddedDisplayStrings(t *testing.T) {
 	type scenario struct {
@@ -12,7 +12,6 @@ import (
 	"fmt"
 	"log"
 	"os"
-	"sort"
 	"strings"

 	"github.com/jesseduffield/lazygit/pkg/app"
@@ -61,85 +60,33 @@ func formatTitle(title string) string {

 func formatBinding(binding *gui.Binding) string {
 	if binding.Alternative != "" {
-		return fmt.Sprintf("  <kbd>%s</kbd>: %s (%s)\n", gui.GetKeyDisplay(binding.Key), binding.Description, binding.Alternative)
+		return fmt.Sprintf("  <kbd>%s</kbd>: %s (%s)\n", binding.GetKey(), binding.Description, binding.Alternative)
 	}
-	return fmt.Sprintf("  <kbd>%s</kbd>: %s\n", gui.GetKeyDisplay(binding.Key), binding.Description)
+	return fmt.Sprintf("  <kbd>%s</kbd>: %s\n", binding.GetKey(), binding.Description)
 }

 func getBindingSections(mApp *app.App) []*bindingSection {
 	bindingSections := []*bindingSection{}

-	bindings := mApp.Gui.GetInitialKeybindings()
-
-	type contextAndViewType struct {
-		context  string
-		viewName string
-	}
-
-	contextAndViewBindingMap := map[contextAndViewType][]*gui.Binding{}
-
-	for _, binding := range bindings {
-		contexts := []string{}
-		if len(binding.Contexts) == 0 {
-			contexts = append(contexts, "")
-		} else {
-			contexts = append(contexts, binding.Contexts...)
+	// TODO: add context-based keybindings
+	for _, binding := range mApp.Gui.GetInitialKeybindings() {
+		if binding.Description == "" {
+			continue
 		}

-		for _, context := range contexts {
-			key := contextAndViewType{context: context, viewName: binding.ViewName}
-			existing := contextAndViewBindingMap[key]
-			if existing == nil {
-				contextAndViewBindingMap[key] = []*gui.Binding{binding}
-			} else {
-				contextAndViewBindingMap[key] = append(contextAndViewBindingMap[key], binding)
-			}
-		}
-	}
-
-	type groupedBindingsType struct {
-		contextAndView contextAndViewType
-		bindings       []*gui.Binding
-	}
-
-	groupedBindings := make([]groupedBindingsType, len(contextAndViewBindingMap))
-
-	for contextAndView, contextBindings := range contextAndViewBindingMap {
-		groupedBindings = append(groupedBindings, groupedBindingsType{contextAndView: contextAndView, bindings: contextBindings})
-	}
-
-	sort.Slice(groupedBindings, func(i, j int) bool {
-		first := groupedBindings[i].contextAndView
-		second := groupedBindings[j].contextAndView
-		if first.viewName == "" {
-			return true
-		}
-		if second.viewName == "" {
-			return false
-		}
-		return first.viewName < second.viewName || (first.viewName == second.viewName && first.context < second.context)
-	})
-
-	for _, group := range groupedBindings {
-		contextAndView := group.contextAndView
-		contextBindings := group.bindings
-		mApp.Log.Warn("viewname: " + contextAndView.viewName + ", context: " + contextAndView.context)
-		viewName := contextAndView.viewName
+		viewName := binding.ViewName
 		if viewName == "" {
 			viewName = "global"
 		}
-		translatedView := localisedTitle(mApp, viewName)
-		var title string
-		if contextAndView.context == "" {
-			addendum := " " + mApp.Tr.SLocalize("Panel")
-			if viewName == "global" {
-				addendum = ""
-			}
-			title = fmt.Sprintf("%s%s", translatedView, addendum)
-		} else {
-			translatedContextName := localisedTitle(mApp, contextAndView.context)
-			title = fmt.Sprintf("%s %s (%s)", translatedView, mApp.Tr.SLocalize("Panel"), translatedContextName)
-		}
+		title := localisedTitle(mApp, viewName)
+
+		bindingSections = addBinding(title, bindingSections, binding)
+	}
+
+	for contextName, contextBindings := range mApp.Gui.GetContextMap() {
+		translatedView := localisedTitle(mApp, contextBindings[0].ViewName)
+		translatedContextName := localisedTitle(mApp, contextName)
+		title := fmt.Sprintf("%s (%s)", translatedView, translatedContextName)

 		for _, binding := range contextBindings {
 			bindingSections = addBinding(title, bindingSections, binding)
@@ -170,7 +117,7 @@ func addBinding(title string, bindingSections []*bindingSection, binding *gui.Bi
 }

 func formatSections(mApp *app.App, bindingSections []*bindingSection) string {
-	content := fmt.Sprintf("# Lazygit %s\n", mApp.Tr.SLocalize("Keybindings"))
+	content := fmt.Sprintf("# Lazygit %s\n", mApp.Tr.SLocalize("menu"))

 	for _, section := range bindingSections {
 		content += formatTitle(section.title)
@@ -5,9 +5,8 @@
 package gocui

 import (
-	"strconv"
-
 	"github.com/go-errors/errors"
+	"strconv"
 )

 type escapeInterpreter struct {
@@ -152,13 +151,13 @@ func (ei *escapeInterpreter) outputNormal() error {

 		switch {
 		case p >= 30 && p <= 37:
-			ei.curFgColor |= Attribute(p - 30 + 1)
+			ei.curFgColor = Attribute(p - 30 + 1)
 		case p == 39:
-			ei.curFgColor |= ColorDefault
+			ei.curFgColor = ColorDefault
 		case p >= 40 && p <= 47:
-			ei.curBgColor |= Attribute(p - 40 + 1)
+			ei.curBgColor = Attribute(p - 40 + 1)
 		case p == 49:
-			ei.curBgColor |= ColorDefault
+			ei.curBgColor = ColorDefault
 		case p == 1:
 			ei.curFgColor |= AttrBold
 		case p == 4:
@@ -6,9 +6,7 @@ package gocui

 import (
 	standardErrors "errors"
-	"fmt"
 	"strings"
-	"sync"
 	"time"

 	"github.com/go-errors/errors"
@@ -91,16 +89,6 @@ type Gui struct {
 	// SupportOverlaps is true when we allow for view edges to overlap with other
 	// view edges
 	SupportOverlaps bool
-
-	// tickingMutex ensures we don't have two loops ticking. The point of 'ticking'
-	// is to refresh the gui rapidly so that loader characters can be animated.
-	tickingMutex sync.Mutex
-
-	OnSearchEscape func() error
-	// these keys must either be of type Key of rune
-	SearchEscapeKey    interface{}
-	NextSearchMatchKey interface{}
-	PrevSearchMatchKey interface{}
 }

 // NewGui returns a new Gui object with a given output mode.
@@ -131,18 +119,15 @@ func NewGui(mode OutputMode, supportOverlaps bool) (*Gui, error) {
 	// view edges
 	g.SupportOverlaps = supportOverlaps

-	// default keys for when searching strings in a view
-	g.SearchEscapeKey = KeyEsc
-	g.NextSearchMatchKey = 'n'
-	g.PrevSearchMatchKey = 'N'
-
 	return g, nil
 }

 // Close finalizes the library. It should be called after a successful
 // initialization and when gocui is not needed anymore.
 func (g *Gui) Close() {
-	close(g.stop)
+	go func() {
+		g.stop <- struct{}{}
+	}()
 	termbox.Close()
 }

@@ -424,6 +409,7 @@ func (g *Gui) SetManagerFunc(manager func(*Gui) error) {
 // MainLoop runs the main loop until an error is returned. A successful
 // finish should return ErrQuit.
 func (g *Gui) MainLoop() error {
+	g.loaderTick()
 	if err := g.flush(); err != nil {
 		return err
 	}
@@ -543,11 +529,6 @@ func (g *Gui) flush() error {
 					return err
 				}
 			}
-			if v.ContainsList {
-				if err := g.drawListFooter(v, fgColor, bgColor); err != nil {
-					return err
-				}
-			}
 		}
 		if err := g.draw(v); err != nil {
 			return err
@@ -735,34 +716,6 @@ func (g *Gui) drawSubtitle(v *View, fgColor, bgColor Attribute) error {
 	return nil
 }

-// drawListFooter draws the footer of a list view, showing something like '1 of 10'
-func (g *Gui) drawListFooter(v *View, fgColor, bgColor Attribute) error {
-	if len(v.lines) == 0 {
-		return nil
-	}
-
-	message := fmt.Sprintf("%d of %d", v.cy+v.oy+1, len(v.lines))
-
-	if v.y1 < 0 || v.y1 >= g.maxY {
-		return nil
-	}
-
-	start := v.x1 - 1 - len(message)
-	if start < v.x0 {
-		return nil
-	}
-	for i, ch := range message {
-		x := start + i
-		if x >= v.x1 {
-			break
-		}
-		if err := g.SetRune(x, v.y1, ch, fgColor, bgColor); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
 // draw manages the cursor and calls the draw function of a view.
 func (g *Gui) draw(v *View) error {
 	if g.Cursor {
@@ -848,23 +801,6 @@ func (g *Gui) execKeybindings(v *View, ev *termbox.Event) (matched bool, err err
 	var globalKb *keybinding
 	var matchingParentViewKb *keybinding

-	// if we're searching, and we've hit n/N/Esc, we ignore the default keybinding
-	if v.IsSearching() && Modifier(ev.Mod) == ModNone {
-		if eventMatchesKey(ev, g.NextSearchMatchKey) {
-			return true, v.gotoNextMatch()
-		} else if eventMatchesKey(ev, g.PrevSearchMatchKey) {
-			return true, v.gotoPreviousMatch()
-		} else if eventMatchesKey(ev, g.SearchEscapeKey) {
-			v.searcher.clearSearch()
-			if g.OnSearchEscape != nil {
-				if err := g.OnSearchEscape(); err != nil {
-					return true, err
-				}
-			}
-			return true, nil
-		}
-	}
-
 	for _, kb := range g.keybindings {
 		if kb.handler == nil {
 			continue
@@ -899,25 +835,14 @@ func (g *Gui) execKeybinding(v *View, kb *keybinding) (bool, error) {
 	return true, nil
 }

-func (g *Gui) StartTicking() {
+func (g *Gui) loaderTick() {
 	go func() {
-		g.tickingMutex.Lock()
-		defer g.tickingMutex.Unlock()
-		ticker := time.NewTicker(time.Millisecond * 50)
-		defer ticker.Stop()
-	outer:
-		for {
-			select {
-			case <-ticker.C:
-				for _, view := range g.Views() {
-					if view.HasLoader {
-						g.userEvents <- userEvent{func(g *Gui) error { return nil }}
-						continue outer
-					}
+		for range time.Tick(time.Millisecond * 50) {
+			for _, view := range g.Views() {
+				if view.HasLoader {
+					g.userEvents <- userEvent{func(g *Gui) error { return nil }}
+					break
 				}
-				return
-			case <-g.stop:
-				return
 			}
 		}
 	}()
@@ -29,20 +29,6 @@ func newKeybinding(viewname string, contexts []string, key Key, ch rune, mod Mod
 	return kb
 }

-func eventMatchesKey(ev *termbox.Event, key interface{}) bool {
-	// assuming ModNone for now
-	if Modifier(ev.Mod) != ModNone {
-		return false
-	}
-
-	k, ch, err := getKey(key)
-	if err != nil {
-		return false
-	}
-
-	return k == Key(ev.Key) && ch == ev.Ch
-}
-
 // matchKeypress returns if the keybinding matches the keypress.
 func (kb *keybinding) matchKeypress(key Key, ch rune, mod Modifier) bool {
 	return kb.key == key && kb.ch == ch && kb.mod == mod
@@ -10,7 +10,6 @@ import (
 	"strings"
 	"sync"
 	"time"
-	"unicode"

 	"github.com/go-errors/errors"

@@ -106,140 +105,6 @@ type View struct {
 	ParentView *View

 	Context string // this is for assigning keybindings to a view only in certain contexts
-
-	searcher *searcher
-
-	// when ContainsList is true, we show the current index and total count in the view
-	ContainsList bool
-}
-
-type searcher struct {
-	searchString       string
-	searchPositions    []cellPos
-	currentSearchIndex int
-	onSelectItem       func(int, int, int) error
-}
-
-func (v *View) SetOnSelectItem(onSelectItem func(int, int, int) error) {
-	v.searcher.onSelectItem = onSelectItem
-}
-
-func (v *View) gotoNextMatch() error {
-	if len(v.searcher.searchPositions) == 0 {
-		return nil
-	}
-	if v.searcher.currentSearchIndex == len(v.searcher.searchPositions)-1 {
-		v.searcher.currentSearchIndex = 0
-	} else {
-		v.searcher.currentSearchIndex++
-	}
-	return v.SelectSearchResult(v.searcher.currentSearchIndex)
-}
-
-func (v *View) gotoPreviousMatch() error {
-	if len(v.searcher.searchPositions) == 0 {
-		return nil
-	}
-	if v.searcher.currentSearchIndex == 0 {
-		if len(v.searcher.searchPositions) > 0 {
-			v.searcher.currentSearchIndex = len(v.searcher.searchPositions) - 1
-		}
-	} else {
-		v.searcher.currentSearchIndex--
-	}
-	return v.SelectSearchResult(v.searcher.currentSearchIndex)
-}
-
-func (v *View) SelectSearchResult(index int) error {
-	y := v.searcher.searchPositions[index].y
-	v.FocusPoint(0, y)
-	if v.searcher.onSelectItem != nil {
-		return v.searcher.onSelectItem(y, index, len(v.searcher.searchPositions))
-	}
-	return nil
-}
-
-func (v *View) Search(str string) error {
-	v.writeMutex.Lock()
-	defer v.writeMutex.Unlock()
-
-	v.searcher.search(str)
-	v.updateSearchPositions()
-	if len(v.searcher.searchPositions) > 0 {
-		// get the first result past the current cursor
-		currentIndex := 0
-		adjustedY := v.oy + v.cy
-		adjustedX := v.ox + v.cx
-		for i, pos := range v.searcher.searchPositions {
-			if pos.y > adjustedY || (pos.y == adjustedY && pos.x > adjustedX) {
-				currentIndex = i
-				break
-			}
-		}
-		v.searcher.currentSearchIndex = currentIndex
-		return v.SelectSearchResult(currentIndex)
-	} else {
-		return v.searcher.onSelectItem(-1, -1, 0)
-	}
-	return nil
-}
-
-func (v *View) ClearSearch() {
-	v.searcher.clearSearch()
-}
-
-func (v *View) IsSearching() bool {
-	return v.searcher.searchString != ""
-}
-
-func (v *View) FocusPoint(cx int, cy int) {
-	lineCount := len(v.lines)
-	if cy < 0 || cy > lineCount {
-		return
-	}
-	_, height := v.Size()
-
-	ly := height - 1
-	if ly == -1 {
-		ly = 0
-	}
-
-	// if line is above origin, move origin and set cursor to zero
-	// if line is below origin + height, move origin and set cursor to max
-	// otherwise set cursor to value - origin
-	if ly > lineCount {
-		v.cx = cx
-		v.cy = cy
-		v.oy = 0
-	} else if cy < v.oy {
-		v.cx = cx
-		v.cy = 0
-		v.oy = cy
-	} else if cy > v.oy+ly {
-		v.cx = cx
-		v.cy = ly
-		v.oy = cy - ly
-	} else {
-		v.cx = cx
-		v.cy = cy - v.oy
-	}
-}
-
-func (s *searcher) search(str string) {
-	s.searchString = str
-	s.searchPositions = []cellPos{}
-	s.currentSearchIndex = 0
-}
-
-func (s *searcher) clearSearch() {
-	s.searchString = ""
-	s.searchPositions = []cellPos{}
-	s.currentSearchIndex = 0
-}
-
-type cellPos struct {
-	x int
-	y int
 }

 type viewLine struct {
@@ -266,16 +131,15 @@ func (l lineType) String() string {
 // newView returns a new View object.
 func newView(name string, x0, y0, x1, y1 int, mode OutputMode) *View {
 	v := &View{
-		name:     name,
-		x0:       x0,
-		y0:       y0,
-		x1:       x1,
-		y1:       y1,
-		Frame:    true,
-		Editor:   DefaultEditor,
-		tainted:  true,
-		ei:       newEscapeInterpreter(mode),
-		searcher: &searcher{},
+		name:    name,
+		x0:      x0,
+		y0:      y0,
+		x1:      x1,
+		y1:      y1,
+		Frame:   true,
+		Editor:  DefaultEditor,
+		tainted: true,
+		ei:      newEscapeInterpreter(mode),
 	}
 	return v
 }
@@ -467,55 +331,8 @@ func (v *View) Rewind() {
 	v.readOffset = 0
 }

-func containsUpcaseChar(str string) bool {
-	for _, ch := range str {
-		if unicode.IsUpper(ch) {
-			return true
-		}
-	}
-	return false
-}
-
-func (v *View) updateSearchPositions() {
-	if v.searcher.searchString != "" {
-		var normalizeRune func(r rune) rune
-		var normalizedSearchStr string
-		// if we have any uppercase characters we'll do a case-sensitive search
-		if containsUpcaseChar(v.searcher.searchString) {
-			normalizedSearchStr = v.searcher.searchString
-			normalizeRune = func(r rune) rune { return r }
-		} else {
-			normalizedSearchStr = strings.ToLower(v.searcher.searchString)
-			normalizeRune = unicode.ToLower
-		}
-
-		v.searcher.searchPositions = []cellPos{}
-		for y, line := range v.lines {
-		lineLoop:
-			for x, _ := range line {
-				if normalizeRune(line[x].chr) == rune(normalizedSearchStr[0]) {
-					for offset := 1; offset < len(normalizedSearchStr); offset++ {
-						if len(line)-1 < x+offset {
-							continue lineLoop
-						}
-						if normalizeRune(line[x+offset].chr) != rune(normalizedSearchStr[offset]) {
-							continue lineLoop
-						}
-					}
-					v.searcher.searchPositions = append(v.searcher.searchPositions, cellPos{x: x, y: y})
-				}
-			}
-		}
-	}
-
-}
-
 // draw re-draws the view's contents.
 func (v *View) draw() error {
-	v.writeMutex.Lock()
-	defer v.writeMutex.Unlock()
-
-	v.updateSearchPositions()
 	maxX, maxY := v.Size()

 	if v.Wrap {
@@ -575,13 +392,6 @@ func (v *View) draw() error {
 			if bgColor == ColorDefault {
 				bgColor = v.BgColor
 			}
-			if matched, selected := v.isPatternMatchedRune(x, y); matched {
-				if selected {
-					bgColor = ColorCyan
-				} else {
-					bgColor = ColorYellow
-				}
-			}

 			if err := v.setRune(x, y, c.chr, fgColor, bgColor); err != nil {
 				return err
@@ -593,18 +403,6 @@ func (v *View) draw() error {
 	return nil
 }

-func (v *View) isPatternMatchedRune(x, y int) (bool, bool) {
-	searchStringLength := len(v.searcher.searchString)
-	for i, pos := range v.searcher.searchPositions {
-		adjustedY := y + v.oy
-		adjustedX := x + v.ox
-		if adjustedY == pos.y && adjustedX >= pos.x && adjustedX < pos.x+searchStringLength {
-			return true, i == v.searcher.currentSearchIndex
-		}
-	}
-	return false, false
-}
-
 // realPosition returns the position in the internal buffer corresponding to the
 // point (x, y) of the view.
 func (v *View) realPosition(vx, vy int) (x, y int, err error) {
@@ -660,8 +458,6 @@ func (v *View) clearRunes() {
 // BufferLines returns the lines in the view's internal
 // buffer.
 func (v *View) BufferLines() []string {
-	v.writeMutex.Lock()
-	defer v.writeMutex.Unlock()
 	lines := make([]string, len(v.lines))
 	for i, l := range v.lines {
 		str := lineType(l).String()
@@ -680,8 +476,6 @@ func (v *View) Buffer() string {
 // ViewBufferLines returns the lines in the view's internal
 // buffer that is shown to the user.
 func (v *View) ViewBufferLines() []string {
-	v.writeMutex.Lock()
-	defer v.writeMutex.Unlock()
 	lines := make([]string, len(v.viewLines))
 	for i, l := range v.viewLines {
 		str := lineType(l.line).String()
@@ -0,0 +1 @@
+rollbar.test
@@ -0,0 +1,24 @@
+0.2.0 - May 22nd, 2016
+====================
+
+* Do not use title to determine fingerprint.
+
+0.1.1 - August 24th, 2016
+=========================
+
+* Fix Go 1.6 support by removing call to runtime.CallersFrames, which was added
+	in Go 1.7.
+
+0.1.0 - August 23rd, 2016
+=========================
+
+* Allow passing in arbitrary function pointer stacks. (thanks @apg!)
+* Remove unneeded exported constants.
+* Make HTTP(S) endpoint configurable.
+* Remove unneeded debug print statement.
+
+0.0.1 - January 19th, 2015
+==========================
+
+* Initial release based on https://github.com/stvp/rollbar
+
@@ -0,0 +1,22 @@
+Copyright (c) 2016 Stovepipe Studios
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 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.
@@ -0,0 +1,53 @@
+roll
+----
+
+`roll` is a basic Rollbar client for Go that reports errors and logs
+messages. It automatically builds stack traces and also supports
+arbitrary traces. All errors and messages are sent to Rollbar
+synchronously.
+
+`roll` is intentionally simple. For more advanced functionality, check
+out [heroku/rollbar](https://github.com/heroku/rollbar).
+
+[API docs on godoc.org](http://godoc.org/github.com/stvp/roll)
+
+Notes
+=====
+
+* Critical-, Error-, and Warning-level messages include a stack trace.
+  However, Go's `error` type doesn't include stack information from the
+  location the error was set or allocated. Instead, `roll` uses the
+  stack information from where the error was reported.
+* Info- and Debug-level Rollbar messages do not include stack traces.
+* When calling `roll` away from where the error actually occurred,
+  `roll`'s stack walking won't represent the actual stack trace at the
+  time the error occurred. The `*Stack` variants of Critical, Error, and
+  Warning take a `[]uintptr`, allowing the stack to be provided, rather
+  than walked.
+
+Running Tests
+=============
+
+`go test` will run tests against a fake server by default.
+
+If the environment variable `TOKEN` is a Rollbar access token, running
+`go test` will produce errors using an environment named `test`.
+
+    TOKEN=f0df01587b8f76b2c217af34c479f9ea go test
+
+Verify the reported errors manually in the Rollbar dashboard.
+
+Contributors
+============
+
+* @challiwill
+* @tysonmote
+* @apg
+
+This library was forked from [stvp/rollbar](https://github.com/stvp/rollbar),
+which had contributions from:
+
+* @kjk
+* @Soulou
+* @paulmach
+
@@ -0,0 +1,242 @@
+package roll
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"hash/adler32"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"reflect"
+	"runtime"
+	"strings"
+	"time"
+)
+
+const (
+	// By default, all Rollbar API requests are sent to this endpoint.
+	endpoint = "https://api.rollbar.com/api/1/item/"
+
+	// Identify this Rollbar client library to the Rollbar API.
+	clientName     = "go-roll"
+	clientVersion  = "0.2.0"
+	clientLanguage = "go"
+)
+
+var (
+	// Endpoint is the default HTTP(S) endpoint that all Rollbar API requests
+	// will be sent to. By default, this is Rollbar's "Items" API endpoint. If
+	// this is blank, no items will be sent to Rollbar.
+	Endpoint = endpoint
+
+	// Rollbar access token for the global client. If this is blank, no items
+	// will be sent to Rollbar.
+	Token = ""
+
+	// Environment for all items reported with the global client.
+	Environment = "development"
+)
+
+type rollbarSuccess struct {
+	Result map[string]string `json:"result"`
+}
+
+// Client reports items to a single Rollbar project.
+type Client interface {
+	Critical(err error, custom map[string]string) (uuid string, e error)
+	CriticalStack(err error, ptrs []uintptr, custom map[string]string) (uuid string, e error)
+	Error(err error, custom map[string]string) (uuid string, e error)
+	ErrorStack(err error, ptrs []uintptr, custom map[string]string) (uuid string, e error)
+	Warning(err error, custom map[string]string) (uuid string, e error)
+	WarningStack(err error, ptrs []uintptr, custom map[string]string) (uuid string, e error)
+	Info(msg string, custom map[string]string) (uuid string, e error)
+	Debug(msg string, custom map[string]string) (uuid string, e error)
+}
+
+type rollbarClient struct {
+	token string
+	env   string
+}
+
+// New creates a new Rollbar client that reports items to the given project
+// token and with the given environment (eg. "production", "development", etc).
+func New(token, env string) Client {
+	return &rollbarClient{token, env}
+}
+
+func Critical(err error, custom map[string]string) (uuid string, e error) {
+	return CriticalStack(err, getCallers(2), custom)
+}
+
+func CriticalStack(err error, ptrs []uintptr, custom map[string]string) (uuid string, e error) {
+	return New(Token, Environment).CriticalStack(err, ptrs, custom)
+}
+
+func Error(err error, custom map[string]string) (uuid string, e error) {
+	return ErrorStack(err, getCallers(2), custom)
+}
+
+func ErrorStack(err error, ptrs []uintptr, custom map[string]string) (uuid string, e error) {
+	return New(Token, Environment).ErrorStack(err, ptrs, custom)
+}
+
+func Warning(err error, custom map[string]string) (uuid string, e error) {
+	return WarningStack(err, getCallers(2), custom)
+}
+
+func WarningStack(err error, ptrs []uintptr, custom map[string]string) (uuid string, e error) {
+	return New(Token, Environment).WarningStack(err, ptrs, custom)
+}
+
+func Info(msg string, custom map[string]string) (uuid string, e error) {
+	return New(Token, Environment).Info(msg, custom)
+}
+
+func Debug(msg string, custom map[string]string) (uuid string, e error) {
+	return New(Token, Environment).Debug(msg, custom)
+}
+
+func (c *rollbarClient) Critical(err error, custom map[string]string) (uuid string, e error) {
+	return c.CriticalStack(err, getCallers(2), custom)
+}
+
+func (c *rollbarClient) CriticalStack(err error, callers []uintptr, custom map[string]string) (uuid string, e error) {
+	item := c.buildTraceItem("critical", err, callers, custom)
+	return c.send(item)
+}
+
+func (c *rollbarClient) Error(err error, custom map[string]string) (uuid string, e error) {
+	return c.ErrorStack(err, getCallers(2), custom)
+}
+
+func (c *rollbarClient) ErrorStack(err error, callers []uintptr, custom map[string]string) (uuid string, e error) {
+	item := c.buildTraceItem("error", err, callers, custom)
+	return c.send(item)
+}
+
+func (c *rollbarClient) Warning(err error, custom map[string]string) (uuid string, e error) {
+	return c.WarningStack(err, getCallers(2), custom)
+}
+
+func (c *rollbarClient) WarningStack(err error, callers []uintptr, custom map[string]string) (uuid string, e error) {
+	item := c.buildTraceItem("warning", err, callers, custom)
+	return c.send(item)
+}
+
+func (c *rollbarClient) Info(msg string, custom map[string]string) (uuid string, e error) {
+	item := c.buildMessageItem("info", msg, custom)
+	return c.send(item)
+}
+
+func (c *rollbarClient) Debug(msg string, custom map[string]string) (uuid string, e error) {
+	item := c.buildMessageItem("debug", msg, custom)
+	return c.send(item)
+}
+
+func (c *rollbarClient) buildTraceItem(level string, err error, callers []uintptr, custom map[string]string) (item map[string]interface{}) {
+	stack := buildRollbarFrames(callers)
+	item = c.buildItem(level, err.Error(), custom)
+	itemData := item["data"].(map[string]interface{})
+	itemData["fingerprint"] = stack.fingerprint()
+	itemData["body"] = map[string]interface{}{
+		"trace": map[string]interface{}{
+			"frames": stack,
+			"exception": map[string]interface{}{
+				"class":   errorClass(err),
+				"message": err.Error(),
+			},
+		},
+	}
+
+	return item
+}
+
+func (c *rollbarClient) buildMessageItem(level string, msg string, custom map[string]string) (item map[string]interface{}) {
+	item = c.buildItem(level, msg, custom)
+	itemData := item["data"].(map[string]interface{})
+	itemData["body"] = map[string]interface{}{
+		"message": map[string]interface{}{
+			"body": msg,
+		},
+	}
+
+	return item
+}
+
+func (c *rollbarClient) buildItem(level, title string, custom map[string]string) map[string]interface{} {
+	hostname, _ := os.Hostname()
+
+	return map[string]interface{}{
+		"access_token": c.token,
+		"data": map[string]interface{}{
+			"environment": c.env,
+			"title":       title,
+			"level":       level,
+			"timestamp":   time.Now().Unix(),
+			"platform":    runtime.GOOS,
+			"language":    clientLanguage,
+			"server": map[string]interface{}{
+				"host": hostname,
+			},
+			"notifier": map[string]interface{}{
+				"name":    clientName,
+				"version": clientVersion,
+			},
+			"custom": custom,
+		},
+	}
+}
+
+// send reports the given item to Rollbar and returns either a UUID for the
+// reported item or an error.
+func (c *rollbarClient) send(item map[string]interface{}) (uuid string, err error) {
+	if len(c.token) == 0 || len(Endpoint) == 0 {
+		return "", nil
+	}
+
+	jsonBody, err := json.Marshal(item)
+	if err != nil {
+		return "", err
+	}
+
+	resp, err := http.Post(Endpoint, "application/json", bytes.NewReader(jsonBody))
+	if err != nil {
+		// If something goes wrong it really does not matter
+		return "", nil
+	}
+	defer func() {
+		io.Copy(ioutil.Discard, resp.Body)
+		resp.Body.Close()
+	}()
+
+	if resp.StatusCode != http.StatusOK {
+		// If something goes wrong it really does not matter
+		return "", nil
+	}
+
+	// Extract UUID from JSON response
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return "", nil
+	}
+	success := rollbarSuccess{}
+	json.Unmarshal(body, &success)
+
+	return success.Result["uuid"], nil
+}
+
+// errorClass returns a class name for an error (eg.  "ErrUnexpectedEOF"). For
+// string errors, it returns an Adler-32 checksum of the error string.
+func errorClass(err error) string {
+	class := reflect.TypeOf(err).String()
+	if class == "" {
+		return "panic"
+	} else if class == "*errors.errorString" {
+		checksum := adler32.Checksum([]byte(err.Error()))
+		return fmt.Sprintf("{%x}", checksum)
+	} else {
+		return strings.TrimPrefix(class, "*")
+	}
+}
@@ -0,0 +1,98 @@
+package roll
+
+import (
+	"fmt"
+	"hash/crc32"
+	"os"
+	"runtime"
+	"strings"
+)
+
+var (
+	knownFilePathPatterns = []string{
+		"github.com/",
+		"code.google.com/",
+		"bitbucket.org/",
+		"launchpad.net/",
+		"gopkg.in/",
+	}
+)
+
+func getCallers(skip int) (pc []uintptr) {
+	pc = make([]uintptr, 1000)
+	i := runtime.Callers(skip+1, pc)
+	return pc[0:i]
+}
+
+// -- rollbarFrames
+
+type rollbarFrame struct {
+	Filename string `json:"filename"`
+	Method   string `json:"method"`
+	Line     int    `json:"lineno"`
+}
+
+type rollbarFrames []rollbarFrame
+
+// buildRollbarFrames takes a slice of function pointers and returns a Rollbar
+// API payload containing the filename, method name, and line number of each
+// function.
+func buildRollbarFrames(callers []uintptr) (frames rollbarFrames) {
+	frames = rollbarFrames{}
+
+	// 2016-08-24 - runtime.CallersFrames was added in Go 1.7, which should
+	// replace the following code when roll is able to require Go 1.7+.
+	for _, caller := range callers {
+		frame := rollbarFrame{
+			Filename: "???",
+			Method:   "???",
+		}
+		if fn := runtime.FuncForPC(caller); fn != nil {
+			name, line := fn.FileLine(caller)
+			frame.Filename = scrubFile(name)
+			frame.Line = line
+			frame.Method = scrubFunction(fn.Name())
+		}
+		frames = append(frames, frame)
+	}
+
+	return frames
+}
+
+// fingerprint returns a checksum that uniquely identifies a stacktrace by the
+// filename, method name, and line number of every frame in the stack.
+func (f rollbarFrames) fingerprint() string {
+	hash := crc32.NewIEEE()
+	for _, frame := range f {
+		fmt.Fprintf(hash, "%s%s%d", frame.Filename, frame.Method, frame.Line)
+	}
+	return fmt.Sprintf("%x", hash.Sum32())
+}
+
+// -- Helpers
+
+// scrubFile removes unneeded information from the path of a source file. This
+// makes them shorter in Rollbar UI as well as making them the same, regardless
+// of the machine the code was compiled on.
+//
+// Example:
+//   /home/foo/go/src/github.com/stvp/roll/rollbar.go -> github.com/stvp/roll/rollbar.go
+func scrubFile(s string) string {
+	var i int
+	for _, pattern := range knownFilePathPatterns {
+		i = strings.Index(s, pattern)
+		if i != -1 {
+			return s[i:]
+		}
+	}
+	return s
+}
+
+// scrubFunction removes unneeded information from the full name of a function.
+//
+// Example:
+//   github.com/stvp/roll.getCallers -> roll.getCallers
+func scrubFunction(name string) string {
+	end := strings.LastIndex(name, string(os.PathSeparator))
+	return name[end+1 : len(name)]
+}
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright © Heroku 2014 - 2015
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER 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.
@@ -0,0 +1,15 @@
+[![Build Status](https://travis-ci.org/heroku/rollrus.svg?branch=master)](https://travis-ci.org/heroku/rollrus)&nbsp;[![GoDoc](https://godoc.org/github.com/heroku/rollrus?status.svg)](https://godoc.org/github.com/heroku/rollrus)
+
+# What
+
+Rollrus is what happens when [Logrus](https://github.com/sirupsen/logrus) meets [Roll](https://github.com/stvp/roll).
+
+When a .Error, .Fatal or .Panic logging function is called, report the details to rollbar via a Logrus hook.
+
+Delivery is synchronous to help ensure that logs are delivered.
+
+If the error includes a [`StackTrace`](https://godoc.org/github.com/pkg/errors#StackTrace), that `StackTrace` is reported to rollbar.
+
+# Usage
+
+Examples available in the [tests](https://github.com/heroku/rollrus/blob/master/rollrus_test.go) or on [GoDoc](https://godoc.org/github.com/heroku/rollrus).
@@ -0,0 +1,7 @@
+module github.com/jesseduffield/rollrus
+
+require (
+	github.com/jesseduffield/roll v0.0.0-20190629104057-695be2e62b00
+	github.com/pkg/errors v0.8.1
+	github.com/sirupsen/logrus v1.3.0
+)
@@ -0,0 +1,19 @@
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/jesseduffield/roll v0.0.0-20190629104057-695be2e62b00 h1:+JaOkfBNYQYlGD7dgru8mCwYNEc5tRRI8mThlVANhSM=
+github.com/jesseduffield/roll v0.0.0-20190629104057-695be2e62b00/go.mod h1:cWNQljQAWYBp4wchyGfql4q2jRNZXxiE1KhVQgz+JaM=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/sirupsen/logrus v1.3.0 h1:hI/7Q+DtNZ2kINb6qt/lS+IyXnHQe9e90POfeewL/ME=
+github.com/sirupsen/logrus v1.3.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+golang.org/x/crypto v0.0.0-20180904163835-0709b304e793 h1:u+LnwYTOOW7Ukr/fppxEb1Nwz0AtPflrblfvUudpo+I=
+golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33 h1:I6FyU15t786LL7oL/hn43zqTuEGr4PN7F4XJ1p4E3Y8=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
--- a/Show More
+++ b/Show More