diff --git a/CHANGELOG b/CHANGELOG
index 7faa634..9f7bfc3 100644
--- a/CHANGELOG
+++ b/CHANGELOG
@@ -1,6 +1,88 @@
 CHANGELOG
 =========
 
+0.14: 2017-07-27
+----------------
+
+Fixes:
+- Fixed bug in remove_reader (ValueError).
+- Pin Pyte requirements belowe 0.6.0.
+
+
+0.13: 2016-10-16
+----------------
+
+New features:
+- Added status-interval option.
+- Support for ANSI colors only.
+  * Added --ansicolor option.
+  * Check PROMPT_TOOLKIT_ANSI_COLORS_ONLY environment variable.
+- Added pane-status option for hiding the pane status bar.
+  (Disabled by default.)
+- Expose shift+arrow keys for key bindings.
+
+Performance improvements:
+- Only do datetime formatting if the string actually contains a '%'
+  character.
+
+Fixes:
+- Catch OSError in os.tcgetpgrp.
+- Clean up sockets, also in case of a crash.
+- Fix in process.py: don't call remove_reader when master is None.
+
+
+0.12: 2016-08-03
+----------------
+
+Fixes:
+- Prompt_toolkit 1.0.4 compatibilty.
+- Python 2.6 compatibility.
+
+
+0.11: 2016-06-27
+----------------
+
+Fixes:
+- Fix for OS X El Capitan: LoadLibrary('libc.dylib') failed.
+- Compatibility with the latest prompt_toolkit.
+
+
+0.10: 2016-05-05
+----------------
+
+Upgrade to prompt_toolkit 1.0.0
+
+New features:
+- Added 'C-b PPage' key binding (like tmux).
+- Many performance improvements in the vt100 parser.
+
+Improvements/fixes:
+- Don't crash when decoding utf-8 input fails. (Sometimes it happens when using
+  the mouse in lxterminal.)
+- Cleanup CLI object when the client was detached. (The server would become
+  very slow if the CLI was not removed for a couple of times.)
+- Replace errors when decoding utf-8 input.
+- Fixes regarding multiwidth characters.
+- Bugfix: Don't use 'del' on a defaultdict, but use pop(..., None) instead, in
+  order to avoid key errors.
+- Handle decomposed unicode characters correctly.
+- Bugfix regarding the handling of 'clear'.
+- Fixes a bug where the cursor stays at the top.
+- Fix: The socket in the pymux client should be blocking.
+
+
+0.9: 2016-03-14
+---------------
+
+Upgrade to prompt_toolkit 0.60
+
+
+0.8: 2016-03-06
+---------------
+
+Upgrade to prompt_toolkit 0.59
+
+
 0.7: 2016-01-16
 ---------------
 
diff --git a/README.rst b/README.rst
index 7d71bd3..8212ec0 100644
--- a/README.rst
+++ b/README.rst
@@ -1,6 +1,13 @@
 Pymux
 =====
 
+WARNING: This project requires maintenance. The current master branch requires
+an old version of both prompt_toolkit and ptterm. There is a prompt-toolkit-3.0
+branch here that is compatible with the latest prompt_toolkit and the latest
+commit of the master branch of ptterm, but for that branch, only `pymux
+standalone` is working at the moment.
+
+
 *A terminal multiplexer (like tmux) in Python*
 
 ::
diff --git a/pymux/arrangement.py b/pymux/arrangement.py
index bafac42..7c3ef58 100644
--- a/pymux/arrangement.py
+++ b/pymux/arrangement.py
@@ -8,13 +8,10 @@
 arranged by ordering them in HSplit/VSplit instances.
 """
 from __future__ import unicode_literals
-from .process import Process
 
+from ptterm import Terminal
+from prompt_toolkit.application.current import get_app, set_app
 from prompt_toolkit.buffer import Buffer
-from prompt_toolkit.document import Document
-from prompt_toolkit.interface import CommandLineInterface
-from prompt_toolkit.search_state import SearchState
-from prompt_toolkit.token import Token
 
 import math
 import os
@@ -50,10 +47,10 @@ class Pane(object):
     """
     _pane_counter = 1000  # Start at 1000, to be sure to not confuse this with pane indexes.
 
-    def __init__(self, process):
-        assert isinstance(process, Process)
+    def __init__(self, terminal=None):
+        assert isinstance(terminal, Terminal)
 
-        self.process = process
+        self.terminal = terminal
         self.chosen_name = None
 
         # Displayed the clock instead of this pane content.
@@ -73,10 +70,9 @@ def __init__(self, process):
         self.display_scroll_buffer = False
         self.scroll_buffer_title = ''
 
-        # Search buffer, for use in copy mode. (Each pane gets its own search buffer.)
-        self.search_buffer = Buffer()
-        self.is_searching = False
-        self.search_state = SearchState(ignore_case=False)
+    @property
+    def process(self):
+        return self.terminal.process
 
     @property
     def name(self):
@@ -99,41 +95,13 @@ def enter_copy_mode(self):
         Suspend the process, and copy the screen content to the `scroll_buffer`.
         That way the user can search through the history and copy/paste.
         """
-        document, get_tokens_for_line = self.process.create_copy_document()
-        self._enter_scroll_buffer('Copy', document, get_tokens_for_line)
-
-    def display_text(self, text, title=''):
-        """
-        Display the given text in the scroll buffer.
-        """
-        document = Document(text, 0)
-
-        def get_tokens_for_line(lineno):
-            return [(Token, document.lines[lineno])]
-
-        self._enter_scroll_buffer(
-            title,
-            document=document,
-            get_tokens_for_line=get_tokens_for_line)
-
-    def _enter_scroll_buffer(self, title, document, get_tokens_for_line):
-        # Suspend child process.
-        self.process.suspend()
+        self.terminal.enter_copy_mode()
 
-        self.scroll_buffer.set_document(document, bypass_readonly=True)
-        self.copy_get_tokens_for_line = get_tokens_for_line
-        self.display_scroll_buffer = True
-        self.scroll_buffer_title = title
-
-        # Reset search state.
-        self.search_state = SearchState(ignore_case=False)
-
-    def exit_scroll_buffer(self):
+    def focus(self):
         """
-        Exit scroll buffer. (Exits help or copy mode.)
+        Focus this pane.
         """
-        self.process.resume()
-        self.display_scroll_buffer = False
+        get_app().layout.focus(self.terminal)
 
 
 class _WeightsDictionary(weakref.WeakKeyDictionary):
@@ -210,6 +178,9 @@ def invalidation_hash(self):
         Return a hash (string) that can be used to determine when the layout
         has to be rebuild.
         """
+#        if not self.root:
+#            return '<empty-window>'
+
         def _hash_for_split(split):
             result = []
             for item in split:
@@ -382,7 +353,10 @@ def active_process(self):
     def focus_next(self, count=1):
         " Focus the next pane. "
         panes = self.panes
-        self.active_pane = panes[(panes.index(self.active_pane) + count) % len(panes)]
+        if panes:
+            self.active_pane = panes[(panes.index(self.active_pane) + count) % len(panes)]
+        else:
+            self.active_pane = None  # No panes left.
 
     def focus_previous(self):
         " Focus the previous pane. "
@@ -590,65 +564,54 @@ def __init__(self):
         # is attached.
         self._last_active_window = None
 
-    def pane_has_priority(self, pane):
-        """
-        Return True when this Pane sohuld get priority in the output processing.
-        This is true for panes that have the focus in any of the visible windows.
-        """
-        windows = set(self._active_window_for_cli.values())
-
-        for w in windows:
-            if w.active_pane == pane:
-                return True
-
-        return False
-
-    def invalidation_hash(self, cli):
+    def invalidation_hash(self):
         """
         When this changes, the layout needs to be rebuild.
         """
-        w = self.get_active_window(cli)
+        if not self.windows:
+            return '<no-windows>'
+
+        w = self.get_active_window()
         return w.invalidation_hash()
 
-    def get_active_window(self, cli):
+    def get_active_window(self):
         """
         The current active :class:`.Window`.
         """
-        assert isinstance(cli, CommandLineInterface)
+        app = get_app()
 
         try:
-            return self._active_window_for_cli[cli]
+            return self._active_window_for_cli[app]
         except KeyError:
-            self._active_window_for_cli[cli] = self._last_active_window or self.windows[0]
+            self._active_window_for_cli[app] = self._last_active_window or self.windows[0]
             return self.windows[0]
 
-    def set_active_window(self, cli, window):
-        assert isinstance(cli, CommandLineInterface)
+    def set_active_window(self, window):
         assert isinstance(window, Window)
+        app = get_app()
 
-        previous = self.get_active_window(cli)
-        self._prev_active_window_for_cli[cli] = previous
-        self._active_window_for_cli[cli] = window
+        previous = self.get_active_window()
+        self._prev_active_window_for_cli[app] = previous
+        self._active_window_for_cli[app] = window
         self._last_active_window = window
 
-    def set_active_window_from_pane_id(self, cli, pane_id):
+    def set_active_window_from_pane_id(self, pane_id):
         """
         Make the window with this pane ID the active Window.
         """
-        assert isinstance(cli, CommandLineInterface)
         assert isinstance(pane_id, int)
 
         for w in self.windows:
             for p in w.panes:
                 if p.pane_id == pane_id:
-                    self.set_active_window(cli, w)
+                    self.set_active_window(w)
 
-    def get_previous_active_window(self, cli):
+    def get_previous_active_window(self):
         " The previous active Window or None if unknown. "
-        assert isinstance(cli, CommandLineInterface)
+        app = get_app()
 
         try:
-            return self._prev_active_window_for_cli[cli]
+            return self._prev_active_window_for_cli[app]
         except KeyError:
             return None
 
@@ -658,17 +621,15 @@ def get_window_by_index(self, index):
             if w.index == index:
                 return w
 
-    def create_window(self, cli, pane, name=None, set_active=True):
+    def create_window(self, pane, name=None, set_active=True):
         """
         Create a new window that contains just this pane.
 
-        :param cli: If been given, this window will be focussed for that client.
         :param pane: The :class:`.Pane` instance to put in the new window.
         :param name: If given, name for the new window.
         :param set_active: When True, focus the new window.
         """
         assert isinstance(pane, Pane)
-        assert cli is None or isinstance(cli, CommandLineInterface)
         assert name is None or isinstance(name, six.text_type)
 
         # Take the first available index.
@@ -686,8 +647,10 @@ def create_window(self, cli, pane, name=None, set_active=True):
         # Sort windows by index.
         self.windows = sorted(self.windows, key=lambda w: w.index)
 
-        if cli is not None and set_active:
-            self.set_active_window(cli, w)
+        app = get_app(return_none=True)
+
+        if app is not None and set_active:
+            self.set_active_window(w)
 
         if name is not None:
             w.chosen_name = name
@@ -707,13 +670,11 @@ def move_window(self, window, new_index):
         # Sort windows by index.
         self.windows = sorted(self.windows, key=lambda w: w.index)
 
-    def get_active_pane(self, cli):
+    def get_active_pane(self):
         """
         The current :class:`.Pane` from the current window.
         """
-        assert isinstance(cli, CommandLineInterface)
-
-        w = self.get_active_window(cli)
+        w = self.get_active_window()
         if w is not None:
             return w.active_pane
 
@@ -729,49 +690,42 @@ def remove_pane(self, pane):
             # No panes left in this window?
             if not w.has_panes:
                 # Focus next.
-                for cli, active_w in self._active_window_for_cli.items():
+                for app, active_w in self._active_window_for_cli.items():
                     if w == active_w:
-                        self.focus_next_window(cli)
+                        with set_app(app):
+                            self.focus_next_window()
 
                 self.windows.remove(w)
 
-    def focus_previous_window(self, cli):
-        assert isinstance(cli, CommandLineInterface)
-
-        w = self.get_active_window(cli)
+    def focus_previous_window(self):
+        w = self.get_active_window()
 
-        self.set_active_window(cli, self.windows[
+        self.set_active_window(self.windows[
             (self.windows.index(w) - 1) % len(self.windows)])
 
-    def focus_next_window(self, cli):
-        assert isinstance(cli, CommandLineInterface)
+    def focus_next_window(self):
+        w = self.get_active_window()
 
-        w = self.get_active_window(cli)
-
-        self.set_active_window(cli, self.windows[
+        self.set_active_window(self.windows[
             (self.windows.index(w) + 1) % len(self.windows)])
 
-    def break_pane(self, cli, set_active=True):
+    def break_pane(self, set_active=True):
         """
         When the current window has multiple panes, remove the pane from this
         window and put it in a new window.
 
         :param set_active: When True, focus the new window.
         """
-        assert isinstance(cli, CommandLineInterface)
-
-        w = self.get_active_window(cli)
+        w = self.get_active_window()
 
         if len(w.panes) > 1:
             pane = w.active_pane
-            self.get_active_window(cli).remove_pane(pane)
-            self.create_window(cli, pane, set_active=set_active)
+            self.get_active_window().remove_pane(pane)
+            self.create_window(pane, set_active=set_active)
 
-    def rotate_window(self, cli, count=1):
+    def rotate_window(self, count=1):
         " Rotate the panes in the active window. "
-        assert isinstance(cli, CommandLineInterface)
-
-        w = self.get_active_window(cli)
+        w = self.get_active_window()
         w.rotate(count=count)
 
     @property
diff --git a/pymux/client/__init__.py b/pymux/client/__init__.py
new file mode 100644
index 0000000..dacbf9e
--- /dev/null
+++ b/pymux/client/__init__.py
@@ -0,0 +1,3 @@
+from __future__ import unicode_literals
+from .base import Client
+from .defaults import create_client, list_clients
diff --git a/pymux/client/base.py b/pymux/client/base.py
new file mode 100644
index 0000000..8443360
--- /dev/null
+++ b/pymux/client/base.py
@@ -0,0 +1,22 @@
+from __future__ import unicode_literals
+
+from prompt_toolkit.output import ColorDepth
+from abc import ABCMeta
+from six import with_metaclass
+
+
+__all__ = [
+    'Client',
+]
+
+
+class Client(with_metaclass(ABCMeta, object)):
+    def run_command(self, command, pane_id=None):
+        """
+        Ask the server to run this command.
+        """
+
+    def attach(self, detach_other_clients=False, color_depth=ColorDepth.DEPTH_8_BIT):
+        """
+        Attach client user interface.
+        """
diff --git a/pymux/client/defaults.py b/pymux/client/defaults.py
new file mode 100644
index 0000000..929e874
--- /dev/null
+++ b/pymux/client/defaults.py
@@ -0,0 +1,24 @@
+from __future__ import unicode_literals
+from prompt_toolkit.utils import is_windows
+__all__ = [
+    'create_client',
+    'list_clients',
+]
+
+
+def create_client(socket_name):
+    if is_windows():
+        from .windows import WindowsClient
+        return WindowsClient(socket_name)
+    else:
+        from .posix import PosixClient
+        return PosixClient(socket_name)
+
+
+def list_clients():
+    if is_windows():
+        from .windows import list_clients
+        return list_clients()
+    else:
+        from .posix import list_clients
+        return list_clients()
diff --git a/pymux/client.py b/pymux/client/posix.py
similarity index 69%
rename from pymux/client.py
rename to pymux/client/posix.py
index 1431092..53b8662 100644
--- a/pymux/client.py
+++ b/pymux/client/posix.py
@@ -1,9 +1,10 @@
 from __future__ import unicode_literals
 
-from prompt_toolkit.terminal.vt100_input import raw_mode, cooked_mode
-from prompt_toolkit.eventloop.posix import _select, call_on_sigwinch
-from prompt_toolkit.eventloop.base import INPUT_TIMEOUT
-from prompt_toolkit.terminal.vt100_output import _get_size, Vt100_Output
+from prompt_toolkit.eventloop.select import select_fds
+from prompt_toolkit.input.posix_utils import PosixStdinReader
+from prompt_toolkit.input.vt100 import raw_mode, cooked_mode
+from prompt_toolkit.output.vt100 import _get_size, Vt100_Output
+from prompt_toolkit.output import ColorDepth
 
 from pymux.utils import nonblocking
 
@@ -15,15 +16,17 @@
 import socket
 import sys
 import tempfile
+from .base import Client
 
+INPUT_TIMEOUT = .5
 
 __all__ = (
-    'Client',
+    'PosixClient',
     'list_clients',
 )
 
 
-class Client(object):
+class PosixClient(Client):
     def __init__(self, socket_name):
         self.socket_name = socket_name
         self._mode_context_managers = []
@@ -31,7 +34,19 @@ def __init__(self, socket_name):
         # Connect to socket.
         self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
         self.socket.connect(socket_name)
-        self.socket.setblocking(0)
+        self.socket.setblocking(1)
+
+        # Input reader.
+        #     Some terminals, like lxterminal send non UTF-8 input sequences,
+        #     even when the input encoding is supposed to be UTF-8. This
+        #     happens in the case of mouse clicks in the right area of a wide
+        #     terminal. Apparently, these are some binary blobs in between the
+        #     UTF-8 input.)
+        #     We should not replace these, because this would break the
+        #     decoding otherwise. (Also don't pass errors='ignore', because
+        #     that doesn't work for parsing mouse input escape sequences, which
+        #     consist of a fixed number of bytes.)
+        self._stdin_reader = PosixStdinReader(sys.stdin.fileno(), errors='replace')
 
     def run_command(self, command, pane_id=None):
         """
@@ -45,18 +60,17 @@ def run_command(self, command, pane_id=None):
             'pane_id': pane_id
         })
 
-    def attach(self, detach_other_clients=False, true_color=False):
+    def attach(self, detach_other_clients=False, color_depth=ColorDepth.DEPTH_8_BIT):
         """
         Attach client user interface.
         """
         assert isinstance(detach_other_clients, bool)
-        assert isinstance(true_color, bool)
 
         self._send_size()
         self._send_packet({
             'cmd': 'start-gui',
             'detach-others': detach_other_clients,
-            'true-color': true_color,
+            'color-depth': color_depth,
             'term': os.environ.get('TERM', ''),
             'data': ''
         })
@@ -68,9 +82,13 @@ def attach(self, detach_other_clients=False, true_color=False):
             socket_fd = self.socket.fileno()
             current_timeout = INPUT_TIMEOUT  # Timeout, used to flush escape sequences.
 
-            with call_on_sigwinch(self._send_size):
+            try:
+                def winch_handler(signum, frame):
+                    self._send_size()
+
+                signal.signal(signal.SIGWINCH, winch_handler)
                 while True:
-                    r, w, x = _select([stdin_fd, socket_fd], [], [], current_timeout)
+                    r = select_fds([stdin_fd, socket_fd], current_timeout)
 
                     if socket_fd in r:
                         # Received packet from server.
@@ -103,6 +121,8 @@ def attach(self, detach_other_clients=False, true_color=False):
                         # Timeout. (Tell the server to flush the vt100 Escape.)
                         self._send_packet({'cmd': 'flush-input'})
                         current_timeout = None
+            finally:
+                signal.signal(signal.SIGWINCH, signal.SIG_IGN)
 
     def _process(self, data_buffer):
         """
@@ -142,17 +162,24 @@ def _process_stdin(self):
         Received data on stdin. Read and send to server.
         """
         with nonblocking(sys.stdin.fileno()):
-            data = sys.stdin.read()
+            data = self._stdin_reader.read()
 
-        self._send_packet({
-            'cmd': 'in',
-            'data': data,
-        })
+        # Send input in chunks of 4k.
+        step = 4056
+        for i in range(0, len(data), step):
+            self._send_packet({
+                'cmd': 'in',
+                'data': data[i:i + step],
+            })
 
     def _send_packet(self, data):
         " Send to server. "
         data = json.dumps(data).encode('utf-8')
 
+        # Be sure that our socket is blocking, otherwise, the send() call could
+        # raise `BlockingIOError` if the buffer is full.
+        self.socket.setblocking(1)
+
         self.socket.send(data + b'\0')
 
     def _send_size(self):
@@ -171,6 +198,6 @@ def list_clients():
     p = '%s/pymux.sock.%s.*' % (tempfile.gettempdir(), getpass.getuser())
     for path in glob.glob(p):
         try:
-            yield Client(path)
+            yield PosixClient(path)
         except socket.error:
             pass
diff --git a/pymux/client/windows.py b/pymux/client/windows.py
new file mode 100644
index 0000000..c22ab7d
--- /dev/null
+++ b/pymux/client/windows.py
@@ -0,0 +1,128 @@
+from __future__ import unicode_literals
+
+from ctypes import byref, windll
+from ctypes.wintypes import DWORD
+from prompt_toolkit.eventloop import ensure_future, From
+from prompt_toolkit.eventloop import get_event_loop
+from prompt_toolkit.input.win32 import Win32Input
+from prompt_toolkit.output import ColorDepth
+from prompt_toolkit.output.win32 import Win32Output
+from prompt_toolkit.win32_types import STD_OUTPUT_HANDLE
+import json
+import os
+import sys
+
+from ..pipes.win32_client import PipeClient
+from .base import Client
+
+__all__ = [
+    'WindowsClient',
+    'list_clients',
+]
+
+# See: https://msdn.microsoft.com/pl-pl/library/windows/desktop/ms686033(v=vs.85).aspx
+ENABLE_PROCESSED_INPUT = 0x0001
+ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+
+
+class WindowsClient(Client):
+    def __init__(self, pipe_name):
+        self._input = Win32Input()
+        self._hconsole = windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE)
+        self._data_buffer = b''
+
+        self.pipe = PipeClient(pipe_name)
+
+    def attach(self, detach_other_clients=False, color_depth=ColorDepth.DEPTH_8_BIT):
+        assert isinstance(detach_other_clients, bool)
+        self._send_size()
+        self._send_packet({
+            'cmd': 'start-gui',
+            'detach-others': detach_other_clients,
+            'color-depth': color_depth,
+            'term': os.environ.get('TERM', ''),
+            'data': ''
+        })
+
+        f = ensure_future(self._start_reader())
+        with self._input.attach(self._input_ready):
+            # Run as long as we have a connection with the server.
+            get_event_loop().run_until_complete(f)  # Run forever.
+
+    def _start_reader(self):
+        """
+        Read messages from the Win32 pipe server and handle them.
+        """
+        while True:
+            message = yield From(self.pipe.read_message())
+            self._process(message)
+
+    def _process(self, data_buffer):
+        """
+        Handle incoming packet from server.
+        """
+        packet = json.loads(data_buffer)
+
+        if packet['cmd'] == 'out':
+            # Call os.write manually. In Python2.6, sys.stdout.write doesn't use UTF-8.
+            original_mode = DWORD(0)
+            windll.kernel32.GetConsoleMode(self._hconsole, byref(original_mode))
+
+            windll.kernel32.SetConsoleMode(self._hconsole, DWORD(
+                ENABLE_PROCESSED_INPUT | ENABLE_VIRTUAL_TERMINAL_PROCESSING))
+
+            try:
+                os.write(sys.stdout.fileno(), packet['data'].encode('utf-8'))
+            finally:
+                windll.kernel32.SetConsoleMode(self._hconsole, original_mode)
+
+        elif packet['cmd'] == 'suspend':
+            # Suspend client process to background.
+            pass
+
+        elif packet['cmd'] == 'mode':
+            pass
+
+            # # Set terminal to raw/cooked.
+            # action = packet['data']
+
+            # if action == 'raw':
+            #     cm = raw_mode(sys.stdin.fileno())
+            #     cm.__enter__()
+            #     self._mode_context_managers.append(cm)
+
+            # elif action == 'cooked':
+            #     cm = cooked_mode(sys.stdin.fileno())
+            #     cm.__enter__()
+            #     self._mode_context_managers.append(cm)
+
+            # elif action == 'restore' and self._mode_context_managers:
+            #     cm = self._mode_context_managers.pop()
+            #     cm.__exit__()
+
+    def _input_ready(self):
+        keys = self._input.read_keys()
+        if keys:
+            self._send_packet({
+                'cmd': 'in',
+                'data': ''.join(key_press.data for key_press in keys),
+            })
+
+    def _send_packet(self, data):
+        " Send to server. "
+        data = json.dumps(data)
+        ensure_future(self.pipe.write_message(data))
+
+    def _send_size(self):
+        " Report terminal size to server. "
+        output = Win32Output(sys.stdout)
+        rows, cols = output.get_size()
+
+        self._send_packet({
+            'cmd': 'size',
+            'data': [rows, cols]
+        })
+
+
+def list_clients():
+    return []
diff --git a/pymux/commands/commands.py b/pymux/commands/commands.py
index 1fca5db..6169aad 100644
--- a/pymux/commands/commands.py
+++ b/pymux/commands/commands.py
@@ -5,14 +5,13 @@
 import shlex
 import six
 
+from prompt_toolkit.application.current import get_app
 from prompt_toolkit.document import Document
-from prompt_toolkit.enums import SEARCH_BUFFER
 from prompt_toolkit.key_binding.vi_state import InputMode
 
 from pymux.arrangement import LayoutTypes
 from pymux.commands.aliases import ALIASES
 from pymux.commands.utils import wrap_argument
-from pymux.enums import PROMPT
 from pymux.format import format_pymux_string
 from pymux.key_mappings import pymux_key_to_prompt_toolkit_key_sequence, prompt_toolkit_key_to_vt100_key
 from pymux.layout import focus_right, focus_left, focus_up, focus_down
@@ -48,7 +47,7 @@ def get_option_flags_for_command(command):
     return COMMANDS_TO_OPTION_FLAGS.get(command, [])
 
 
-def handle_command(pymux, cli, input_string):
+def handle_command(pymux, input_string):
     """
     Handle command.
     """
@@ -68,12 +67,12 @@ def handle_command(pymux, cli, input_string):
                 parts = shlex.split(input_string)
         except ValueError as e:
             # E.g. missing closing quote.
-            pymux.show_message(cli, 'Invalid command %s: %s' % (input_string, e))
+            pymux.show_message('Invalid command %s: %s' % (input_string, e))
         else:
-            call_command_handler(parts[0], pymux, cli, parts[1:])
+            call_command_handler(parts[0], pymux, parts[1:])
 
 
-def call_command_handler(command, pymux, cli, arguments):
+def call_command_handler(command, pymux, arguments):
     """
     Execute command.
 
@@ -87,19 +86,19 @@ def call_command_handler(command, pymux, cli, arguments):
     try:
         handler = COMMANDS_TO_HANDLERS[command]
     except KeyError:
-        pymux.show_message(cli, 'Invalid command: %s' % (command,))
+        pymux.show_message('Invalid command: %s' % (command,))
     else:
         try:
-            handler(pymux, cli, arguments)
+            handler(pymux, arguments)
         except CommandException as e:
-            pymux.show_message(cli, e.message)
+            pymux.show_message(e.message)
 
 
 def cmd(name, options=''):
     """
     Decorator for all commands.
 
-    Commands will receive (pymux, cli, variables) as input.
+    Commands will receive (pymux, variables) as input.
     Commands can raise CommandException.
     """
     # Validate options.
@@ -110,7 +109,7 @@ def cmd(name, options=''):
             pass
 
     def decorator(func):
-        def command_wrapper(pymux, cli, arguments):
+        def command_wrapper(pymux, arguments):
             # Hack to make the 'bind-key' option work.
             # (bind-key expects a variable number of arguments.)
             if name == 'bind-key' and '--' not in arguments:
@@ -146,7 +145,7 @@ def command_wrapper(pymux, cli, arguments):
                 raise CommandException('Usage: %s %s' % (name, options))
 
             # Call handler.
-            func(pymux, cli, received_options)
+            func(pymux, received_options)
 
             # Invalidate all clients, not just the current CLI.
             pymux.invalidate()
@@ -173,19 +172,19 @@ def __init__(self, message):
 
 
 @cmd('break-pane', options='[-d]')
-def break_pane(pymux, cli, variables):
+def break_pane(pymux, variables):
     dont_focus_window = variables['-d']
 
-    pymux.arrangement.break_pane(cli, set_active=not dont_focus_window)
+    pymux.arrangement.break_pane(set_active=not dont_focus_window)
     pymux.invalidate()
 
 
 @cmd('select-pane', options='(-L|-R|-U|-D|-t <pane-id>)')
-def select_pane(pymux, cli, variables):
+def select_pane(pymux, variables):
 
     if variables['-t']:
         pane_id = variables['<pane-id>']
-        w = pymux.arrangement.get_active_window(cli)
+        w = pymux.arrangement.get_active_window()
 
         if pane_id == ':.+':
             w.focus_next()
@@ -205,11 +204,11 @@ def select_pane(pymux, cli, variables):
         if variables['-D']: h = focus_down
         if variables['-R']: h = focus_right
 
-        h(pymux, cli)
+        h(pymux)
 
 
 @cmd('select-window', options='(-t <target-window>)')
-def select_window(pymux, cli, variables):
+def select_window(pymux, variables):
     """
     Select a window. E.g:  select-window -t :3
     """
@@ -226,7 +225,7 @@ def invalid_window():
         else:
             w = pymux.arrangement.get_window_by_index(number)
             if w:
-                pymux.arrangement.set_active_window(cli, w)
+                pymux.arrangement.set_active_window(w)
             else:
                 invalid_window()
     else:
@@ -234,7 +233,7 @@ def invalid_window():
 
 
 @cmd('move-window', options='(-t <dst-window>)')
-def move_window(pymux, cli, variables):
+def move_window(pymux, variables):
     """
     Move window to a new index.
     """
@@ -249,54 +248,54 @@ def move_window(pymux, cli, variables):
         raise CommandException("Can't move window: index in use.")
 
     # Save index.
-    w = pymux.arrangement.get_active_window(cli)
+    w = pymux.arrangement.get_active_window()
     pymux.arrangement.move_window(w, new_index)
 
 
 @cmd('rotate-window', options='[-D|-U]')
-def rotate_window(pymux, cli, variables):
+def rotate_window(pymux, variables):
     if variables['-D']:
-        pymux.arrangement.rotate_window(cli, count=-1)
+        pymux.arrangement.rotate_window(count=-1)
     else:
-        pymux.arrangement.rotate_window(cli)
+        pymux.arrangement.rotate_window()
 
 
 @cmd('swap-pane', options='(-D|-U)')
-def swap_pane(pymux, cli, variables):
-    pymux.arrangement.get_active_window(cli).rotate(with_pane_after_only=variables['-U'])
+def swap_pane(pymux, variables):
+    pymux.arrangement.get_active_window().rotate(with_pane_after_only=variables['-U'])
 
 
 @cmd('kill-pane')
-def kill_pane(pymux, cli, variables):
-    pane = pymux.arrangement.get_active_pane(cli)
+def kill_pane(pymux, variables):
+    pane = pymux.arrangement.get_active_pane()
     pymux.kill_pane(pane)
 
 
 @cmd('kill-window')
-def kill_window(pymux, cli, variables):
+def kill_window(pymux, variables):
     " Kill all panes in the current window. "
-    for pane in pymux.arrangement.get_active_window(cli).panes:
+    for pane in pymux.arrangement.get_active_window().panes:
         pymux.kill_pane(pane)
 
 
 @cmd('suspend-client')
-def suspend_client(pymux, cli, variables):
-    connection = pymux.get_connection_for_cli(cli)
+def suspend_client(pymux, variables):
+    connection = pymux.get_connection()
 
     if connection:
         connection.suspend_client_to_background()
 
 
 @cmd('clock-mode')
-def clock_mode(pymux, cli, variables):
-    pane = pymux.arrangement.get_active_pane(cli)
+def clock_mode(pymux, variables):
+    pane = pymux.arrangement.get_active_pane()
     if pane:
         pane.clock_mode = not pane.clock_mode
 
 
 @cmd('last-pane')
-def last_pane(pymux, cli, variables):
-    w = pymux.arrangement.get_active_window(cli)
+def last_pane(pymux, variables):
+    w = pymux.arrangement.get_active_window()
     prev_active_pane = w.previous_active_pane
 
     if prev_active_pane:
@@ -304,79 +303,79 @@ def last_pane(pymux, cli, variables):
 
 
 @cmd('next-layout')
-def next_layout(pymux, cli, variables):
+def next_layout(pymux, variables):
     " Select next layout. "
-    pane = pymux.arrangement.get_active_window(cli)
+    pane = pymux.arrangement.get_active_window()
     if pane:
         pane.select_next_layout()
 
 
 @cmd('previous-layout')
-def previous_layout(pymux, cli, variables):
+def previous_layout(pymux, variables):
     " Select previous layout. "
-    pane = pymux.arrangement.get_active_window(cli)
+    pane = pymux.arrangement.get_active_window()
     if pane:
         pane.select_previous_layout()
 
 
 @cmd('new-window', options='[(-n <name>)] [(-c <start-directory>)] [<executable>]')
-def new_window(pymux, cli, variables):
+def new_window(pymux, variables):
     executable = variables['<executable>']
     start_directory = variables['<start-directory>']
     name = variables['<name>']
 
-    pymux.create_window(cli, executable, start_directory=start_directory, name=name)
+    pymux.create_window(executable, start_directory=start_directory, name=name)
 
 
 @cmd('next-window')
-def next_window(pymux, cli, variables):
+def next_window(pymux, variables):
     " Focus the next window. "
-    pymux.arrangement.focus_next_window(cli)
+    pymux.arrangement.focus_next_window()
 
 
 @cmd('last-window')
-def _(pymux, cli, variables):
+def _(pymux, variables):
     " Go to previous active window. "
-    w = pymux.arrangement.get_previous_active_window(cli)
+    w = pymux.arrangement.get_previous_active_window()
 
     if w:
-        pymux.arrangement.set_active_window(cli, w)
+        pymux.arrangement.set_active_window(w)
 
 
 @cmd('previous-window')
-def previous_window(pymux, cli, variables):
+def previous_window(pymux, variables):
     " Focus the previous window. "
-    pymux.arrangement.focus_previous_window(cli)
+    pymux.arrangement.focus_previous_window()
 
 
 @cmd('select-layout', options='<layout-type>')
-def select_layout(pymux, cli, variables):
+def select_layout(pymux, variables):
     layout_type = variables['<layout-type>']
 
     if layout_type in LayoutTypes._ALL:
-        pymux.arrangement.get_active_window(cli).select_layout(layout_type)
+        pymux.arrangement.get_active_window().select_layout(layout_type)
     else:
         raise CommandException('Invalid layout type.')
 
 
 @cmd('rename-window', options='<name>')
-def rename_window(pymux, cli, variables):
+def rename_window(pymux, variables):
     """
     Rename the active window.
     """
-    pymux.arrangement.get_active_window(cli).chosen_name = variables['<name>']
+    pymux.arrangement.get_active_window().chosen_name = variables['<name>']
 
 
 @cmd('rename-pane', options='<name>')
-def rename_pane(pymux, cli, variables):
+def rename_pane(pymux, variables):
     """
     Rename the active pane.
     """
-    pymux.arrangement.get_active_pane(cli).chosen_name = variables['<name>']
+    pymux.arrangement.get_active_pane().chosen_name = variables['<name>']
 
 
 @cmd('rename-session', options='<name>')
-def rename_session(pymux, cli, variables):
+def rename_session(pymux, variables):
     """
     Rename this session.
     """
@@ -384,7 +383,7 @@ def rename_session(pymux, cli, variables):
 
 
 @cmd('split-window', options='[-v|-h] [(-c <start-directory>)] [<executable>]')
-def split_window(pymux, cli, variables):
+def split_window(pymux, variables):
     """
     Split horizontally or vertically.
     """
@@ -392,12 +391,12 @@ def split_window(pymux, cli, variables):
     start_directory = variables['<start-directory>']
 
     # The tmux definition of horizontal is the opposite of prompt_toolkit.
-    pymux.add_process(cli, executable, vsplit=variables['-h'],
+    pymux.add_process(executable, vsplit=variables['-h'],
                       start_directory=start_directory)
 
 
 @cmd('resize-pane', options="[(-L <left>)] [(-U <up>)] [(-D <down>)] [(-R <right>)] [-Z]")
-def resize_pane(pymux, cli, variables):
+def resize_pane(pymux, variables):
     """
     Resize/zoom the active pane.
     """
@@ -409,7 +408,7 @@ def resize_pane(pymux, cli, variables):
     except ValueError:
         raise CommandException('Expecting an integer.')
 
-    w = pymux.arrangement.get_active_window(cli)
+    w = pymux.arrangement.get_active_window()
 
     if w:
         w.change_size_for_active_pane(up=up, right=right, down=down, left=left)
@@ -420,27 +419,27 @@ def resize_pane(pymux, cli, variables):
 
 
 @cmd('detach-client')
-def detach_client(pymux, cli, variables):
+def detach_client(pymux, variables):
     """
     Detach client.
     """
-    pymux.detach_client(cli)
+    pymux.detach_client(get_app())
 
 
 @cmd('confirm-before', options='[(-p <message>)] <command>')
-def confirm_before(pymux, cli, variables):
-    client_state = pymux.get_client_state(cli)
+def confirm_before(pymux, variables):
+    client_state = pymux.get_client_state()
 
     client_state.confirm_text = variables['<message>'] or ''
     client_state.confirm_command = variables['<command>']
 
 
 @cmd('command-prompt', options='[(-p <message>)] [(-I <default>)] [<command>]')
-def command_prompt(pymux, cli, variables):
+def command_prompt(pymux, variables):
     """
     Enter command prompt.
     """
-    client_state = pymux.get_client_state(cli)
+    client_state = pymux.get_client_state()
 
     if variables['<command>']:
         # When a 'command' has been given.
@@ -448,25 +447,27 @@ def command_prompt(pymux, cli, variables):
         client_state.prompt_command = variables['<command>']
 
         client_state.prompt_mode = True
-        cli.buffers[PROMPT].reset(Document(
-            format_pymux_string(pymux, cli, variables['<default>'] or '')))
+        client_state.prompt_buffer.reset(Document(
+            format_pymux_string(pymux, variables['<default>'] or '')))
+
+        get_app().layout.focus(client_state.prompt_buffer)
     else:
         # Show the ':' prompt.
         client_state.prompt_text = ''
         client_state.prompt_command = ''
 
-        client_state.command_mode = True
+        get_app().layout.focus(client_state.command_buffer)
 
     # Go to insert mode.
-    client_state.vi_state.input_mode = InputMode.INSERT
+    get_app().vi_state.input_mode = InputMode.INSERT
 
 
 @cmd('send-prefix')
-def send_prefix(pymux, cli, variables):
+def send_prefix(pymux, variables):
     """
     Send prefix to active pane.
     """
-    process = pymux.arrangement.get_active_pane(cli).process
+    process = pymux.arrangement.get_active_pane().process
 
     for k in pymux.key_bindings_manager.prefix:
         vt100_data = prompt_toolkit_key_to_vt100_key(k)
@@ -474,7 +475,7 @@ def send_prefix(pymux, cli, variables):
 
 
 @cmd('bind-key', options='[-n] <key> [--] <command> [<arguments>...]')
-def bind_key(pymux, cli, variables):
+def bind_key(pymux, variables):
     """
     Bind a key sequence.
     -n: Not necessary to use the prefix.
@@ -492,7 +493,7 @@ def bind_key(pymux, cli, variables):
 
 
 @cmd('unbind-key', options='[-n] <key>')
-def unbind_key(pymux, cli, variables):
+def unbind_key(pymux, variables):
     """
     Remove key binding.
     """
@@ -504,11 +505,11 @@ def unbind_key(pymux, cli, variables):
 
 
 @cmd('send-keys', options='<keys>...')
-def send_keys(pymux, cli, variables):
+def send_keys(pymux, variables):
     """
     Send key strokes to the active process.
     """
-    pane = pymux.arrangement.get_active_pane(cli)
+    pane = pymux.arrangement.get_active_pane()
 
     if pane.display_scroll_buffer:
         raise CommandException('Cannot send keys. Pane is in copy mode.')
@@ -525,28 +526,29 @@ def send_keys(pymux, cli, variables):
             pane.process.write_key(k)
 
 
-@cmd('copy-mode')
-def copy_mode(pymux, cli, variables):
+@cmd('copy-mode', options='[-u]')
+def copy_mode(pymux, variables):
     """
     Enter copy mode.
     """
-    pane = pymux.arrangement.get_active_pane(cli)
-    pane.enter_copy_mode()
+    go_up = variables['-u']  # Go in copy mode and page-up directly.
+    # TODO: handle '-u'
 
-    cli.buffers[SEARCH_BUFFER].reset()
+    pane = pymux.arrangement.get_active_pane()
+    pane.enter_copy_mode()
 
 
 @cmd('paste-buffer')
-def paste_buffer(pymux, cli, variables):
+def paste_buffer(pymux, variables):
     """
     Paste clipboard content into buffer.
     """
-    pane = pymux.arrangement.get_active_pane(cli)
-    pane.process.write_input(cli.clipboard.get_data().text, paste=True)
+    pane = pymux.arrangement.get_active_pane()
+    pane.process.write_input(get_app().clipboard.get_data().text, paste=True)
 
 
 @cmd('source-file', options='<filename>')
-def source_file(pymux, cli, variables):
+def source_file(pymux, variables):
     """
     Source configuration file.
     """
@@ -555,13 +557,13 @@ def source_file(pymux, cli, variables):
         with open(filename, 'rb') as f:
             for line in f:
                 line = line.decode('utf-8')
-                handle_command(pymux, cli, line)
+                handle_command(pymux, line)
     except IOError as e:
         raise CommandException('IOError: %s' % (e, ))
 
 
 @cmd('set-option', options='<option> <value>')
-def set_option(pymux, cli, variables, window=False):
+def set_option(pymux, variables, window=False):
     name = variables['<option>']
     value = variables['<value>']
 
@@ -572,35 +574,35 @@ def set_option(pymux, cli, variables, window=False):
 
     if option:
         try:
-            option.set_value(pymux, cli, value)
+            option.set_value(pymux, value)
         except SetOptionError as e:
             raise CommandException(e.message)
     else:
         raise CommandException('Invalid option: %s' % (name, ))
 
 @cmd('set-window-option', options='<option> <value>')
-def set_window_option(pymux, cli, variables):
-    set_option(pymux, cli, variables, window=True)
+def set_window_option(pymux, variables):
+    set_option(pymux, variables, window=True)
 
 
 @cmd('display-panes')
-def display_panes(pymux, cli, variables):
+def display_panes(pymux, variables):
     " Display the pane numbers. "
     pymux.display_pane_numbers = True
 
 
 @cmd('display-message', options='<message>')
-def display_message(pymux, cli, variables):
+def display_message(pymux, variables):
     " Display a message. "
     message = variables['<message>']
-    client_state = pymux.get_client_state(cli)
+    client_state = pymux.get_client_state()
     client_state.message = message
 
 
 @cmd('clear-history')
-def clear_history(pymux, cli, variables):
+def clear_history(pymux, variables):
     " Clear scrollback buffer. "
-    pane = pymux.arrangement.get_active_pane(cli)
+    pane = pymux.arrangement.get_active_pane()
 
     if pane.display_scroll_buffer:
         raise CommandException('Not available in copy mode')
@@ -609,7 +611,7 @@ def clear_history(pymux, cli, variables):
 
 
 @cmd('list-keys')
-def list_keys(pymux, cli, variables):
+def list_keys(pymux, variables):
     """
     Display all configured key bindings.
     """
@@ -623,19 +625,17 @@ def list_keys(pymux, cli, variables):
             ('-n' if needs_prefix else ''), key, custom_binding.command,
             ' '.join(map(wrap_argument, custom_binding.arguments))))
 
-    result = '\n'.join(sorted(result))
-
     # Display help in pane.
-    pane = pymux.arrangement.get_active_pane(cli)
-    pane.display_text(result, title='list-keys')
+    result = '\n'.join(sorted(result))
+    pymux.get_client_state().layout_manager.display_popup('list-keys', result)
 
 
 @cmd('list-panes')
-def list_panes(pymux, cli, variables):
+def list_panes(pymux, variables):
     """
     Display a list of all the panes.
     """
-    w = pymux.arrangement.get_active_window(cli)
+    w = pymux.arrangement.get_active_window()
     active_pane = w.active_pane
 
     result = []
@@ -643,14 +643,24 @@ def list_panes(pymux, cli, variables):
     for i, p in enumerate(w.panes):
         process = p.process
 
-        result.append('%i: [%sx%s] [history %s/%s] %s\n' % (
+        result.append('%i: [%sx%s] [history %s/%s] %s' % (
             i, process.sx, process.sy,
             min(pymux.history_limit, process.screen.line_offset + process.sy),
             pymux.history_limit,
             ('(active)' if p == active_pane else '')))
 
     # Display help in pane.
-    active_pane.display_text(''.join(result), title='list-panes')
+    result = '\n'.join(sorted(result))
+    pymux.get_client_state().layout_manager.display_popup('list-keys', result)
+
+
+@cmd('show-buffer')
+def show_buffer(pymux, variables):
+    """
+    Display the clipboard content.
+    """
+    text = get_app().clipboard.get_data().text
+    pymux.get_client_state().layout_manager.display_popup('show-buffer', text)
 
 
 # Check whether all aliases point to real commands.
diff --git a/pymux/commands/completer.py b/pymux/commands/completer.py
index cdfd195..6e2c018 100644
--- a/pymux/commands/completer.py
+++ b/pymux/commands/completer.py
@@ -1,8 +1,6 @@
 from __future__ import unicode_literals
 
-from prompt_toolkit.completion import Completer, Completion
-from prompt_toolkit.completion import Completer
-from prompt_toolkit.contrib.completers import WordCompleter
+from prompt_toolkit.completion import Completer, Completion, WordCompleter
 from prompt_toolkit.document import Document
 
 from .aliases import ALIASES
diff --git a/pymux/darwin.py b/pymux/darwin.py
deleted file mode 100644
index 8b0dc20..0000000
--- a/pymux/darwin.py
+++ /dev/null
@@ -1,88 +0,0 @@
-"""
-Tools for Darwin. (Mac OS X.)
-"""
-from __future__ import unicode_literals
-from ctypes import cdll, pointer, c_uint, c_ubyte, c_ulong
-from struct import pack
-
-import six
-
-__all__ = (
-    'get_proc_info',
-    'get_proc_name'
-)
-
-# Current Values as of El Capitan
-
-# /usr/include/sys/sysctl.h
-CTL_KERN = 1
-KERN_PROC = 14
-KERN_PROC_PID = 1
-KERN_PROC_PGRP = 2
-
-# /usr/include/sys/param.h
-MAXCOMLEN = 16
-
-# kinfo_proc (/usr/include/sys/sysctl.h)
-#  \-> extern_proc (/usr/include/sys/proc.h)
-P_COMM_OFFSET = 243
-
-# Finding the type for PIDs was *interesting*
-# pid_t in /usr/include/sys/types.h -> \
-#   pid_t in /usr/include/sys/_types/_pid_t.h -> \
-#   __darwin_pid_t -> /usr/include/sys/_types.h -> \
-#   __int32_t
-
-LIBC = None
-
-
-def _init():
-    """
-    Initialize ctypes DLL link.
-    """
-    global LIBC
-
-    if LIBC is None:
-        LIBC = cdll.LoadLibrary('libc.dylib')
-
-
-def get_proc_info(pid):
-    """
-    Use sysctl to retrieve process info.
-    """
-    # Ensure that we have the DLL loaded.
-    _init()
-
-    # Request the length of the process data.
-    mib = (c_uint * 4)(CTL_KERN, KERN_PROC, KERN_PROC_PID, pid)
-    oldlen = c_ulong()
-    oldlenp = pointer(oldlen)
-    r = LIBC.sysctl(mib, len(mib), None, oldlenp, None, 0)
-    if r:
-        return
-
-    # Request the process data.
-    reslen = oldlen.value
-    old = (c_ubyte * reslen)()
-    oldp = pointer(old)
-    r = LIBC.sysctl(mib, len(mib), old, oldlenp, None, 0)
-    if r:
-        return
-    #assert oldlen.value <= reslen
-
-    return old[:reslen]
-
-
-def get_proc_name(pid):
-    """
-    Use sysctl to retrive process name.
-    """
-    proc_kinfo = get_proc_info(pid)
-    if not proc_kinfo:
-        return
-
-    p_comm_range = proc_kinfo[P_COMM_OFFSET:P_COMM_OFFSET + MAXCOMLEN + 1]
-    p_comm_raw = ''.join(six.unichr(c) for c in p_comm_range)
-    p_comm = p_comm_raw.split('\0', 1)[0]
-
-    return p_comm
diff --git a/pymux/entry_points/run_pymux.py b/pymux/entry_points/run_pymux.py
index c48ddd1..b881c0f 100644
--- a/pymux/entry_points/run_pymux.py
+++ b/pymux/entry_points/run_pymux.py
@@ -3,7 +3,7 @@
 pymux: Pure Python terminal multiplexer.
 Usage:
     pymux [(standalone|start-server|attach)] [-d]
-          [--truecolor] [(-S <socket>)] [(-f <file>)]
+          [--truecolor] [--ansicolor] [(-S <socket>)] [(-f <file>)]
           [(--log <logfile>)]
           [--] [<command>]
     pymux list-sessions
@@ -25,8 +25,9 @@
 """
 from __future__ import unicode_literals, absolute_import
 
+from prompt_toolkit.output import ColorDepth
 from pymux.main import Pymux
-from pymux.client import Client, list_clients
+from pymux.client import create_client, list_clients
 from pymux.utils import daemonize
 
 import docopt
@@ -48,6 +49,8 @@ def run():
     filename = a['<file>']
     command = a['<command>']
     true_color = a['--truecolor']
+    ansi_colors_only = a['--ansicolor'] or \
+        bool(os.environ.get('PROMPT_TOOLKIT_ANSI_COLORS_ONLY', False))
 
     # Parse pane_id from socket_name. It looks like "socket_name,pane_id".
     if socket_name and ',' in socket_name:
@@ -55,6 +58,14 @@ def run():
     else:
         pane_id = None
 
+    # Color depth.
+    if ansi_colors_only:
+        color_depth = ColorDepth.DEPTH_4_BIT
+    elif true_color:
+        color_depth = ColorDepth.DEPTH_24_BIT
+    else:
+        color_depth = ColorDepth.DEPTH_8_BIT
+
     # Expand socket name. (Make it possible to just accept numbers.)
     if socket_name and socket_name.isdigit():
         socket_name = '%s/pymux.sock.%s.%s' % (
@@ -76,7 +87,7 @@ def run():
         logging.basicConfig(filename=a['<logfile>'], level=logging.DEBUG)
 
     if a['standalone']:
-        mux.run_standalone(true_color=true_color)
+        mux.run_standalone(color_depth=color_depth)
 
     elif a['list-sessions'] or a['<command>'] in ('ls', 'list-sessions'):
         for c in list_clients():
@@ -105,21 +116,21 @@ def run():
         detach_other_clients = a['-d']
 
         if socket_name:
-            Client(socket_name).attach(
+            create_client(socket_name).attach(
                 detach_other_clients=detach_other_clients,
-                true_color=true_color)
+                color_depth=color_depth)
         else:
             # Connect to the first server.
             for c in list_clients():
                 c.attach(detach_other_clients=detach_other_clients,
-                         true_color=true_color)
+                         color_depth=color_depth)
                 break
             else:  # Nobreak.
                 print('No pymux instance found.')
                 sys.exit(1)
 
     elif a['<command>'] and socket_name:
-        Client(socket_name).run_command(a['<command>'], pane_id)
+        create_client(socket_name).run_command(a['<command>'], pane_id)
 
     elif not socket_name:
         # Run client/server combination.
@@ -132,7 +143,7 @@ def run():
             # daemon. (Otherwise the `waitpid` call won't work.)
             mux.run_server()
         else:
-            Client(socket_name).attach(true_color=true_color)
+            create_client(socket_name).attach(color_depth=color_depth)
 
     else:
         if socket_name_from_env:
diff --git a/pymux/filters.py b/pymux/filters.py
index 0831372..49f99bf 100644
--- a/pymux/filters.py
+++ b/pymux/filters.py
@@ -19,8 +19,8 @@ class HasPrefix(Filter):
     def __init__(self, pymux):
         self.pymux = pymux
 
-    def __call__(self, cli):
-        return self.pymux.get_client_state(cli).has_prefix
+    def __call__(self):
+        return self.pymux.get_client_state().has_prefix
 
 
 class WaitsForConfirmation(Filter):
@@ -30,8 +30,8 @@ class WaitsForConfirmation(Filter):
     def __init__(self, pymux):
         self.pymux = pymux
 
-    def __call__(self, cli):
-        return bool(self.pymux.get_client_state(cli).confirm_command)
+    def __call__(self):
+        return bool(self.pymux.get_client_state().confirm_command)
 
 
 class InCommandMode(Filter):
@@ -41,8 +41,8 @@ class InCommandMode(Filter):
     def __init__(self, pymux):
         self.pymux = pymux
 
-    def __call__(self, cli):
-        client_state = self.pymux.get_client_state(cli)
+    def __call__(self):
+        client_state = self.pymux.get_client_state()
         return client_state.command_mode and not client_state.confirm_command
 
 
@@ -53,14 +53,14 @@ class WaitsForPrompt(Filter):
     def __init__(self, pymux):
         self.pymux = pymux
 
-    def __call__(self, cli):
-        client_state = self.pymux.get_client_state(cli)
+    def __call__(self):
+        client_state = self.pymux.get_client_state()
         return bool(client_state.prompt_command) and not client_state.confirm_command
 
 
-def _confirm_or_prompt_or_command(pymux, cli):
+def _confirm_or_prompt_or_command(pymux):
     " True when we are waiting for a command, prompt or confirmation. "
-    client_state = pymux.get_client_state(cli)
+    client_state = pymux.get_client_state()
     if client_state.confirm_text or client_state.prompt_command or client_state.command_mode:
         return True
 
@@ -69,11 +69,11 @@ class InScrollBuffer(Filter):
     def __init__(self, pymux):
         self.pymux = pymux
 
-    def __call__(self, cli):
-        if _confirm_or_prompt_or_command(self.pymux, cli):
+    def __call__(self):
+        if _confirm_or_prompt_or_command(self.pymux):
             return False
 
-        pane = self.pymux.arrangement.get_active_pane(cli)
+        pane = self.pymux.arrangement.get_active_pane()
         return pane.display_scroll_buffer
 
 
@@ -81,11 +81,11 @@ class InScrollBufferNotSearching(Filter):
     def __init__(self, pymux):
         self.pymux = pymux
 
-    def __call__(self, cli):
-        if _confirm_or_prompt_or_command(self.pymux, cli):
+    def __call__(self):
+        if _confirm_or_prompt_or_command(self.pymux):
             return False
 
-        pane = self.pymux.arrangement.get_active_pane(cli)
+        pane = self.pymux.arrangement.get_active_pane()
         return pane.display_scroll_buffer and not pane.is_searching
 
 
@@ -93,9 +93,9 @@ class InScrollBufferSearching(Filter):
     def __init__(self, pymux):
         self.pymux = pymux
 
-    def __call__(self, cli):
-        if _confirm_or_prompt_or_command(self.pymux, cli):
+    def __call__(self):
+        if _confirm_or_prompt_or_command(self.pymux):
             return False
 
-        pane = self.pymux.arrangement.get_active_pane(cli)
+        pane = self.pymux.arrangement.get_active_pane()
         return pane.display_scroll_buffer and pane.is_searching
diff --git a/pymux/format.py b/pymux/format.py
index 3c6abda..3f2cdad 100644
--- a/pymux/format.py
+++ b/pymux/format.py
@@ -11,7 +11,7 @@
 )
 
 
-def format_pymux_string(pymux, cli, string, window=None, pane=None):
+def format_pymux_string(pymux, string, window=None, pane=None):
     """
     Apply pymux sting formatting. (Similar to tmux.)
     E.g.  #P is replaced by the index of the active pane.
@@ -26,7 +26,7 @@ def format_pymux_string(pymux, cli, string, window=None, pane=None):
     arrangement = pymux.arrangement
 
     if window is None:
-        window = arrangement.get_active_window(cli)
+        window = arrangement.get_active_window()
 
     if pane is None:
         pane = window.active_pane
@@ -49,9 +49,9 @@ def name_of_window():
     def window_flags():
         z = 'Z' if window.zoom else ''
 
-        if window == arrangement.get_active_window(cli):
+        if window == arrangement.get_active_window():
             return '*' + z
-        elif window == arrangement.get_previous_active_window(cli):
+        elif window == arrangement.get_previous_active_window():
             return '-' + z
         else:
             return z + ' '
@@ -81,14 +81,15 @@ def literal():
     }
 
     # Date/time formatting.
-    try:
-        if six.PY2:
-            string = datetime.datetime.now().strftime(
-                string.encode('utf-8')).decode('utf-8')
-        else:
-            string = datetime.datetime.now().strftime(string)
-    except ValueError:  # strftime format ends with raw %
-        string = '<ValueError>'
+    if '%' in string:
+        try:
+            if six.PY2:
+                string = datetime.datetime.now().strftime(
+                    string.encode('utf-8')).decode('utf-8')
+            else:
+                string = datetime.datetime.now().strftime(string)
+        except ValueError:  # strftime format ends with raw %
+            string = '<ValueError>'
 
     # Apply '#' formatting.
     for symbol, f in format_table.items():
diff --git a/pymux/key_bindings.py b/pymux/key_bindings.py
index 5f26353..2e93365 100644
--- a/pymux/key_bindings.py
+++ b/pymux/key_bindings.py
@@ -2,98 +2,68 @@
 Key bindings.
 """
 from __future__ import unicode_literals
-from prompt_toolkit.enums import IncrementalSearchDirection
-from prompt_toolkit.filters import HasFocus, Condition, HasSelection
-from prompt_toolkit.key_binding.manager import KeyBindingManager as pt_KeyBindingManager
-from prompt_toolkit.key_binding.vi_state import InputMode
+from prompt_toolkit.filters import has_focus, Condition, has_selection
 from prompt_toolkit.keys import Keys
 from prompt_toolkit.selection import SelectionType
+from prompt_toolkit.key_binding import KeyBindings, merge_key_bindings
 
 from .enums import COMMAND, PROMPT
-from .filters import WaitsForConfirmation, HasPrefix, InScrollBuffer, InScrollBufferNotSearching, InScrollBufferSearching
+from .filters import WaitsForConfirmation, HasPrefix, InScrollBufferNotSearching
 from .key_mappings import pymux_key_to_prompt_toolkit_key_sequence
 from .commands.commands import call_command_handler
 
 import six
 
 __all__ = (
-    'KeyBindingsManager',
+    'PymuxKeyBindings',
 )
 
 
-class KeyBindingsManager(object):
+class PymuxKeyBindings(object):
     """
     Pymux key binding manager.
     """
     def __init__(self, pymux):
         self.pymux = pymux
 
-        def enable_vi_mode(cli):
-            " Return True when Vi mode is currently active. "
-            client_state = pymux.get_client_state(cli)
-            if client_state.confirm_text or client_state.prompt_command or client_state.command_mode:
-                return pymux.status_keys_vi_mode
-            else:
-                return pymux.mode_keys_vi_mode
-
-        def get_search_state(cli):
-            " Return the currently active SearchState. (The one for the focussed pane.) "
-            return pymux.arrangement.get_active_pane(cli).search_state
-
-        # Start from this KeyBindingManager from prompt_toolkit, to have basic
-        # editing functionality for the command line. These key binding are
-        # however only active when the following `enable_all` condition is met.
-        self.pt_key_bindings_manager = pt_KeyBindingManager(
-            enable_vi_mode=Condition(enable_vi_mode),
-            enable_all=(HasFocus(COMMAND) | HasFocus(PROMPT) | InScrollBuffer(pymux)) & ~HasPrefix(pymux),
-            enable_auto_suggest_bindings=True,
-            enable_search=False,  # We have our own search bindings, that support multiple panes.
-            enable_extra_page_navigation=True,
-            get_vi_state=self._get_vi_state,
-            get_search_state=get_search_state)
-
-        self.registry = self.pt_key_bindings_manager.registry
-
-        self._prefix = (Keys.ControlB, )
+        def get_search_state():
+            " Return the currently active SearchState. (The one for the focused pane.) "
+            return pymux.arrangement.get_active_pane().search_state
+
+        self.custom_key_bindings = KeyBindings()
+
+        self.key_bindings = merge_key_bindings([
+            self._load_builtins(),
+            self.custom_key_bindings,
+        ])
+
+        self._prefix = ('c-b', )
         self._prefix_binding = None
 
         # Load initial bindings.
-        self._load_builtins()
         self._load_prefix_binding()
-        _load_search_bindings(pymux, self.registry, self._get_vi_state)
 
         # Custom user configured key bindings.
         # { (needs_prefix, key) -> (command, handler) }
         self.custom_bindings = {}
 
-    def _get_vi_state(self, cli):
-        " Return the ViState instance for the current client. "
-        vi_state = self.pymux.get_client_state(cli).vi_state
-
-        # Make sure to put the Vi state in navigation mode for read only
-        # buffers.
-        if cli.current_buffer.read_only():
-            vi_state.input_mode = InputMode.NAVIGATION
-
-        return vi_state
-
     def _load_prefix_binding(self):
         """
         Load the prefix key binding.
         """
         pymux = self.pymux
-        registry = self.registry
 
         # Remove previous binding.
         if self._prefix_binding:
-            self.registry.remove_binding(self._prefix_binding)
+            self.custom_key_bindings.remove_binding(self._prefix_binding)
 
         # Create new Python binding.
-        @registry.add_binding(*self._prefix, filter=
-            ~(HasPrefix(pymux) | HasFocus(COMMAND) | HasFocus(PROMPT) | WaitsForConfirmation(pymux)))
+        @self.custom_key_bindings.add(*self._prefix, filter=
+            ~(HasPrefix(pymux) | has_focus(COMMAND) | has_focus(PROMPT) |
+              WaitsForConfirmation(pymux)))
         def enter_prefix_handler(event):
             " Enter prefix mode. "
-            pymux.get_client_state(event.cli).has_prefix = True
+            pymux.get_client_state().has_prefix = True
 
         self._prefix_binding = enter_prefix_handler
 
@@ -117,116 +87,73 @@ def _load_builtins(self):
         Fill the Registry with the hard coded key bindings.
         """
         pymux = self.pymux
-        registry = self.registry
+        kb = KeyBindings()
 
         # Create filters.
         has_prefix = HasPrefix(pymux)
         waits_for_confirmation = WaitsForConfirmation(pymux)
-        prompt_or_command_focus = HasFocus(COMMAND) | HasFocus(PROMPT)
-        display_pane_numbers = Condition(lambda cli: pymux.display_pane_numbers)
+        prompt_or_command_focus = has_focus(COMMAND) | has_focus(PROMPT)
+        display_pane_numbers = Condition(lambda: pymux.display_pane_numbers)
         in_scroll_buffer_not_searching = InScrollBufferNotSearching(pymux)
-        pane_input_allowed = ~(prompt_or_command_focus | has_prefix |
-                               waits_for_confirmation | display_pane_numbers |
-                               InScrollBuffer(pymux))
-
-        @registry.add_binding(Keys.Any, filter=pane_input_allowed, invalidate_ui=False)
-        def _(event):
-            """
-            When a pane has the focus, key bindings are redirected to the
-            process running inside the pane.
-            """
-            # NOTE: we don't invalidate the UI, because for pymux itself,
-            #       nothing in the output changes yet. It's the application in
-            #       the pane that will probably echo back the typed characters.
-            #       When we receive them, they are draw to the UI and it's
-            #       invalidated.
-            w = pymux.arrangement.get_active_window(event.cli)
-            pane = w.active_pane
-
-            if pane.clock_mode:
-                # Leave clock mode on key press.
-                pane.clock_mode = False
-                pymux.invalidate()
-            else:
-                # Write input to pane. If 'synchronize_panes' is on, write
-                # input to all panes in the current window.
-                panes = w.panes if w.synchronize_panes else [pane]
-                for p in panes:
-                    p.process.write_key(event.key_sequence[0].key)
-
-        @registry.add_binding(Keys.BracketedPaste, filter=pane_input_allowed, invalidate_ui=False)
-        def _(event):
-            """
-            Pasting to the active pane. (Using bracketed paste.)
-            """
-            w = pymux.arrangement.get_active_window(event.cli)
-            pane = w.active_pane
-
-            if not pane.clock_mode:
-                # Paste input to pane. If 'synchronize_panes' is on, paste
-                # input to all panes in the current window.
-                panes = w.panes if w.synchronize_panes else [pane]
-                for p in panes:
-                    p.process.write_input(event.data, paste=True)
 
-        @registry.add_binding(Keys.Any, filter=has_prefix)
+        @kb.add(Keys.Any, filter=has_prefix)
         def _(event):
             " Ignore unknown Ctrl-B prefixed key sequences. "
-            pymux.get_client_state(event.cli).has_prefix = False
+            pymux.get_client_state().has_prefix = False
 
-        @registry.add_binding(Keys.ControlC, filter=prompt_or_command_focus & ~has_prefix)
-        @registry.add_binding(Keys.ControlG, filter=prompt_or_command_focus & ~has_prefix)
-        @registry.add_binding(Keys.Backspace, filter=HasFocus(COMMAND) & ~has_prefix &
-                              Condition(lambda cli: cli.buffers[COMMAND].text == ''))
+        @kb.add('c-c', filter=prompt_or_command_focus & ~has_prefix)
+        @kb.add('c-g', filter=prompt_or_command_focus & ~has_prefix)
+#        @kb.add('backspace', filter=has_focus(COMMAND) & ~has_prefix &
+#                              Condition(lambda: cli.buffers[COMMAND].text == ''))
         def _(event):
             " Leave command mode. "
-            pymux.leave_command_mode(event.cli, append_to_history=False)
+            pymux.leave_command_mode(append_to_history=False)
 
-        @registry.add_binding('y', filter=waits_for_confirmation)
-        @registry.add_binding('Y', filter=waits_for_confirmation)
+        @kb.add('y', filter=waits_for_confirmation)
+        @kb.add('Y', filter=waits_for_confirmation)
         def _(event):
             """
             Confirm command.
             """
-            client_state = pymux.get_client_state(event.cli)
+            client_state = pymux.get_client_state()
 
             command = client_state.confirm_command
             client_state.confirm_command = None
             client_state.confirm_text = None
 
-            pymux.handle_command(event.cli, command)
+            pymux.handle_command(command)
 
-        @registry.add_binding('n', filter=waits_for_confirmation)
-        @registry.add_binding('N', filter=waits_for_confirmation)
-        @registry.add_binding(Keys.ControlC, filter=waits_for_confirmation)
+        @kb.add('n', filter=waits_for_confirmation)
+        @kb.add('N', filter=waits_for_confirmation)
+        @kb.add('c-c' , filter=waits_for_confirmation)
         def _(event):
             """
             Cancel command.
             """
-            client_state = pymux.get_client_state(event.cli)
+            client_state = pymux.get_client_state()
             client_state.confirm_command = None
             client_state.confirm_text = None
 
-        @registry.add_binding(Keys.ControlC, filter=in_scroll_buffer_not_searching)
-        @registry.add_binding(Keys.ControlJ, filter=in_scroll_buffer_not_searching)
-        @registry.add_binding('q', filter=in_scroll_buffer_not_searching)
+        @kb.add('c-c', filter=in_scroll_buffer_not_searching)
+        @kb.add('enter', filter=in_scroll_buffer_not_searching)
+        @kb.add('q', filter=in_scroll_buffer_not_searching)
         def _(event):
             " Exit scroll buffer. "
-            pane = pymux.arrangement.get_active_pane(event.cli)
+            pane = pymux.arrangement.get_active_pane()
             pane.exit_scroll_buffer()
 
-        @registry.add_binding(' ', filter=in_scroll_buffer_not_searching)
+        @kb.add(' ', filter=in_scroll_buffer_not_searching)
         def _(event):
             " Enter selection mode when pressing space in copy mode. "
             event.current_buffer.start_selection(selection_type=SelectionType.CHARACTERS)
 
-        @registry.add_binding(Keys.ControlJ, filter=in_scroll_buffer_not_searching & HasSelection())
+        @kb.add('enter', filter=in_scroll_buffer_not_searching & has_selection)
         def _(event):
             " Copy selection when pressing Enter. "
             clipboard_data = event.current_buffer.copy_selection()
-            event.cli.clipboard.set_data(clipboard_data)
+            event.app.clipboard.set_data(clipboard_data)
 
-        @registry.add_binding('v', filter=in_scroll_buffer_not_searching & HasSelection())
+        @kb.add('v', filter=in_scroll_buffer_not_searching & has_selection)
         def _(event):
             " Toggle between selection types. "
             types = [SelectionType.LINES, SelectionType.BLOCK, SelectionType.CHARACTERS]
@@ -239,12 +166,33 @@ def _(event):
 
             selection_state.type = types[(index + 1) % len(types)]
 
-        @registry.add_binding(Keys.Any, filter=display_pane_numbers)
+        @Condition
+        def popup_displayed():
+            return self.pymux.get_client_state().display_popup
+
+        @kb.add('q', filter=popup_displayed, eager=True)
+        def _(event):
+            " Quit pop-up dialog. "
+            self.pymux.get_client_state().display_popup = False
+
+        @kb.add(Keys.Any, eager=True, filter=display_pane_numbers)
         def _(event):
             " When the pane numbers are shown. Any key press should hide them. "
             pymux.display_pane_numbers = False
 
-        return registry
+        @Condition
+        def clock_displayed():
+            " "
+            pane = pymux.arrangement.get_active_pane()
+            return pane.clock_mode
+
+        @kb.add(Keys.Any, eager=True, filter=clock_displayed)
+        def _(event):
+            " When the clock is displayed. Any key press should hide it. "
+            pane = pymux.arrangement.get_active_pane()
+            pane.clock_mode = False
+
+        return kb
 
     def add_custom_binding(self, key_name, command, arguments, needs_prefix=False):
         """
@@ -271,14 +219,14 @@ def add_custom_binding(self, key_name, command, arguments, needs_prefix=False):
             filter = ~HasPrefix(self.pymux)
 
         filter = filter & ~(WaitsForConfirmation(self.pymux) |
-                            HasFocus(COMMAND) | HasFocus(PROMPT))
+                            has_focus(COMMAND) | has_focus(PROMPT))
 
         def key_handler(event):
             " The actual key handler. "
-            call_command_handler(command, self.pymux, event.cli, arguments)
-            self.pymux.get_client_state(event.cli).has_prefix = False
+            call_command_handler(command, self.pymux, arguments)
+            self.pymux.get_client_state().has_prefix = False
 
-        self.registry.add_binding(*keys_sequence, filter=filter)(key_handler)
+        self.custom_key_bindings.add(*keys_sequence, filter=filter)(key_handler)
 
         # Store key in `custom_bindings` in order to be able to call
         # "unbind-key" later on.
@@ -294,7 +242,7 @@ def remove_custom_binding(self, key_name, needs_prefix=False):
         k = (needs_prefix, key_name)
 
         if k in self.custom_bindings:
-            self.registry.remove_binding(self.custom_bindings[k].handler)
+            self.custom_key_bindings.remove(self.custom_bindings[k].handler)
             del self.custom_bindings[k]
 
 
@@ -310,110 +258,3 @@ def __init__(self, handler, command, arguments):
         self.handler = handler
         self.command = command
         self.arguments = arguments
-
-
-def _load_search_bindings(pymux, registry, get_vi_state):
-    """
-    Load the key bindings for searching. (Vi and Emacs)
-
-    This is different from the ones of prompt_toolkit, because we have a
-    individual search buffers for each pane.
-    """
-    is_searching = InScrollBufferSearching(pymux)
-    in_scroll_buffer_not_searching = InScrollBufferNotSearching(pymux)
-
-    def search_buffer_is_empty(cli):
-        """ Returns True when the search buffer is empty. """
-        return pymux.arrangement.get_active_pane(cli).search_buffer.text == ''
-
-    @registry.add_binding(Keys.ControlG, filter=is_searching)
-    @registry.add_binding(Keys.ControlC, filter=is_searching)
-    @registry.add_binding(Keys.Backspace, filter=is_searching & Condition(search_buffer_is_empty))
-    def _(event):
-        """
-        Abort an incremental search and restore the original line.
-        """
-        pane = pymux.arrangement.get_active_pane(event.cli)
-        pane.search_buffer.reset()
-        pane.is_searching = False
-
-    @registry.add_binding(Keys.ControlJ, filter=is_searching)
-    def _(event):
-        """
-        When enter pressed in isearch, accept search.
-        """
-        pane = pymux.arrangement.get_active_pane(event.cli)
-
-        input_buffer = pane.scroll_buffer
-        search_buffer = pane.search_buffer
-
-        # Update search state.
-        if search_buffer.text:
-            pane.search_state.text = search_buffer.text
-
-        # Apply search.
-        input_buffer.apply_search(pane.search_state, include_current_position=True)
-
-        # Add query to history of search line.
-        search_buffer.append_to_history()
-
-        # Focus previous document again.
-        pane.search_buffer.reset()
-        pane.is_searching = False
-
-    def enter_search(cli):
-        get_vi_state(cli).input_mode = InputMode.INSERT
-
-        pane = pymux.arrangement.get_active_pane(cli)
-        pane.is_searching = True
-        return pane.search_state
-
-    @registry.add_binding(Keys.ControlR, filter=in_scroll_buffer_not_searching)
-    @registry.add_binding('?', filter=in_scroll_buffer_not_searching)
-    def _(event):
-        " Enter reverse search. "
-        search_state = enter_search(event.cli)
-        search_state.direction = IncrementalSearchDirection.BACKWARD
-
-    @registry.add_binding(Keys.ControlS, filter=in_scroll_buffer_not_searching)
-    @registry.add_binding('/', filter=in_scroll_buffer_not_searching)
-    def _(event):
-        " Enter forward search. "
-        search_state = enter_search(event.cli)
-        search_state.direction = IncrementalSearchDirection.FORWARD
-
-    @registry.add_binding(Keys.ControlR, filter=is_searching)
-    @registry.add_binding(Keys.Up, filter=is_searching)
-    def _(event):
-        " Repeat reverse search. (While searching.) "
-        pane = pymux.arrangement.get_active_pane(event.cli)
-
-        # Update search_state.
-        search_state = pane.search_state
-        direction_changed = search_state.direction != IncrementalSearchDirection.BACKWARD
-
-        search_state.text = pane.search_buffer.text
-        search_state.direction = IncrementalSearchDirection.BACKWARD
-
-        # Apply search to current buffer.
-        if not direction_changed:
-            pane.scroll_buffer.apply_search(
-                pane.search_state, include_current_position=False, count=event.arg)
-
-    @registry.add_binding(Keys.ControlS, filter=is_searching)
-    @registry.add_binding(Keys.Down, filter=is_searching)
-    def _(event):
-        " Repeat forward search. (While searching.) "
-        pane = pymux.arrangement.get_active_pane(event.cli)
-
-        # Update search_state.
-        search_state = pane.search_state
-        direction_changed = search_state.direction != IncrementalSearchDirection.FORWARD
-
-        search_state.text = pane.search_buffer.text
-        search_state.direction = IncrementalSearchDirection.FORWARD
-
-        # Apply search to current buffer.
-        if not direction_changed:
-            pane.scroll_buffer.apply_search(
-                pane.search_state, include_current_position=False, count=event.arg)
diff --git a/pymux/key_mappings.py b/pymux/key_mappings.py
index d4e7805..36ce5aa 100644
--- a/pymux/key_mappings.py
+++ b/pymux/key_mappings.py
@@ -4,7 +4,7 @@
 """
 from __future__ import unicode_literals
 from prompt_toolkit.keys import Keys
-from prompt_toolkit.terminal.vt100_input import ANSI_SEQUENCES
+from prompt_toolkit.input.vt100_parser import ANSI_SEQUENCES
 
 __all__ = (
     'pymux_key_to_prompt_toolkit_key_sequence',
@@ -57,6 +57,11 @@ def prompt_toolkit_key_to_vt100_key(key, application_mode=False):
         Keys.Down: '\x1bOB',
     }
 
+    if key == Keys.ControlJ:
+        # Required for redis-cli. This can be removed when prompt_toolkit stops
+        # replacing \r by \n.
+        return '\r'
+
     if key == '\n':
         return '\r'
 
@@ -102,6 +107,11 @@ def prompt_toolkit_key_to_vt100_key(key, application_mode=False):
     'C-Down': (Keys.ControlDown, ),
     'C-\\': (Keys.ControlBackslash, ),
 
+    'S-Left':  (Keys.ShiftLeft, ),
+    'S-Right': (Keys.ShiftRight, ),
+    'S-Up':    (Keys.ShiftUp, ),
+    'S-Down':  (Keys.ShiftDown, ),
+
     'M-C-a': (Keys.Escape, Keys.ControlA, ),
     'M-C-b': (Keys.Escape, Keys.ControlB, ),
     'M-C-c': (Keys.Escape, Keys.ControlC, ),
diff --git a/pymux/layout.py b/pymux/layout.py
index 14a2180..6ec8fda 100644
--- a/pymux/layout.py
+++ b/pymux/layout.py
@@ -4,36 +4,31 @@
 """
 from __future__ import unicode_literals
 
-from prompt_toolkit.enums import IncrementalSearchDirection
-from prompt_toolkit.filters import Condition, to_cli_filter
-from prompt_toolkit.layout.containers import VSplit, HSplit, Window, FloatContainer, Float, ConditionalContainer, Container
-from prompt_toolkit.layout.controls import TokenListControl, FillControl, BufferControl
-from prompt_toolkit.layout.dimension import LayoutDimension
-from prompt_toolkit.layout.dimension import LayoutDimension as D
-from prompt_toolkit.layout.lexers import Lexer
-from prompt_toolkit.layout.lexers import SimpleLexer
+from prompt_toolkit.application.current import get_app
+from prompt_toolkit.filters import Condition, has_focus
+from prompt_toolkit.formatted_text import FormattedText, HTML
+from prompt_toolkit.layout.containers import VSplit, HSplit, Window, FloatContainer, Float, ConditionalContainer, Container, WindowAlign, to_container
+from prompt_toolkit.layout.controls import BufferControl, FormattedTextControl
+from prompt_toolkit.layout.dimension import Dimension
+from prompt_toolkit.layout.dimension import Dimension as D
+from prompt_toolkit.layout.dimension import to_dimension, is_dimension
 from prompt_toolkit.layout.menus import CompletionsMenu
-from prompt_toolkit.layout.processors import BeforeInput, AfterInput, AppendAutoSuggestion, Processor, Transformation, HighlightSearchProcessor, HighlightSelectionProcessor
-from prompt_toolkit.layout.prompt import DefaultPrompt
+from prompt_toolkit.layout.processors import BeforeInput, ShowArg, AppendAutoSuggestion, Processor, Transformation, HighlightSelectionProcessor
 from prompt_toolkit.layout.screen import Char
-from prompt_toolkit.layout.screen import Point
-from prompt_toolkit.layout.toolbars import TokenListToolbar
-from prompt_toolkit.mouse_events import MouseEvent
-from prompt_toolkit.mouse_events import MouseEventTypes
-from prompt_toolkit.token import Token
+from prompt_toolkit.mouse_events import MouseEventType
+from prompt_toolkit.widgets import FormattedTextToolbar, TextArea, Dialog, SearchToolbar
 
 from six.moves import range
+from functools import partial
 
 import pymux.arrangement as arrangement
 import datetime
-import six
 import weakref
+import six
 
-from .enums import COMMAND, PROMPT
-from .filters import WaitsForConfirmation, WaitsForPrompt, InCommandMode
+from .filters import WaitsForConfirmation
 from .format import format_pymux_string
 from .log import logger
-from .screen import DEFAULT_TOKEN
 
 __all__ = (
     'LayoutManager',
@@ -49,6 +44,15 @@ class Justify:
     _ALL = [LEFT, CENTER, RIGHT]
 
 
+class Z_INDEX:
+    HIGHLIGHTED_BORDER = 2
+    STATUS_BAR = 5
+    COMMAND_LINE = 6
+    MESSAGE_TOOLBAR = 7
+    WINDOW_TITLE_BAR = 8
+    POPUP = 9
+
+
 class Background(Container):
     """
     Generate the background of dots, which becomes visible when several clients
@@ -60,16 +64,17 @@ class Background(Container):
     def reset(self):
         pass
 
-    def preferred_width(self, cli, max_available_width):
+    def preferred_width(self, max_available_width):
         return D()
 
-    def preferred_height(self, cli, width, max_available_height):
+    def preferred_height(self, width, max_available_height):
         return D()
 
-    def write_to_screen(self, cli, screen, mouse_handlers, write_position):
+    def write_to_screen(self, screen, mouse_handlers, write_position,
+                        parent_style, erase_bg, z_index):
         " Fill the whole area of write_position with dots. "
-        default_char = Char(' ', Token.Background)
-        dot = Char('.', Token.Background)
+        default_char = Char(' ', 'class:background')
+        dot = Char('.', 'class:background')
 
         ypos = write_position.ypos
         xpos = write_position.xpos
@@ -80,7 +85,7 @@ def write_to_screen(self, cli, screen, mouse_handlers, write_position):
             for x in range(xpos, xpos + write_position.width):
                 row[x] = dot if (x + y) % 3 == 0 else default_char
 
-    def walk(self, cli):
+    def get_children(self):
         return []
 
 
@@ -94,11 +99,11 @@ def walk(self, cli):
 ]))
 
 
-def _draw_number(screen, x_offset, y_offset, number, token=Token.Clock,
+def _draw_number(screen, x_offset, y_offset, number, style='class:clock',
                  transparent=False):
     " Write number at position. "
-    fg = Char(' ', token)
-    bg = Char(' ', Token)
+    fg = Char(' ', 'class:clock')
+    bg = Char(' ', '')
 
     for y, row in enumerate(_numbers[number]):
         screen_row = screen.data_buffer[y + y_offset]
@@ -123,57 +128,61 @@ def __init__(self, on_click):
     def reset(self):
         pass
 
-    def write_to_screen(self, cli, screen, mouse_handlers, write_position):
+    def write_to_screen(self, screen, mouse_handlers, write_position,
+                        parent_style, erase_bg, z_index):
         xpos = write_position.xpos
         ypos = write_position.ypos
 
         # Erase background.
-        bg = Char(' ', Token)
+        bg = Char(' ', '')
 
-        for y in range(ypos, self.HEIGHT + ypos):
-            row = screen.data_buffer[y]
-            for x in range(xpos, xpos + self.WIDTH):
-                row[x] = bg
-
-        # Display time.
-        now = datetime.datetime.now()
-        _draw_number(screen, xpos + 0, ypos, now.hour // 10)
-        _draw_number(screen, xpos + 6, ypos, now.hour % 10)
-        _draw_number(screen, xpos + 16, ypos, now.minute // 10)
-        _draw_number(screen, xpos + 23, ypos, now.minute % 10)
-
-        # Add a colon
-        screen.data_buffer[ypos + 1][xpos + 13] = Char(' ', Token.Clock)
-        screen.data_buffer[ypos + 3][xpos + 13] = Char(' ', Token.Clock)
-
-        screen.width = self.WIDTH
-        screen.height = self.HEIGHT
-
-        mouse_handlers.set_mouse_handler_for_range(
-            x_min=xpos,
-            x_max=xpos + write_position.width,
-            y_min=ypos,
-            y_max=ypos + write_position.height,
-            handler=self._mouse_handler)
+        def draw_func():
+            for y in range(ypos, self.HEIGHT + ypos):
+                row = screen.data_buffer[y]
+                for x in range(xpos, xpos + self.WIDTH):
+                    row[x] = bg
+
+            # Display time.
+            now = datetime.datetime.now()
+            _draw_number(screen, xpos + 0, ypos, now.hour // 10)
+            _draw_number(screen, xpos + 6, ypos, now.hour % 10)
+            _draw_number(screen, xpos + 16, ypos, now.minute // 10)
+            _draw_number(screen, xpos + 23, ypos, now.minute % 10)
+
+            # Add a colon
+            screen.data_buffer[ypos + 1][xpos + 13] = Char(' ', 'class:clock')
+            screen.data_buffer[ypos + 3][xpos + 13] = Char(' ', 'class:clock')
+
+            screen.width = self.WIDTH
+            screen.height = self.HEIGHT
+
+            mouse_handlers.set_mouse_handler_for_range(
+                x_min=xpos,
+                x_max=xpos + write_position.width,
+                y_min=ypos,
+                y_max=ypos + write_position.height,
+                handler=self._mouse_handler)
+
+        screen.draw_with_z_index(z_index=z_index, draw_func=draw_func)
 
     def _mouse_handler(self, cli, mouse_event):
         " Click callback. "
-        if mouse_event.event_type == MouseEventTypes.MOUSE_UP:
+        if mouse_event.event_type == MouseEventType.MOUSE_UP:
             self.on_click(cli)
         else:
             return NotImplemented
 
-    def preferred_width(self, cli, max_available_width):
+    def preferred_width(self, max_available_width):
         return D.exact(BigClock.WIDTH)
 
-    def preferred_height(self, cli, width, max_available_height):
+    def preferred_height(self, width, max_available_height):
         return D.exact(BigClock.HEIGHT)
 
-    def walk(self, cli):
-        yield self
+    def get_children(self):
+        return []
 
 
-class PaneNumber(Container):
+class PaneNumber(Container):  # XXX: make FormattedTextControl
     """
     Number of panes, to be drawn in the middle of the pane.
     """
@@ -187,239 +196,217 @@ def __init__(self, pymux, arrangement_pane):
     def reset(self):
         pass
 
-    def _get_index(self, cli):
-        window = self.pymux.arrangement.get_active_window(cli)
+    def _get_index(self):
+        window = self.pymux.arrangement.get_active_window()
         try:
             return window.get_pane_index(self.arrangement_pane)
         except ValueError:
             return 0
 
-    def preferred_width(self, cli, max_available_width):
+    def preferred_width(self, max_available_width):
         # Enough to display all the digits.
-        return LayoutDimension.exact(6 * len('%s' % self._get_index(cli)) - 1)
+        return Dimension.exact(6 * len('%s' % self._get_index()) - 1)
 
-    def preferred_height(self, cli, width, max_available_height):
-        return LayoutDimension.exact(self.HEIGHT)
+    def preferred_height(self, width, max_available_height):
+        return Dimension.exact(self.HEIGHT)
 
-    def write_to_screen(self, cli, screen, mouse_handlers, write_position):
-        if self.pymux.arrangement.get_active_pane(cli) == self.arrangement_pane:
-            token = Token.PaneNumber.Focussed
-        else:
-            token = Token.PaneNumber
+    def write_to_screen(self, screen, mouse_handlers, write_position,
+                        parent_style, erase_bg, z_index):
+        style = 'class:panenumber'
 
-        for i, d in enumerate('%s' % (self._get_index(cli))):
-            _draw_number(screen, write_position.xpos + i * 6, write_position.ypos,
-                         int(d), token=token, transparent=True)
+        def draw_func():
+            for i, d in enumerate('%s' % (self._get_index(),)):
+                _draw_number(screen, write_position.xpos + i * 6, write_position.ypos,
+                             int(d), style=style, transparent=True)
 
-    def walk(self, cli):
-        yield self
+        screen.draw_with_z_index(z_index=z_index, draw_func=draw_func)
 
+    def get_children(self):
+        return []
 
-class SearchWindow(Window):
-    """
-    Display the search input in copy mode.
-    """
-    def __init__(self, pymux, arrangement_pane):
-        assert isinstance(arrangement_pane, arrangement.Pane)
-
-        def focussed(cli):
-            return pymux.arrangement.get_active_pane(cli) == arrangement_pane
-
-        def get_before_input(cli):
-            if not arrangement_pane.is_searching:
-                text = ''
-            elif arrangement_pane.search_state.direction == IncrementalSearchDirection.BACKWARD:
-                text = 'Search up: '
-            else:
-                text = 'Search down: '
-
-            if focussed(cli):
-                return [(Token.Search.Focussed, text)]
-            else:
-                return [(Token.Search, text)]
 
-        def get_after_input(cli):
-            if focussed(cli):
-                return [(Token.Search.Focussed, ' ')]
-            else:
-                return []
-
-        class SearchLexer(Lexer):
-            " Color for the search string. "
-            def lex_document(self, cli, document):
-                def get_line(lineno):
-                    text = document.lines[lineno]
-                    if focussed(cli):
-                        return [(Token.Search.Focussed.Text, text)]
-                    else:
-                        return [(Token.Search.Text, text)]
-                return get_line
-
-        super(SearchWindow, self).__init__(
-            content=BufferControl(
-                buffer_name='search-%i' % arrangement_pane.pane_id,
-                input_processors=[BeforeInput(get_before_input), AfterInput(get_after_input)],
-                lexer=SearchLexer(),
-                default_char=Char(token=Token)),
-            dont_extend_height=True)
-
-
-class MessageToolbar(TokenListToolbar):
+class MessageToolbar(FormattedTextToolbar):
     """
     Pop-up (at the bottom) for showing error/status messages.
     """
-    def __init__(self, pymux):
-        def get_message(cli):
+    def __init__(self, client_state):
+        def get_message():
             # If there is a message to be shown for this client, show that.
-            client_state = pymux.get_client_state(cli)
-
             if client_state.message:
                 return client_state.message
             else:
                 return ''
 
-        def get_tokens(cli):
-            message = get_message(cli)
+        def get_tokens():
+            message = get_message()
             if message:
-                return [
-                    (Token.Message, message),
-                    (Token.SetCursorPosition, ''),
-                    (Token.Message, ' '),
-                ]
+                return FormattedText([
+                    ('class:message', message),
+                    ('[SetCursorPosition]', ''),
+                    ('class:message', ' '),
+                ])
             else:
-                return []
+                return ''
 
-        f = Condition(lambda cli: get_message(cli) is not None)
+        @Condition
+        def is_visible():
+            return bool(get_message())
 
-        super(MessageToolbar, self).__init__(get_tokens, filter=f, has_focus=f)
+        super(MessageToolbar, self).__init__(get_tokens)
 
 
 class LayoutManager(object):
     """
     The main layout class, that contains the whole Pymux layout.
     """
-    def __init__(self, pymux):
+    def __init__(self, pymux, client_state):
         self.pymux = pymux
+        self.client_state = client_state
+
+        # Popup dialog for displaying keys, etc...
+        search_textarea = SearchToolbar()
+        self._popup_textarea = TextArea(scrollbar=True, read_only=True, search_field=search_textarea)
+        self.popup_dialog = Dialog(
+            title='Keys',
+            body=HSplit([
+                Window(FormattedTextControl(text=''), height=1),  # 1 line margin.
+                self._popup_textarea,
+                search_textarea,
+                Window(
+                    FormattedTextControl(
+                        text=HTML('Press [<b>q</b>] to quit or [<b>/</b>] for searching.')),
+                    align=WindowAlign.CENTER,
+                    height=1)
+                ])
+            )
+
         self.layout = self._create_layout()
 
         # Keep track of render information.
         self.pane_write_positions = {}
-        self.body_write_position = None
+
+    def reset_write_positions(self):
+        """
+        Clear write positions right before rendering. (They are populated
+        during rendering).
+        """
+        self.pane_write_positions = {}
+
+    def display_popup(self, title, content):
+        """
+        Display a pop-up dialog.
+        """
+        assert isinstance(title, six.text_type)
+        assert isinstance(content, six.text_type)
+
+        self.popup_dialog.title = title
+        self._popup_textarea.text = content
+        self.client_state.display_popup = True
+        get_app().layout.focus(self._popup_textarea)
 
     def _create_select_window_handler(self, window):
         " Return a mouse handler that selects the given window when clicking. "
-        def handler(cli, mouse_event):
-            if mouse_event.event_type == MouseEventTypes.MOUSE_DOWN:
-                self.pymux.arrangement.set_active_window(cli, window)
+        def handler(mouse_event):
+            if mouse_event.event_type == MouseEventType.MOUSE_DOWN:
+                self.pymux.arrangement.set_active_window(window)
                 self.pymux.invalidate()
             else:
                 return NotImplemented  # Event not handled here.
         return handler
 
-    def _get_status_tokens(self, cli):
+    def _get_status_tokens(self):
         " The tokens for the status bar. "
         result = []
 
         # Display panes.
         for i, w in enumerate(self.pymux.arrangement.windows):
             if i > 0:
-                result.append((Token.StatusBar, ' '))
+                result.append(('', ' '))
 
-            if w == self.pymux.arrangement.get_active_window(cli):
-                token = Token.StatusBar.Window.Current
+            if w == self.pymux.arrangement.get_active_window():
+                style = 'class:window.current'
                 format_str = self.pymux.window_status_current_format
 
             else:
-                token = Token.StatusBar.Window
+                style = 'class:window'
                 format_str = self.pymux.window_status_format
 
             result.append((
-                token,
-                format_pymux_string(self.pymux, cli, format_str, window=w),
+                style,
+                format_pymux_string(self.pymux, format_str, window=w),
                 self._create_select_window_handler(w)))
 
         return result
 
-    def _get_status_left_tokens(self, cli):
-        return [
-            (Token.StatusBar,
-             format_pymux_string(self.pymux, cli, self.pymux.status_left)),
-        ]
-
-    def _get_status_right_tokens(self, cli):
-        return [
-            (Token.StatusBar,
-             format_pymux_string(self.pymux, cli, self.pymux.status_right)),
-        ]
+    def _get_status_left_tokens(self):
+        return format_pymux_string(self.pymux, self.pymux.status_left)
 
-    def _status_align_right(self, cli):
-        return self.pymux.status_justify == Justify.RIGHT
+    def _get_status_right_tokens(self):
+        return format_pymux_string(self.pymux, self.pymux.status_right)
 
-    def _status_align_center(self, cli):
-        return self.pymux.status_justify == Justify.CENTER
+    def _get_align(self):
+        if self.pymux.status_justify == Justify.RIGHT:
+            return WindowAlign.RIGHT
+        elif self.pymux.status_justify == Justify.CENTER:
+            return WindowAlign.CENTER
+        else:
+            return WindowAlign.LEFT
 
-    def _before_prompt_command_tokens(self, cli):
-        client_state = self.pymux.get_client_state(cli)
-        return [(Token.CommandLine.Prompt, '%s ' % (client_state.prompt_text, ))]
+    def _before_prompt_command_tokens(self):
+        return [('class:commandline.prompt', '%s ' % (self.client_state.prompt_text, ))]
 
     def _create_layout(self):
         """
         Generate the main prompt_toolkit layout.
         """
         waits_for_confirmation = WaitsForConfirmation(self.pymux)
-        waits_for_prompt = WaitsForPrompt(self.pymux)
-        in_command_mode = InCommandMode(self.pymux)
 
         return FloatContainer(
             content=HSplit([
                 # The main window.
-                HighlightBorders(self, self.pymux, FloatContainer(
+                FloatContainer(
                     Background(),
                     floats=[
-                        Float(get_width=lambda cli: self.pymux.get_window_size(cli).columns,
-                              get_height=lambda cli: self.pymux.get_window_size(cli).rows,
-                              content=TraceBodyWritePosition(self.pymux, DynamicBody(self.pymux)))
-                    ])),
+                        Float(width=lambda: self.pymux.get_window_size().columns,
+                              height=lambda: self.pymux.get_window_size().rows,
+                              content=DynamicBody(self.pymux))
+                    ]),
                 # Status bar.
                 ConditionalContainer(
                     content=VSplit([
                         # Left.
                         Window(
-                            height=D.exact(1),
-                            get_width=(lambda cli: D(max=self.pymux.status_left_length)),
+                            height=1,
+                            width=(lambda: D(max=self.pymux.status_left_length)),
                             dont_extend_width=True,
-                            content=TokenListControl(
-                                self._get_status_left_tokens,
-                                default_char=Char(' ', Token.StatusBar))),
+                            content=FormattedTextControl(self._get_status_left_tokens)),
                         # List of windows in the middle.
                         Window(
-                            height=D.exact(1),
-                            content=TokenListControl(
-                                self._get_status_tokens,
-                                align_right=Condition(self._status_align_right),
-                                align_center=Condition(self._status_align_center),
-                                default_char=Char(' ', Token.StatusBar))),
+                            height=1,
+                            char=' ',
+                            align=self._get_align,
+                            content=FormattedTextControl(self._get_status_tokens)),
                         # Right.
                         Window(
-                            height=D.exact(1),
-                            get_width=(lambda cli: D(max=self.pymux.status_right_length)),
+                            height=1,
+                            width=(lambda: D(max=self.pymux.status_right_length)),
                             dont_extend_width=True,
-                            content=TokenListControl(
-                                self._get_status_right_tokens,
-                                align_right=True,
-                                default_char=Char(' ', Token.StatusBar)))
-                    ]),
-                    filter=Condition(lambda cli: self.pymux.enable_status),
+                            align=WindowAlign.RIGHT,
+                            content=FormattedTextControl(self._get_status_right_tokens))
+                    ], z_index=Z_INDEX.STATUS_BAR, style='class:statusbar'),
+                    filter=Condition(lambda: self.pymux.enable_status),
                 )
             ]),
             floats=[
-                Float(bottom=1, left=0, content=MessageToolbar(self.pymux)),
+                Float(bottom=1, left=0, z_index=Z_INDEX.MESSAGE_TOOLBAR,
+                      content=MessageToolbar(self.client_state)),
                 Float(left=0, right=0, bottom=0, content=HSplit([
                     # Wait for confirmation toolbar.
                     ConditionalContainer(
                         content=Window(
-                            height=D.exact(1),
-                            content=ConfirmationToolbar(self.pymux),
+                            height=1,
+                            content=ConfirmationToolbar(self.pymux, self.client_state),
+                            z_index=Z_INDEX.COMMAND_LINE,
                         ),
                         filter=waits_for_confirmation,
                     ),
@@ -427,62 +414,70 @@ def _create_layout(self):
                     ConditionalContainer(
                         content=Window(
                             height=D(min=1),  # Can be more if the command is multiline.
+                            style='class:commandline',
                             dont_extend_height=True,
                             content=BufferControl(
-                                buffer_name=COMMAND,
-                                default_char=Char(' ', Token.CommandLine),
-                                lexer=SimpleLexer(Token.CommandLine),
+                                buffer=self.client_state.command_buffer,
                                 preview_search=True,
                                 input_processors=[
                                     AppendAutoSuggestion(),
-                                    DefaultPrompt(lambda cli:[(Token.CommandLine.Prompt, ':')]),
+                                    BeforeInput(':', style='class:commandline-prompt'),
+                                    ShowArg(),
                                     HighlightSelectionProcessor(),
-                                ])
+                                ]),
+                            z_index=Z_INDEX.COMMAND_LINE,
                         ),
-                        filter=in_command_mode,
+                        filter=has_focus(self.client_state.command_buffer),
                     ),
                     # Other command-prompt commands toolbar.
                     ConditionalContainer(
                         content=Window(
-                            height=D.exact(1),
+                            height=1,
+                            style='class:commandline',
                             content=BufferControl(
-                                buffer_name=PROMPT,
-                                default_char=Char(' ', Token.CommandLine),
-                                lexer=SimpleLexer(Token.CommandLine),
+                                buffer=self.client_state.prompt_buffer,
                                 input_processors=[
                                     BeforeInput(self._before_prompt_command_tokens),
                                     AppendAutoSuggestion(),
                                     HighlightSelectionProcessor(),
-                                ])
+                                ]),
+                            z_index=Z_INDEX.COMMAND_LINE,
                         ),
-                        filter=waits_for_prompt,
+                        filter=has_focus(self.client_state.prompt_buffer),
                     ),
                 ])),
+                # Keys pop-up.
+                Float(
+                    content=ConditionalContainer(
+                        content=self.popup_dialog,
+                        filter=Condition(lambda: self.client_state.display_popup),
+                    ),
+                    left=3, right=3, top=5, bottom=5,
+                    z_index=Z_INDEX.POPUP,
+                ),
                 Float(xcursor=True, ycursor=True, content=CompletionsMenu(max_height=12)),
             ]
         )
 
 
-class ConfirmationToolbar(TokenListControl):
+class ConfirmationToolbar(FormattedTextControl):
     """
     Window that displays the yes/no confirmation dialog.
     """
-    def __init__(self, pymux):
-        token = Token.ConfirmationToolbar
-
-        def get_tokens(cli):
-            client_state = pymux.get_client_state(cli)
+    def __init__(self, pymux, client_state):
+        def get_tokens():
             return [
-                (token.Question, ' '),
-                (token.Question, format_pymux_string(
-                    pymux, cli, client_state.confirm_text or '')),
-                (token.Question, ' '),
-                (token.YesNo, '  y/n'),
-                (Token.SetCursorPosition, ''),
-                (token.YesNo, '  '),
+                ('class:question', ' '),
+                ('class:question', format_pymux_string(
+                    pymux, client_state.confirm_text or '')),
+                ('class:question', ' '),
+                ('class:yesno', '  y/n'),
+                ('[SetCursorPosition]', ''),
+                ('class:yesno', '  '),
             ]
 
-        super(ConfirmationToolbar, self).__init__(get_tokens, default_char=Char(' ', token))
+        super(ConfirmationToolbar, self).__init__(
+            get_tokens, style='class:confirmationtoolbar')
 
 
 class DynamicBody(Container):
@@ -496,87 +491,122 @@ class DynamicBody(Container):
     """
     def __init__(self, pymux):
         self.pymux = pymux
-        self._bodies_for_clis = weakref.WeakKeyDictionary()  # Maps CLI to (hash, Container)
+        self._bodies_for_app = weakref.WeakKeyDictionary()  # Maps Application to (hash, Container)
 
-    def _get_body(self, cli):
+    def _get_body(self):
         " Return the Container object for the current CLI. "
-        new_hash = self.pymux.arrangement.invalidation_hash(cli)
+        new_hash = self.pymux.arrangement.invalidation_hash()
 
         # Return existing layout if nothing has changed to the arrangement.
-        if cli in self._bodies_for_clis:
-            existing_hash, container = self._bodies_for_clis[cli]
+        app = get_app()
+
+        if app in self._bodies_for_app:
+            existing_hash, container = self._bodies_for_app[app]
             if existing_hash == new_hash:
                 return container
 
         # The layout changed. Build a new layout when the arrangement changed.
-        new_layout = self._build_layout(cli)
-        self._bodies_for_clis[cli] = (new_hash, new_layout)
+        new_layout = self._build_layout()
+        self._bodies_for_app[app] = (new_hash, new_layout)
         return new_layout
 
-    def _build_layout(self, cli):
+    def _build_layout(self):
         " Rebuild a new Container object and return that. "
         logger.info('Rebuilding layout.')
-        active_window = self.pymux.arrangement.get_active_window(cli)
+
+        if not self.pymux.arrangement.windows:
+            # No Pymux windows in the arrangement.
+            return Window()
+
+        active_window = self.pymux.arrangement.get_active_window()
 
         # When zoomed, only show the current pane, otherwise show all of them.
         if active_window.zoom:
-            return _create_container_for_process(self.pymux, active_window.active_pane, zoom=True)
+            return to_container(_create_container_for_process(
+                self.pymux, active_window, active_window.active_pane, zoom=True))
         else:
-            return _create_split(self.pymux, self.pymux.arrangement.get_active_window(cli).root)
+            window = self.pymux.arrangement.get_active_window()
+            return HSplit([
+                # Some spacing for the top status bar.
+                ConditionalContainer(
+                    content=Window(height=1),
+                    filter=Condition(lambda: self.pymux.enable_pane_status)),
+                # The actual content.
+                _create_split(self.pymux, window, window.root)
+            ])
 
     def reset(self):
-        for invalidation_hash, body in self._bodies_for_clis.values():
+        for invalidation_hash, body in self._bodies_for_app.values():
             body.reset()
 
-    def preferred_width(self, cli, max_available_width):
-        body = self._get_body(cli)
-        return body.preferred_width(cli, max_available_width)
+    def preferred_width(self, max_available_width):
+        body = self._get_body()
+        return body.preferred_width(max_available_width)
 
-    def preferred_height(self, cli, width, max_available_height):
-        body = self._get_body(cli)
-        return body.preferred_height(cli, width, max_available_height)
+    def preferred_height(self, width, max_available_height):
+        body = self._get_body()
+        return body.preferred_height(width, max_available_height)
 
-    def write_to_screen(self, cli, screen, mouse_handlers, write_position):
-        body = self._get_body(cli)
-        body.write_to_screen(cli, screen, mouse_handlers, write_position)
+    def write_to_screen(self, screen, mouse_handlers, write_position,
+                        parent_style, erase_bg, z_index):
+        body = self._get_body()
+        body.write_to_screen(screen, mouse_handlers, write_position,
+                             parent_style, erase_bg, z_index)
 
-    def walk(self, cli):
+    def get_children(self):
         # (Required for prompt_toolkit.layout.utils.find_window_for_buffer_name.)
-        body = self._get_body(cli)
-        return body.walk(cli)
+        body = self._get_body()
+        return [body]
 
 
-def _create_split(pymux, split):
+class SizedBox(Container):
     """
-    Create a prompt_toolkit `Container` instance for the given pymux split.
+    Container whith enforces a given width/height without taking the children
+    into account (even if no width/height is given).
+
+    :param content: `Container`.
+    :param report_write_position_callback: `None` or a callable for reporting
+        back the dimensions used while drawing.
     """
-    assert isinstance(split, (arrangement.HSplit, arrangement.VSplit))
+    def __init__(self, content, width=None, height=None,
+                 report_write_position_callback=None):
+        assert is_dimension(width)
+        assert is_dimension(height)
+        assert report_write_position_callback is None or callable(report_write_position_callback)
 
-    is_vsplit = isinstance(split, arrangement.VSplit)
+        self.content = to_container(content)
+        self.width = width
+        self.height = height
+        self.report_write_position_callback = report_write_position_callback
 
-    content = []
+    def reset(self):
+        self.content.reset()
 
-    def vertical_line():
-        " Draw a vertical line between windows. (In case of a vsplit) "
-        char = '│'
-        content.append(HSplit([
-                Window(
-                   width=D.exact(1), height=D.exact(1),
-                   content=FillControl(char, token=Token.TitleBar.Line)),
-                Window(width=D.exact(1),
-                       content=FillControl(char, token=Token.Line))
-            ]))
+    def preferred_width(self, max_available_width):
+        return to_dimension(self.width)
 
-    for i, item in enumerate(split):
-        if isinstance(item, (arrangement.VSplit, arrangement.HSplit)):
-            content.append(_create_split(pymux, item))
-        elif isinstance(item, arrangement.Pane):
-            content.append(_create_container_for_process(pymux, item))
-        else:
-            raise TypeError('Got %r' % (item,))
+    def preferred_height(self, width, max_available_height):
+        return to_dimension(self.height)
 
-        if is_vsplit and i != len(split) - 1:
-            vertical_line()
+    def write_to_screen(self, screen, mouse_handlers, write_position,
+                        parent_style, erase_bg, z_index):
+        # Report dimensions.
+        if self.report_write_position_callback:
+            self.report_write_position_callback(write_position)
+
+        self.content.write_to_screen(
+            screen, mouse_handlers, write_position, parent_style, erase_bg, z_index)
+
+    def get_children(self):
+        return [self.content]
+
+
+def _create_split(pymux, window, split):
+    """
+    Create a prompt_toolkit `Container` instance for the given pymux split.
+    """
+    assert isinstance(split, (arrangement.HSplit, arrangement.VSplit))
+    is_vsplit = isinstance(split, arrangement.VSplit)
 
     def get_average_weight():
         """ Calculate average weight of the children. Return 1 if none of
@@ -594,27 +624,7 @@ def get_average_weight():
         else:
             return 1
 
-    def get_dimensions(cli):
-        """
-        Return a list of LayoutDimension instances for this split.
-        These dimensions will take the weight from the
-        arrangement.VSplit/HSplit instances.
-        """
-        average_weight = get_average_weight()
-
-        # Make sure that weight is distributed
-
-        result = []
-        for i, item in enumerate(split):
-            result.append(D(weight=split.weights.get(item) or average_weight))
-
-            # Add dimension for the vertical border.
-            if is_vsplit and i != len(split) - 1:
-                result.append(D.exact(1))
-
-        return result
-
-    def report_dimensions_callback(cli, dimensions):
+    def report_write_position_callback(item, write_position):
         """
         When the layout is rendered, store the actial dimensions as
         weights in the arrangement.VSplit/HSplit classes.
@@ -624,19 +634,49 @@ def report_dimensions_callback(cli, dimensions):
         column. So, that updating weights corresponds exactly 1/1 to updating
         the size of the panes.
         """
-        sizes = []
-        for i, size in enumerate(dimensions):
-            if not (is_vsplit and i % 2 != 0):
-                sizes.append(size)
+        if is_vsplit:
+            split.weights[item] = write_position.width
+        else:
+            split.weights[item] = write_position.height
+
+    def get_size(item):
+        return D(weight=split.weights.get(item) or average_weight)
+
+    content = []
+    average_weight = get_average_weight()
+
+    for i, item in enumerate(split):
+        # Create function for calculating dimensions for child.
+        width = height = None
+        if is_vsplit:
+            width = partial(get_size, item)
+        else:
+            height = partial(get_size, item)
+
+        # Create child.
+        if isinstance(item, (arrangement.VSplit, arrangement.HSplit)):
+            child = _create_split(pymux, window, item)
+        elif isinstance(item, arrangement.Pane):
+            child = _create_container_for_process(pymux, window, item)
+        else:
+            raise TypeError('Got %r' % (item,))
 
-        for c, size in zip(split, sizes):
-            split.weights[c] = size
+        # Wrap child in `SizedBox` to enforce dimensions and sync back.
+        content.append(SizedBox(
+            child, width=width, height=height,
+            report_write_position_callback=partial(report_write_position_callback, item)))
 
     # Create prompt_toolkit Container.
-    return_cls = VSplit if is_vsplit else HSplit
+    if is_vsplit:
+        return_cls = VSplit
+        padding_char = _border_vertical
+    else:
+        return_cls = HSplit
+        padding_char = _border_horizontal
 
-    return return_cls(content, get_dimensions=get_dimensions,
-                      report_dimensions_callback=report_dimensions_callback)
+    return return_cls(content,
+            padding=1,
+            padding_char=padding_char)
 
 
 class _UseCopyTokenListProcessor(Processor):
@@ -648,184 +688,121 @@ class _UseCopyTokenListProcessor(Processor):
     def __init__(self, arrangement_pane):
         self.arrangement_pane = arrangement_pane
 
-    def apply_transformation(self, cli, document, lineno, source_to_display, tokens):
+    def apply_transformation(self, document, lineno, source_to_display, tokens):
         tokens = self.arrangement_pane.copy_get_tokens_for_line(lineno)
         return Transformation(tokens[:])
 
-    def invalidation_hash(self, cli, document):
+    def invalidation_hash(self, document):
         return document.text
 
 
-def _create_container_for_process(pymux, arrangement_pane, zoom=False):
+def _create_container_for_process(pymux, window, arrangement_pane, zoom=False):
     """
     Create a `Container` with a titlebar for a process.
     """
-    assert isinstance(arrangement_pane, arrangement.Pane)
-    process = arrangement_pane.process
+    @Condition
+    def clock_is_visible():
+        return arrangement_pane.clock_mode
 
-    def has_focus(cli):
-        return pymux.arrangement.get_active_pane(cli) == arrangement_pane
+    @Condition
+    def pane_numbers_are_visible():
+        return pymux.display_pane_numbers
 
-    def get_titlebar_token(cli):
-        return Token.TitleBar.Focussed if has_focus(cli) else Token.TitleBar
+    terminal_is_focused = has_focus(arrangement_pane.terminal)
 
-    def get_titlebar_name_token(cli):
-        return Token.TitleBar.Name.Focussed if has_focus(cli) else Token.TitleBar.Name
+    def get_terminal_style():
+        if terminal_is_focused():
+            result = 'class:terminal.focused'
+        else:
+            result = 'class:terminal'
+        return result
 
-    def get_title_tokens(cli):
-        token = get_titlebar_token(cli)
-        name_token = get_titlebar_name_token(cli)
+    def get_titlebar_text_fragments():
         result = []
 
         if zoom:
-            result.append((Token.TitleBar.Zoom, ' Z '))
+            result.append(('class:titlebar-zoom', ' Z '))
 
-        if process.is_terminated:
-            result.append((Token.Terminated, ' Terminated '))
+        if arrangement_pane.process.is_terminated:
+            result.append(('class:terminated', ' Terminated '))
 
         # Scroll buffer info.
         if arrangement_pane.display_scroll_buffer:
-            result.append((token.CopyMode, ' %s ' % arrangement_pane.scroll_buffer_title))
+            result.append(('class:copymode', ' %s ' % arrangement_pane.scroll_buffer_title))
 
             # Cursor position.
             document = arrangement_pane.scroll_buffer.document
-            result.append((token.CopyMode.Position, ' %i,%i ' % (
+            result.append(('class:copymode.position', ' %i,%i ' % (
                 document.cursor_position_row, document.cursor_position_col)))
 
         if arrangement_pane.name:
-            result.append((name_token, ' %s ' % arrangement_pane.name))
-            result.append((token, ' '))
+            result.append(('class:name', ' %s ' % arrangement_pane.name))
+            result.append(('', ' '))
 
         return result + [
-            (token.Title, format_pymux_string(pymux, cli, ' #T ', pane=arrangement_pane))  # XXX: Make configurable.
+            ('', format_pymux_string(pymux, ' #T ', pane=arrangement_pane))  # XXX: Make configurable.
         ]
 
-    def get_pane_index(cli):
-        token = get_titlebar_token(cli)
-
+    def get_pane_index():
         try:
-            w = pymux.arrangement.get_active_window(cli)
+            w = pymux.arrangement.get_active_window()
             index = w.get_pane_index(arrangement_pane)
         except ValueError:
             index = '/'
 
-        return [(token.PaneIndex, '%3s ' % index)]
+        return '%3s ' % index
 
-    def on_click(cli):
+    def on_click():
         " Click handler for the clock. When clicked, select this pane. "
         arrangement_pane.clock_mode = False
-        pymux.arrangement.get_active_window(cli).active_pane = arrangement_pane
-        pymux.invalidate()
-
-    def set_focus(cli):
-        pymux.arrangement.get_active_window(cli).active_pane = arrangement_pane
+        pymux.arrangement.get_active_window().active_pane = arrangement_pane
         pymux.invalidate()
 
-    clock_is_visible = Condition(lambda cli: arrangement_pane.clock_mode)
-    pane_numbers_are_visible = Condition(lambda cli: pymux.display_pane_numbers)
 
-    return TracePaneWritePosition(
-        pymux, arrangement_pane,
-        content=HSplit([
-            # The title bar.
-            VSplit([
-                Window(
-                    height=D.exact(1),
-                    content=TokenListControl(
-                        get_title_tokens,
-                        get_default_char=lambda cli: Char(' ', get_titlebar_token(cli)))
-                ),
-                Window(
-                    height=D.exact(1),
-                    width=D.exact(4),
-                    content=TokenListControl(get_pane_index)
-                )
+    return HighlightBordersIfActive(
+        window,
+        arrangement_pane,
+        get_terminal_style,
+        FloatContainer(
+            HSplit([
+                # The terminal.
+                TracePaneWritePosition(
+                    pymux, arrangement_pane,
+                    content=arrangement_pane.terminal),
             ]),
-            # The pane content.
-            FloatContainer(
-                content=HSplit([
-                    # The 'screen' of the pseudo terminal.
-                    ConditionalContainer(
-                        content=Vt100Window(
-                            process=process,
-                            has_focus=Condition(lambda cli: (
-                                cli.current_buffer_name != COMMAND and
-                                pymux.arrangement.get_active_pane(cli) == arrangement_pane)),
-                            set_focus=set_focus,
-                        ),
-                        filter=~clock_is_visible & Condition(lambda cli: not arrangement_pane.display_scroll_buffer)),
 
-                    # The copy/paste buffer.
-                    ConditionalContainer(
-                        content=Window(BufferControl(
-                            buffer_name='pane-%i' % arrangement_pane.pane_id,
-                            focus_on_click=True,
-                            default_char=Char(token=Token),
-                            preview_search=True,
-                            get_search_state=lambda cli: arrangement_pane.search_state,
-                            search_buffer_name='search-%i' % arrangement_pane.pane_id,
-                            input_processors=[
-                                _UseCopyTokenListProcessor(arrangement_pane),
-                                HighlightSearchProcessor(
-                                    search_buffer_name='search-%i' % arrangement_pane.pane_id,
-                                    get_search_state=lambda cli: arrangement_pane.search_state,
-                                    preview_search=True,
-                                ),
-                                HighlightSelectionProcessor(),
-                            ],
-                        ),
-                            wrap_lines=False,
-                        ),
-                        filter=~clock_is_visible & Condition(lambda cli: arrangement_pane.display_scroll_buffer)
-                    ),
-                    # Search toolbar. (Displayed when this pane has the focus, and searching.)
-                    ConditionalContainer(
-                        content=SearchWindow(pymux, arrangement_pane),
-                        filter=~clock_is_visible & Condition(lambda cli: arrangement_pane.is_searching)
-                    ),
-                    # The clock.
+            #
+            floats=[
+                # The title bar.
+                Float(content=
                     ConditionalContainer(
-                        # Add a dummy VSplit/HSplit around the BigClock in order to center it.
-                        # (Using a FloatContainer to do the centering doesn't work well, because
-                        # the boundaries are not clipped when the parent is smaller.)
                         content=VSplit([
-                            Window(_FillControl(on_click)),
-                            HSplit([
-                                Window(_FillControl(on_click)),
-                                BigClock(on_click),
-                                Window(_FillControl(on_click)),
-                            ]),
-                            Window(_FillControl(on_click)),
-                        ], get_dimensions=lambda cli: [None, D.exact(BigClock.WIDTH), None]),
-
-                        filter=clock_is_visible,
-                    ),
-                ]),
-                # Pane numbers. (Centered.)
-                floats=[
-                    Float(content=ConditionalContainer(
-                        content=PaneNumber(pymux, arrangement_pane),
-                        filter=pane_numbers_are_visible)),
-                ]
-            )
-        ])
+                                Window(
+                                    height=1,
+                                    content=FormattedTextControl(
+                                        get_titlebar_text_fragments)),
+                                Window(
+                                    height=1,
+                                    width=4,
+                                    content=FormattedTextControl(get_pane_index),
+                                    style='class:paneindex')
+                            ], style='class:titlebar'),
+                        filter=Condition(lambda: pymux.enable_pane_status)),
+                    left=0, right=0, top=-1, height=1, z_index=Z_INDEX.WINDOW_TITLE_BAR),
+
+                # The clock.
+                Float(
+                    content=ConditionalContainer(BigClock(on_click),
+                      filter=clock_is_visible)),
+
+                # Pane number.
+                Float(content=ConditionalContainer(
+                      content=PaneNumber(pymux, arrangement_pane),
+                      filter=pane_numbers_are_visible)),
+            ]
+        )
     )
 
-class _FillControl(FillControl):
-    """
-    Extension to `FillControl` with click handlers.
-    """
-    def __init__(self, click_callback=None):
-        self.click_callback = click_callback
-        super(_FillControl, self).__init__()
-
-    def mouse_handler(self, cli, mouse_event):
-        " Call callback on click. "
-        if mouse_event.event_type == MouseEventTypes.MOUSE_UP and self.click_callback:
-            self.click_callback(cli)
-        else:
-            return NotImplemented
-
 
 class _ContainerProxy(Container):
     def __init__(self, content):
@@ -834,196 +811,124 @@ def __init__(self, content):
     def reset(self):
         self.content.reset()
 
-    def preferred_width(self, cli, max_available_width):
-        return self.content.preferred_width(cli, max_available_width)
+    def preferred_width(self, max_available_width):
+        return self.content.preferred_width(max_available_width)
 
-    def preferred_height(self, cli, width, max_available_height):
-        return self.content.preferred_height(cli, width, max_available_height)
+    def preferred_height(self, width, max_available_height):
+        return self.content.preferred_height(width, max_available_height)
 
-    def write_to_screen(self, cli, screen, mouse_handlers, write_position):
-        self.content.write_to_screen(cli, screen, mouse_handlers, write_position)
+    def write_to_screen(self, screen, mouse_handlers, write_position, parent_style, erase_bg, z_index):
+        self.content.write_to_screen(screen, mouse_handlers, write_position, parent_style, erase_bg, z_index)
 
-    def walk(self, cli):
-        return self.content.walk(cli)
+    def get_children(self):
+        return [self.content]
 
 
-_focussed_border_titlebar = Char('┃', Token.TitleBar.Line.Focussed)
-_focussed_border_vertical = Char('┃', Token.Line.Focussed)
-_focussed_border_horizontal = Char('━', Token.Line.Focussed)
-_focussed_border_left_top = Char('┏', Token.Line.Focussed)
-_focussed_border_right_top = Char('┓', Token.Line.Focussed)
-_focussed_border_left_bottom = Char('┗', Token.Line.Focussed)
-_focussed_border_right_bottom = Char('┛', Token.Line.Focussed)
+_focused_border_titlebar = '┃'
+_focused_border_vertical = '┃'
+_focused_border_horizontal = '━'
+_focused_border_left_top = '┏'
+_focused_border_right_top = '┓'
+_focused_border_left_bottom = '┗'
+_focused_border_right_bottom = '┛'
 
-_border_vertical = Char('│', Token.Line)
-_border_horizontal = Char('─', Token.Line)
-_border_left_bottom = Char('└', Token.Line)
-_border_right_bottom = Char('┘', Token.Line)
-_border_left_top = Char('┌', Token.Line)
-_border_right_top = Char('┐', Token.Line)
+_border_vertical = '│'
+_border_horizontal = '─'
+_border_left_bottom = '└'
+_border_right_bottom = '┘'
+_border_left_top = '┌'
+_border_right_top = '┐'
 
 
-class HighlightBorders(_ContainerProxy):
+class HighlightBordersIfActive(object):
     """
-    Highlight the active borders. Happens post rendering.
-
-    (We highlight the active pane when the rendering of everything else is
-    done, otherwise, rendering of panes on the right will replace the result of
-    this one.
+    Put borders around this control if active.
     """
-    def __init__(self, layout_manager, pymux, content):
-        _ContainerProxy.__init__(self, content)
-        self.pymux = pymux
-        self.layout_manager = layout_manager
-
-    def write_to_screen(self, cli, screen, mouse_handlers, write_position):
-        # Clear previous list of pane coordinates.
-        self.layout_manager.pane_write_positions = {}   # XXX: Should be for each CLI individually!!!!!
-        self.layout_manager.body_write_position = None
-
-        # Render everything.
-        _ContainerProxy.write_to_screen(self, cli, screen, mouse_handlers, write_position)
-
-        # When rendering is done. Draw borders and highlight the borders of the
-        # active pane.
-        self._draw_borders(screen, write_position)
-
-        try:
-            pane_wp = self.layout_manager.pane_write_positions[
-                self.pymux.arrangement.get_active_pane(cli)]
-        except KeyError:
-            pass
-        else:
-            self._highlight_active_pane(screen, pane_wp, write_position)
-
-    def _draw_borders(self, screen, write_position):
-        """
-        Draw borders around the whole window. (When there is space.)
-        """
-        data_buffer = screen.data_buffer
-
-        if self.layout_manager.body_write_position:
-            wp = self.layout_manager.body_write_position
-
-            # Bottom line.
-            if wp.ypos + wp.height < write_position.ypos + write_position.height:
-                row = data_buffer[wp.ypos + wp.height]
-
-                for x in range(wp.xpos, wp.xpos + wp.width):
-                    row[x] = _border_horizontal
-
-                # Left/right bottom.
-                data_buffer[wp.ypos + wp.height][wp.xpos - 1] = _border_left_bottom
-                data_buffer[wp.ypos + wp.height][wp.xpos + wp.width] = _border_right_bottom
-
-            # Left and right line.
-            for y in range(wp.ypos + 1, wp.ypos + wp.height):
-                data_buffer[y][wp.xpos - 1] = _border_vertical
-                data_buffer[y][wp.xpos + wp.width] = _border_vertical
-
-            # Left/right top
-            data_buffer[wp.ypos][wp.xpos - 1] = _border_left_top
-            data_buffer[wp.ypos][wp.xpos + wp.width] = _border_right_top
-
-    def _highlight_active_pane(self, screen, pane_wp, write_position):
-        " Highlight the current, active pane. "
-        data_buffer = screen.data_buffer
-        xpos, ypos, width, height = pane_wp.xpos, pane_wp.ypos, pane_wp.width, pane_wp.height
-
-        xleft = xpos - 1
-        xright = xpos + width
-
-        # First line.
-        row = data_buffer[ypos]
-
-        if row[xleft].token == Token.Line:
-            row[xleft] = _focussed_border_left_top
-        else:
-            row[xleft] = _focussed_border_titlebar
-
-        if row[xright].token == Token.Line:
-            row[xright] = _focussed_border_right_top
-        else:
-            row[xright] = _focussed_border_titlebar
-
-        # Every following line.
-        for y in range(ypos + 1, ypos + height):
-            row = data_buffer[y]
-            row[xleft] = row[xright] = _focussed_border_vertical
-
-        # Draw the bottom line. (Only when there is space.)
-        if ypos + height < write_position.ypos + write_position.height:
-            row = data_buffer[ypos + height]
+    def __init__(self, window, pane, style, content):
+        @Condition
+        def is_selected():
+            return window.active_pane == pane
+
+        def conditional_float(char, left=None, right=None, top=None,
+                              bottom=None, width=None, height=None):
+            return Float(
+                content=ConditionalContainer(
+                    Window(char=char, style='class:border'),
+                    filter=is_selected),
+                left=left, right=right, top=top, bottom=bottom, width=width, height=height,
+                z_index=Z_INDEX.HIGHLIGHTED_BORDER)
+
+        self.container = FloatContainer(
+            content,
+            style=style,
+            floats=[
+                # Sides.
+                conditional_float(_focused_border_vertical, left=-1, top=0, bottom=0, width=1),
+                conditional_float(_focused_border_vertical, right=-1, top=0, bottom=0, width=1),
+                conditional_float(_focused_border_horizontal, left=0, right=0, top=-1, height=1),
+                conditional_float(_focused_border_horizontal, left=0, right=0, bottom=-1, height=1),
 
-            for x in range(xpos, xpos + width):
-                # Don't overwrite the titlebar of a pane below.
-                if row[x].token == Token.Line:
-                    row[x] = _focussed_border_horizontal
+                # Corners.
+                conditional_float(_focused_border_left_top, left=-1, top=-1, width=1, height=1),
+                conditional_float(_focused_border_right_top, right=-1, top=-1, width=1, height=1),
+                conditional_float(_focused_border_left_bottom, left=-1, bottom=-1, width=1, height=1),
+                conditional_float(_focused_border_right_bottom, right=-1, bottom=-1, width=1, height=1),
+            ])
 
-            # Bottom corners.
-            row[xpos - 1] = _focussed_border_left_bottom
-            row[xpos + width] = _focussed_border_right_bottom
+    def __pt_container__(self):
+        return self.container
 
 
-class TracePaneWritePosition(_ContainerProxy):
+class TracePaneWritePosition(_ContainerProxy):   # XXX: replace with SizedBox
     " Trace the write position of this pane. "
     def __init__(self, pymux, arrangement_pane, content):
+        content = to_container(content)
         _ContainerProxy.__init__(self, content)
 
         self.pymux = pymux
         self.arrangement_pane = arrangement_pane
 
-    def write_to_screen(self, cli, screen, mouse_handlers, write_position):
-        _ContainerProxy.write_to_screen(self, cli, screen, mouse_handlers, write_position)
-
-        self.pymux.layout_manager.pane_write_positions[self.arrangement_pane] = write_position
-
-
-class TraceBodyWritePosition(_ContainerProxy):
-    " Trace the write position of the whole body. "
-    def __init__(self, pymux, content):
-        _ContainerProxy.__init__(self, content)
-        self.pymux = pymux
+    def write_to_screen(self, screen, mouse_handlers, write_position, parent_style, erase_bg, z_inedx):
+        _ContainerProxy.write_to_screen(self, screen, mouse_handlers, write_position, parent_style, erase_bg, z_inedx)
+        self.pymux.get_client_state().layout_manager.pane_write_positions[self.arrangement_pane] = write_position
 
-    def write_to_screen(self, cli, screen, mouse_handlers, write_position):
-        _ContainerProxy.write_to_screen(self, cli, screen, mouse_handlers, write_position)
-        self.pymux.layout_manager.body_write_position = write_position
 
-
-def focus_left(pymux, cli):
+def focus_left(pymux):
     " Move focus to the left. "
-    _move_focus(pymux, cli,
+    _move_focus(pymux,
                 lambda wp: wp.xpos - 2,  # 2 in order to skip over the border.
                 lambda wp: wp.ypos)
 
 
-def focus_right(pymux, cli):
+def focus_right(pymux):
     " Move focus to the right. "
-    _move_focus(pymux, cli,
+    _move_focus(pymux,
                 lambda wp: wp.xpos + wp.width + 1,
                 lambda wp: wp.ypos)
 
 
-def focus_down(pymux, cli):
+def focus_down(pymux):
     " Move focus down. "
-    _move_focus(pymux, cli,
+    _move_focus(pymux,
                 lambda wp: wp.xpos,
-                lambda wp: wp.ypos + wp.height + 1)
+                lambda wp: wp.ypos + wp.height + 2)
+        # 2 in order to skip over the border. Only required when the
+        # pane-status is not shown, but a border instead.
 
 
-def focus_up(pymux, cli):
+def focus_up(pymux):
     " Move focus up. "
-    _move_focus(pymux, cli,
+    _move_focus(pymux,
                 lambda wp: wp.xpos,
-                lambda wp: wp.ypos - 1)
+                lambda wp: wp.ypos - 2)
 
 
-def _move_focus(pymux, cli, get_x, get_y):
+def _move_focus(pymux, get_x, get_y):
     " Move focus of the active window. "
-    window = pymux.arrangement.get_active_window(cli)
+    window = pymux.arrangement.get_active_window()
 
     try:
-        write_pos = pymux.layout_manager.pane_write_positions[window.active_pane]
+        write_pos = pymux.get_client_state().layout_manager.pane_write_positions[window.active_pane]
     except KeyError:
         pass
     else:
@@ -1031,193 +936,8 @@ def _move_focus(pymux, cli, get_x, get_y):
         y = get_y(write_pos)
 
         # Look for the pane at this position.
-        for pane, wp in pymux.layout_manager.pane_write_positions.items():
+        for pane, wp in pymux.get_client_state().layout_manager.pane_write_positions.items():
             if (wp.xpos <= x < wp.xpos + wp.width and
                     wp.ypos <= y < wp.ypos + wp.height):
                 window.active_pane = pane
                 return
-
-
-class Vt100Window(Container):
-    """
-    Container that holds the VT100 control.
-    """
-    def __init__(self, process, has_focus, set_focus):
-        self.process = process
-        self.has_focus = to_cli_filter(has_focus)
-        self.set_focus = set_focus
-
-    def reset(self):
-        pass
-
-    def preferred_width(self, cli, max_available_width):
-        return LayoutDimension()
-
-    def preferred_height(self, cli, width, max_available_height):
-        return LayoutDimension()
-
-    def write_to_screen(self, cli, screen, mouse_handlers, write_position):
-        """
-        Write window to screen. This renders the user control, the margins and
-        copies everything over to the absolute position at the given screen.
-        """
-        # Set size of the screen.
-        self.process.set_size(write_position.width, write_position.height)
-
-        vertical_scroll = self.process.screen.line_offset
-
-        # Render UserControl.
-        temp_screen = self.process.screen.pt_screen
-
-        # Write body to screen.
-        self._copy_body(cli, temp_screen, screen, write_position, vertical_scroll,
-                        write_position.width)
-
-        # Set mouse handlers.
-        def mouse_handler(cli, mouse_event):
-            """ Wrapper around the mouse_handler of the `UIControl` that turns
-            absolute coordinates into relative coordinates. """
-            position = mouse_event.position
-
-            # Call the mouse handler of the UIControl first.
-            self._mouse_handler(
-                cli, MouseEvent(
-                    position=Point(x=position.x - write_position.xpos,
-                                   y=position.y - write_position.ypos + vertical_scroll),
-                    event_type=mouse_event.event_type))
-
-        mouse_handlers.set_mouse_handler_for_range(
-            x_min=write_position.xpos,
-            x_max=write_position.xpos + write_position.width,
-            y_min=write_position.ypos,
-            y_max=write_position.ypos + write_position.height,
-            handler=mouse_handler)
-
-        # If reverse video is enabled for the whole screen.
-        if self.process.screen.has_reverse_video:
-            data_buffer = screen.data_buffer
-
-            for y in range(write_position.ypos, write_position.ypos + write_position.height):
-                row = data_buffer[y]
-
-                for x in range(write_position.xpos, write_position.xpos + write_position.width):
-                    char = row[x]
-                    token = list(char.token or DEFAULT_TOKEN)
-
-                    # The token looks like ('C', *attrs). Replace the value of the reverse flag.
-                    if token and token[0] == 'C':
-                        token[-1] = not token[-1]  # Invert reverse value.
-                        row[x] = Char(char.char, tuple(token))
-
-    def _copy_body(self, cli, temp_screen, new_screen, write_position,
-                   vertical_scroll, width):
-        """
-        Copy characters from the temp screen that we got from the `UIControl`
-        to the real screen.
-        """
-        xpos = write_position.xpos
-        ypos = write_position.ypos
-        height = write_position.height
-
-        temp_buffer = temp_screen.data_buffer
-        new_buffer = new_screen.data_buffer
-        temp_screen_height = temp_screen.height
-
-        vertical_scroll = self.process.screen.line_offset
-        y = 0
-
-        # Now copy the region we need to the real screen.
-        for y in range(0, height):
-            # We keep local row variables. (Don't look up the row in the dict
-            # for each iteration of the nested loop.)
-            new_row = new_buffer[y + ypos]
-
-            if y >= temp_screen_height and y >= write_position.height:
-                # Break out of for loop when we pass after the last row of the
-                # temp screen. (We use the 'y' position for calculation of new
-                # screen's height.)
-                break
-            else:
-                temp_row = temp_buffer[y + vertical_scroll]
-
-                # Copy row content, except for transparent tokens.
-                # (This is useful in case of floats.)
-                for x in range(0, width):
-                    new_row[x + xpos] = temp_row[x]
-
-        if self.has_focus(cli):
-            new_screen.cursor_position = Point(
-                y=temp_screen.cursor_position.y + ypos - vertical_scroll,
-                x=temp_screen.cursor_position.x + xpos)
-
-            new_screen.show_cursor = temp_screen.show_cursor
-
-        # Update height of the output screen. (new_screen.write_data is not
-        # called, so the screen is not aware of its height.)
-        new_screen.height = max(new_screen.height, ypos + y + 1)
-
-    def _mouse_handler(self, cli, mouse_event):
-        """
-        Handle mouse events in a pane. A click in a non-active pane will select
-        it, one in an active pane, will send the mouse event to the application
-        running inside it.
-        """
-        process = self.process
-        x = mouse_event.position.x
-        y = mouse_event.position.y
-
-        # The containing Window translates coordinates to the absolute position
-        # of the whole screen, but in this case, we need the relative
-        # coordinates of the visible area.
-        y -= self.process.screen.line_offset
-
-        if not self.has_focus(cli):
-            # Focus this process when the mouse has been clicked.
-            if mouse_event.event_type == MouseEventTypes.MOUSE_UP:
-                self.set_focus(cli)
-        else:
-            # Already focussed, send event to application when it requested
-            # mouse support.
-            if process.screen.sgr_mouse_support_enabled:
-                # Xterm SGR mode.
-                ev, m = {
-                    MouseEventTypes.MOUSE_DOWN: ('0', 'M'),
-                    MouseEventTypes.MOUSE_UP: ('0', 'm'),
-                    MouseEventTypes.SCROLL_UP: ('64', 'M'),
-                    MouseEventTypes.SCROLL_DOWN: ('65', 'M'),
-                }.get(mouse_event.event_type)
-
-                self.process.write_input(
-                    '\x1b[<%s;%s;%s%s' % (ev, x + 1, y + 1, m))
-
-            elif process.screen.urxvt_mouse_support_enabled:
-                # Urxvt mode.
-                ev = {
-                    MouseEventTypes.MOUSE_DOWN: 32,
-                    MouseEventTypes.MOUSE_UP: 35,
-                    MouseEventTypes.SCROLL_UP: 96,
-                    MouseEventTypes.SCROLL_DOWN: 97,
-                }.get(mouse_event.event_type)
-
-                self.process.write_input(
-                    '\x1b[%s;%s;%sM' % (ev, x + 1, y + 1))
-
-            elif process.screen.mouse_support_enabled:
-                # Fall back to old mode.
-                if x < 96 and y < 96:
-                    ev = {
-                            MouseEventTypes.MOUSE_DOWN: 32,
-                            MouseEventTypes.MOUSE_UP: 35,
-                            MouseEventTypes.SCROLL_UP: 96,
-                            MouseEventTypes.SCROLL_DOWN: 97,
-                    }.get(mouse_event.event_type)
-
-                    self.process.write_input('\x1b[M%s%s%s' % (
-                        six.unichr(ev),
-                        six.unichr(x + 33),
-                        six.unichr(y + 33)))
-
-
-    def walk(self, cli):
-        # Only yield self. A window doesn't have children.
-        yield self
diff --git a/pymux/main.py b/pymux/main.py
index 93d56b3..4c5f96d 100644
--- a/pymux/main.py
+++ b/pymux/main.py
@@ -1,63 +1,68 @@
 from __future__ import unicode_literals
 
 from prompt_toolkit.application import Application
+from prompt_toolkit.application.current import get_app, set_app
 from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
-from prompt_toolkit.buffer import Buffer, AcceptAction
-from prompt_toolkit.buffer_mapping import BufferMapping
-from prompt_toolkit.enums import DUMMY_BUFFER
-from prompt_toolkit.eventloop.callbacks import EventLoopCallbacks
-from prompt_toolkit.eventloop.posix import PosixEventLoop
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.enums import EditingMode
+from prompt_toolkit.eventloop import Future
+from prompt_toolkit.eventloop import get_event_loop
+from prompt_toolkit.eventloop.context import context
 from prompt_toolkit.filters import Condition
-from prompt_toolkit.input import PipeInput
-from prompt_toolkit.interface import CommandLineInterface
-from prompt_toolkit.key_binding.vi_state import InputMode, ViState
+from prompt_toolkit.input.defaults import create_input
+from prompt_toolkit.key_binding.vi_state import InputMode
+from prompt_toolkit.layout.layout import Layout
 from prompt_toolkit.layout.screen import Size
-from prompt_toolkit.terminal.vt100_output import Vt100_Output, _get_size
+from prompt_toolkit.output.defaults import create_output
+from prompt_toolkit.styles import ConditionalStyleTransformation, SwapLightAndDarkStyleTransformation
 
 from .arrangement import Arrangement, Pane, Window
 from .commands.commands import handle_command, call_command_handler
 from .commands.completer import create_command_completer
 from .enums import COMMAND, PROMPT
-from .key_bindings import KeyBindingsManager
+from .key_bindings import PymuxKeyBindings
 from .layout import LayoutManager, Justify
 from .log import logger
 from .options import ALL_OPTIONS, ALL_WINDOW_OPTIONS
-from .process import Process
+from .pipes import bind_and_listen_on_socket
 from .rc import STARTUP_COMMANDS
-from .server import ServerConnection, bind_socket
-from .style import PymuxStyle
+from .server import ServerConnection
+from .style import ui_style
 from .utils import get_default_shell
+from ptterm import Terminal
 
 import os
 import signal
 import six
 import sys
 import tempfile
+import threading
+import time
 import traceback
 import weakref
 
-__all__ = (
+__all__ = [
     'Pymux',
-)
+]
 
 
 class ClientState(object):
     """
     State information that is independent for each client.
     """
-    def __init__(self):
+    def __init__(self, pymux, input, output, color_depth, connection):
+        self.pymux = pymux
+        self.input = input
+        self.output = output
+        self.color_depth = color_depth
+        self.connection = connection
+
         #: True when the prefix key (Ctrl-B) has been pressed.
         self.has_prefix = False
 
         #: Error/info message.
         self.message = None
 
-        # Vi state. (Each client has its own state.)
-        self.vi_state = ViState()
-
-        # True when the command prompt is visible.
-        self.command_mode = False
-
         # When a "confirm-before" command is running,
         # Show this text in the command bar. When confirmed, execute
         # confirm_command.
@@ -68,6 +73,159 @@ def __init__(self):
         self.prompt_text = None
         self.prompt_command = None
 
+        # Popup.
+        self.display_popup = False
+
+        # Input buffers.
+        self.command_buffer = Buffer(
+            name=COMMAND,
+            accept_handler=self._handle_command,
+            auto_suggest=AutoSuggestFromHistory(),
+            multiline=False,
+            complete_while_typing=False,
+            completer=create_command_completer(pymux))
+
+        self.prompt_buffer = Buffer(
+            name=PROMPT,
+            accept_handler=self._handle_prompt_command,
+            multiline=False,
+            auto_suggest=AutoSuggestFromHistory())
+
+        # Layout.
+        self.layout_manager = LayoutManager(self.pymux, self)
+
+        self.app = self._create_app()
+
+        # Clear write positions right before rendering. (They are populated
+        # during rendering).
+        def before_render(_):
+            self.layout_manager.reset_write_positions()
+        self.app.before_render += before_render
+
+    @property
+    def command_mode(self):
+        return get_app().layout.has_focus(COMMAND)
+
+    def _handle_command(self, buffer):
+        " When text is accepted in the command line. "
+        text = buffer.text
+
+        # First leave command mode. We want to make sure that the working
+        # pane is focused again before executing the command handers.
+        self.pymux.leave_command_mode(append_to_history=True)
+
+        # Execute command.
+        self.pymux.handle_command(text)
+
+    def _handle_prompt_command(self, buffer):
+        " When a command-prompt command is accepted. "
+        text = buffer.text
+        prompt_command = self.prompt_command
+
+        # Leave command mode and handle command.
+        self.pymux.leave_command_mode(append_to_history=True)
+        self.pymux.handle_command(prompt_command.replace('%%', text))
+
+    def _create_app(self):
+        """
+        Create `Application` instance for this .
+        """
+        pymux = self.pymux
+
+        def on_focus_changed():
+            """ When the focus changes to a read/write buffer, make sure to go
+            to insert mode. This happens when the ViState was set to NAVIGATION
+            in the copy buffer. """
+            vi_state = app.vi_state
+
+            if app.current_buffer.read_only():
+                vi_state.input_mode = InputMode.NAVIGATION
+            else:
+                vi_state.input_mode = InputMode.INSERT
+
+        app = Application(
+            output=self.output,
+            input=self.input,
+            color_depth=self.color_depth,
+
+            layout=Layout(container=self.layout_manager.layout),
+            key_bindings=pymux.key_bindings_manager.key_bindings,
+            mouse_support=Condition(lambda: pymux.enable_mouse_support),
+            full_screen=True,
+            style=self.pymux.style,
+            style_transformation=ConditionalStyleTransformation(
+                SwapLightAndDarkStyleTransformation(),
+                Condition(lambda: self.pymux.swap_dark_and_light),
+            ),
+            on_invalidate=(lambda _: pymux.invalidate()))
+
+        # Synchronize the Vi state with the CLI object.
+        # (This is stored in the current class, but expected to be in the
+        # CommandLineInterface.)
+        def sync_vi_state(_):
+            VI = EditingMode.VI
+            EMACS = EditingMode.EMACS
+
+            if self.confirm_text or self.prompt_command or self.command_mode:
+                app.editing_mode = VI if pymux.status_keys_vi_mode else EMACS
+            else:
+                app.editing_mode = VI if pymux.mode_keys_vi_mode else EMACS
+
+        app.key_processor.before_key_press += sync_vi_state
+        app.key_processor.after_key_press += sync_vi_state
+        app.key_processor.after_key_press += self.sync_focus
+
+        # Set render postpone time. (.1 instead of 0).
+        # This small change ensures that if for a split second a process
+        # outputs a lot of information, we don't give the highest priority to
+        # rendering output. (Nobody reads that fast in real-time.)
+        app.max_render_postpone_time = .1  # Second.
+
+        # Hide message when a key has been pressed.
+        def key_pressed(_):
+            self.message = None
+        app.key_processor.before_key_press += key_pressed
+
+        # The following code needs to run with the application active.
+        # Especially, `create_window` needs to know what the current
+        # application is, in order to focus the new pane.
+        with set_app(app):
+            # Redraw all CLIs. (Adding a new client could mean that the others
+            # change size, so everything has to be redrawn.)
+            pymux.invalidate()
+
+            pymux.startup()
+
+        return app
+
+    def sync_focus(self, *_):
+        """
+        Focus the focused window from the pymux arrangement.
+        """
+        # Pop-up displayed?
+        if self.display_popup:
+            self.app.layout.focus(self.layout_manager.popup_dialog)
+            return
+
+        # Confirm.
+        if self.confirm_text:
+            return
+
+        # Custom prompt.
+        if self.prompt_command:
+            return # Focus prompt
+
+        # Command mode.
+        if self.command_mode:
+            return # Focus command
+
+        # No windows left, return. We will quit soon.
+        if not self.pymux.arrangement.windows:
+            return
+
+        pane = self.pymux.arrangement.get_active_pane()
+        self.app.layout.focus(pane.terminal)
+
 
 class Pymux(object):
     """
@@ -85,19 +243,18 @@ class Pymux(object):
         p.run_standalone()
     """
     def __init__(self, source_file=None, startup_command=None):
-        self.arrangement = Arrangement()
-        self.layout_manager = LayoutManager(self)
-
-        self._client_states = weakref.WeakKeyDictionary()  # Mapping from CLI to ClientState.
+        self._client_states = {}  # connection -> client_state
 
         # Options
         self.enable_mouse_support = True
         self.enable_status = True
+        self.enable_pane_status = True#False
         self.enable_bell = True
         self.remain_on_exit = False
         self.status_keys_vi_mode = False
         self.mode_keys_vi_mode = False
         self.history_limit = 2000
+        self.status_interval = 4
         self.default_terminal = 'xterm-256color'
         self.status_left = '[#S] '
         self.status_left_length = 20
@@ -108,6 +265,7 @@ def __init__(self, source_file=None, startup_command=None):
         self.session_name = '0'
         self.status_justify = Justify.LEFT
         self.default_shell = get_default_shell()
+        self.swap_dark_and_light = False
 
         self.options = ALL_OPTIONS
         self.window_options = ALL_WINDOW_OPTIONS
@@ -120,7 +278,7 @@ def __init__(self, source_file=None, startup_command=None):
         #: List of clients.
         self._runs_standalone = False
         self.connections = []
-        self.clis = {}  # Mapping from Connection to CommandLineInterface.
+        self.done_f = Future()
 
         self._startup_done = False
         self.source_file = source_file
@@ -133,30 +291,71 @@ def __init__(self, source_file=None, startup_command=None):
         self.socket = None
         self.socket_name = None
 
-        # Create eventloop.
-        self.eventloop = PosixEventLoop()
-
         # Key bindings manager.
-        self.key_bindings_manager = KeyBindingsManager(self)
+        self.key_bindings_manager = PymuxKeyBindings(self)
 
-        self.style = PymuxStyle()
+        self.arrangement = Arrangement()
+
+        self.style = ui_style
 
-    def get_client_state(self, cli):
+    def _start_auto_refresh_thread(self):
         """
-        Return the ClientState instance for this CommandLineInterface.
+        Start the background thread that auto refreshes all clients according to
+        `self.status_interval`.
         """
-        try:
-            return self._client_states[cli]
-        except KeyError:
-            s = ClientState()
-            self._client_states[cli] = s
-            return s
+        def run():
+            while True:
+                time.sleep(self.status_interval)
+                self.invalidate()
+
+        t = threading.Thread(target=run)
+        t.daemon = True
+        t.start()
+
+    @property
+    def apps(self):
+        return [c.app for c in self._client_states.values()]
+
+    def get_client_state(self):
+        " Return the active ClientState instance. "
+        app = get_app()
+        for client_state in self._client_states.values():
+            if client_state.app == app:
+                return client_state
+
+        raise ValueError('Client state for app %r not found' % (app, ))
+
+    def get_connection(self):
+        " Return the active Connection instance. "
+        app = get_app()
+        for connection, client_state in self._client_states.items():
+            if client_state.app == app:
+                return connection
+
+        raise ValueError('Connection for app %r not found' % (app, ))
+
+    def startup(self):
+        # Handle start-up comands.
+        # (Does initial key bindings.)
+        if not self._startup_done:
+            self._startup_done = True
+
+            # Execute default config.
+            for cmd in STARTUP_COMMANDS.splitlines():
+                self.handle_command(cmd)
+
+            # Source the given file.
+            if self.source_file:
+                call_command_handler('source-file', self, [self.source_file])
+
+            # Make sure that there is one window created.
+            self.create_window(command=self.startup_command)
 
-    def get_title(self, cli):
+    def get_title(self):
         """
         The title to be displayed in the titlebar of the terminal.
         """
-        w = self.arrangement.get_active_window(cli)
+        w = self.arrangement.get_active_window()
 
         if w and w.active_process:
             title = w.active_process.screen.title
@@ -168,25 +367,24 @@ def get_title(self, cli):
         else:
             return 'Pymux'
 
-    def get_window_size(self, cli):
+    def get_window_size(self):
         """
         Get the size to be used for the DynamicBody.
         This will be the smallest size of all clients.
         """
-        get_active_window = self.arrangement.get_active_window
-        active_window = get_active_window(cli)
+        def active_window_for_app(app):
+            with set_app(app):
+                return self.arrangement.get_active_window()
 
-        # Get connections watching the same window.
-        connections = [c for c in self.connections if
-                       c.cli and get_active_window(c.cli) == active_window]
+        active_window = self.arrangement.get_active_window()
 
-        rows = [c.size.rows for c in connections]
-        columns = [c.size.columns for c in connections]
+        # Get sizes for connections watching the same window.
+        apps = [client_state.app for client_state in self._client_states.values()
+                if active_window_for_app(client_state.app) == active_window]
+        sizes = [app.output.get_size() for app in apps]
 
-        if self._runs_standalone:
-            r, c = _get_size(sys.stdout.fileno())
-            rows.append(r)
-            columns.append(c)
+        rows = [s.rows for s in sizes]
+        columns = [s.columns for s in sizes]
 
         if rows and columns:
             return Size(rows=min(rows) - (1 if self.enable_status else 0),
@@ -216,14 +414,18 @@ def done_callback():
 
                 # No panes left? -> Quit.
                 if not self.arrangement.has_panes:
-                    self.eventloop.stop()
+                    self.stop()
+
+                # Make sure the right pane is focused for each client.
+                for client_state in self._client_states.values():
+                    client_state.sync_focus()
 
             self.invalidate()
 
         def bell():
             " Sound bell on all clients. "
             if self.enable_bell:
-                for c in self.clis.values():
+                for c in self.apps:
                     c.output.bell()
 
         # Start directory.
@@ -257,59 +459,56 @@ def before_exec():
         else:
             command = [self.default_shell]
 
-        # Create process and pane.
-        def has_priority():
-            return self.arrangement.pane_has_priority(pane)
-
-        process = Process.from_command(
-            self.eventloop, self.invalidate, command, done_callback,
-            bell_func=bell,
-            before_exec_func=before_exec,
-            has_priority=has_priority)
-
-        pane = Pane(process)
+        # Create new pane and terminal.
+        terminal = Terminal(done_callback=done_callback, bell_func=bell,
+                            before_exec_func=before_exec)
+        pane = Pane(terminal)
 
         # Keep track of panes. This is a WeakKeyDictionary, we only add, but
         # don't remove.
         self.panes_by_id[pane.pane_id] = pane
 
         logger.info('Created process %r.', command)
-        process.start()
 
         return pane
 
     def invalidate(self):
         " Invalidate the UI for all clients. "
-        for c in self.clis.values():
-            c.invalidate()
+        logger.info('Invalidating %s applications', len(self.apps))
 
-    def create_window(self, cli=None, command=None, start_directory=None, name=None):
+        for app in self.apps:
+            app.invalidate()
+
+    def stop(self):
+        for app in self.apps:
+            app.exit()
+        self.done_f.set_result(None)
+
+    def create_window(self, command=None, start_directory=None, name=None):
         """
         Create a new :class:`pymux.arrangement.Window` in the arrangement.
-
-        :param cli: If been given, this window will be focussed for that client.
         """
-        assert cli is None or isinstance(cli, CommandLineInterface)
         assert command is None or isinstance(command, six.text_type)
         assert start_directory is None or isinstance(start_directory, six.text_type)
 
         pane = self._create_pane(None, command, start_directory=start_directory)
 
-        self.arrangement.create_window(cli, pane, name=name)
+        self.arrangement.create_window(pane, name=name)
+        pane.focus()
         self.invalidate()
 
-    def add_process(self, cli, command=None, vsplit=False, start_directory=None):
+    def add_process(self, command=None, vsplit=False, start_directory=None):
         """
         Add a new process to the current window. (vsplit/hsplit).
         """
-        assert isinstance(cli, CommandLineInterface)
         assert command is None or isinstance(command, six.text_type)
         assert start_directory is None or isinstance(start_directory, six.text_type)
 
-        window = self.arrangement.get_active_window(cli)
+        window = self.arrangement.get_active_window()
 
         pane = self._create_pane(window, command, start_directory=start_directory)
         window.add_pane(pane, vsplit=vsplit)
+        pane.focus()
         self.invalidate()
 
     def kill_pane(self, pane):
@@ -320,131 +519,46 @@ def kill_pane(self, pane):
 
         # Send kill signal.
         if not pane.process.is_terminated:
-            pane.process.send_signal(signal.SIGKILL)
+            pane.process.kill()
 
         # Remove from layout.
         self.arrangement.remove_pane(pane)
 
-        # No panes left? -> Quit.
-        if not self.arrangement.has_panes:
-            self.eventloop.stop()
-
-    def leave_command_mode(self, cli, append_to_history=False):
+    def leave_command_mode(self, append_to_history=False):
         """
         Leave the command/prompt mode.
         """
-        cli.buffers[COMMAND].reset(append_to_history=append_to_history)
-        cli.buffers[PROMPT].reset(append_to_history=True)
+        client_state = self.get_client_state()
+
+        client_state.command_buffer.reset(append_to_history=append_to_history)
+        client_state.prompt_buffer.reset(append_to_history=True)
 
-        client_state = self.get_client_state(cli)
-        client_state.command_mode = False
         client_state.prompt_command = ''
         client_state.confirm_command = ''
 
-    def handle_command(self, cli, command):
+        client_state.app.layout.focus_previous()
+
+    def handle_command(self, command):
         """
         Handle command from the command line.
         """
-        handle_command(self, cli, command)
+        handle_command(self, command)
 
-    def show_message(self, cli, message):
+    def show_message(self, message):
         """
         Set a warning message. This will be shown at the bottom until a key has
         been pressed.
 
-        :param cli: CommandLineInterface instance. (The client.)
         :param message: String.
         """
-        self.get_client_state(cli).message = message
+        self.get_client_state().message = message
 
-    def create_cli(self, connection, output, input=None):
-        """
-        Create `CommandLineInterface` instance for this connection.
-        """
-        def get_title():
-            return self.get_title(cli)
-
-        def on_focus_changed():
-            """ When the focus changes to a read/write buffer, make sure to go
-            to insert mode. This happens when the ViState was set to NAVIGATION
-            in the copy buffer. """
-            vi_state = self.key_bindings_manager.pt_key_bindings_manager.get_vi_state(cli)
-
-            if cli.current_buffer.read_only():
-                vi_state.input_mode = InputMode.NAVIGATION
-            else:
-                vi_state.input_mode = InputMode.INSERT
-
-        application = Application(
-            layout=self.layout_manager.layout,
-            key_bindings_registry=self.key_bindings_manager.registry,
-            buffers=_BufferMapping(self),
-            mouse_support=Condition(lambda cli: self.enable_mouse_support),
-            use_alternate_screen=True,
-            style=self.style,
-            get_title=get_title)
-
-        cli = CommandLineInterface(
-            application=application,
-            output=output,
-            input=input,
-            eventloop=self.eventloop)
-
-        # Set render postpone time. (.1 instead of 0).
-        # This small change ensures that if for a split second a process
-        # outputs a lot of information, we don't give the highest priority to
-        # rendering output. (Nobody reads that fast in real-time.)
-        cli.max_render_postpone_time = .1  # Second.
-
-        # Hide message when a key has been pressed.
-        def key_pressed():
-            self.get_client_state(cli).message = None
-        cli.input_processor.beforeKeyPress += key_pressed
-
-        cli._is_running = True
-
-        self.clis[connection] = cli
-
-        # Redraw all CLIs. (Adding a new client could mean that the others
-        # change size, so everything has to be redrawn.)
-        self.invalidate()
-
-        cli.on_invalidate += lambda: self.invalidate()
-
-        # Handle start-up comands.
-        # (Does initial key bindings.)
-        if not self._startup_done:
-            self._startup_done = True
-
-            # Execute default config.
-            for cmd in STARTUP_COMMANDS.splitlines():
-                self.handle_command(cli, cmd)
-
-            # Source the given file.
-            if self.source_file:
-                call_command_handler('source-file', self, cli, [self.source_file])
-
-            # Make sure that there is one window created.
-            self.create_window(cli, command=self.startup_command)
-
-        return cli
-
-    def get_connection_for_cli(self, cli):
-        """
-        Return the `CommandLineInterface` instance for this connection, if any.
-        `None` otherwise.
-        """
-        for connection, c in self.clis.items():
-            if c == cli:
-                return connection
-
-    def detach_client(self, cli):
+    def detach_client(self, app):
         """
         Detach the client that belongs to this CLI.
         """
-        connection = self.get_connection_for_cli(cli)
-
-        if connection is not None:
+        connection = self.get_connection()
+        if connection:
             connection.detach_and_close()
 
         # Redraw all clients -> Maybe their size has to change.
@@ -455,35 +569,23 @@ def listen_on_socket(self, socket_name=None):
         Listen for clients on a Unix socket.
         Returns the socket name.
         """
-        if self.socket is None:
-            # Py2 uses 0027 and Py3 uses 0o027, but both know
-            # how to create the right value from the string '0027'.
-            old_umask = os.umask(int('0027', 8))
-            self.socket_name, self.socket = bind_socket(socket_name)
-            _ = os.umask(old_umask)
-            self.socket.listen(0)
-            self.eventloop.add_reader(self.socket.fileno(), self._socket_accept)
+        def connection_cb(pipe_connection):
+            # We have to create a new `context`, because this will be the scope for
+            # a new prompt_toolkit.Application to become active.
+            with context():
+                connection = ServerConnection(self, pipe_connection)
+
+            self.connections.append(connection)
+
+        self.socket_name = bind_and_listen_on_socket(socket_name, connection_cb)
 
         # Set session_name according to socket name.
-        if '.' in self.socket_name:
-            self.session_name = self.socket_name.rsplit('.')[-1]
+#        if '.' in self.socket_name:
+#            self.session_name = self.socket_name.rpartition('.')[-1]
 
         logger.info('Listening on %r.' % self.socket_name)
         return self.socket_name
 
-    def _socket_accept(self):
-        """
-        Accept connection from client.
-        """
-        logger.info('Client attached.')
-
-        connection, client_address = self.socket.accept()
-        # Note: We don't have to put this socket in non blocking mode.
-        #       This can cause crashes when sending big packets on OS X.
-
-        connection = ServerConnection(self, connection, client_address)
-        self.connections.append(connection)
-
     def run_server(self):
         # Ignore keyboard. (When people run "pymux server" and press Ctrl-C.)
         # Pymux has to be terminated by termining all the processes running in
@@ -493,15 +595,12 @@ def handle_sigint(*a):
 
         signal.signal(signal.SIGINT, handle_sigint)
 
-        # Run eventloop.
+        # Start background threads.
+        self._start_auto_refresh_thread()
 
-        # XXX: Both the PipeInput and DummyCallbacks are not used.
-        #      This is a workaround to run the PosixEventLoop continuously
-        #      without having a CommandLineInterface instance.
-        #      A better API in prompt_toolkit is desired.
+        # Run eventloop.
         try:
-            self.eventloop.run(
-                PipeInput(), DummyCallbacks())
+            get_event_loop().run_until_complete(self.done_f)
         except:
             # When something bad happens, always dump the traceback.
             # (Otherwise, when running as a daemon, and stdout/stderr are not
@@ -513,144 +612,37 @@ def handle_sigint(*a):
             os.close(fd)
             raise
 
-        # Clean up socket.
-        os.remove(self.socket_name)
+        finally:
+            # Clean up socket.
+            os.remove(self.socket_name)
 
-    def run_standalone(self, true_color=False):
+    def run_standalone(self, color_depth):
         """
         Run pymux standalone, rather than using a client/server architecture.
         This is mainly useful for debugging.
         """
         self._runs_standalone = True
-        cli = self.create_cli(
-            connection=None,
-            output=Vt100_Output.from_pty(sys.stdout, true_color=true_color))
-        cli._is_running = False
-        cli.run()
+        self._start_auto_refresh_thread()
 
+        client_state = self.add_client(
+            input=create_input(),
+            output=create_output(stdout=sys.stdout),
+            color_depth=color_depth,
+            connection=None)
 
-class _BufferMapping(BufferMapping):
-    """
-    Container for all the Buffer objects in a CommandLineInterface.
-    """
-    def __init__(self, pymux):
-        self.pymux = pymux
+        client_state.app.run()
 
-        def _handle_command(cli, buffer):
-            " When text is accepted in the command line. "
-            text = buffer.text
-
-            # First leave command mode. We want to make sure that the working
-            # pane is focussed again before executing the command handers.
-            pymux.leave_command_mode(cli, append_to_history=True)
-
-            # Execute command.
-            pymux.handle_command(cli, text)
-
-        def _handle_prompt_command(cli, buffer):
-            " When a command-prompt command is accepted. "
-            text = buffer.text
-            client_state = pymux.get_client_state(cli)
-            prompt_command = client_state.prompt_command
-
-            # Leave command mode and handle command.
-            pymux.leave_command_mode(cli, append_to_history=True)
-            pymux.handle_command(cli, prompt_command.replace('%%', text))
-
-        super(_BufferMapping, self).__init__({
-            COMMAND: Buffer(
-                complete_while_typing=True,
-                completer=create_command_completer(pymux),
-                accept_action=AcceptAction(handler=_handle_command),
-                auto_suggest=AutoSuggestFromHistory(),
-            ),
-            PROMPT: Buffer(
-                accept_action=AcceptAction(handler=_handle_prompt_command),
-                auto_suggest=AutoSuggestFromHistory(),
-            ),
-        })
-
-    def __getitem__(self, name):
-        " Override __getitem__ to make lookup of pane- buffers dynamic. "
-        if name.startswith('pane-'):
-            try:
-                id = int(name[len('pane-'):])
-                return self.pymux.panes_by_id[id].scroll_buffer
-            except (ValueError, KeyError):
-                raise KeyError
-
-        elif name.startswith('search-'):
-            try:
-                id = int(name[len('search-'):])
-                return self.pymux.panes_by_id[id].search_buffer
-            except (ValueError, KeyError):
-                raise KeyError
-        else:
-            return super(_BufferMapping, self).__getitem__(name)
-
-    def current(self, cli):
-        """
-        Return the currently focussed Buffer.
-        """
-        return self[self.current_name(cli)]
-
-    def current_name(self, cli):
-        """
-        Name of the current buffer.
-        """
-        client_state = self.pymux.get_client_state(cli)
-
-        # Confirm.
-        if client_state.confirm_text:
-            return DUMMY_BUFFER
-
-        # Custom prompt.
-        if client_state.prompt_command:
-            return PROMPT
-
-        # Command mode.
-        if client_state.command_mode:
-            return COMMAND
-
-        # Copy/search mode.
-        pane = self.pymux.arrangement.get_active_pane(cli)
-
-        if pane and pane.display_scroll_buffer:
-            if pane.is_searching:
-                return 'search-%i' % pane.pane_id
-            else:
-                return 'pane-%i' % pane.pane_id
-
-        return DUMMY_BUFFER
-
-    def focus(self, cli, buffer_name):
-        """
-        Focus buffer with the given name.
-
-        Called when a :class:`BufferControl` in the layout has been clicked.
-        Make sure that we focus the pane in the :class:`.Arrangement`.
-        """
-        self._focus(cli, buffer_name)
-        super(_BufferMapping, self).focus(cli, buffer_name)
-
-    def push(self, cli, buffer_name):
-        """
-        Push to focus stack.
-        """
-        self._focus(cli, buffer_name)
-        super(_BufferMapping, self).push(cli, buffer_name)
-
-    def _focus(self, cli, buffer_name):
-        if buffer_name.startswith('pane-'):
-            id = int(buffer_name[len('pane-'):])
-            pane = self.pymux.panes_by_id[id]
+    def add_client(self, output, input, color_depth, connection):
+        client_state = ClientState(self,
+            connection=None,
+            input=input,
+            output=output,
+            color_depth=color_depth)
 
-            w = self.pymux.arrangement.get_active_window(cli)
-            w.active_pane = pane
+        self._client_states[connection] = client_state
 
+        return client_state
 
-class DummyCallbacks(EventLoopCallbacks):
-    " Required in order to call eventloop.run() without having a CLI instance. "
-    def terminal_size_changed(self): pass
-    def input_timeout(self): pass
-    def feed_key(self, key): pass
+    def remove_client(self, connection):
+        if connection in self._client_states:
+            del self._client_states[connection]
diff --git a/pymux/options.py b/pymux/options.py
index 3136b95..c9e2bc7 100644
--- a/pymux/options.py
+++ b/pymux/options.py
@@ -30,7 +30,7 @@ def get_all_values(self):
         """
 
     @abstractmethod
-    def set_value(self, pymux, cli, value):
+    def set_value(self, pymux, value):
         " Set option. This can raise SetOptionError. "
 
 
@@ -53,12 +53,12 @@ def __init__(self, attribute_name, window_option=False):
     def get_all_values(self, pymux):
         return ['on', 'off']
 
-    def set_value(self, pymux, cli, value):
+    def set_value(self, pymux, value):
         value = value.lower()
 
         if value in ('on', 'off'):
             if self.window_option:
-                w = pymux.arrangement.get_active_window(cli)
+                w = pymux.arrangement.get_active_window()
                 setattr(w, self.attribute_name, (value == 'on'))
             else:
                 setattr(pymux, self.attribute_name, (value == 'on'))
@@ -79,7 +79,7 @@ def get_all_values(self, pymux):
             self.possible_values + [getattr(pymux, self.attribute_name)]
         ))
 
-    def set_value(self, pymux, cli, value):
+    def set_value(self, pymux, value):
         setattr(pymux, self.attribute_name, value)
 
 
@@ -97,7 +97,7 @@ def get_all_values(self, pymux):
             ['%s' % getattr(pymux, self.attribute_name)]
         ))
 
-    def set_value(self, pymux, cli, value):
+    def set_value(self, pymux, value):
         """
         Take a string, and return an integer. Raise SetOptionError when the
         given text does not parse to a positive integer.
@@ -116,7 +116,7 @@ class KeyPrefixOption(Option):
     def get_all_values(self, pymux):
         return PYMUX_TO_PROMPT_TOOLKIT_KEYS.keys()
 
-    def set_value(self, pymux, cli, value):
+    def set_value(self, pymux, value):
         # Translate prefix to prompt_toolkit
         try:
             keys = pymux_key_to_prompt_toolkit_key_sequence(value)
@@ -131,7 +131,7 @@ class BaseIndexOption(Option):
     def get_all_values(self, pymux):
         return ['0', '1']
 
-    def set_value(self, pymux, cli, value):
+    def set_value(self, pymux, value):
         try:
             value = int(value)
         except ValueError:
@@ -148,7 +148,7 @@ def __init__(self, attribute_name):
     def get_all_values(self, pymux):
         return ['emacs', 'vi']
 
-    def set_value(self, pymux, cli, value):
+    def set_value(self, pymux, value):
         if value in ('emacs', 'vi'):
             setattr(pymux, self.attribute_name, value == 'vi')
         else:
@@ -161,7 +161,7 @@ def __init__(self, attribute_name):
     def get_all_values(self, pymux):
         return Justify._ALL
 
-    def set_value(self, pymux, cli, value):
+    def set_value(self, pymux, value):
         if value in Justify._ALL:
             setattr(pymux, self.attribute_name, value)
         else:
@@ -177,6 +177,7 @@ def set_value(self, pymux, cli, value):
     'prefix': KeyPrefixOption(),
     'remain-on-exit': OnOffOption('remain_on_exit'),
     'status': OnOffOption('enable_status'),
+    'pane-border-status': OnOffOption('enable_pane_status'),
     'status-keys': KeysOption('status_keys_vi_mode'),
     'mode-keys': KeysOption('mode_keys_vi_mode'),
     'default-terminal': StringOption(
@@ -190,6 +191,11 @@ def set_value(self, pymux, cli, value):
     'default-shell': StringOption(
         'default_shell', [get_default_shell()]),
     'status-justify': JustifyOption('status_justify'),
+    'status-interval': PositiveIntOption(
+        'status_interval', [1, 2, 4, 8, 16, 30, 60]),
+
+    # Prompt-toolkit/pymux specific.
+    'swap-light-and-dark-colors': OnOffOption('swap_dark_and_light'),
 }
 
 
diff --git a/pymux/pipes/__init__.py b/pymux/pipes/__init__.py
new file mode 100644
index 0000000..23fd63f
--- /dev/null
+++ b/pymux/pipes/__init__.py
@@ -0,0 +1,30 @@
+"""
+Platform specific (Windows+posix) implementations for inter process
+communication through pipes between the Pymux server and clients.
+"""
+from __future__ import unicode_literals
+from prompt_toolkit.utils import is_windows
+from .base import PipeConnection, BrokenPipeError
+
+__all__ = [
+    'bind_and_listen_on_socket',
+
+    # Base.
+    'PipeConnection',
+    'BrokenPipeError',
+]
+
+
+def bind_and_listen_on_socket(socket_name, accept_callback):
+    """
+    Return socket name.
+
+    :param accept_callback: Callback is called with a `PipeConnection` as
+        argument.
+    """
+    if is_windows():
+        from .win32_server import bind_and_listen_on_win32_socket
+        return bind_and_listen_on_win32_socket(socket_name, accept_callback)
+    else:
+        from .posix import bind_and_listen_on_posix_socket
+        return bind_and_listen_on_posix_socket(socket_name, accept_callback)
diff --git a/pymux/pipes/base.py b/pymux/pipes/base.py
new file mode 100644
index 0000000..b23e94d
--- /dev/null
+++ b/pymux/pipes/base.py
@@ -0,0 +1,43 @@
+from __future__ import unicode_literals
+from abc import ABCMeta, abstractmethod
+from six import with_metaclass
+
+__all__ = [
+    'PipeConnection',
+    'BrokenPipeError',
+]
+
+
+class PipeConnection(with_metaclass(ABCMeta, object)):
+    """
+    A single active Win32 pipe connection on the server side.
+
+    - Win32PipeConnection
+    """
+    @abstractmethod
+    def read(self):
+        """
+        (coroutine)
+        Read a single message from the pipe. (Return as text.)
+
+        This can can BrokenPipeError.
+        """
+
+    @abstractmethod
+    def write(self, message):
+        """
+        (coroutine)
+        Write a single message into the pipe.
+
+        This can can BrokenPipeError.
+        """
+
+    @abstractmethod
+    def close(self):
+        """
+        Close connection.
+        """
+
+
+class BrokenPipeError(Exception):
+    " Raised when trying to write to or read from a broken pipe. "
diff --git a/pymux/pipes/posix.py b/pymux/pipes/posix.py
new file mode 100644
index 0000000..26c28a2
--- /dev/null
+++ b/pymux/pipes/posix.py
@@ -0,0 +1,165 @@
+from __future__ import unicode_literals
+import getpass
+import os
+import six
+import socket
+import tempfile
+
+from prompt_toolkit.eventloop import From, Return, Future, get_event_loop
+
+from ..log import logger
+from .base import PipeConnection, BrokenPipeError
+
+__all__ = [
+    'bind_and_listen_on_posix_socket',
+    'PosixSocketConnection',
+]
+
+
+def bind_and_listen_on_posix_socket(socket_name, accept_callback):
+    """
+    :param accept_callback: Called with `PosixSocketConnection` when a new
+        connection is established.
+    """
+    assert socket_name is None or isinstance(socket_name, six.text_type)
+    assert callable(accept_callback)
+
+    # Py2 uses 0027 and Py3 uses 0o027, but both know
+    # how to create the right value from the string '0027'.
+    old_umask = os.umask(int('0027', 8))
+
+    # Bind socket.
+    socket_name, socket = _bind_posix_socket(socket_name)
+
+    _ = os.umask(old_umask)
+
+    # Listen on socket.
+    socket.listen(0)
+
+    def _accept_cb():
+        connection, client_address = socket.accept()
+        # Note: We don't have to put this socket in non blocking mode.
+        #       This can cause crashes when sending big packets on OS X.
+
+        posix_connection = PosixSocketConnection(connection)
+
+        accept_callback(posix_connection)
+
+    get_event_loop().add_reader(socket.fileno(), _accept_cb)
+
+    logger.info('Listening on %r.' % socket_name)
+    return socket_name
+
+
+def _bind_posix_socket(socket_name=None):
+    """
+    Find a socket to listen on and return it.
+
+    Returns (socket_name, sock_obj)
+    """
+    assert socket_name is None or isinstance(socket_name, six.text_type)
+
+    s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+
+    if socket_name:
+        s.bind(socket_name)
+        return socket_name, s
+    else:
+        i = 0
+        while True:
+            try:
+                socket_name = '%s/pymux.sock.%s.%i' % (
+                    tempfile.gettempdir(), getpass.getuser(), i)
+                s.bind(socket_name)
+                return socket_name, s
+            except (OSError, socket.error):
+                i += 1
+
+                # When 100 times failed, cancel server
+                if i == 100:
+                    logger.warning('100 times failed to listen on posix socket. '
+                                   'Please clean up old sockets.')
+                    raise
+
+
+class PosixSocketConnection(PipeConnection):
+    """
+    A single active posix pipe connection on the server side.
+    """
+    def __init__(self, socket):
+        self.socket = socket
+        self._fd = socket.fileno()
+        self._recv_buffer = b''
+
+    def read(self):
+        r"""
+        Coroutine that reads the next packet.
+        (Packets are \0 separated.)
+        """
+        # Read until we have a \0 in our buffer.
+        while b'\0' not in self._recv_buffer:
+            self._recv_buffer += yield From(_read_chunk_from_socket(self.socket))
+
+        # Split on the first separator.
+        pos = self._recv_buffer.index(b'\0')
+
+        packet = self._recv_buffer[:pos]
+        self._recv_buffer = self._recv_buffer[pos + 1:]
+
+        raise Return(packet)
+
+
+    def write(self, message):
+        """
+        Coroutine that writes the next packet.
+        """
+        try:
+            self.socket.send(message.encode('utf-8') + b'\0')
+        except socket.error:
+            if not self._closed:
+                raise BrokenPipeError
+
+        return Future.succeed(None)
+
+    def close(self):
+        """
+        Close connection.
+        """
+        self.socket.close()
+
+        # Make sure to remove the reader from the event loop.
+        get_event_loop().remove_reader(self._fd)
+
+
+def _read_chunk_from_socket(socket):
+    """
+    (coroutine)
+    Turn socket reading into coroutine.
+    """
+    fd = socket.fileno()
+    f = Future()
+
+    def read_callback():
+        get_event_loop().remove_reader(fd)
+
+        # Read next chunk.
+        try:
+            data = socket.recv(1024)
+        except OSError as e:
+            # On OSX, when we try to create a new window by typing "pymux
+            # new-window" in a centain pane, very often we get the following
+            # error: "OSError: [Errno 9] Bad file descriptor."
+            # This doesn't seem very harmful, and we can just try again.
+            logger.warning('Got OSError while reading data from client: %s. '
+                           'Trying again.', e)
+            f.set_result('')
+            return
+
+        if data:
+            f.set_result(data)
+        else:
+            f.set_exception(BrokenPipeError)
+
+    get_event_loop().add_reader(fd, read_callback)
+
+    return f
diff --git a/pymux/pipes/win32.py b/pymux/pipes/win32.py
new file mode 100644
index 0000000..d8d2da2
--- /dev/null
+++ b/pymux/pipes/win32.py
@@ -0,0 +1,205 @@
+"""
+Common Win32 pipe operations.
+"""
+from __future__ import unicode_literals
+from ctypes import windll, byref, create_string_buffer
+from ctypes.wintypes import DWORD, BOOL
+from prompt_toolkit.eventloop import get_event_loop, From, Return, Future
+from ptterm.backends.win32_pipes import OVERLAPPED
+from .base import BrokenPipeError
+
+__all__ = [
+    'read_message_from_pipe',
+    'read_message_bytes_from_pipe',
+    'write_message_to_pipe',
+    'write_message_bytes_to_pipe',
+    'wait_for_event',
+]
+
+BUFSIZE = 4096
+
+GENERIC_READ = 0x80000000
+GENERIC_WRITE = 0x40000000
+OPEN_EXISTING = 0x3
+
+ERROR_BROKEN_PIPE = 109
+ERROR_IO_PENDING = 997
+ERROR_MORE_DATA = 234
+ERROR_NO_DATA = 232
+FILE_FLAG_OVERLAPPED = 0x40000000
+
+PIPE_READMODE_MESSAGE = 0x2
+FILE_WRITE_ATTRIBUTES = 0x100  # 256
+INVALID_HANDLE_VALUE = -1
+
+
+def connect_to_pipe(pipe_name):
+    """
+    Connect to a new pipe in message mode.
+    """
+    pipe_handle = windll.kernel32.CreateFileW(
+        pipe_name,
+        DWORD(GENERIC_READ | GENERIC_WRITE | FILE_WRITE_ATTRIBUTES),
+        DWORD(0),  # No sharing.
+        None,  # Default security attributes.
+        DWORD(OPEN_EXISTING),  # dwCreationDisposition.
+        FILE_FLAG_OVERLAPPED,  # dwFlagsAndAttributes.
+        None  # hTemplateFile,
+    )
+    if pipe_handle == INVALID_HANDLE_VALUE:
+        raise Exception('Invalid handle. Connecting to pipe %r failed.' % pipe_name)
+
+    # Turn pipe into message mode.
+    dwMode = DWORD(PIPE_READMODE_MESSAGE)
+    windll.kernel32.SetNamedPipeHandleState(
+        pipe_handle,
+        byref(dwMode),
+        None,
+        None)
+
+    return pipe_handle
+
+
+def create_event():
+    """
+    Create Win32 event.
+    """
+    event = windll.kernel32.CreateEventA(
+        None,  # Default security attributes.
+        BOOL(True),  # Manual reset event.
+        BOOL(True),  # Initial state = signaled.
+        None  # Unnamed event object.
+    )
+    if not event:
+        raise Exception('event creation failed.')
+    return event
+
+
+def read_message_from_pipe(pipe_handle):
+    """
+    (coroutine)
+    Read message from this pipe. Return text.
+    """
+    data = yield From(read_message_bytes_from_pipe(pipe_handle))
+    assert isinstance(data, bytes)
+    raise Return(data.decode('utf-8', 'ignore'))
+
+
+def read_message_bytes_from_pipe(pipe_handle):
+    """
+    (coroutine)
+    Read message from this pipe. Return bytes.
+    """
+    overlapped = OVERLAPPED()
+    overlapped.hEvent = create_event()
+
+    try:
+        buff = create_string_buffer(BUFSIZE + 1)
+        c_read = DWORD()
+
+        success = windll.kernel32.ReadFile(
+            pipe_handle,
+            buff,
+            DWORD(BUFSIZE),
+            byref(c_read),
+            byref(overlapped))
+
+        if success:
+            buff[c_read.value] = b'\0'
+            raise Return(buff.value)
+
+        error_code = windll.kernel32.GetLastError()
+
+        if error_code == ERROR_IO_PENDING:
+            yield From(wait_for_event(overlapped.hEvent))
+
+            success = windll.kernel32.GetOverlappedResult(
+                pipe_handle,
+                byref(overlapped),
+                byref(c_read),
+                BOOL(False))
+
+            if success:
+                buff[c_read.value] = b'\0'
+                raise Return(buff.value)
+
+            else:
+                error_code = windll.kernel32.GetLastError()
+                if error_code == ERROR_BROKEN_PIPE:
+                    raise BrokenPipeError
+
+                elif error_code == ERROR_MORE_DATA:
+                    more_data = yield From(read_message_bytes_from_pipe(pipe_handle))
+                    raise Return(buff.value + more_data)
+                else:
+                    raise Exception(
+                        'reading overlapped IO failed. error_code=%r' % error_code)
+
+        elif error_code == ERROR_BROKEN_PIPE:
+            raise BrokenPipeError
+
+        elif error_code == ERROR_MORE_DATA:
+            more_data = yield From(read_message_bytes_from_pipe(pipe_handle))
+            raise Return(buff.value + more_data)
+
+        else:
+            raise Exception('Reading pipe failed, error_code=%s' % error_code)
+    finally:
+        windll.kernel32.CloseHandle(overlapped.hEvent)
+
+
+def write_message_to_pipe(pipe_handle, text):
+    data = text.encode('utf-8')
+    yield From(write_message_bytes_to_pipe(pipe_handle, data))
+
+
+def write_message_bytes_to_pipe(pipe_handle, data):
+    overlapped = OVERLAPPED()
+    overlapped.hEvent = create_event()
+
+    try:
+        c_written = DWORD()
+
+        success = windll.kernel32.WriteFile(
+            pipe_handle,
+            create_string_buffer(data),
+            len(data),
+            byref(c_written),
+            byref(overlapped))
+
+        if success:
+            return
+
+        error_code = windll.kernel32.GetLastError()
+        if error_code == ERROR_IO_PENDING:
+            yield From(wait_for_event(overlapped.hEvent))
+
+            success = windll.kernel32.GetOverlappedResult(
+                pipe_handle,
+                byref(overlapped),
+                byref(c_written),
+                BOOL(False))
+
+            if not success:
+                error_code = windll.kernel32.GetLastError()
+                if error_code == ERROR_BROKEN_PIPE:
+                    raise BrokenPipeError
+                else:
+                    raise Exception('Writing overlapped IO failed. error_code=%r' % error_code)
+
+        elif error_code == ERROR_BROKEN_PIPE:
+            raise BrokenPipeError
+    finally:
+        windll.kernel32.CloseHandle(overlapped.hEvent)
+
+
+def wait_for_event(event):
+    """
+    Wraps a win32 event into a `Future` and wait for it.
+    """
+    f = Future()
+    def ready():
+        get_event_loop().remove_win32_handle(event)
+        f.set_result(None)
+    get_event_loop().add_win32_handle(event, ready)
+    return f
diff --git a/pymux/pipes/win32_client.py b/pymux/pipes/win32_client.py
new file mode 100644
index 0000000..e7692be
--- /dev/null
+++ b/pymux/pipes/win32_client.py
@@ -0,0 +1,41 @@
+from __future__ import unicode_literals
+from .win32 import read_message_from_pipe, write_message_to_pipe, connect_to_pipe
+from ctypes import windll
+from prompt_toolkit.eventloop import From, Return
+import six
+
+__all__ = [
+    'PipeClient',
+]
+
+
+class PipeClient(object):
+    r"""
+    Windows pipe client.
+
+    :param pipe_name: Name of the pipe. E.g. \\.\pipe\pipe_name
+    """
+    def __init__(self, pipe_name):
+        assert isinstance(pipe_name, six.text_type)
+        self.pipe_handle = connect_to_pipe(pipe_name)
+
+    def write_message(self, text):
+        """
+        (coroutine)
+        Write message into the pipe.
+        """
+        yield From(write_message_to_pipe(self.pipe_handle, text))
+
+    def read_message(self):
+        """
+        (coroutine)
+        Read one single message from the pipe and return as text.
+        """
+        message = yield From(read_message_from_pipe(self.pipe_handle))
+        raise Return(message)
+
+    def close(self):
+        """
+        Close the connection.
+        """
+        windll.kernel32.CloseHandle(self.pipe_handle)
diff --git a/pymux/pipes/win32_server.py b/pymux/pipes/win32_server.py
new file mode 100644
index 0000000..92d259a
--- /dev/null
+++ b/pymux/pipes/win32_server.py
@@ -0,0 +1,170 @@
+from __future__ import unicode_literals
+from ctypes import windll, byref
+from ctypes.wintypes import DWORD
+from prompt_toolkit.eventloop import From, Future, Return, ensure_future
+from ptterm.backends.win32_pipes import OVERLAPPED
+
+from .win32 import wait_for_event, create_event, read_message_from_pipe, write_message_to_pipe
+from .base import PipeConnection, BrokenPipeError
+from ..log import logger
+
+__all__ = [
+    'bind_and_listen_on_win32_socket',
+    'Win32PipeConnection',
+    'PipeInstance',
+]
+
+
+INSTANCES = 10
+BUFSIZE = 4096
+
+# CreateNamedPipeW flags.
+# See: https://docs.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-createnamedpipea
+PIPE_ACCESS_DUPLEX = 0x00000003
+FILE_FLAG_OVERLAPPED = 0x40000000
+PIPE_TYPE_MESSAGE = 0x00000004
+PIPE_READMODE_MESSAGE = 0x00000002
+PIPE_WAIT = 0x00000000
+PIPE_NOWAIT = 0x00000001
+
+ERROR_IO_PENDING = 997
+ERROR_BROKEN_PIPE= 109
+ERROR_NO_DATA = 232
+
+CONNECTING_STATE = 0
+READING_STATE = 1
+WRITING_STATE = 2
+
+
+def bind_and_listen_on_win32_socket(socket_name, accept_callback):
+    """
+    :param accept_callback: Called with `Win32PipeConnection` when a new
+        connection is established.
+    """
+    assert callable(accept_callback)
+    socket_name = r'\\.\pipe\pymux.sock.jonathan.42'
+
+    pipes = [PipeInstance(socket_name, pipe_connection_cb=accept_callback)
+             for i in range(INSTANCES)]
+
+    for p in pipes:
+        # Start pipe.
+        ensure_future(p.handle_pipe())
+
+    return socket_name
+
+
+class Win32PipeConnection(PipeConnection):
+    """
+    A single active Win32 pipe connection on the server side.
+    """
+    def __init__(self, pipe_instance):
+        assert isinstance(pipe_instance, PipeInstance)
+        self.pipe_instance = pipe_instance
+        self.done_f = Future()
+
+    def read(self):
+        """
+        (coroutine)
+        Read a single message from the pipe. (Return as text.)
+        """
+        if self.done_f.done():
+            raise BrokenPipeError
+
+        try:
+            result = yield From(read_message_from_pipe(self.pipe_instance.pipe_handle))
+            raise Return(result)
+        except BrokenPipeError:
+            self.done_f.set_result(None)
+            raise
+
+    def write(self, message):
+        """
+        (coroutine)
+        Write a single message into the pipe.
+        """
+        if self.done_f.done():
+            raise BrokenPipeError
+
+        try:
+            yield From(write_message_to_pipe(self.pipe_instance.pipe_handle, message))
+        except BrokenPipeError:
+            self.done_f.set_result(None)
+            raise
+
+    def close(self):
+        pass
+
+
+class PipeInstance(object):
+    def __init__(self, pipe_name, instances=INSTANCES, buffsize=BUFSIZE,
+                 timeout=5000, pipe_connection_cb=None):
+
+        self.pipe_handle = windll.kernel32.CreateNamedPipeW(
+            pipe_name,  # Pipe name.
+            PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,
+            PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT,
+            DWORD(instances), # Max instances. (TODO: increase).
+            DWORD(buffsize),  # Output buffer size.
+            DWORD(buffsize),  # Input buffer size.
+            DWORD(timeout),  # Client time-out.
+            None, # Default security attributes.
+        )
+        self.pipe_connection_cb = pipe_connection_cb
+
+        if not self.pipe_handle:
+            raise Exception('invalid pipe')
+
+    def handle_pipe(self):
+        """
+        Coroutine that handles this pipe.
+        """
+        while True:
+            yield From(self._handle_client())
+
+    def _handle_client(self):
+        """
+        Coroutine that connects to a single client and handles that.
+        """
+        while True:
+            try:
+                # Wait for connection.
+                logger.info('Waiting for connection in pipe instance.')
+                yield From(self._connect_client())
+                logger.info('Connected in pipe instance')
+
+                conn = Win32PipeConnection(self)
+                self.pipe_connection_cb(conn)
+
+                yield From(conn.done_f)
+                logger.info('Pipe instance done.')
+
+            finally:
+                # Disconnect and reconnect.
+                logger.info('Disconnecting pipe instance.')
+                windll.kernel32.DisconnectNamedPipe(self.pipe_handle)
+
+    def _connect_client(self):
+        """
+        Wait for a client to connect to this pipe.
+        """
+        overlapped = OVERLAPPED()
+        overlapped.hEvent = create_event()
+
+        while True:
+            success = windll.kernel32.ConnectNamedPipe(
+                self.pipe_handle,
+                byref(overlapped))
+
+            if success:
+                return
+
+            last_error = windll.kernel32.GetLastError()
+            if last_error == ERROR_IO_PENDING:
+                yield From(wait_for_event(overlapped.hEvent))
+
+                # XXX: Call GetOverlappedResult.
+                return  # Connection succeeded.
+
+            else:
+                raise Exception('connect failed with error code' + str(last_error))
diff --git a/pymux/process.py b/pymux/process.py
deleted file mode 100644
index d01bcd3..0000000
--- a/pymux/process.py
+++ /dev/null
@@ -1,451 +0,0 @@
-"""
-The child process.
-"""
-from __future__ import unicode_literals
-
-from prompt_toolkit.document import Document
-from prompt_toolkit.eventloop.base import EventLoop
-from prompt_toolkit.eventloop.posix_utils import PosixStdinReader
-from six.moves import range
-
-from .key_mappings import prompt_toolkit_key_to_vt100_key
-from .screen import BetterScreen
-from .stream import BetterStream
-from .utils import set_terminal_size, pty_make_controlling_tty
-
-import os
-import resource
-import signal
-import sys
-import time
-import traceback
-import datetime
-
-__all__ = (
-    'Process',
-)
-
-
-class Process(object):
-    """
-    Child process.
-    Functionality for parsing the vt100 output (the Pyte screen and stream), as
-    well as sending input to the process.
-
-    Usage:
-
-        p = Process(eventloop, ...):
-        p.start()
-
-    :param eventloop: Prompt_toolkit eventloop. Used for executing blocking
-        stuff in an executor, as well as adding additional readers to the
-        eventloop.
-    :param invalidate: When the screen content changes, and the renderer needs
-        to redraw the output, this callback is called.
-    :param exec_func: Callable that is called in the child process. (Usualy,
-        this calls execv.)
-    :param bell_func: Called when the process does a `bell`.
-    :param done_callback: Called when the process terminates.
-    :param has_priority: Callable that returns True when this Process should
-        get priority in the event loop. (When this pane has the focus.)
-        Otherwise output can be delayed.
-    """
-    def __init__(self, eventloop, invalidate, exec_func, bell_func=None,
-                 done_callback=None, has_priority=None):
-        assert isinstance(eventloop, EventLoop)
-        assert callable(invalidate)
-        assert callable(exec_func)
-        assert bell_func is None or callable(bell_func)
-        assert done_callback is None or callable(done_callback)
-        assert has_priority is None or callable(has_priority)
-
-        self.eventloop = eventloop
-        self.invalidate = invalidate
-        self.exec_func = exec_func
-        self.done_callback = done_callback
-        self.has_priority = has_priority or (lambda: True)
-
-        self.pid = None
-        self.is_terminated = False
-        self.suspended = False
-
-        # Create pseudo terminal for this pane.
-        self.master, self.slave = os.openpty()
-
-        # Master side -> attached to terminal emulator.
-        self._reader = PosixStdinReader(self.master)
-
-        # Create output stream and attach to screen
-        self.sx = 0
-        self.sy = 0
-
-        self.screen = BetterScreen(self.sx, self.sy,
-                                   write_process_input=self.write_input,
-                                   bell_func=bell_func)
-
-        self.stream = BetterStream(self.screen)
-        self.stream.attach(self.screen)
-
-    def start(self):
-        """
-        Start the process: fork child.
-        """
-        self.set_size(120, 24)
-        self._start()
-        self._connect_reader()
-        self._waitpid()
-
-    @classmethod
-    def from_command(cls, eventloop, invalidate, command, done_callback,
-                     bell_func=None, before_exec_func=None, has_priority=None):
-        """
-        Create Process from command,
-        e.g. command=['python', '-c', 'print("test")']
-
-        :param before_exec_func: Function that is called before `exec` in the process fork.
-        """
-        assert isinstance(command, list)
-
-        def execv():
-            if before_exec_func:
-                before_exec_func()
-
-            for p in os.environ['PATH'].split(':'):
-                path = os.path.join(p, command[0])
-                if os.path.exists(path) and os.access(path, os.X_OK):
-                    os.execv(path, command)
-
-        return cls(eventloop, invalidate, execv,
-                   bell_func=bell_func, done_callback=done_callback,
-                   has_priority=has_priority)
-
-    def _start(self):
-        """
-        Create fork and start the child process.
-        """
-        pid = os.fork()
-
-        if pid == 0:
-            self._in_child()
-        elif pid > 0:
-            # In parent.
-            os.close(self.slave)
-            self.slave = None
-
-            # We wait a very short while, to be sure the child had the time to
-            # call _exec. (Otherwise, we are still sharing signal handlers and
-            # FDs.) Resizing the pty, when the child is still in our Python
-            # code and has the signal handler from prompt_toolkit, but closed
-            # the 'fd' for 'call_from_executor', will cause OSError.
-            time.sleep(0.1)
-
-            self.pid = pid
-
-    def _waitpid(self):
-        """
-        Create an executor that waits and handles process termination.
-        """
-        def wait_for_finished():
-            " Wait for PID in executor. "
-            os.waitpid(self.pid, 0)
-            self.eventloop.call_from_executor(done)
-
-        def done():
-            " PID received. Back in the main thread. "
-            # Close pty and remove reader.
-            os.close(self.master)
-            self.eventloop.remove_reader(self.master)
-            self.master = None
-
-            # Callback.
-            self.is_terminated = True
-            self.done_callback()
-
-        self.eventloop.run_in_executor(wait_for_finished)
-
-    def set_size(self, width, height):
-        """
-        Set terminal size.
-        """
-        assert isinstance(width, int)
-        assert isinstance(height, int)
-
-        if self.master is not None:
-            if (self.sx, self.sy) != (width, height):
-                set_terminal_size(self.master, height, width)
-        self.screen.resize(lines=height, columns=width)
-
-        self.screen.lines = height
-        self.screen.columns = width
-
-        self.sx = width
-        self.sy = height
-
-    def _in_child(self):
-        " Will be executed in the forked child. "
-        os.close(self.master)
-
-        # Remove signal handler for SIGWINCH as early as possible.
-        # (We don't want this to be triggered when execv has not been called
-        # yet.)
-        signal.signal(signal.SIGWINCH, 0)
-
-        pty_make_controlling_tty(self.slave)
-
-        # In the fork, set the stdin/out/err to our slave pty.
-        os.dup2(self.slave, 0)
-        os.dup2(self.slave, 1)
-        os.dup2(self.slave, 2)
-
-        # Execute in child.
-        try:
-            self._close_file_descriptors()
-            self.exec_func()
-        except Exception:
-            traceback.print_exc()
-            time.sleep(5)
-
-            os._exit(1)
-        os._exit(0)
-
-    def _close_file_descriptors(self):
-        # Do not allow child to inherit open file descriptors from parent.
-        # (In case that we keep running Python code. We shouldn't close them.
-        # because the garbage collector is still active, and he will close them
-        # eventually.)
-        max_fd = resource.getrlimit(resource.RLIMIT_NOFILE)[-1]
-
-        try:
-            os.closerange(3, max_fd)
-        except OverflowError:
-            # On OS X, max_fd can return very big values, than closerange
-            # doesn't understand, e.g. 9223372036854775807. In this case, just
-            # use 4096. This is what Linux systems report, and should be
-            # sufficient. (I hope...)
-            os.closerange(3, 4096)
-
-    def write_input(self, data, paste=False):
-        """
-        Write user key strokes to the input.
-
-        :param data: (text, not bytes.) The input.
-        :param paste: When True, and the process running here understands
-            bracketed paste. Send as pasted text.
-        """
-        # send as bracketed paste?
-        if paste and self.screen.bracketed_paste_enabled:
-            data = '\x1b[200~' + data + '\x1b[201~'
-
-        while self.master is not None:
-            try:
-                os.write(self.master, data.encode('utf-8'))
-            except OSError as e:
-                # This happens when the window resizes and a SIGWINCH was received.
-                # We get 'Error: [Errno 4] Interrupted system call'
-                if e.errno == 4:
-                    continue
-            return
-
-    def write_key(self, key):
-        """
-        Write prompt_toolkit Key.
-        """
-        data = prompt_toolkit_key_to_vt100_key(
-            key, application_mode=self.screen.in_application_mode)
-        self.write_input(data)
-
-    def _connect_reader(self):
-        """
-        Process stdout output from the process.
-        """
-        if self.master is not None:
-            self.eventloop.add_reader(self.master, self._read)
-
-    def _read(self):
-        """
-        Read callback, called by the eventloop.
-        """
-        d = self._reader.read(4096)  # Make sure not to read too much at once. (Otherwise,
-                                     # this could block the event loop.)
-
-        if d:
-            def process():
-                self.stream.feed(d)
-                self.invalidate()
-
-            # Feed directly, if this process has priority. (That is when this
-            # pane has the focus in any of the clients.)
-            if self.has_priority():
-                process()
-
-            # Otherwise, postpone processing until we have CPU time available.
-            else:
-                self.eventloop.remove_reader(self.master)
-
-                def do_asap():
-                    " Process output and reconnect to event loop. "
-                    process()
-                    self._connect_reader()
-
-                # When the event loop is saturated because of CPU, we will
-                # postpone this processing max 'x' seconds.
-
-                # '1' seems like a reasonable value, because that way we say
-                # that we will process max 1k/1s in case of saturation.
-                # That should be enough to prevent the UI from feeling
-                # unresponsive.
-                timestamp = datetime.datetime.now() + datetime.timedelta(seconds=1)
-
-                self.eventloop.call_from_executor(
-                    do_asap, _max_postpone_until=timestamp)
-        else:
-            # End of stream. Remove child.
-            self.eventloop.remove_reader(self.master)
-
-    def suspend(self):
-        """
-        Suspend process. Stop reading stdout. (Called when going into copy mode.)
-        """
-        self.suspended = True
-        self.eventloop.remove_reader(self.master)
-
-    def resume(self):
-        """
-        Resume from 'suspend'.
-        """
-        if self.suspended and self.master is not None:
-            self._connect_reader()
-            self.suspended = False
-
-    def get_cwd(self):
-        """
-        The current working directory for this process. (Or `None` when
-        unknown.)
-        """
-        return get_cwd_for_pid(self.pid)
-
-    def get_name(self):
-        """
-        The name for this process. (Or `None` when unknown.)
-        """
-        # TODO: Maybe cache for short time.
-        if self.master is not None:
-            return get_name_for_fd(self.master)
-
-    def send_signal(self, signal):
-        " Send signal to running process. "
-        assert isinstance(signal, int), type(signal)
-
-        if self.pid and not self.is_terminated:
-            try:
-                os.kill(self.pid, signal)
-            except OSError:
-                pass  # [Errno 3] No such process.
-
-    def create_copy_document(self):
-        """
-        Create a Document instance and token list that can be used in copy
-        mode.
-        """
-        data_buffer = self.screen.data_buffer
-        text = []
-        token_lists = []
-
-        first_row = min(data_buffer.keys())
-        last_row = max(data_buffer.keys())
-
-        def token_has_no_background(token):
-            try:
-                # Token looks like ('C', color, bgcolor, bold, underline, ...)
-                return token[2] is None
-            except IndexError:
-                return True
-
-        for lineno in range(first_row, last_row + 1):
-            token_list = []
-
-            row = data_buffer[lineno]
-            max_column = max(row.keys()) if row else 0
-
-            # Remove trailing whitespace. (If the background is transparent.)
-            row_data = [row[x] for x in range(0, max_column + 1)]
-
-            while (row_data and row_data[-1].char.isspace() and
-                   token_has_no_background(row_data[-1].token)):
-                row_data.pop()
-
-            # Walk through row.
-            char_iter = iter(range(len(row_data)))
-
-            for x in char_iter:
-                c = row[x]
-                text.append(c.char)
-                token_list.append((c.token, c.char))
-
-                # Skip next cell when this is a double width character.
-                if c.width == 2:
-                    try:
-                        next(char_iter)
-                    except StopIteration:
-                        pass
-
-            token_lists.append(token_list)
-            text.append('\n')
-
-        def get_tokens_for_line(lineno):
-            try:
-                return token_lists[lineno]
-            except IndexError:
-                return []
-
-        # Calculate cursor position.
-        d = Document(text=''.join(text))
-
-        return Document(text=d.text,
-                        cursor_position=d.translate_row_col_to_index(
-                            row=self.screen.pt_screen.cursor_position.y,
-                            col=self.screen.pt_screen.cursor_position.x)), get_tokens_for_line
-
-
-def get_cwd_for_pid(pid):
-    """
-    Return the current working directory for a given process ID.
-    """
-    if sys.platform in ('linux', 'linux2', 'cygwin'):
-        try:
-            return os.readlink('/proc/%s/cwd' % pid)
-        except OSError:
-            pass
-
-
-if sys.platform in ('linux', 'linux2', 'cygwin'):
-    def get_name_for_fd(fd):
-        """
-        Return the process name for a given process ID.
-        """
-        pgrp = os.tcgetpgrp(fd)
-
-        try:
-            with open('/proc/%s/cmdline' % pgrp, 'rb') as f:
-                return f.read().decode('utf-8', 'ignore').split('\0')[0]
-        except IOError:
-            pass
-elif sys.platform == 'darwin':
-    from .darwin import get_proc_name
-
-    def get_name_for_fd(fd):
-        """
-        Return the process name for a given process ID.
-        """
-        pgrp = os.tcgetpgrp(fd)
-
-        try:
-            return get_proc_name(pgrp)
-        except IOError:
-            pass
-else:
-    def get_name_for_fd(fd):
-        """
-        Return the process name for a given process ID.
-        """
-        return
diff --git a/pymux/rc.py b/pymux/rc.py
index aeeae50..e526b8d 100644
--- a/pymux/rc.py
+++ b/pymux/rc.py
@@ -66,6 +66,7 @@
 bind-key [ copy-mode
 bind-key ] paste-buffer
 bind-key ? list-keys
+bind-key PPage copy-mode -u
 
 # Layouts.
 bind-key M-1 select-layout even-horizontal
diff --git a/pymux/screen.py b/pymux/screen.py
deleted file mode 100644
index cc3fb66..0000000
--- a/pymux/screen.py
+++ /dev/null
@@ -1,980 +0,0 @@
-"""
-Custom `Screen` class for the `pyte` library.
-
-Changes compared to the original `Screen` class:
-    - We store the layout in a prompt_toolkit.layout.screen.Screen instance.
-      This allows fast rendering in a prompt_toolkit user control.
-    - 256 colour and true color support.
-    - CPR support and device attributes.
-"""
-from __future__ import unicode_literals
-from collections import defaultdict
-
-from pyte import charsets as cs
-from pyte import modes as mo
-from pyte.screens import Margins
-from six.moves import range
-
-from prompt_toolkit.cache import FastDictCache
-from prompt_toolkit.layout.screen import Screen, Char
-from prompt_toolkit.styles import Attrs
-from prompt_toolkit.terminal.vt100_output import FG_ANSI_COLORS, BG_ANSI_COLORS
-from prompt_toolkit.terminal.vt100_output import _256_colors as _256_colors_table
-from collections import namedtuple
-
-import copy
-
-__all__ = (
-    'BetterScreen',
-    'DEFAULT_TOKEN',
-)
-
-DEFAULT_TOKEN = ('C', ) + Attrs(color=None, bgcolor=None, bold=False, underline=False,
-                                italic=False, blink=False, reverse=False)
-
-
-class CursorPosition(object):
-    " Mutable CursorPosition. "
-    def __init__(self, x=0, y=0):
-        self.x = x
-        self.y = y
-
-    def __repr__(self):
-        return 'pymux.CursorPosition(x=%r, y=%r)' % (self.x, self.y)
-
-
-_CHAR_CACHE = FastDictCache(Char, size=1000 * 1000)
-
-
-# Custom Savepoint that also stores the Attrs.
-_Savepoint = namedtuple("_Savepoint", [
-    'cursor',
-    'g0_charset',
-    'g1_charset',
-    'charset',
-    'origin',
-    'wrap',
-    'attrs',
-])
-
-
-class BetterScreen(object):
-    """
-    Custom screen class. Most of the methods are called from a vt100 Pyte
-    stream.
-
-    The data buffer is stored in a :class:`prompt_toolkit.layout.screen.Screen`
-    class, because this way, we can send it to the renderer without any
-    transformation.
-    """
-    swap_variables = [
-        'mode',
-        'margins',
-        'charset',
-        'g0_charset',
-        'g1_charset',
-        'tabstops',
-        'data_buffer',
-        'max_y',
-    ]
-
-    def __init__(self, lines, columns, write_process_input, bell_func=None,
-                 get_history_limit=None):
-        assert isinstance(lines, int)
-        assert isinstance(columns, int)
-        assert callable(write_process_input)
-        assert bell_func is None or callable(bell_func)
-        assert get_history_limit is None or callable(get_history_limit)
-
-        bell_func = bell_func or (lambda: None)
-        get_history_limit = get_history_limit or (lambda: 2000)
-
-        self._history_cleanup_counter = 0
-
-        self.savepoints = []
-        self.lines = lines
-        self.columns = columns
-        self.write_process_input = write_process_input
-        self.bell_func = bell_func
-        self.get_history_limit = get_history_limit
-        self.reset()
-
-    @property
-    def in_application_mode(self):
-        """
-        True when we are in application mode. This means that the process is
-        expecting some other key sequences as input. (Like for the arrows.)
-        """
-        # Not in cursor mode.
-        return (1 << 5) in self.mode
-
-    @property
-    def mouse_support_enabled(self):
-        " True when mouse support has been enabled by the application. "
-        return (1000 << 5) in self.mode
-
-    @property
-    def urxvt_mouse_support_enabled(self):
-        return (1015 << 5) in self.mode
-
-    @property
-    def sgr_mouse_support_enabled(self):
-        " Xterm Sgr mouse support. "
-        return (1006 << 5) in self.mode
-
-    @property
-    def bracketed_paste_enabled(self):
-        return (2004 << 5) in self.mode
-
-    @property
-    def has_reverse_video(self):
-        " The whole screen is set to reverse video. "
-        return mo.DECSCNM in self.mode
-
-    def reset(self):
-        """Resets the terminal to its initial state.
-
-        * Scroll margins are reset to screen boundaries.
-        * Cursor is moved to home location -- ``(0, 0)`` and its
-          attributes are set to defaults (see :attr:`default_char`).
-        * Screen is cleared -- each character is reset to
-          :attr:`default_char`.
-        * Tabstops are reset to "every eight columns".
-
-        .. note::
-
-           Neither VT220 nor VT102 manuals mentioned that terminal modes
-           and tabstops should be reset as well, thanks to
-           :manpage:`xterm` -- we now know that.
-        """
-        self._reset_screen()
-
-        self.title = ''
-        self.icon_name = ''
-
-        # Reset modes.
-        self.mode = set([mo.DECAWM, mo.DECTCEM])
-
-        # According to VT220 manual and ``linux/drivers/tty/vt.c``
-        # the default G0 charset is latin-1, but for reasons unknown
-        # latin-1 breaks ascii-graphics; so G0 defaults to cp437.
-
-        # XXX: The comment above comes from the original Pyte implementation,
-        #      it seems for us that LAT1_MAP should indeed be the default, if
-        #      not a French version of Vim would incorrectly show some
-        #      characters.
-        self.charset = 0
-        # self.g0_charset = cs.IBMPC_MAP
-        self.g0_charset = cs.LAT1_MAP
-        self.g1_charset = cs.VT100_MAP
-
-        # From ``man terminfo`` -- "... hardware tabs are initially
-        # set every `n` spaces when the terminal is powered up. Since
-        # we aim to support VT102 / VT220 and linux -- we use n = 8.
-
-        # (We choose to create tab stops until x=1000, because we keep the
-        # tab stops when the screen increases in size. The OS X 'ls' command
-        # relies on the stops to be there.)
-        self.tabstops = set(range(8, 1000, 8))
-
-        # The original Screen instance, when going to the alternate screen.
-        self._original_screen = None
-
-    def _reset_screen(self):
-        """ Reset the Screen content. (also called when switching from/to
-        alternate buffer. """
-        self.pt_screen = Screen(default_char=Char(' ', DEFAULT_TOKEN))
-
-        self.pt_screen.cursor_position = CursorPosition(0, 0)
-        self.pt_screen.show_cursor = True
-
-        self.data_buffer = self.pt_screen.data_buffer
-
-        self._attrs = Attrs(color=None, bgcolor=None, bold=False,
-                            underline=False, italic=False, blink=False, reverse=False)
-
-        self.margins = Margins(0, self.lines - 1)
-
-        self.max_y = 0  # Max 'y' position to which is written.
-
-    def resize(self, lines=None, columns=None):
-        # don't do anything except saving the dimensions
-        lines = lines if lines is not None else self.lines
-        columns = columns if columns is not None else self.columns
-
-        if self.lines != lines or self.columns != columns:
-            self.lines = lines
-            self.columns = columns
-
-            self._reset_offset_and_margins()
-
-    @property
-    def line_offset(self):
-        cpos_y = self.pt_screen.cursor_position.y
-        return max(0, min(cpos_y, self.max_y - self.lines + 1))
-
-    def set_margins(self, top=None, bottom=None):
-        """Selects top and bottom margins for the scrolling region.
-        Margins determine which screen lines move during scrolling
-        (see :meth:`index` and :meth:`reverse_index`). Characters added
-        outside the scrolling region do not cause the screen to scroll.
-        :param int top: the smallest line number that is scrolled.
-        :param int bottom: the biggest line number that is scrolled.
-        """
-        if top is None and bottom is None:
-            return
-
-        top = self.margins.top if top is None else top - 1
-        bottom = self.margins.bottom if bottom is None else bottom - 1
-
-        # Arguments are 1-based, while :attr:`margins` are zero based --
-        # so we have to decrement them by one. We also make sure that
-        # both of them is bounded by [0, lines - 1].
-        top = max(0, min(top, self.lines - 1))
-        bottom = max(0, min(bottom, self.lines - 1))
-
-        # Even though VT102 and VT220 require DECSTBM to ignore regions
-        # of width less than 2, some programs (like aptitude for example)
-        # rely on it. Practicality beats purity.
-        if bottom - top >= 1:
-            self.margins = Margins(top, bottom)
-
-            # The cursor moves to the home position when the top and
-            # bottom margins of the scrolling region (DECSTBM) changes.
-            self.cursor_position()
-
-    def _reset_offset_and_margins(self):
-        """
-        Recalculate offset and move cursor (make sure that the bottom is
-        visible.)
-        """
-        self.margins = Margins(0, self.lines - 1)
-
-    def set_charset(self, code, mode):
-        """Set active ``G0`` or ``G1`` charset.
-
-        :param str code: character set code, should be a character
-                         from ``"B0UK"`` -- otherwise ignored.
-        :param str mode: if ``"("`` ``G0`` charset is set, if
-                         ``")"`` -- we operate on ``G1``.
-
-        .. warning:: User-defined charsets are currently not supported.
-        """
-        if code in cs.MAPS:
-            charset_map = cs.MAPS[code]
-            if mode == '(':
-                self.g0_charset = charset_map
-            elif mode == ')':
-                self.g1_charset = charset_map
-
-    def set_mode(self, *modes, **kwargs):
-        # Private mode codes are shifted, to be distingiushed from non
-        # private ones.
-        if kwargs.get("private"):
-            modes = [mode << 5 for mode in modes]
-
-        self.mode.update(modes)
-
-        # When DECOLM mode is set, the screen is erased and the cursor
-        # moves to the home position.
-        if mo.DECCOLM in modes:
-            self.resize(columns=132)
-            self.erase_in_display(2)
-            self.cursor_position()
-
-        # According to `vttest`, DECOM should also home the cursor, see
-        # vttest/main.c:303.
-        if mo.DECOM in modes:
-            self.cursor_position()
-
-        # Make the cursor visible.
-        if mo.DECTCEM in modes:
-            self.pt_screen.show_cursor = True
-
-        # On "\e[?1049h", enter alternate screen mode. Backup the current state,
-        if (1049 << 5) in modes:
-            self._original_screen = self.pt_screen
-            self._original_screen_vars = \
-                dict((v, getattr(self, v)) for v in self.swap_variables)
-            self._reset_screen()
-            self._reset_offset_and_margins()
-
-    def reset_mode(self, *modes, **kwargs):
-        """Resets (disables) a given list of modes.
-
-        :param list modes: modes to reset -- hopefully, each mode is a
-                           constant from :mod:`pyte.modes`.
-        """
-        # Private mode codes are shifted, to be distingiushed from non
-        # private ones.
-        if kwargs.get("private"):
-            modes = [mode << 5 for mode in modes]
-
-        self.mode.difference_update(modes)
-
-        # Lines below follow the logic in :meth:`set_mode`.
-        if mo.DECCOLM in modes:
-            self.resize(columns=80)
-            self.erase_in_display(2)
-            self.cursor_position()
-
-        if mo.DECOM in modes:
-            self.cursor_position()
-
-        # Hide the cursor.
-        if mo.DECTCEM in modes:
-            self.pt_screen.show_cursor = False
-
-        # On "\e[?1049l", restore from alternate screen mode.
-        if (1049 << 5) in modes and self._original_screen:
-            for k, v in self._original_screen_vars.items():
-                setattr(self, k, v)
-            self.pt_screen = self._original_screen
-
-            self._original_screen = None
-            self._original_screen_vars = {}
-            self._reset_offset_and_margins()
-
-    @property
-    def _in_alternate_screen(self):
-        return bool(self._original_screen)
-
-    def shift_in(self):
-        " Activates ``G0`` character set. "
-        self.charset = 0
-
-    def shift_out(self):
-        " Activates ``G1`` character set. "
-        self.charset = 1
-
-    def draw(self, char):
-        """
-        Draw a single character.
-        """
-        # Aliases for variables that are used more than once in this function.
-        # For better performance. (This draw function is called for every
-        # printable character that a process outputs; it should be as
-        # performant as possible.)
-        pt_screen = self.pt_screen
-        cursor_position = pt_screen.cursor_position
-        cursor_position_x = cursor_position.x
-        cursor_position_y = cursor_position.y
-
-        # Translating a given character.
-        if self.charset:
-            char = char.translate(self.g1_charset)
-        else:
-            char = char.translate(self.g0_charset)
-
-        # Create 'Char' instance.
-        token = ('C', ) + self._attrs
-        pt_char = _CHAR_CACHE[char, token]
-        char_width = pt_char.width
-
-        # If this was the last column in a line and auto wrap mode is
-        # enabled, move the cursor to the beginning of the next line,
-        # otherwise replace characters already displayed with newly
-        # entered.
-        if cursor_position_x >= self.columns:
-            if mo.DECAWM in self.mode:
-                self.carriage_return()
-                self.linefeed()
-            else:
-                cursor_position.x -= char_width
-                cursor_position_x = cursor_position.x
-
-        # If Insert mode is set, new characters move old characters to
-        # the right, otherwise terminal is in Replace mode and new
-        # characters replace old characters at cursor position.
-        if mo.IRM in self.mode:
-            self.insert_characters(char_width)
-
-        row = pt_screen.data_buffer[cursor_position_y]
-        row[cursor_position_x] = pt_char
-
-        if char_width > 1:
-            row[cursor_position_x + 1] = _CHAR_CACHE[' ', token]
-
-        # .. note:: We can't use :meth:`cursor_forward()`, because that
-        #           way, we'll never know when to linefeed.
-        cursor_position.x += char_width
-
-        # Update max_y. (Don't use 'max()' for comparing only two values, that
-        # is less efficient.)
-        if cursor_position_y > self.max_y:
-            self.max_y = cursor_position_y
-
-    def carriage_return(self):
-        " Move the cursor to the beginning of the current line. "
-        self.pt_screen.cursor_position.x = 0
-
-    def index(self):
-        """Move the cursor down one line in the same column. If the
-        cursor is at the last line, create a new line at the bottom.
-        """
-        top, bottom = self.margins
-
-        # When scrolling over the full screen height -> keep history.
-        if top == 0 and bottom >= self.lines - 1:
-            self.cursor_down()
-        else:
-            if self.pt_screen.cursor_position.y - self.line_offset == bottom:
-                for line in range(top, bottom):
-                    self.data_buffer[line + self.line_offset] = \
-                        self.data_buffer[line + self.line_offset + 1]
-                    del self.data_buffer[line + self.line_offset + 1]
-            else:
-                self.cursor_down()
-
-        # Cleanup the history, but only every 100 calls.
-        self._history_cleanup_counter += 1
-        if self._history_cleanup_counter == 100:
-            self._remove_old_lines_from_history()
-            self._history_cleanup_counter = 0
-
-    def _remove_old_lines_from_history(self):
-        """
-        Remove top from the scroll buffer. (Outside bounds of history limit.)
-        """
-        remove_above = max(0, self.pt_screen.cursor_position.y - self.get_history_limit())
-        data_buffer = self.pt_screen.data_buffer
-        for line in list(data_buffer):
-            if line < remove_above:
-                del data_buffer[line]
-
-    def clear_history(self):
-        """
-        Delete all history from the scroll buffer.
-        """
-        for line in list(self.data_buffer):
-            if line < self.line_offset:
-                del self.data_buffer[line]
-
-    def reverse_index(self):
-        top, bottom = self.margins
-        line_offset = self.line_offset
-
-        # When scrolling over the full screen -> keep history.
-        if self.pt_screen.cursor_position.y - line_offset == top:
-            for i in range(bottom - 1, top - 1, -1):
-                self.data_buffer[i + line_offset + 1] = self.data_buffer[i + line_offset]
-                del self.data_buffer[i + line_offset]
-        else:
-            self.cursor_up()
-
-    def linefeed(self):
-        """Performs an index and, if :data:`~pyte.modes.LNM` is set, a
-        carriage return.
-        """
-        self.index()
-
-        if mo.LNM in self.mode:
-            self.carriage_return()
-
-        self.ensure_bounds()
-
-    def next_line(self):
-        """ When `EscE` has been received. Go to the next line, even when LNM has
-        not been set. """
-        self.index()
-        self.carriage_return()
-        self.ensure_bounds()
-
-    def tab(self):
-        """Move to the next tab space, or the end of the screen if there
-        aren't anymore left.
-        """
-        for stop in sorted(self.tabstops):
-            if self.pt_screen.cursor_position.x < stop:
-                column = stop
-                break
-        else:
-            column = self.columns - 1
-
-        self.pt_screen.cursor_position.x = column
-
-    def backspace(self):
-        """Move cursor to the left one or keep it in it's position if
-        it's at the beginning of the line already.
-        """
-        self.cursor_back()
-
-    def save_cursor(self):
-        """Push the current cursor position onto the stack."""
-        self.savepoints.append(_Savepoint(
-            copy.copy(self.pt_screen.cursor_position),
-            self.g0_charset,
-            self.g1_charset,
-            self.charset,
-            mo.DECOM in self.mode,
-            mo.DECAWM in self.mode,
-            self._attrs))
-
-    def restore_cursor(self):
-        """Set the current cursor position to whatever cursor is on top
-        of the stack.
-        """
-        if self.savepoints:
-            savepoint = self.savepoints.pop()
-
-            self.g0_charset = savepoint.g0_charset
-            self.g1_charset = savepoint.g1_charset
-            self.charset = savepoint.charset
-            self._attrs = savepoint.attrs
-
-            if savepoint.origin:
-                self.set_mode(mo.DECOM)
-            if savepoint.wrap:
-                self.set_mode(mo.DECAWM)
-
-            self.pt_screen.cursor_position = savepoint.cursor
-            self.ensure_bounds(use_margins=True)
-        else:
-            # If nothing was saved, the cursor moves to home position;
-            # origin mode is reset. :todo: DECAWM?
-            self.reset_mode(mo.DECOM)
-            self.cursor_position()
-
-    def insert_lines(self, count=None):
-        """Inserts the indicated # of lines at line with cursor. Lines
-        displayed **at** and below the cursor move down. Lines moved
-        past the bottom margin are lost.
-
-        :param count: number of lines to delete.
-        """
-        count = count or 1
-        top, bottom = self.margins
-
-        # If cursor is outside scrolling margins it -- do nothing.
-        if top <= self.pt_screen.cursor_position.y - self.line_offset <= bottom:
-            for line in range(bottom, self.pt_screen.cursor_position.y - self.line_offset, -1):
-                if line - count < top:
-                    try:
-                        del self.data_buffer[line + self.line_offset]
-                    except KeyError:
-                        pass
-                else:
-                    self.data_buffer[line + self.line_offset] = self.data_buffer[line + self.line_offset - count]
-                    try:
-                        del self.data_buffer[line + self.line_offset - count]
-                    except KeyError:
-                        pass
-
-            self.carriage_return()
-
-    def delete_lines(self, count=None):
-        """Deletes the indicated # of lines, starting at line with
-        cursor. As lines are deleted, lines displayed below cursor
-        move up. Lines added to bottom of screen have spaces with same
-        character attributes as last line moved up.
-
-        :param int count: number of lines to delete.
-        """
-        count = count or 1
-        top, bottom = self.margins
-
-        # If cursor is outside scrolling margins it -- do nothin'.
-        if top <= self.pt_screen.cursor_position.y - self.line_offset <= bottom:
-            # Iterate from the cursor Y position until the end of the visible input.
-            for line in range(self.pt_screen.cursor_position.y - self.line_offset, bottom + 1):
-
-                # When 'x' lines further are out of the margins, replace by an empty line,
-                # Otherwise copy the line from there.
-                if line + count > bottom:
-                    del self.data_buffer[line + self.line_offset]
-                else:
-                    self.data_buffer[line + self.line_offset] = self.data_buffer[line + count + self.line_offset]
-
-    def insert_characters(self, count=None):  # XXX: used by pressing space in bash vi mode
-        """Inserts the indicated # of blank characters at the cursor
-        position. The cursor does not move and remains at the beginning
-        of the inserted blank characters. Data on the line is shifted
-        forward.
-
-        :param int count: number of characters to insert.
-        """
-        count = count or 1
-
-        line = self.data_buffer[self.pt_screen.cursor_position.y]
-
-        if line:
-            max_columns = max(line.keys())
-
-            for i in range(max_columns, self.pt_screen.cursor_position.x - 1, -1):
-                line[i + count] = line[i]
-                del line[i]
-
-    def delete_characters(self, count=None):
-        count = count or 1
-
-        line = self.data_buffer[self.pt_screen.cursor_position.y]
-        if line:
-            max_columns = max(line.keys())
-
-            for i in range(self.pt_screen.cursor_position.x, max_columns + 1):
-                line[i] = line[i + count]
-                del line[i + count]
-
-    def cursor_position(self, line=None, column=None):
-        """Set the cursor to a specific `line` and `column`.
-
-        Cursor is allowed to move out of the scrolling region only when
-        :data:`~pyte.modes.DECOM` is reset, otherwise -- the position
-        doesn't change.
-
-        :param int line: line number to move the cursor to.
-        :param int column: column number to move the cursor to.
-        """
-        column = (column or 1) - 1
-        line = (line or 1) - 1
-
-        # If origin mode (DECOM) is set, line number are relative to
-        # the top scrolling margin.
-        if mo.DECOM in self.mode:
-            line += self.margins.top
-
-            # Cursor is not allowed to move out of the scrolling region.
-            if not (self.margins.top <= line <= self.margins.bottom):
-                return
-
-        self.pt_screen.cursor_position.x = column
-        self.pt_screen.cursor_position.y = line + self.line_offset
-        self.ensure_bounds()
-
-    def cursor_to_column(self, column=None):
-        """Moves cursor to a specific column in the current line.
-
-        :param int column: column number to move the cursor to.
-        """
-        self.pt_screen.cursor_position.x = (column or 1) - 1
-        self.ensure_bounds()
-
-    def cursor_to_line(self, line=None):
-        """Moves cursor to a specific line in the current column.
-
-        :param int line: line number to move the cursor to.
-        """
-        self.pt_screen.cursor_position.y = (line or 1) - 1 + self.line_offset
-
-        # If origin mode (DECOM) is set, line number are relative to
-        # the top scrolling margin.
-        if mo.DECOM in self.mode:
-            self.pt_screen.cursor_position.y += self.margins.top
-
-            # FIXME: should we also restrict the cursor to the scrolling
-            # region?
-
-        self.ensure_bounds()
-
-    def bell(self, *args):
-        " Bell "
-        self.bell_func()
-
-    def cursor_down(self, count=None):
-        """Moves cursor down the indicated # of lines in same column.
-        Cursor stops at bottom margin.
-
-        :param int count: number of lines to skip.
-        """
-        self.pt_screen.cursor_position.y += count or 1
-        self.ensure_bounds(use_margins=True)
-
-        self.max_y = max(self.max_y, self.pt_screen.cursor_position.y)
-
-    def cursor_down1(self, count=None):
-        """Moves cursor down the indicated # of lines to column 1.
-        Cursor stops at bottom margin.
-
-        :param int count: number of lines to skip.
-        """
-        self.cursor_down(count)
-        self.carriage_return()
-
-    def cursor_up(self, count=None):
-        """Moves cursor up the indicated # of lines in same column.
-        Cursor stops at top margin.
-
-        :param int count: number of lines to skip.
-        """
-        self.pt_screen.cursor_position.y -= count or 1
-        self.ensure_bounds(use_margins=True)
-
-    def cursor_up1(self, count=None):
-        """Moves cursor up the indicated # of lines to column 1. Cursor
-        stops at bottom margin.
-
-        :param int count: number of lines to skip.
-        """
-        self.cursor_up(count)
-        self.carriage_return()
-
-    def cursor_back(self, count=None):
-        """Moves cursor left the indicated # of columns. Cursor stops
-        at left margin.
-
-        :param int count: number of columns to skip.
-        """
-        self.pt_screen.cursor_position.x = max(
-            0, self.pt_screen.cursor_position.x - (count or 1))
-        self.ensure_bounds()
-
-    def cursor_forward(self, count=None):
-        """Moves cursor right the indicated # of columns. Cursor stops
-        at right margin.
-
-        :param int count: number of columns to skip.
-        """
-        self.pt_screen.cursor_position.x += count or 1
-        self.ensure_bounds()
-
-    def erase_characters(self, count=None):
-        """Erases the indicated # of characters, starting with the
-        character at cursor position. Character attributes are set
-        cursor attributes. The cursor remains in the same position.
-
-        :param int count: number of characters to erase.
-
-        .. warning::
-
-           Even though *ALL* of the VTXXX manuals state that character
-           attributes **should be reset to defaults**, ``libvte``,
-           ``xterm`` and ``ROTE`` completely ignore this. Same applies
-           too all ``erase_*()`` and ``delete_*()`` methods.
-        """
-        count = count or 1
-        cursor_position = self.pt_screen.cursor_position
-        row = self.data_buffer[cursor_position.y]
-
-        for column in range(cursor_position.x,
-                            min(cursor_position.x + count, self.columns)):
-            row[column] = Char(token=row[column].token)
-
-    def erase_in_line(self, type_of=0, private=False):
-        """Erases a line in a specific way.
-
-        :param int type_of: defines the way the line should be erased in:
-
-            * ``0`` -- Erases from cursor to end of line, including cursor
-              position.
-            * ``1`` -- Erases from beginning of line to cursor,
-              including cursor position.
-            * ``2`` -- Erases complete line.
-        :param bool private: when ``True`` character attributes aren left
-                             unchanged **not implemented**.
-        """
-        if type_of == 2:
-            # Delete line completely.
-            del self.data_buffer[self.pt_screen.cursor_position.y]
-        else:
-            line = self.data_buffer[self.pt_screen.cursor_position.y]
-
-            def should_we_delete(column):  # TODO: check for off-by-one errors!
-                if type_of == 0:
-                    return column >= self.pt_screen.cursor_position.x
-                if type_of == 1:
-                    return column <= self.pt_screen.cursor_position.x
-
-            for column in list(line.keys()):
-                if should_we_delete(column):
-                    del line[column]
-
-    def erase_in_display(self, type_of=0, private=False):
-        """Erases display in a specific way.
-
-        :param int type_of: defines the way the line should be erased in:
-
-            * ``0`` -- Erases from cursor to end of screen, including
-              cursor position.
-            * ``1`` -- Erases from beginning of screen to cursor,
-              including cursor position.
-            * ``2`` -- Erases complete display. All lines are erased
-              and changed to single-width. Cursor does not move.
-            * ``3`` -- Erase saved lines. (Xterm) Clears the history.
-        :param bool private: when ``True`` character attributes aren left
-                             unchanged **not implemented**.
-        """
-        if type_of == 3:
-            # Clear data buffer.
-            for y in list(self.data_buffer):
-                del self.data_buffer[y]
-
-            # Reset line_offset.
-            self.pt_screen.cursor_position.y -= self.line_offset
-#            self.line_offset = 0
-        else:
-            try:
-                interval = (
-                    # a) erase from cursor to the end of the display, including
-                    # the cursor,
-                    range(self.pt_screen.cursor_position.y + 1, self.line_offset + self.lines),
-                    # b) erase from the beginning of the display to the cursor,
-                    # including it,
-                    range(self.line_offset, self.pt_screen.cursor_position.y),
-                    # c) erase the whole display.
-                    range(self.line_offset, self.line_offset + self.lines)
-                )[type_of]
-            except IndexError:
-                return
-
-            for line in interval:
-                self.data_buffer[line] = defaultdict(lambda: Char(' '))
-
-            # In case of 0 or 1 we have to erase the line with the cursor.
-            if type_of in [0, 1]:
-                self.erase_in_line(type_of)
-
-    def set_tab_stop(self):
-        " Set a horizontal tab stop at cursor position. "
-        self.tabstops.add(self.pt_screen.cursor_position.x)
-
-    def clear_tab_stop(self, type_of=None):
-        """Clears a horizontal tab stop in a specific way, depending
-        on the ``type_of`` value:
-        * ``0`` or nothing -- Clears a horizontal tab stop at cursor
-          position.
-        * ``3`` -- Clears all horizontal tab stops.
-        """
-        if not type_of:
-            # Clears a horizontal tab stop at cursor position, if it's
-            # present, or silently fails if otherwise.
-            self.tabstops.discard(self.pt_screen.cursor_position.x)
-        elif type_of == 3:
-            self.tabstops = set()  # Clears all horizontal tab stops.
-
-    def ensure_bounds(self, use_margins=None):
-        """Ensure that current cursor position is within screen bounds.
-
-        :param bool use_margins: when ``True`` or when
-                                 :data:`~pyte.modes.DECOM` is set,
-                                 cursor is bounded by top and and bottom
-                                 margins, instead of ``[0; lines - 1]``.
-        """
-        if use_margins or mo.DECOM in self.mode:
-            top, bottom = self.margins
-        else:
-            top, bottom = 0, self.lines - 1
-
-        cursor_position = self.pt_screen.cursor_position
-
-        cursor_position.x = min(max(0, cursor_position.x), self.columns - 1)
-        cursor_position.y = min(max(top + self.line_offset, cursor_position.y),
-                                bottom + self.line_offset + 1)
-
-    def alignment_display(self):
-        for y in range(0, self.lines):
-            line = self.data_buffer[y + self.line_offset]
-            for x in range(0, self.columns):
-                line[x] = Char('E')
-
-    # Mapping of the ANSI color codes to their names.
-    _fg_colors = dict((v, k) for k, v in FG_ANSI_COLORS.items())
-    _bg_colors = dict((v, k) for k, v in BG_ANSI_COLORS.items())
-
-    # Mapping of the escape codes for 256colors to their 'ffffff' value.
-    _256_colors = {}
-
-    for i, (r, g, b) in enumerate(_256_colors_table.colors):
-        _256_colors[1024 + i] = '%02x%02x%02x' % (r, g, b)
-
-    def select_graphic_rendition(self, *attrs):
-        """ Support 256 colours """
-        replace = {}
-
-        if not attrs:
-            attrs = [0]
-        else:
-            attrs = list(attrs[::-1])
-
-        while attrs:
-            attr = attrs.pop()
-
-            if attr in self._fg_colors:
-                replace["color"] = self._fg_colors[attr]
-            elif attr in self._bg_colors:
-                replace["bgcolor"] = self._bg_colors[attr]
-            elif attr == 1:
-                replace["bold"] = True
-            elif attr == 3:
-                replace["italic"] = True
-            elif attr == 4:
-                replace["underline"] = True
-            elif attr == 5:
-                replace["blink"] = True
-            elif attr == 6:
-                replace["blink"] = True  # Fast blink.
-            elif attr == 7:
-                replace["reverse"] = True
-            elif attr == 22:
-                replace["bold"] = False
-            elif attr == 23:
-                replace["italic"] = False
-            elif attr == 24:
-                replace["underline"] = False
-            elif attr == 25:
-                replace["blink"] = False
-            elif attr == 27:
-                replace["reverse"] = False
-            elif not attr:
-                replace = {}
-                self._attrs = Attrs(color=None, bgcolor=None, bold=False,
-                                    underline=False, italic=False, blink=False, reverse=False)
-
-            elif attr in (38, 48):
-                n = attrs.pop()
-
-                # 256 colors.
-                if n == 5:
-                    if attr == 38:
-                        m = attrs.pop()
-                        replace["color"] = self._256_colors.get(1024 + m)
-                    elif attr == 48:
-                        m = attrs.pop()
-                        replace["bgcolor"] = self._256_colors.get(1024 + m)
-
-                # True colors.
-                if n == 2:
-                    try:
-                        color_str = '%02x%02x%02x' % (attrs.pop(), attrs.pop(), attrs.pop())
-                    except IndexError:
-                        pass
-                    else:
-                        if attr == 38:
-                            replace["color"] = color_str
-                        elif attr == 48:
-                            replace["bgcolor"] = color_str
-
-        self._attrs = self._attrs._replace(**replace)
-
-    def square_close(self, data):
-        # Xterm title / icon name.
-        if data.startswith(('0;', '2;')):
-            self.title = data[2:]
-        elif data.startswith('1;'):
-            self.icon_name = data[2:]
-
-    def report_device_status(self, data):
-        """
-        Report cursor position.
-        """
-        if data == 6:
-            y = self.pt_screen.cursor_position.y - self.line_offset + 1
-            x = self.pt_screen.cursor_position.x + 1
-
-            response = '\x1b[%i;%iR' % (y, x)
-            self.write_process_input(response)
-
-    def report_device_attributes(self, data):
-        response = '\x1b[>84;0;0c'
-        self.write_process_input(response)
-
-    def charset_default(self, *a, **kw):
-        " Not implemented. "
-
-    def  charset_utf8(self, *a, **kw):
-        " Not implemented. "
-
-    def debug(self, *args, **kwargs):
-        pass
-
-    def dummy(self, *a, **kw):
-        pass
diff --git a/pymux/server.py b/pymux/server.py
index bcdddf0..c036905 100644
--- a/pymux/server.py
+++ b/pymux/server.py
@@ -1,19 +1,18 @@
 from __future__ import unicode_literals
-import getpass
 import json
-import socket
-import tempfile
 
+from prompt_toolkit.application.current import set_app
+from prompt_toolkit.eventloop import ensure_future, From
+from prompt_toolkit.input.vt100_parser import Vt100Parser
 from prompt_toolkit.layout.screen import Size
-from prompt_toolkit.terminal.vt100_input import InputStream
-from prompt_toolkit.terminal.vt100_output import Vt100_Output
-from prompt_toolkit.input import Input
+from prompt_toolkit.output.vt100 import Vt100_Output
+from prompt_toolkit.utils import is_windows
 
 from .log import logger
+from .pipes import BrokenPipeError
 
 __all__ = (
     'ServerConnection',
-    'bind_socket',
 )
 
 
@@ -21,47 +20,51 @@ class ServerConnection(object):
     """
     For each client that connects, we have one instance of this class.
     """
-    def __init__(self, pymux, connection, client_address):
+    def __init__(self, pymux, pipe_connection):
         self.pymux = pymux
-        self.connection = connection
-        self.client_address = client_address
+
+        self.pipe_connection = pipe_connection
+
         self.size = Size(rows=20, columns=80)
         self._closed = False
 
         self._recv_buffer = b''
-        self.cli = None
-        self._inputstream = InputStream(
-            lambda key: self.cli.input_processor.feed_key(key))
+        self.client_state = None
 
-        pymux.eventloop.add_reader(
-            connection.fileno(), self._recv)
+        def feed_key(key):
+            self.client_state.app.key_processor.feed(key)
+            self.client_state.app.key_processor.process_keys()
 
-    def _recv(self):
-        """
-        Data received from the client.
-        (Parse it.)
-        """
-        # Read next chunk.
-        data = self.connection.recv(1024)
-
-        if data == b'':
-            # End of file. Close connection.
-            self.detach_and_close()
-        else:
-            # Receive and process packets.
-            self._recv_buffer += data
-
-            while b'\0' in self._recv_buffer:
-                # Zero indicates end of packet.
-                pos = self._recv_buffer.index(b'\0')
-                self._process(self._recv_buffer[:pos])
-                self._recv_buffer = self._recv_buffer[pos + 1:]
+        self._inputstream = Vt100Parser(feed_key)
+        self._pipeinput = _ClientInput(self._send_packet)
+
+        ensure_future(self._start_reading())
+
+    def _start_reading(self):
+        while True:
+            try:
+                data = yield From(self.pipe_connection.read())
+                self._process(data)
+            except BrokenPipeError:
+                self.detach_and_close()
+                break
+
+            except Exception as e:
+                import traceback; traceback.print_stack()
+                print('got exception ', repr(e))
+                break
 
     def _process(self, data):
         """
         Process packet received from client.
         """
-        packet = json.loads(data.decode('utf-8'))
+        try:
+            packet = json.loads(data)
+        except ValueError:
+            # So far, this never happened. But it would be good to have some
+            # protection.
+            logger.warning('Received invalid JSON from client. Ignoring.')
+            return
 
         # Handle commands.
         if packet['cmd'] == 'run-command':
@@ -69,10 +72,10 @@ def _process(self, data):
 
         # Handle stdin.
         elif packet['cmd'] == 'in':
-            self._inputstream.feed(packet['data'])
+            self._pipeinput.send_text(packet['data'])
 
-        elif packet['cmd'] == 'flush-input':
-            self._inputstream.flush()  # Flush escape key.
+#        elif packet['cmd'] == 'flush-input':
+#            self._inputstream.flush()  # Flush escape key.  # XXX: I think we no longer need this.
 
         # Set size. (The client reports the size.)
         elif packet['cmd'] == 'size':
@@ -83,30 +86,37 @@ def _process(self, data):
         # Start GUI. (Create CommandLineInterface front-end for pymux.)
         elif packet['cmd'] == 'start-gui':
             detach_other_clients = bool(packet['detach-others'])
-            true_color = bool(packet['true-color'])
+            color_depth = packet['color-depth']
             term = packet['term']
 
             if detach_other_clients:
                 for c in self.pymux.connections:
                     c.detach_and_close()
 
-            self._create_cli(true_color=true_color, term=term)
+            print('Create app...')
+            self._create_app(color_depth=color_depth, term=term)
 
     def _send_packet(self, data):
         """
         Send packet to client.
         """
-        try:
-            self.connection.send(json.dumps(data).encode('utf-8') + b'\0')
-        except socket.error:
-            if not self._closed:
+        if self._closed:
+            return
+
+        data = json.dumps(data)
+
+        def send():
+            try:
+                yield From(self.pipe_connection.write(data))
+            except BrokenPipeError:
                 self.detach_and_close()
+        ensure_future(send())
 
     def _run_command(self, packet):
         """
         Execute a run command from the client.
         """
-        create_temp_cli = self.cli is None
+        create_temp_cli = self.client_states is None
 
         if create_temp_cli:
             # If this client doesn't have a CLI. Create a Fake CLI where the
@@ -114,80 +124,59 @@ def _run_command(self, packet):
             # will be removed before the render function is called, so it doesn't
             # hurt too much and makes the code easier.)
             pane_id = int(packet['pane_id'])
-            self._create_cli()
-            self.pymux.arrangement.set_active_window_from_pane_id(self.cli, pane_id)
+            self._create_app()
+            with set_app(self.client_state.app):
+                self.pymux.arrangement.set_active_window_from_pane_id(pane_id)
 
-        try:
-            self.pymux.handle_command(self.cli, packet['data'])
-        finally:
-            self._close_cli()
+        with set_app(self.client_state.app):
+            try:
+                self.pymux.handle_command(packet['data'])
+            finally:
+                self._close_connection()
 
-    def _create_cli(self, true_color=False, term='xterm'):
+    def _create_app(self, color_depth, term='xterm'):
         """
         Create CommandLineInterface for this client.
         Called when the client wants to attach the UI to the server.
         """
         output = Vt100_Output(_SocketStdout(self._send_packet),
                               lambda: self.size,
-                              true_color=true_color,
-                              term=term)
-        input = _ClientInput(self._send_packet)
-        self.cli = self.pymux.create_cli(self, output, input)
-
-    def _close_cli(self):
-        if self in self.pymux.clis:
-            del self.pymux.clis[self]
+                              term=term,
+                              write_binary=False)
+
+        self.client_state = self.pymux.add_client(
+            input=self._pipeinput, output=output, connection=self, color_depth=color_depth)
+
+        print('Start running app...')
+        future = self.client_state.app.run_async()
+        print('Start running app got future...', future)
+
+        @future.add_done_callback
+        def done(_):
+            print('APP DONE.........')
+            print(future.result())
+            self._close_connection()
+
+    def _close_connection(self):
+        # This is important. If we would forget this, the server will
+        # render CLI output for clients that aren't connected anymore.
+        self.pymux.remove_client(self)
+        self.client_state = None
+        self._closed = True
 
-        self.cli = None
+        # Remove from eventloop.
+        self.pipe_connection.close()
 
     def suspend_client_to_background(self):
         """
         Ask the client to suspend itself. (Like, when Ctrl-Z is pressed.)
         """
-        if self.cli:
-            def suspend():
-                self._send_packet({'cmd': 'suspend'})
-
-            self.cli.run_in_terminal(suspend)
+        self._send_packet({'cmd': 'suspend'})
 
     def detach_and_close(self):
         # Remove from Pymux.
-        self.pymux.connections.remove(self)
+        self._close_connection()
 
-        # Remove from eventloop.
-        self.pymux.eventloop.remove_reader(self.connection.fileno())
-        self.connection.close()
-
-        self._closed = True
-
-
-def bind_socket(socket_name=None):
-    """
-    Find a socket to listen on and return it.
-
-    Returns (socket_name, sock_obj)
-    """
-    s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-
-    if socket_name:
-        s.bind(socket_name)
-        return socket_name, s
-    else:
-        i = 0
-        while True:
-            try:
-                socket_name = '%s/pymux.sock.%s.%i' % (
-                    tempfile.gettempdir(), getpass.getuser(), i)
-                s.bind(socket_name)
-                return socket_name, s
-            except (OSError, socket.error):
-                i += 1
-
-                # When 100 times failed, cancel server
-                if i == 100:
-                    logger.warning('100 times failed to listen on posix socket. '
-                                   'Please clean up old sockets.')
-                    raise
 
 
 class _SocketStdout(object):
@@ -209,20 +198,22 @@ def flush(self):
         self._buffer = []
 
 
-class _ClientInput(Input):
+if is_windows():
+    from prompt_toolkit.input.win32_pipe import Win32PipeInput as PipeInput
+else:
+    from prompt_toolkit.input.posix_pipe import PosixPipeInput as PipeInput
+
+class _ClientInput(PipeInput):
     """
     Input class that can be given to the CommandLineInterface.
     We only need this for turning the client into raw_mode/cooked_mode.
     """
     def __init__(self, send_packet):
+        super(_ClientInput, self).__init__()
         assert callable(send_packet)
         self.send_packet = send_packet
 
-    def fileno(self):
-        raise NotImplementedError
-
-    def read(self):
-        raise NotImplementedError
+    # Implement raw/cooked mode by sending this to the attached client.
 
     def raw_mode(self):
         return self._create_context_manager('raw')
diff --git a/pymux/stream.py b/pymux/stream.py
deleted file mode 100644
index 53de144..0000000
--- a/pymux/stream.py
+++ /dev/null
@@ -1,169 +0,0 @@
-"""
-Improvements on Pyte.
-"""
-from __future__ import unicode_literals
-from pyte.streams import Stream
-from pyte.escape import NEL
-from pyte import control as ctrl
-from collections import defaultdict
-
-from .log import logger
-
-__all__ = (
-    'BetterStream',
-)
-
-
-class BetterStream(Stream):
-    """
-    Extension to the Pyte `Stream` class that also handles "Esc]<num>...BEL"
-    sequences. This is used by xterm to set the terminal title.
-    """
-    escape = Stream.escape.copy()
-    escape.update({
-        # Call next_line instead of line_feed. We always want to go to the left
-        # margin if we receive this, unlike \n, which goes one row down.
-        # (Except when LNM has been set.)
-        NEL: "next_line",
-    })
-
-    def __init__(self, screen):
-        super(BetterStream, self).__init__()
-        self.listener = screen
-
-        self._validate_screen()
-
-        # Start parser.
-        self._parser = self._parser_generator()
-        self._parser.send(None)
-        self._send = self._parser.send
-
-    def _validate_screen(self):
-        """
-        Check whether our Screen class has all the required callbacks.
-        (We want to verify this statically, before feeding content to the
-        screen.)
-        """
-        for d in [self.basic, self.escape, self.sharp, self.percent, self.csi]:
-            for name in d.values():
-                assert hasattr(self.listener, name), 'Screen is missing %r' % name
-
-    def feed(self, chars):
-        """
-        Custom, much more efficient 'feed' function.
-        """
-        # Send all input to the parser coroutine.
-        send = self._send
-
-        for c in chars:
-            send(c)
-
-    def _parser_generator(self):
-        """
-        Coroutine that processes VT100 output.
-
-        It's actually a state machine, implemented as a coroutine. So all the
-        'state' that we have is stored in local variables.
-
-        This generator is not the most beautiful, but it is as performant as
-        possible. When a process generates a lot of output (That is often much
-        more than a person would give as input), then this will be the
-        bottleneck, because it processes just one character at a time.
-
-        We did many manual optimizations to this function in order to make it
-        as efficient as possible. Don't change anything without profiling
-        first.
-        """
-        listener = self.listener
-        draw = listener.draw
-
-        # In order to avoid getting KeyError exceptions below, we make sure that
-        # these dictionaries resolve to 'Screen.dummy'
-        basic = defaultdict(lambda: 'dummy', self.basic)
-        escape = defaultdict(lambda: 'dummy', self.escape)
-        sharp = defaultdict(lambda: 'dummy', self.sharp)
-        percent = defaultdict(lambda: 'dummy', self.percent)
-        csi = defaultdict(lambda: 'dummy', self.csi)
-
-        ESC = ctrl.ESC
-        CSI = ctrl.CSI
-        CTRL_SEQUENCES_ALLOWED_IN_CSI = set([
-            ctrl.BEL, ctrl.BS, ctrl.HT, ctrl.LF, ctrl.VT, ctrl.FF, ctrl.CR])
-        NOT_DRAW = set([ESC, CSI, ctrl.NUL, ctrl.DEL]) | set(basic)
-
-        def dispatch(event, *args, **flags):
-            getattr(listener, event)(*args, **flags)
-
-        while True:
-            char = yield
-
-            # Handle normal draw operations first. (All overhead here is the
-            # most expensive.)
-            while char not in NOT_DRAW:
-                draw(char)
-                char = yield
-
-            if char == ESC:  # \x1b
-                char = yield
-
-                if char == '[':
-                    char = CSI  # Go to CSI.
-                else:
-                    if char == '#':
-                        dispatch(sharp[(yield)])
-                    elif char == '%':
-                        dispatch(percent[(yield)])
-                    elif char in '()':
-                        listener.set_charset((yield), mode=char)
-                    elif char == ']':
-                        data = []
-                        while True:
-                            c = yield
-                            if c == '\07':
-                                break
-                            else:
-                                data.append(c)
-                        listener.square_close(''.join(data))
-                    else:
-                        dispatch(escape[char])
-                    continue  # Do not go to CSI.
-
-            if char in basic:  # 'if', not 'elif', because we need to be
-                               # able to jump here from Esc[ above in the CSI
-                               # section below.
-                dispatch(basic[char])
-
-            elif char == CSI:  # \x9b
-                current = ''
-                params = []
-                private = False
-
-                while True:
-                    char = yield
-                    if char == '?':
-                        private = True
-                    elif char in CTRL_SEQUENCES_ALLOWED_IN_CSI:
-                        dispatch(basic[char])
-                    elif char in (ctrl.SP, '>'):
-                        # Ignore '>' because of 'ESC[>c' (Send device attributes.)
-                        pass
-                    elif char.isdigit():
-                        current += char
-                    else:
-                        params.append(min(int(current or 0), 9999))
-
-                        if char == ';':
-                            current = ''
-                        else:
-                            try:
-                                if private:
-                                    dispatch(csi[char], *params, private=True)
-                                else:
-                                    dispatch(csi[char], *params)
-                            except TypeError:
-                                # Handler doesn't take params or private attribute.
-                                # (Not the cleanest way to handle this, but
-                                # it's safe and performant enough.)
-                                logger.warning('Dispatch %s failed. params=%s, private=%s',
-                                               params, private)
-                            break  # Break outside CSI loop.
diff --git a/pymux/style.py b/pymux/style.py
index d0d0527..b39ddb9 100644
--- a/pymux/style.py
+++ b/pymux/style.py
@@ -2,88 +2,75 @@
 The color scheme.
 """
 from __future__ import unicode_literals
-from prompt_toolkit.styles import style_from_dict, Style, Attrs
-from prompt_toolkit.token import Token
+from prompt_toolkit.styles import Style, Priority
 
 __all__ = (
-    'PymuxStyle',
+    'ui_style',
 )
 
 
-ui_style = {
-    Token.Line:                         '#888888',
-    Token.Line.Focussed:                '#448844',
+ui_style = Style.from_dict({
+    'border':                         '#888888',
+    'terminal.focused border':      'ansigreen bold',
 
-    Token.TitleBar:                     'bg:#888888 #dddddd ',
-    Token.TitleBar.Title:               '',
-    Token.TitleBar.Name:                '#ffffff noitalic',
-    Token.TitleBar.Name.Focussed:       'bg:#88aa44',
-    Token.TitleBar.Line:                '#444444',
-    Token.TitleBar.Line.Focussed:       '#448844 noinherit',
-    Token.TitleBar.Focussed:            'bg:#5f875f #ffffff bold',
-    Token.TitleBar.Focussed.Title:      '',
-    Token.TitleBar.Zoom:                'bg:#884400 #ffffff',
-    Token.TitleBar.PaneIndex:           '',
-    Token.TitleBar.CopyMode:            'bg:#88aa88 #444444',
-    Token.TitleBar.CopyMode.Position:   '',
+    #'terminal titleba':            'bg:#aaaaaa #dddddd ',
+    'terminal titlebar':            'bg:#888888 #ffffff',
+#    'terminal titlebar paneindex':  'bg:#888888 #000000',
 
-    Token.TitleBar.Focussed.PaneIndex:         'bg:#88aa44 #ffffff',
-    Token.TitleBar.Focussed.CopyMode:          'bg:#aaff44 #000000',
-    Token.TitleBar.Focussed.CopyMode.Position: '#888888',
+    'terminal.focused titlebar':   'bg:#448844 #ffffff',
+    'terminal.focused titlebar name':   'bg:#88aa44 #ffffff',
+    'terminal.focused titlebar paneindex':         'bg:#ff0000',
 
-    Token.CommandLine:                  'bg:#4e4e4e #ffffff',
-    Token.CommandLine.Command:          'bold',
-    Token.CommandLine.Prompt:           'bold',
-    Token.StatusBar:                    'bg:#444444 #ffffff',
-    Token.StatusBar.Window:             'bg:#888888',
-    Token.StatusBar.Window.Current:     '#88ff88 bold',
-    Token.AutoSuggestion:               'bg:#4e5e4e #88aa88',
-    Token.Message:                      'bg:#bbee88 #222222',
-    Token.Background:                   '#888888',
-    Token.Clock:                        'bg:#88aa00',
-    Token.PaneNumber:                   'bg:#888888',
-    Token.PaneNumber.Focussed:          'bg:#aa8800',
-    Token.Terminated:                   'bg:#aa0000 #ffffff',
+#    'titlebar title':               '',
+#    'titlebar name':                '#ffffff noitalic',
+#    'focused-terminal titlebar name':       'bg:#88aa44',
+#    'titlebar.line':                '#444444',
+#    'titlebar.line focused':       '#448844 noinherit',
+#    'titlebar focused':            'bg:#5f875f #ffffff bold',
+#    'titlebar.title focused':      '',
+#    'titlebar.zoom':                'bg:#884400 #ffffff',
+#    'titlebar paneindex':           '',
+#    'titlebar.copymode':            'bg:#88aa88 #444444',
+#    'titlebar.copymode.position':   '',
 
-    Token.ConfirmationToolbar:          'bg:#880000 #ffffff',
-    Token.ConfirmationToolbar.Question: '',
-    Token.ConfirmationToolbar.YesNo:    'bg:#440000',
+#    'focused-terminal titlebar.copymode':          'bg:#aaff44 #000000',
+#    'titlebar.copymode.position': '#888888',
 
-    Token.Search:                       'bg:#88aa88 #444444',
-    Token.Search.Text:                  '',
-    Token.Search.Focussed:              'bg:#aaff44 #444444',
-    Token.Search.Focussed.Text:         'bold #000000',
+    'commandline':                  'bg:#4e4e4e #ffffff',
+    'commandline.command':          'bold',
+    'commandline.prompt':           'bold',
+    #'statusbar':                    'noreverse bg:#448844 #000000',
+    'statusbar':                    'noreverse bg:ansigreen #000000',
+    'statusbar window':             '#ffffff',
+    'statusbar window.current':     'bg:#44ff44 #000000',
+    'auto-suggestion':               'bg:#4e5e4e #88aa88',
+    'message':                      'bg:#bbee88 #222222',
+    'background':                   '#888888',
+    'clock':                        'bg:#88aa00',
+    'panenumber':                   'bg:#888888',
+    'panenumber focused':          'bg:#aa8800',
+    'terminated':                   'bg:#aa0000 #ffffff',
 
-    Token.SearchMatch:                  '#000000 bg:#88aa88',
-    Token.SearchMatch.Current:          '#000000 bg:#aaffaa underline',
+    'confirmationtoolbar':          'bg:#880000 #ffffff',
+    'confirmationtoolbar question': '',
+    'confirmationtoolbar yesno':    'bg:#440000',
 
+    'copy-mode-cursor-position':   'bg:ansiyellow ansiblack',
 
-    # Completions menu.
-    Token.Menu.Completions.Completion:         'bg:#88aa88 #222222',
-    Token.Menu.Completions.Completion.Current: 'bg:#88cc88 #000000',
-    Token.Menu.Completions.ProgressBar:        'bg:#889988',
-    Token.Menu.Completions.ProgressButton:     'bg:#004400',
-}
+#    'search-toolbar':                       'bg:#88ff44 #444444',
+    'search-toolbar.prompt':                'bg:#88ff44 #444444',
+    'search-toolbar.text':                  'bg:#88ff44 #000000',
+#    'search-toolbar focused':              'bg:#aaff44 #444444',
+#    'search-toolbar.text focused':         'bold #000000',
 
+    'search-match':                  '#000000 bg:#88aa88',
+    'search-match.current':          '#000000 bg:#aaffaa underline',
 
-class PymuxStyle(Style):
-    """
-    The styling. It includes the UI style from above. But further, in order to
-    proxy all the output from the processes, it interprets all tokens starting
-    with ('C,) as tokens that describe their own style.
-    """
-    def __init__(self):
-        self.ui_style = style_from_dict(ui_style)
-        self._token_to_attrs_dict = None
+    # Pop-up dialog. Ignore built-in style.
+    'dialog':                        'noinherit',
+    'dialog.body':                   'noinherit',
+    'dialog frame':                  'noinherit',
+    'dialog.body text-area':         'noinherit',
+    'dialog.body text-area last-line': 'noinherit',
 
-    def get_attrs_for_token(self, token):
-        if token and token[0] == 'C':
-            # Token starts with ('C',). Token describes its own style.
-            c, fg, bg, bold, underline, italic, blink, reverse = token
-            return Attrs(fg, bg, bold, underline, italic, blink, reverse)
-        else:
-            # Take styles from UI style.
-            return self.ui_style.get_attrs_for_token(token)
-
-    def invalidation_hash(self):
-        return None
+}, priority=Priority.MOST_PRECISE)
diff --git a/pymux/utils.py b/pymux/utils.py
index 6ec2f53..f201187 100644
--- a/pymux/utils.py
+++ b/pymux/utils.py
@@ -2,76 +2,18 @@
 Some utilities.
 """
 from __future__ import unicode_literals
-import array
-import fcntl
-import getpass
+from prompt_toolkit.utils import is_windows
+
 import os
-import pwd
 import sys
-import termios
 
 __all__ = (
-    'pty_make_controlling_tty',
     'daemonize',
-    'set_terminal_size',
     'nonblocking',
     'get_default_shell',
 )
 
 
-def pty_make_controlling_tty(tty_fd):
-    """
-    This makes the pseudo-terminal the controlling tty. This should be
-    more portable than the pty.fork() function. Specifically, this should
-    work on Solaris.
-
-    Thanks to pexpect:
-    http://pexpect.sourceforge.net/pexpect.html
-    """
-    child_name = os.ttyname(tty_fd)
-
-    # Disconnect from controlling tty. Harmless if not already connected.
-    try:
-        fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY)
-        if fd >= 0:
-            os.close(fd)
-    # which exception, shouldnt' we catch explicitly .. ?
-    except:
-        # Already disconnected. This happens if running inside cron.
-        pass
-
-    os.setsid()
-
-    # Verify we are disconnected from controlling tty
-    # by attempting to open it again.
-    try:
-        fd = os.open("/dev/tty", os.O_RDWR | os.O_NOCTTY)
-        if fd >= 0:
-            os.close(fd)
-            raise Exception('Failed to disconnect from controlling '
-                            'tty. It is still possible to open /dev/tty.')
-    # which exception, shouldnt' we catch explicitly .. ?
-    except:
-        # Good! We are disconnected from a controlling tty.
-        pass
-
-    # Verify we can open child pty.
-    fd = os.open(child_name, os.O_RDWR)
-    if fd < 0:
-        raise Exception("Could not open child pty, " + child_name)
-    else:
-        os.close(fd)
-
-    # Verify we now have a controlling tty.
-    if os.name != 'posix':
-        # Skip this on BSD-like systems since it will break.
-        fd = os.open("/dev/tty", os.O_WRONLY)
-        if fd < 0:
-            raise Exception("Could not open controlling tty, /dev/tty")
-        else:
-            os.close(fd)
-
-
 def daemonize(stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'):
     """
     Double fork-trick. For starting a posix daemon.
@@ -129,25 +71,6 @@ def daemonize(stdin='/dev/null', stdout='/dev/null', stderr='/dev/null'):
     return 1
 
 
-def set_terminal_size(stdout_fileno, rows, cols):
-    """
-    Set terminal size.
-
-    (This is also mainly for internal use. Setting the terminal size
-    automatically happens when the window resizes. However, sometimes the
-    process that created a pseudo terminal, and the process that's attached to
-    the output window are not the same, e.g. in case of a telnet connection, or
-    unix domain socket, and then we have to sync the sizes by hand.)
-    """
-    # Buffer for the C call
-    # (The first parameter of 'array.array' needs to be 'str' on both Python 2
-    # and Python 3.)
-    buf = array.array(str('h'), [rows, cols, 0, 0])
-
-    # Do: TIOCSWINSZ (Set)
-    fcntl.ioctl(stdout_fileno, termios.TIOCSWINSZ, buf)
-
-
 class nonblocking(object):
     """
     Make fd non blocking.
@@ -156,10 +79,12 @@ def __init__(self, fd):
         self.fd = fd
 
     def __enter__(self):
+        import fcntl
         self.orig_fl = fcntl.fcntl(self.fd, fcntl.F_GETFL)
         fcntl.fcntl(self.fd, fcntl.F_SETFL, self.orig_fl | os.O_NONBLOCK)
 
     def __exit__(self, *args):
+        import fcntl
         fcntl.fcntl(self.fd, fcntl.F_SETFL, self.orig_fl)
 
 
@@ -167,9 +92,15 @@ def get_default_shell():
     """
     return the path to the default shell for the current user.
     """
-    if 'SHELL' in os.environ:
-        return os.environ['SHELL']
+    if is_windows():
+        return 'cmd.exe'
     else:
-        username = getpass.getuser()
-        shell = pwd.getpwnam(username).pw_shell
-        return shell
+        import pwd
+        import getpass
+
+        if 'SHELL' in os.environ:
+            return os.environ['SHELL']
+        else:
+            username = getpass.getuser()
+            shell = pwd.getpwnam(username).pw_shell
+            return shell
diff --git a/setup.py b/setup.py
index 0c8867b..af794f7 100644
--- a/setup.py
+++ b/setup.py
@@ -3,26 +3,22 @@
 from setuptools import setup, find_packages
 
 
-long_description = open(
-    os.path.join(
-        os.path.dirname(__file__),
-        'README.rst'
-    )
-).read()
+with open(os.path.join(os.path.dirname(__file__), 'README.rst')) as f:
+    long_description = f.read()
 
 
 setup(
     name='pymux',
     author='Jonathan Slenders',
-    version='0.7',
+    version='0.14',
     license='LICENSE',
     url='https://github.com/jonathanslenders/',
     description='Pure Python terminal multiplexer.',
     long_description=long_description,
     packages=find_packages('.'),
     install_requires = [
-        'prompt_toolkit==0.59',
-        'pyte>=0.5.1',
+        'prompt_toolkit>=2.0.0,<2.1.0',
+        'ptterm',
         'six>=1.9.0',
         'docopt>=0.6.2',
     ],