diff --git a/src/core/EntrySearcher.cc b/src/core/EntrySearcher.cc
index e3e75f79..73fd2cd1 100644
--- a/src/core/EntrySearcher.cc
+++ b/src/core/EntrySearcher.cc
@@ -16,18 +16,14 @@
  */
 
 #include "core/EntrySearcher.h"
-#include "core/EntryListCache.h"
 #include "core/RelativeDate.h"
 
-#include <QtDebug>
-
-#include <QRegExp>
 #include <QStringList>
+#include <QtDebug>
 
 PreferenceItem<bool> EntrySearcher::allowRomajiSearch("", "allowRomajiSearch", false);
 
-EntrySearcher::EntrySearcher(EntryType entryType)
-    : commandMatch(SearchCommand::commandMatch().pattern()), _entryType(entryType) {
+EntrySearcher::EntrySearcher(EntryType entryType) : _entryType(entryType) {
     QueryBuilder::Join::addTablePriority("training", -100);
     QueryBuilder::Join::addTablePriority("notes", -40);
     QueryBuilder::Join::addTablePriority("notesText", -45);
@@ -211,7 +207,7 @@ QueryBuilder::Column EntrySearcher::canSort(const QString &sort,
 bool EntrySearcher::searchToCommands(const QStringList &searches,
                                      QList<SearchCommand> &commands) const {
     foreach (const QString &search, searches) {
-        if (commandMatch.exactMatch(search)) {
+        if (SearchCommand::commandMatch().match(search).hasMatch()) {
             SearchCommand command = SearchCommand::fromString(search);
             if (validCommands.contains(command.command()))
                 commands << command;
diff --git a/src/core/EntrySearcher.h b/src/core/EntrySearcher.h
index 52cfa8c6..69fdc147 100644
--- a/src/core/EntrySearcher.h
+++ b/src/core/EntrySearcher.h
@@ -24,6 +24,7 @@
 #include "core/SearchCommand.h"
 
 #include <QList>
+#include <QRegularExpression>
 #include <QStringList>
 
 /**
@@ -32,7 +33,6 @@
  */
 class EntrySearcher {
   private:
-    QRegExp commandMatch;
     EntryType _entryType;
 
   protected:
diff --git a/src/core/EntrySearcherManager.cc b/src/core/EntrySearcherManager.cc
index 52422937..9c3c819b 100644
--- a/src/core/EntrySearcherManager.cc
+++ b/src/core/EntrySearcherManager.cc
@@ -17,13 +17,12 @@
 
 #include "core/EntrySearcherManager.h"
 #include "core/Preferences.h"
+#include <qregularexpression.h>
 
 EntrySearcherManager *EntrySearcherManager::_instance = 0;
 PreferenceItem<bool> EntrySearcherManager::studiedEntriesFirst("mainWindow/resultsView",
                                                                "studiedEntriesFirst", true);
 
-const int resultsPerPage = 50;
-
 EntrySearcherManager::EntrySearcherManager()
     : quotedWordsMatch(SearchCommand::quotedWordsMatch().pattern()),
       validSearchCompoundMatch(SearchCommand::commandMatch().pattern() + "|" +
@@ -34,17 +33,23 @@ EntrySearcherManager::EntrySearcherManager()
 }
 
 QStringList EntrySearcherManager::splitSearchString(const QString &searchString) {
-    if (!validSearchMatch.exactMatch(searchString))
+    if (!validSearchMatch
+             .match(searchString, 0, QRegularExpression::NormalMatch,
+                    QRegularExpression::AnchoredMatchOption)
+             .hasMatch())
         return QStringList();
-    int pos = 0;
     QStringList res;
-    while ((pos = validSearchCompoundMatch.indexIn(searchString, pos)) != -1) {
-        QString compound = validSearchCompoundMatch.cap();
+    QRegularExpressionMatchIterator matches = validSearchCompoundMatch.globalMatch(searchString);
+    while (matches.hasNext()) {
+        QRegularExpressionMatch match = matches.next();
+        QString compound = match.captured();
         // Special handling for quoted words
-        if (quotedWordsMatch.exactMatch(compound))
+        if (quotedWordsMatch
+                .match(compound, 0, QRegularExpression::NormalMatch,
+                       QRegularExpression::AnchoredMatchOption)
+                .hasMatch())
             compound.remove(compound.size() - 1, 1).remove(0, 1);
         res << compound;
-        pos += validSearchCompoundMatch.matchedLength();
     }
     return res;
 }
diff --git a/src/core/EntrySearcherManager.h b/src/core/EntrySearcherManager.h
index 6f64940c..73cede39 100644
--- a/src/core/EntrySearcherManager.h
+++ b/src/core/EntrySearcherManager.h
@@ -22,16 +22,16 @@
 #include "core/Preferences.h"
 #include "core/QueryBuilder.h"
 
-#include <QRegExp>
+#include <QRegularExpression>
 
 class EntrySearcherManager {
   private:
     static EntrySearcherManager *_instance;
     QList<EntrySearcher *> _instances;
 
-    QRegExp quotedWordsMatch;
-    QRegExp validSearchCompoundMatch;
-    QRegExp validSearchMatch;
+    QRegularExpression quotedWordsMatch;
+    QRegularExpression validSearchCompoundMatch;
+    QRegularExpression validSearchMatch;
 
   public:
     EntrySearcherManager();
diff --git a/src/core/QueryBuilder.cc b/src/core/QueryBuilder.cc
index dd0682a1..442ce91a 100644
--- a/src/core/QueryBuilder.cc
+++ b/src/core/QueryBuilder.cc
@@ -249,7 +249,7 @@ void QueryBuilder::Statement::autoJoin() {
     // Now do the same for where statements
     // TODO would be nice to analyze where statements as well!
     /*	foreach (const Where &where, wheres()) {
-                    QRegExp regexp("[a-zA-Z][\w.]*\w* *[^\\(]");
+                    QRegularExpression regexp("[a-zA-Z][\w.]*\w* *[^\\(]");
             }*/
 }
 
diff --git a/src/core/RelativeDate.cc b/src/core/RelativeDate.cc
index b0ee3063..091e0861 100644
--- a/src/core/RelativeDate.cc
+++ b/src/core/RelativeDate.cc
@@ -18,7 +18,7 @@
 #include "core/RelativeDate.h"
 #include "core/Preferences.h"
 
-#include <QRegExp>
+#include <QRegularExpression>
 
 PreferenceItem<int> RelativeDate::firstDayOfWeek("", "firstDayOfWeek", Qt::Monday);
 
@@ -61,16 +61,23 @@ QString RelativeDate::dateString() const {
 }
 
 void RelativeDate::setDateString(const QString &date) {
-    static QRegExp isoDatePattern("\\d\\d\\d\\d-\\d\\d-\\d\\d");
-    static QRegExp relativeDatePattern("(\\d+) (days|weeks|months|years) ago");
-    static QRegExp naturalReadingPattern("(this|last) (week|month|year)");
+    static QRegularExpression isoDatePattern(
+        QRegularExpression::anchoredPattern("\\d\\d\\d\\d-\\d\\d-\\d\\d"));
+    static QRegularExpression relativeDatePattern(
+        QRegularExpression::anchoredPattern("(\\d+) (days|weeks|months|years) ago"));
+    static QRegularExpression naturalReadingPattern(
+        QRegularExpression::anchoredPattern("(this|last) (week|month|year)"));
 
-    if (isoDatePattern.exactMatch(date)) {
+    if (isoDatePattern.match(date).hasMatch()) {
         setDateType(AbsoluteDate);
         setAbsoluteDate(QDate::fromString(date, Qt::ISODate));
-    } else if (naturalReadingPattern.exactMatch(date)) {
-        QString when(naturalReadingPattern.cap(1));
-        QString what(naturalReadingPattern.cap(2));
+        return;
+    }
+
+    QRegularExpressionMatch match = naturalReadingPattern.match(date);
+    if (match.hasMatch()) {
+        QString when(match.captured(1));
+        QString what(match.captured(2));
         if (when == "this")
             setAgo(0);
         else
@@ -81,9 +88,13 @@ void RelativeDate::setDateString(const QString &date) {
             setDateType(MonthsAgo);
         else if (what == "year")
             setDateType(YearsAgo);
-    } else if (relativeDatePattern.exactMatch(date)) {
-        setAgo(relativeDatePattern.cap(1).toInt());
-        QString what(relativeDatePattern.cap(2));
+        return;
+    }
+
+    match = relativeDatePattern.match(date);
+    if (match.hasMatch()) {
+        setAgo(match.captured(1).toInt());
+        QString what(match.captured(2));
         if (what == "days")
             setDateType(DaysAgo);
         else if (what == "weeks")
@@ -92,7 +103,10 @@ void RelativeDate::setDateString(const QString &date) {
             setDateType(MonthsAgo);
         else if (what == "years")
             setDateType(YearsAgo);
-    } else if (date == "today" || date == "yesterday") {
+        return;
+    }
+
+    if (date == "today" || date == "yesterday") {
         setDateType(DaysAgo);
         if (date == "today")
             setAgo(0);
diff --git a/src/core/SearchCommand.cc b/src/core/SearchCommand.cc
index 703914b6..185230fe 100644
--- a/src/core/SearchCommand.cc
+++ b/src/core/SearchCommand.cc
@@ -25,29 +25,37 @@ static QString singleWordString = "(-?[\\w\\*\\?\\-\\._:]+)";
 static QString quotedWordsString = "\"([^\"]*)\"";
 static QString argString = singleWordString + "|" + quotedWordsString;
 
-QRegExp SearchCommand::_singleWordMatch(singleWordString);
-QRegExp SearchCommand::_quotedWordsMatch(quotedWordsString);
-QRegExp SearchCommand::_argMatch(argString);
-QRegExp SearchCommand::_commandMatch(":(\\w+)(?:=(?:(?:" + argString +
-                                     QString::fromUtf8(")(?:[,、](?:") + argString + "))*))?");
+QRegularExpression SearchCommand::_singleWordMatch(singleWordString);
+QRegularExpression SearchCommand::_quotedWordsMatch(quotedWordsString);
+QRegularExpression SearchCommand::_argMatch(argString);
+QRegularExpression SearchCommand::_commandMatch(":(\\w+)(?:=(?:(?:" + argString +
+                                                QString::fromUtf8(")(?:[,、](?:") + argString +
+                                                "))*))?");
 
 SearchCommand SearchCommand::fromString(const QString &string) {
-    if (!_commandMatch.exactMatch(string)) {
+    QRegularExpressionMatch match = _commandMatch.match(string, 0, QRegularExpression::NormalMatch,
+                                                        QRegularExpression::AnchoredMatchOption);
+
+    if (!match.hasMatch()) {
         qDebug("Cannot match command string!");
         return SearchCommand::invalid();
     }
+
     QStringList caps;
-    SearchCommand ret(_commandMatch.cap(1));
+    SearchCommand ret(match.captured(1));
     int pos = string.indexOf('=');
-    if (pos != -1)
-        while ((pos = _argMatch.indexIn(string, pos)) != -1) {
+    if (pos != -1) {
+        QRegularExpressionMatchIterator i = _argMatch.globalMatch(string.mid(pos));
+
+        while (i.hasNext()) {
+            QRegularExpressionMatch match = i.next();
             // Whether we matched a single word or a string
-            if (_argMatch.cap(1) == "")
-                ret.addArgument(_argMatch.cap(2));
+            if (match.captured(1) == "")
+                ret.addArgument(match.captured(2));
             else
-                ret.addArgument(_argMatch.cap(1));
-            pos += _argMatch.matchedLength();
+                ret.addArgument(match.captured(1));
         }
+    }
     return ret;
 }
 
diff --git a/src/core/SearchCommand.h b/src/core/SearchCommand.h
index 214b77da..5e49f99c 100644
--- a/src/core/SearchCommand.h
+++ b/src/core/SearchCommand.h
@@ -18,7 +18,7 @@
 #ifndef __CORE_SEARCHCOMMAND_H
 #define __CORE_SEARCHCOMMAND_H
 
-#include <QRegExp>
+#include <QRegularExpression>
 #include <QStringList>
 
 /**
@@ -31,16 +31,16 @@ class SearchCommand {
     QStringList _args;
     static SearchCommand _invalid;
 
-    static QRegExp _singleWordMatch;
-    static QRegExp _quotedWordsMatch;
-    static QRegExp _argMatch;
-    static QRegExp _commandMatch;
+    static QRegularExpression _singleWordMatch;
+    static QRegularExpression _quotedWordsMatch;
+    static QRegularExpression _argMatch;
+    static QRegularExpression _commandMatch;
 
   public:
-    static const QRegExp singleWordMatch() { return _singleWordMatch; }
-    static const QRegExp quotedWordsMatch() { return _quotedWordsMatch; }
-    static const QRegExp argMatch() { return _argMatch; }
-    static const QRegExp commandMatch() { return _commandMatch; }
+    static const QRegularExpression &singleWordMatch() { return _singleWordMatch; }
+    static const QRegularExpression &quotedWordsMatch() { return _quotedWordsMatch; }
+    static const QRegularExpression &argMatch() { return _argMatch; }
+    static const QRegularExpression &commandMatch() { return _commandMatch; }
 
   public:
     SearchCommand() {}
diff --git a/src/core/Tag.h b/src/core/Tag.h
index 8e57de14..9453ef3e 100644
--- a/src/core/Tag.h
+++ b/src/core/Tag.h
@@ -23,6 +23,7 @@
 #include <QDateTime>
 #include <QHash>
 #include <QList>
+#include <QRegularExpression>
 #include <QString>
 #include <QStringList>
 
@@ -41,7 +42,9 @@ class TagsListModel : public QAbstractListModel {
     QVariant data(const QModelIndex &index, int role) const;
     bool contains(const QString &str) const { return _data.contains(str, Qt::CaseInsensitive); }
     bool containsMatch(const QString &str) const {
-        return _data.indexOf(QRegExp(str, Qt::CaseInsensitive, QRegExp::Wildcard)) != -1;
+        return _data.indexOf(
+                   QRegularExpression(QRegularExpression::wildcardToRegularExpression(str),
+                                      QRegularExpression::CaseInsensitiveOption)) != -1;
     }
     const QStringList &contents() const { return _data; }
 
diff --git a/src/core/jmdict/JMdictEntrySearcher.cc b/src/core/jmdict/JMdictEntrySearcher.cc
index 86f4994d..2400063a 100644
--- a/src/core/jmdict/JMdictEntrySearcher.cc
+++ b/src/core/jmdict/JMdictEntrySearcher.cc
@@ -19,7 +19,6 @@
 #include "core/TextTools.h"
 #include "core/jmdict/JMdictEntry.h"
 #include "core/jmdict/JMdictPlugin.h"
-#include "sqlite/SQLite.h"
 
 PreferenceItem<QString> JMdictEntrySearcher::miscPropertiesFilter("jmdict", "miscPropertiesFilter",
                                                                   "arch,obs");
@@ -64,7 +63,7 @@ SearchCommand JMdictEntrySearcher::commandFromWord(const QString &word) const {
 
     QString checkString(word);
     // Remove all wild cards
-    checkString.remove(QRegExp("[\\?\\*]"));
+    checkString.remove(QRegularExpression("[\\?\\*]"));
     // Only wildcards? Lets assume romaji
     if (checkString.size() == 0)
         return SearchCommand::fromString(QString(":mean=\"%1\"").arg(word));
@@ -88,7 +87,7 @@ SearchCommand JMdictEntrySearcher::commandFromWord(const QString &word) const {
 }
 
 static QString buildTextSearchCondition(const QStringList &words, const QString &table) {
-    static QRegExp regExpChars = QRegExp("[\\?\\*]");
+    static QRegularExpression regExpChars = QRegularExpression("[\\?\\*]");
     static QString ftsMatch("jmdict%3.%2Text.reading MATCH '%1'");
     static QString regexpMatch("jmdict%3.%2Text.reading REGEXP '%1'");
     static QString glossRegexpMatch("{{leftcolumn}} in (select id from jmdict_%2.glosses where "
@@ -109,8 +108,11 @@ static QString buildTextSearchCondition(const QStringList &words, const QString
                 // First check if we can optimize by using the FTS index (i.e.
                 // the first character is not a wildcard)
                 int wildcardIdx = 0;
-                while (!regExpChars.exactMatch(w[wildcardIdx]))
+                QRegularExpressionMatch match = regExpChars.match(w[wildcardIdx]);
+                while (!match.hasMatch()) {
                     wildcardIdx++;
+                    match = regExpChars.match(w[wildcardIdx]);
+                }
                 if (wildcardIdx != 0)
                     fts << "\"" + w.mid(0, wildcardIdx) + "*\"";
                 // If the wildcard we found is the last character and a star,
@@ -495,4 +497,4 @@ QVector<quint64> JMdictEntrySearcher::miscFilterMask() {
 
     ret.append(miscMask);
     return ret;
-}
\ No newline at end of file
+}
diff --git a/src/core/jmdict/JMdictParser.cc b/src/core/jmdict/JMdictParser.cc
index c90662d6..44dbcbdc 100644
--- a/src/core/jmdict/JMdictParser.cc
+++ b/src/core/jmdict/JMdictParser.cc
@@ -19,7 +19,8 @@
 
 #include "core/jmdict/JMdictParser.h"
 
-QRegExp JMdictParser::versionRegExp(" JMdict created: (\\d\\d\\d\\d\\-\\d\\d\\-\\d\\d) ");
+QRegularExpression
+    JMdictParser::versionRegExp(" JMdict created: (\\d\\d\\d\\d\\-\\d\\d\\-\\d\\d) ");
 
 JMdictParser::JMdictParser(const QStringList &langs)
     : languages(langs), gotVersion(false), posBitFieldsCount(0), fieldBitFieldsCount(0),
@@ -182,9 +183,12 @@ bool JMdictParser::parse(QXmlStreamReader &reader) {
         // We are not interested in senses for which there is no gloss!
         if (sense.gloss.isEmpty()) entry.senses.removeLast();
     DONE TAG_POST if (!onItemParsed(entry)) return false;
-    DONE ENDTAG COMMENT if (!gotVersion && versionRegExp.exactMatch(TEXT)) {
-        _dictVersion = versionRegExp.capturedTexts()[1];
-        gotVersion = true;
+    DONE ENDTAG COMMENT if (!gotVersion) {
+        QRegularExpressionMatch match = versionRegExp.match(TEXT);
+        if (match.hasMatch()) {
+            _dictVersion = match.captured(1);
+            gotVersion = true;
+        }
     }
     DONE DOCUMENT_END
 }
diff --git a/src/core/jmdict/JMdictParser.h b/src/core/jmdict/JMdictParser.h
index dab745f0..b0fd10d8 100644
--- a/src/core/jmdict/JMdictParser.h
+++ b/src/core/jmdict/JMdictParser.h
@@ -22,7 +22,7 @@
 
 #include <QHash>
 #include <QMap>
-#include <QRegExp>
+#include <QRegularExpression>
 #include <QSet>
 #include <QStringList>
 
@@ -80,9 +80,7 @@ class JMdictDeletedItem {
 
 class JMdictParser {
   protected:
-    static QRegExp versionRegExp;
-    static QRegExp deletedItemRegExp;
-    static QRegExp mergedItemRegExp;
+    static QRegularExpression versionRegExp;
 
     QStringList languages;
     bool gotVersion;
diff --git a/src/core/kanjidic2/KanjiVGParser.cc b/src/core/kanjidic2/KanjiVGParser.cc
index 0eb13e68..10cb882c 100644
--- a/src/core/kanjidic2/KanjiVGParser.cc
+++ b/src/core/kanjidic2/KanjiVGParser.cc
@@ -20,7 +20,7 @@
 #include "core/TextTools.h"
 #include "core/kanjidic2/KanjiVGParser.h"
 
-QRegExp KanjiVGParser::versionRegExp(
+QRegularExpression KanjiVGParser::versionRegExp(
     "This file has been generated on (\\d\\d\\d\\d\\-\\d\\d\\-\\d\\d)");
 
 #define TAG_KANJIVG kanjivg
@@ -155,9 +155,12 @@ bool KanjiVGParser::parse(QXmlStreamReader &reader) {
     }
     TAG_POST
     onItemParsed(kanji);
-    DONE ENDTAG COMMENT if (!gotVersion && versionRegExp.indexIn(TEXT) != -1) {
-        _version = versionRegExp.capturedTexts()[1];
-        gotVersion = true;
+    DONE ENDTAG COMMENT if (!gotVersion) {
+        QRegularExpressionMatch match = versionRegExp.match(TEXT);
+        if (match.hasMatch()) {
+            _version = match.captured(1);
+            gotVersion = true;
+        }
     }
     DONE DOCUMENT_END
 }
diff --git a/src/core/kanjidic2/KanjiVGParser.h b/src/core/kanjidic2/KanjiVGParser.h
index 185d776c..276162a0 100644
--- a/src/core/kanjidic2/KanjiVGParser.h
+++ b/src/core/kanjidic2/KanjiVGParser.h
@@ -21,7 +21,7 @@
 #include "core/XmlParserHelper.h"
 
 #include <QMap>
-#include <QRegExp>
+#include <QRegularExpression>
 #include <QStack>
 #include <QStringList>
 
@@ -56,7 +56,7 @@ class KanjiVGItem {
 
 class KanjiVGParser {
   private:
-    static QRegExp versionRegExp;
+    static QRegularExpression versionRegExp;
 
     QString _version;
     bool gotVersion;
diff --git a/src/core/kanjidic2/Kanjidic2EntrySearcher.cc b/src/core/kanjidic2/Kanjidic2EntrySearcher.cc
index 40f2d30a..bb5bb60b 100644
--- a/src/core/kanjidic2/Kanjidic2EntrySearcher.cc
+++ b/src/core/kanjidic2/Kanjidic2EntrySearcher.cc
@@ -19,7 +19,6 @@
 #include "core/TextTools.h"
 #include "core/kanjidic2/Kanjidic2Entry.h"
 #include "core/kanjidic2/Kanjidic2Plugin.h"
-#include "sqlite/SQLite.h"
 
 #include <QtDebug>
 
@@ -44,7 +43,7 @@ SearchCommand Kanjidic2EntrySearcher::commandFromWord(const QString &word) const
 
     QString checkString(word);
     // Remove all wild cards
-    checkString.remove(QRegExp("[\\?\\*]"));
+    checkString.remove(QRegularExpression("[\\?\\*]"));
 
     // We have a kanji command if the string is of size 1 and the character is a
     // kanji.
@@ -64,7 +63,7 @@ SearchCommand Kanjidic2EntrySearcher::commandFromWord(const QString &word) const
 }
 
 static QString buildTextSearchCondition(const QStringList &words, const QString &table) {
-    static QRegExp regExpChars = QRegExp("[\\?\\*]");
+    static QRegularExpression regExpChars = QRegularExpression("[\\?\\*]");
     static QString ftsMatch("kanjidic2%3.%2Text.reading MATCH '%1'");
     static QString regexpMatch("kanjidic2%3.%2Text.reading REGEXP '%1'");
     static QString glossRegexpMatch(
@@ -87,8 +86,11 @@ static QString buildTextSearchCondition(const QStringList &words, const QString
                 // First check if we can optimize by using the FTS index (i.e.
                 // the first character is not a wildcard)
                 int wildcardIdx = 0;
-                while (!regExpChars.exactMatch(w[wildcardIdx]))
+                QRegularExpressionMatch match = regExpChars.match(w[wildcardIdx]);
+                while (!match.hasMatch()) {
                     wildcardIdx++;
+                    match = regExpChars.match(w[wildcardIdx]);
+                }
                 if (wildcardIdx != 0)
                     fts << "\"" + w.mid(0, wildcardIdx) + "*\"";
                 // If the wildcard we found is the last character and a star,
diff --git a/src/core/tatoeba/BuildTatoebaDB.cc b/src/core/tatoeba/BuildTatoebaDB.cc
index a11f52e3..981b1847 100644
--- a/src/core/tatoeba/BuildTatoebaDB.cc
+++ b/src/core/tatoeba/BuildTatoebaDB.cc
@@ -23,10 +23,11 @@
 
 #include <QFile>
 #include <QHash>
-#include <QRegExp>
+#include <QRegularExpression>
 #include <QString>
 
 #include <QtDebug>
+#include <qregularexpression.h>
 
 static QMap<QString, SQLite::Connection> connection;
 static SQLite::Connection jmdictConnection;
@@ -102,9 +103,9 @@ static bool createTables(SQLite::Connection &connection, const QString &lang) {
 // matching word. The sentence id is recorded into sentencesToRecord, with an
 // empty list of sentences to be filled by parse_links and parse_sentences
 static bool parseIndices(const QString &sfile) {
-    QRegExp lineRegExp("(\\d+)\t(-?\\d+)\t(.*)\n");
-    QRegExp wordRegExp("(\\w+)(?:\\|\\d*)?(?:\\(([^\\)]+)\\))?(?:\\[([^\\]]+)\\])"
-                       "?(?:\\{([^\\}]+)\\})?~?");
+    QRegularExpression lineRegExp("(\\d+)\t(-?\\d+)\t(.*)\n");
+    QRegularExpression wordRegExp("(\\w+)(?:\\|\\d*)?(?:\\(([^\\)]+)\\))?(?:\\[([^\\]]+)\\])"
+                                  "?(?:\\{([^\\}]+)\\})?~?");
     // wordRegExp.setMinimal(true);
     QFile f(sfile);
     if (!f.open(QIODevice::ReadOnly))
@@ -118,15 +119,17 @@ static bool parseIndices(const QString &sfile) {
         line = QString::fromUtf8(f.readLine());
         if (line.isEmpty())
             break;
-        if (!lineRegExp.exactMatch(line)) {
+        QRegularExpressionMatch match = lineRegExp.match(line, 0, QRegularExpression::NormalMatch,
+                                                         QRegularExpression::AnchoredMatchOption);
+        if (!match.hasMatch()) {
 #ifdef TATOEBA_DB_DEBUG
             qDebug("Cannot match line %d", lineCpt);
 #endif
             continue;
         }
-        sid jid = lineRegExp.cap(1).toInt();
+        sid jid = match.captured(1).toInt();
         // sid eNbr = lineRegExp.cap(2).toInt();
-        QString sentenceBits(lineRegExp.cap(3));
+        QString sentenceBits(match.captured(3));
 
         // if (eNbr == -1) continue;
 
@@ -135,14 +138,16 @@ static bool parseIndices(const QString &sfile) {
         for (int wordPos = 0; wordPos < words.size(); wordPos++) {
             const QString &word = words[wordPos];
 
-            if (!wordRegExp.exactMatch(word)) {
+            QRegularExpressionMatch match = wordRegExp.match(
+                word, 0, QRegularExpression::NormalMatch, QRegularExpression::AnchoredMatchOption);
+            if (!match.hasMatch()) {
 #ifdef TATOEBA_DB_DEBUG
                 qDebug("Cannot match word %s at line %d", word.toUtf8().data(), lineCpt);
 #endif
                 continue;
             }
-            QString writing(wordRegExp.cap(1));
-            QString reading(wordRegExp.cap(2));
+            QString writing(match.captured(1));
+            QString reading(match.captured(2));
             // unsigned int meaning(wordRegExp.cap(3).toUInt());
             // QString original(wordRegExp.cap(4));
             bool checked = word.contains('~');
@@ -191,7 +196,7 @@ static bool parseIndices(const QString &sfile) {
 }
 
 static bool parseLinks(const QString &sfile) {
-    QRegExp lineRegExp("(\\d+)\t(\\d+)\n");
+    QRegularExpression lineRegExp("(\\d+)\t(\\d+)\n");
     QFile f(sfile);
     if (!f.open(QIODevice::ReadOnly))
         return false;
@@ -199,19 +204,21 @@ static bool parseLinks(const QString &sfile) {
         QString line = QString::fromUtf8(f.readLine());
         if (line.isEmpty())
             break;
-        if (!lineRegExp.exactMatch(line))
+        QRegularExpressionMatch match = lineRegExp.match(line, 0, QRegularExpression::NormalMatch,
+                                                         QRegularExpression::AnchoredMatchOption);
+        if (!match.hasMatch())
             continue;
-        sid jid = lineRegExp.cap(2).toInt();
+        sid jid = match.captured(2).toInt();
         if (!sentencesToRecord.contains(jid))
             continue;
-        sid fid = lineRegExp.cap(1).toInt();
+        sid fid = match.captured(1).toInt();
         links[fid] = jid;
     }
     return true;
 }
 
 static bool parseSentences(const QString &sfile) {
-    QRegExp lineRegExp("(\\d+)\t(...)\t(.*)\n");
+    QRegularExpression lineRegExp("(\\d+)\t(...)\t(.*)\n");
     QFile f(sfile);
     if (!f.open(QIODevice::ReadOnly))
         return false;
@@ -219,16 +226,18 @@ static bool parseSentences(const QString &sfile) {
         QString line = QString::fromUtf8(f.readLine());
         if (line.isEmpty())
             break;
-        if (!lineRegExp.exactMatch(line))
+        QRegularExpressionMatch match = lineRegExp.match(line, 0, QRegularExpression::NormalMatch,
+                                                         QRegularExpression::AnchoredMatchOption);
+        if (!match.hasMatch())
             continue;
-        sid fid = lineRegExp.cap(1).toInt();
+        sid fid = match.captured(1).toInt();
         if (!links.contains(fid))
             continue;
-        QString lang(lineRegExp.cap(2));
+        QString lang(match.captured(2));
         if (!languages.contains(lang))
             continue;
         sid jid = links[fid];
-        QString sentence(lineRegExp.cap(3));
+        QString sentence(match.captured(3));
         if (!sentencesToRecord[jid].contains(lang))
             sentencesToRecord[jid].insert(lang, sentence);
     }
diff --git a/src/gui/DetailedView.cc b/src/gui/DetailedView.cc
index ff6fe3c7..f3e1779a 100644
--- a/src/gui/DetailedView.cc
+++ b/src/gui/DetailedView.cc
@@ -167,11 +167,11 @@ void DetailedView::_display(const EntryPointer &entry, bool update) {
         document()->setDefaultStyleSheet(css);
         document()->setHtml(html);
         // Now find the jobs that need to be run from the document
-        QRegExp funcMatch("\\$\\!\\$(\\w+)");
+        QRegularExpression funcMatch("\\$\\!\\$(\\w+)");
         QTextCursor pos(document()), matchPos;
         while (!(matchPos = document()->find(funcMatch, pos)).isNull()) {
-            funcMatch.exactMatch(matchPos.selectedText());
-            QString jobClass(funcMatch.cap(1));
+            QRegularExpressionMatch match = funcMatch.match(matchPos.selectedText());
+            QString jobClass(match.captured(1));
             // Remove the matched text and update the current position
             matchPos.removeSelectedText();
             pos = matchPos;
diff --git a/src/gui/NotesFilterWidget.cc b/src/gui/NotesFilterWidget.cc
index 5ecb8863..f0ec9131 100644
--- a/src/gui/NotesFilterWidget.cc
+++ b/src/gui/NotesFilterWidget.cc
@@ -21,6 +21,7 @@
 #include <QFocusEvent>
 #include <QGroupBox>
 #include <QHBoxLayout>
+#include <QRegularExpression>
 
 NotesFilterWidget::NotesFilterWidget(QWidget *parent) : SearchFilterWidget(parent) {
     _propsToSave << "notes";
@@ -47,7 +48,7 @@ void NotesFilterWidget::setNotes(const QString &notes) {
 QString NotesFilterWidget::currentTitle() const {
     if (words->text().isEmpty())
         return tr("Notes");
-    QStringList args(words->text().split(QRegExp("[ ,\\.]"), QString::SkipEmptyParts));
+    QStringList args(words->text().split(QRegularExpression("[ ,\\.]"), QString::SkipEmptyParts));
     if (args.size() == 1 && args[0] == "*")
         return tr("Has note");
     return tr("Note contains %1").arg(words->text());
@@ -56,14 +57,17 @@ QString NotesFilterWidget::currentTitle() const {
 QString NotesFilterWidget::currentCommand() const {
     if (words->text().isEmpty())
         return "";
-    QStringList args(words->text().split(QRegExp("[ ,\\.]"), QString::SkipEmptyParts));
+    QStringList args(words->text().split(QRegularExpression("[ ,\\.]"), QString::SkipEmptyParts));
     if (args.size() == 1 && args[0] == "*")
         return ":note";
     return QString(":note=%1").arg(args.join(","));
 }
 
 void NotesFilterWidget::onTextChanged(const QString &newText) {
-    if (newText.isEmpty() || QRegExp("^.*[ ,\\.\\*]$").exactMatch(newText))
+    if (newText.isEmpty() ||
+        QRegularExpression(QRegularExpression::anchoredPattern("^.*[ ,\\.\\*]$"))
+            .match(newText)
+            .hasMatch())
         commandUpdate();
 }
 
diff --git a/src/gui/TJSpinBox.cc b/src/gui/TJSpinBox.cc
index d47227a2..e2d3eea8 100644
--- a/src/gui/TJSpinBox.cc
+++ b/src/gui/TJSpinBox.cc
@@ -18,7 +18,7 @@
 
 TJSpinBox::TJSpinBox(QWidget *parent, const QString &validRegExp, unsigned int base)
     : QSpinBox(parent), _base(base) {
-    _validator = new QRegExpValidator(QRegExp(validRegExp), this);
+    _validator = new QRegularExpressionValidator(QRegularExpression(validRegExp), this);
 }
 
 QValidator::State TJSpinBox::validate(QString &input, int &pos) const {
diff --git a/src/gui/TJSpinBox.h b/src/gui/TJSpinBox.h
index 35e4c9df..1cbe1f75 100644
--- a/src/gui/TJSpinBox.h
+++ b/src/gui/TJSpinBox.h
@@ -17,13 +17,13 @@
 #ifndef __GUI_TJSPINBOX_H
 #define __GUI_TJSPINBOX_H
 
-#include <QRegExpValidator>
+#include <QRegularExpressionValidator>
 #include <QSpinBox>
 
 class TJSpinBox : public QSpinBox {
     Q_OBJECT
   private:
-    QRegExpValidator *_validator;
+    QRegularExpressionValidator *_validator;
     unsigned int _base;
 
   protected:
diff --git a/src/gui/TagsDialogs.cc b/src/gui/TagsDialogs.cc
index 6f35a12a..a3331e7d 100644
--- a/src/gui/TagsDialogs.cc
+++ b/src/gui/TagsDialogs.cc
@@ -46,7 +46,7 @@ TagsLineInput::TagsLineInput(QWidget *parent) : TJLineEdit(parent) {
 }
 
 void TagsLineInput::onTextChanged(const QString &newText) {
-    QStringList tags = newText.split(QRegExp("[ ,\\.]"), QString::SkipEmptyParts);
+    QStringList tags = newText.split(QRegularExpression("[ ,\\.]"), QString::SkipEmptyParts);
     foreach (const QString &tag, tags) {
         if (tag.endsWith('*')) {
             if (!Tag::knownTagsModel()->containsMatch(tag))
@@ -74,7 +74,7 @@ void TagsLineInput::checkCompletion() {
 
     // We have a potential completion to perform, let's isolate the interesting
     // portion
-    int pos = curText.lastIndexOf(QRegExp("[ ,.!?]")) + 1;
+    int pos = curText.lastIndexOf(QRegularExpression("[ ,.!?]")) + 1;
 
     curText = curText.right(curText.size() - pos);
 
@@ -123,7 +123,7 @@ TagsInputDialog::TagsInputDialog(const QString &title, const QString &message,
 
 bool TagsDialogs::splitTagsString(const QString &string, QStringList &tagsList,
                                   QStringList &invalidTags) {
-    tagsList = string.split(QRegExp("[ ,\\.]"), QString::SkipEmptyParts);
+    tagsList = string.split(QRegularExpression("[ ,\\.]"), QString::SkipEmptyParts);
     for (int j = 0; j < tagsList.size(); j++) {
         tagsList[j] = tagsList[j].trimmed();
         if (tagsList[j].isEmpty())
diff --git a/src/gui/TagsFilterWidget.cc b/src/gui/TagsFilterWidget.cc
index faabc0dc..f2df053e 100644
--- a/src/gui/TagsFilterWidget.cc
+++ b/src/gui/TagsFilterWidget.cc
@@ -51,7 +51,7 @@ void TagsFilterWidget::populateTagsMenu() {
     QMenu *menu = tagsButton->menu();
     menu->clear();
     QStringList tags(
-        lineInput->text().toLower().split(QRegExp("[ ,\\.]"), QString::SkipEmptyParts));
+        lineInput->text().toLower().split(QRegularExpression("[ ,\\.]"), QString::SkipEmptyParts));
     foreach (QString tag, Tag::knownTagsModel()->contents()) {
         QString tagStr = tag;
         QAction *action = menu->addAction(tag.replace(0, 1, tag[0].toUpper()));
@@ -64,7 +64,7 @@ void TagsFilterWidget::populateTagsMenu() {
 
 void TagsFilterWidget::tagMenuClicked(QAction *action) {
     QStringList tags(
-        lineInput->text().toLower().split(QRegExp("[ ,\\.]"), QString::SkipEmptyParts));
+        lineInput->text().toLower().split(QRegularExpression("[ ,\\.]"), QString::SkipEmptyParts));
     QString tag(action->property("TJtag").toString());
     if (!tags.contains(tag)) {
         QString str(lineInput->text());
@@ -72,12 +72,12 @@ void TagsFilterWidget::tagMenuClicked(QAction *action) {
             str += " ";
         lineInput->setText(str + tag + " ");
     } else {
-        QRegExp regexp(QString("\\b%1\\b").arg(tag));
+        QRegularExpression regexp(QString("\\b%1\\b").arg(tag),
+                                  QRegularExpression::CaseInsensitiveOption);
         QString text(lineInput->text());
         text.remove(regexp);
-        text.remove(QRegExp("^ *"));
-        text.replace(QRegExp("  +"), " ");
-        regexp.setCaseSensitivity(Qt::CaseInsensitive);
+        text.remove(QRegularExpression("^ *"));
+        text.replace(QRegularExpression("  +"), " ");
         lineInput->setText(text);
     }
 }
@@ -95,7 +95,8 @@ QString TagsFilterWidget::currentTitle() const {
     if (untaggedBox->isChecked())
         return tr("Untagged");
 
-    QStringList tags(lineInput->text().split(QRegExp("[ ,\\.]"), QString::SkipEmptyParts));
+    QStringList tags(
+        lineInput->text().split(QRegularExpression("[ ,\\.]"), QString::SkipEmptyParts));
     if (tags.isEmpty())
         return tr("Tags");
     else
@@ -106,7 +107,8 @@ QString TagsFilterWidget::currentCommand() const {
     if (untaggedBox->isChecked())
         return QString(":untagged");
 
-    QStringList tags(lineInput->text().split(QRegExp("[ ,\\.]"), QString::SkipEmptyParts));
+    QStringList tags(
+        lineInput->text().split(QRegularExpression("[ ,\\.]"), QString::SkipEmptyParts));
     if (tags.isEmpty())
         return "";
     return QString(":tag%1%2").arg(tags.isEmpty() ? "" : "=").arg(tags.join(","));
diff --git a/src/gui/TemplateFiller.cc b/src/gui/TemplateFiller.cc
index 331e0ba4..e28693db 100644
--- a/src/gui/TemplateFiller.cc
+++ b/src/gui/TemplateFiller.cc
@@ -19,8 +19,7 @@
 #include "core/Entry.h"
 
 #include <QMetaObject>
-#include <QRegExp>
-
+#include <QRegularExpression>
 #include <QtDebug>
 
 QString TemplateFiller::fill(const QString &tmpl, const EntryFormatter *formatter,
@@ -28,14 +27,17 @@ QString TemplateFiller::fill(const QString &tmpl, const EntryFormatter *formatte
     // For 'T' option
     int tablePos = -1;
     int colCpt = 0;
+    int tmplPos = 0;
 
-    QString ret(tmpl);
-    QRegExp funcMatch("\\$\\$(\\w+)(?:\\[([^\\]]+)\\]){0,1}");
-    int pos = 0, matchPos;
-    while ((matchPos = funcMatch.indexIn(ret, pos)) != -1) {
-        QString whole = funcMatch.cap(0);
-        QString meth = funcMatch.cap(1);
-        QStringList options = funcMatch.cap(2).split(',', QString::SkipEmptyParts);
+    QString ret;
+    QRegularExpression funcMatch("\\$\\$(\\w+)(?:\\[([^\\]]+)\\]){0,1}");
+    QRegularExpressionMatchIterator matches = funcMatch.globalMatch(tmpl);
+    while (matches.hasNext()) {
+        QRegularExpressionMatch match = matches.next();
+        int matchPos = match.capturedStart();
+        QString whole = match.captured(0);
+        QString meth = match.captured(1);
+        QStringList options = match.captured(2).split(',', QString::SkipEmptyParts);
         QString repl;
         // Try to invoke the format method
         QMetaObject::invokeMethod(const_cast<EntryFormatter *>(formatter),
@@ -51,17 +53,17 @@ QString TemplateFiller::fill(const QString &tmpl, const EntryFormatter *formatte
                     break;
                 QString tag(option.mid(1));
                 // Extend the match position to the tag we want to remove
-                int nPos = ret.lastIndexOf("<" + tag, matchPos);
+                int nPos = tmpl.lastIndexOf("<" + tag, matchPos);
                 if (nPos == -1)
                     break;
                 matchPos = nPos;
-                nPos = ret.indexOf("</" + tag, matchPos);
+                nPos = tmpl.indexOf("</" + tag, matchPos);
                 if (nPos != -1)
-                    nPos = ret.indexOf(">", nPos);
+                    nPos = tmpl.indexOf(">", nPos);
                 if (nPos == -1)
                     break;
                 ++nPos;
-                whole = ret.mid(matchPos, nPos - matchPos);
+                whole = tmpl.mid(matchPos, nPos - matchPos);
                 break;
             }
             // Output the result as a table cell according to the given number
@@ -70,7 +72,7 @@ QString TemplateFiller::fill(const QString &tmpl, const EntryFormatter *formatte
                 // Do not output cell for empty string
                 if (repl.isEmpty())
                     break;
-                int tPos = ret.lastIndexOf("<table", matchPos);
+                int tPos = tmpl.lastIndexOf("<table", matchPos);
                 // Found matching table?
                 if (tPos != -1) {
                     int maxCols = option.mid(1).toInt();
@@ -89,42 +91,47 @@ QString TemplateFiller::fill(const QString &tmpl, const EntryFormatter *formatte
             default:
                 break;
             }
-        ret.replace(matchPos, whole.size(), repl);
+        ret += tmpl.mid(tmplPos, matchPos - tmplPos);
+        ret += repl;
+        tmplPos = match.capturedEnd();
         // If we did not output anything, remove ending newline of space
         if (repl.isEmpty())
             while (matchPos < ret.size() && (ret[matchPos] == '\n' || ret[matchPos] == ' '))
                 ret.remove(matchPos, 1);
-        pos = matchPos;
     }
+    ret += tmpl.chopped(tmplPos);
     return ret;
 }
 
 QString TemplateFiller::extract(const QString &tmpl, const QStringList &parts,
                                 bool includeRootText) {
     QString ret;
-    int pos = 0, cPos = -0;
-    QRegExp partMatch("<!-- *PART *: *(\\w+) *-->"), closePartMatch("<!-- */PART *-->");
+    int cPos = -0;
+    QRegularExpression partMatch("<!-- *PART *: *(\\w+) *-->"), closePartMatch("<!-- */PART *-->");
 
     // Find an opening part tag
-    while ((pos = partMatch.indexIn(tmpl, pos)) != -1) {
+    QRegularExpressionMatchIterator matches = partMatch.globalMatch(tmpl);
+    while ((matches.hasNext())) {
+        QRegularExpressionMatch match = matches.next();
+        int pos = match.capturedStart();
         // If the root text is to be included, do so
         if (includeRootText)
             ret += tmpl.mid(cPos, pos - cPos);
 
         // Find the associated closing tag
-        cPos = closePartMatch.indexIn(tmpl, pos);
+        QRegularExpressionMatch closeMatch = closePartMatch.match(tmpl, pos);
         // No closing tag, assume end of document
-        if (cPos < 0)
+        if (!closeMatch.hasMatch())
             cPos = tmpl.size() - 1;
         // Otherwise remove trailing spaces and end of line after closing tag
         else {
-            cPos += closePartMatch.cap().size();
+            cPos = closeMatch.capturedEnd();
             while (cPos < tmpl.size() && (tmpl[cPos] == '\n' || tmpl[cPos] == ' '))
                 ++cPos;
         }
 
         // Now decide whether or not to output this part
-        QString partName(partMatch.cap(1));
+        QString partName(match.captured(1));
         if (parts.contains(partName))
             ret += tmpl.mid(pos, cPos - pos);
 
@@ -135,4 +142,4 @@ QString TemplateFiller::extract(const QString &tmpl, const QStringList &parts,
         ret += tmpl.mid(cPos);
 
     return ret;
-}
\ No newline at end of file
+}
diff --git a/src/gui/kanjidic2/KanjiRenderer.cc b/src/gui/kanjidic2/KanjiRenderer.cc
index bb8c51a6..69d74040 100644
--- a/src/gui/kanjidic2/KanjiRenderer.cc
+++ b/src/gui/kanjidic2/KanjiRenderer.cc
@@ -50,10 +50,10 @@ QPainterPath KanjiRenderer::Stroke::pathFromSVG(QString svgPath) {
 
     // Process the string - add spaces between unseparated tokens
     int idx;
-    while ((idx = svgPath.indexOf(QRegExp("[a-zA-Z]\\d|\\d[a-zA-Z]|\\w-"))) != -1)
+    while ((idx = svgPath.indexOf(QRegularExpression("[a-zA-Z]\\d|\\d[a-zA-Z]|\\w-"))) != -1)
         svgPath.insert(idx + 1, ' ');
 
-    QStringList tokens = svgPath.split(QRegExp(" +|,"), QString::SkipEmptyParts);
+    QStringList tokens = svgPath.split(QRegularExpression(" +|,"), QString::SkipEmptyParts);
 
     SVGPathCommand curAction = None;
     QPointF dest;
diff --git a/src/sqlite/sqlite3ext.cc b/src/sqlite/sqlite3ext.cc
index 4ecffd20..4c2ba149 100644
--- a/src/sqlite/sqlite3ext.cc
+++ b/src/sqlite/sqlite3ext.cc
@@ -20,7 +20,7 @@
 #include "sqlite/fts3_tokenizer.h"
 
 #include <QRandomGenerator>
-#include <QRegExp>
+#include <QRegularExpression>
 #include <QSet>
 #include <QtDebug>
 #include <qrandom.h>
@@ -31,9 +31,9 @@ static QByteArray kanasConverted;
 static void regexpFunc(sqlite3_context *context, int argc, sqlite3_value **argv) {
     const QString text(
         TextTools::hiragana2Katakana(QString::fromUtf8((const char *)sqlite3_value_text(argv[1]))));
-    QRegExp regexp = QRegExp(
-        TextTools::hiragana2Katakana(QString::fromUtf8((const char *)sqlite3_value_text(argv[0]))));
-    regexp.setCaseSensitivity(Qt::CaseInsensitive);
+    QRegularExpression regexp = QRegularExpression(
+        TextTools::hiragana2Katakana(QString::fromUtf8((const char *)sqlite3_value_text(argv[0]))),
+        QRegularExpression::CaseInsensitiveOption);
 
     bool res = text.contains(regexp);
     sqlite3_result_int(context, res);