diff --git a/qutebrowser/commands/utils.py b/qutebrowser/commands/utils.py
index 5e83367b6..b4705a3e9 100644
--- a/qutebrowser/commands/utils.py
+++ b/qutebrowser/commands/utils.py
@@ -19,13 +19,7 @@
 
 import inspect
 
-from PyQt5.QtCore import pyqtSignal, pyqtSlot, QObject
-from PyQt5.QtWebKitWidgets import QWebPage
-
-import qutebrowser.config.config as config
 from qutebrowser.commands.command import Command
-from qutebrowser.commands.exceptions import (ArgumentCountError,
-                                             NoSuchCommandError)
 
 # A mapping from command-strings to command objects.
 cmd_dict = {}
@@ -136,206 +130,3 @@ class register:
             else:
                 maxargs = len(spec.args) - int(count)  # -1 if count is defined
         return (count, (minargs, maxargs))
-
-
-class SearchParser(QObject):
-
-    """Parse qutebrowser searches.
-
-    Attributes:
-        _text: The text from the last search.
-        _flags: The flags from the last search.
-
-    Signals:
-        do_search: Emitted when a search should be started.
-                   arg 1: Search string.
-                   arg 2: Flags to use.
-
-    """
-
-    do_search = pyqtSignal(str, 'QWebPage::FindFlags')
-
-    def __init__(self, parent=None):
-        self._text = None
-        self._flags = 0
-        super().__init__(parent)
-
-    def _search(self, text, rev=False):
-        """Search for a text on the current page.
-
-        Args:
-            text: The text to search for.
-            rev: Search direction, True if reverse, else False.
-
-        Emit:
-            do_search: If a search should be started.
-
-        """
-        if self._text is not None and self._text != text:
-            self.do_search.emit('', 0)
-        self._text = text
-        self._flags = 0
-        if config.config.getboolean('general', 'ignorecase', fallback=True):
-            self._flags |= QWebPage.FindCaseSensitively
-        if config.config.getboolean('general', 'wrapsearch', fallback=True):
-            self._flags |= QWebPage.FindWrapsAroundDocument
-        if rev:
-            self._flags |= QWebPage.FindBackward
-        self.do_search.emit(self._text, self._flags)
-
-    @pyqtSlot(str)
-    def search(self, text):
-        """Search for a text on a website.
-
-        Args:
-            text: The text to search for.
-
-        """
-        self._search(text)
-
-    @pyqtSlot(str)
-    def search_rev(self, text):
-        """Search for a text on a website in reverse direction.
-
-        Args:
-            text: The text to search for.
-
-        """
-        self._search(text, rev=True)
-
-    @register(instance='searchparser', hide=True)
-    def nextsearch(self, count=1):
-        """Continue the search to the ([count]th) next term.
-
-        Args:
-            count: How many elements to ignore.
-
-        Emit:
-            do_search: If a search should be started.
-
-        """
-        if self._text is not None:
-            for i in range(count):  # pylint: disable=unused-variable
-                self.do_search.emit(self._text, self._flags)
-
-
-class CommandParser(QObject):
-
-    """Parse qutebrowser commandline commands.
-
-    Attributes:
-        _cmd: The command which was parsed.
-        _args: The arguments which were parsed.
-
-    Signals:
-        error: Emitted if there was an error.
-               arg: The error message.
-
-    """
-
-    error = pyqtSignal(str)
-
-    def __init__(self, parent=None):
-        super().__init__(parent)
-        self._cmd = None
-        self._args = []
-
-    def _parse(self, text, aliases=True):
-        """Split the commandline text into command and arguments.
-
-        Args:
-            text: Text to parse.
-            aliases: Whether to handle aliases.
-
-        Raise:
-            NoSuchCommandError if a command wasn't found.
-
-        """
-        parts = text.strip().split(maxsplit=1)
-        if not parts:
-            raise NoSuchCommandError("No command given")
-        cmdstr = parts[0]
-        if aliases:
-            try:
-                alias = config.config.get('aliases', cmdstr)
-            except config.NoOptionError:
-                pass
-            else:
-                return self._parse(alias, aliases=False)
-        try:
-            cmd = cmd_dict[cmdstr]
-        except KeyError:
-            raise NoSuchCommandError("Command {} not found.".format(cmdstr))
-
-        if len(parts) == 1:
-            args = []
-        elif cmd.split_args:
-            args = shlex.split(parts[1])
-        else:
-            args = [parts[1]]
-        self._cmd = cmd
-        self._args = args
-
-    def _check(self):
-        """Check if the argument count for the command is correct."""
-        self._cmd.check(self._args)
-
-    def _run(self, count=None):
-        """Run a command with an optional count.
-
-        Args:
-            count: Count to pass to the command.
-
-        """
-        if count is not None:
-            self._cmd.run(self._args, count=count)
-        else:
-            self._cmd.run(self._args)
-
-    @pyqtSlot(str, int, bool)
-    def run(self, text, count=None, ignore_exc=True):
-        """Parse a command from a line of text.
-
-        If ignore_exc is True, ignore exceptions and return True/False.
-
-        Args:
-            text: The text to parse.
-            count: The count to pass to the command.
-            ignore_exc: Ignore exceptions and return False instead.
-
-        Raise:
-            NoSuchCommandError: if a command wasn't found.
-            ArgumentCountError: if a command was called with the wrong count of
-            arguments.
-
-        Return:
-            True if command was called (handler returnstatus is ignored!).
-            False if command wasn't called (there was an ignored exception).
-
-        Emit:
-            error: If there was an error parsing a command.
-
-        """
-        if ';;' in text:
-            retvals = []
-            for sub in text.split(';;'):
-                retvals.append(self.run(sub, count, ignore_exc))
-            return all(retvals)
-        try:
-            self._parse(text)
-            self._check()
-        except ArgumentCountError:
-            if ignore_exc:
-                self.error.emit("{}: invalid argument count".format(
-                    self._cmd.name))
-                return False
-            else:
-                raise
-        except NoSuchCommandError as e:
-            if ignore_exc:
-                self.error.emit("{}: no such command".format(e))
-                return False
-            else:
-                raise
-        self._run(count=count)
-        return True