diff --git a/data/schema/language.xsd b/data/schema/language.xsd
--- a/data/schema/language.xsd
+++ b/data/schema/language.xsd
@@ -478,14 +478,12 @@
     commonAttributes: Common attributes
     char:             The first character
     char1:            The second character
-    dynamic:          Uses 0 ... 9 as placeholders for dynamic arguments (in fact, first char of arg...) [boolean, optional, default=false]
   -->
   <xs:element name="Detect2Chars">
     <xs:complexType>
       <xs:attributeGroup ref="commonAttributes"/>
       <xs:attribute name="char" use="required"/>
       <xs:attribute name="char1" use="required"/>
-      <xs:attribute name="dynamic" type="xs:boolean"/>
     </xs:complexType>
   </xs:element>
   <!--
@@ -525,7 +523,6 @@
       commonAttributes: Common attributes
       String:           The string to look for
       insensitive:      Whether the string is matched case INsensitive. [boolean, optional, default=false]
-      dynamic:          Uses %0 ... %9 as placeholders for dynamic arguments [boolean, optional, default=false]
 
     TODO
       - What's default of insensitive? I'm not sure...
@@ -535,7 +532,6 @@
       <xs:attributeGroup ref="commonAttributes"/>
       <xs:attribute name="String" use="required"/>
       <xs:attribute name="insensitive" type="xs:boolean"/>
-      <xs:attribute name="dynamic" type="xs:boolean"/>
     </xs:complexType>
   </xs:element>
   <!--
diff --git a/src/lib/rule.cpp b/src/lib/rule.cpp
--- a/src/lib/rule.cpp
+++ b/src/lib/rule.cpp
@@ -116,11 +116,6 @@
     return m_lookAhead;
 }
 
-bool Rule::isDynamic() const
-{
-    return m_dynamic;
-}
-
 bool Rule::firstNonSpace() const
 {
     return m_firstNonSpace;
@@ -154,7 +149,6 @@
     m_column = reader.attributes().value(QStringLiteral("column")).toInt(&colOk);
     if (!colOk)
         m_column = -1;
-    m_dynamic = Xml::attrToBool(reader.attributes().value(QStringLiteral("dynamic")));
 
     auto regionName = reader.attributes().value(QLatin1String("beginRegion"));
     if (!regionName.isEmpty())
@@ -229,7 +223,7 @@
     return true;
 }
 
-MatchResult Rule::match(const QString &text, int offset, const QStringList &captures)
+MatchResult Rule::match(const QString &text, int offset, const QStringList &captures) const
 {
     Q_ASSERT(!text.isEmpty());
 
@@ -306,7 +300,7 @@
     return !m_chars.isEmpty();
 }
 
-MatchResult AnyChar::doMatch(const QString& text, int offset, const QStringList&)
+MatchResult AnyChar::doMatch(const QString& text, int offset, const QStringList&) const
 {
     if (m_chars.contains(text.at(offset)))
         return offset + 1;
@@ -320,15 +314,16 @@
     if (s.isEmpty())
         return false;
     m_char = s.at(0);
-    if (isDynamic()) {
+    m_dynamic = Xml::attrToBool(reader.attributes().value(QStringLiteral("dynamic")));
+    if (m_dynamic) {
         m_captureIndex = m_char.digitValue();
     }
     return true;
 }
 
-MatchResult DetectChar::doMatch(const QString& text, int offset, const QStringList &captures)
+MatchResult DetectChar::doMatch(const QString& text, int offset, const QStringList &captures) const
 {
-    if (isDynamic()) {
+    if (m_dynamic) {
         if (captures.size() <= m_captureIndex || captures.at(m_captureIndex).isEmpty())
             return offset;
         if (text.at(offset) == captures.at(m_captureIndex).at(0))
@@ -353,18 +348,17 @@
     return true;
 }
 
-MatchResult Detect2Char::doMatch(const QString& text, int offset, const QStringList &captures)
+MatchResult Detect2Char::doMatch(const QString& text, int offset, const QStringList &) const
 {
-    Q_UNUSED(captures); // TODO
     if (text.size() - offset < 2)
         return offset;
     if (text.at(offset) == m_char1 && text.at(offset + 1) == m_char2)
         return offset + 2;
     return offset;
 }
 
 
-MatchResult DetectIdentifier::doMatch(const QString& text, int offset, const QStringList&)
+MatchResult DetectIdentifier::doMatch(const QString& text, int offset, const QStringList&) const
 {
     if (!text.at(offset).isLetter() && text.at(offset) != QLatin1Char('_'))
         return offset;
@@ -379,15 +373,15 @@
 }
 
 
-MatchResult DetectSpaces::doMatch(const QString& text, int offset, const QStringList&)
+MatchResult DetectSpaces::doMatch(const QString& text, int offset, const QStringList&) const
 {
     while(offset < text.size() && text.at(offset).isSpace())
         ++offset;
     return offset;
 }
 
 
-MatchResult Float::doMatch(const QString& text, int offset, const QStringList&)
+MatchResult Float::doMatch(const QString& text, int offset, const QStringList&) const
 {
     if (offset > 0 && !isWordDelimiter(text.at(offset - 1)))
         return offset;
@@ -425,7 +419,7 @@
 }
 
 
-MatchResult HlCChar::doMatch(const QString& text, int offset, const QStringList&)
+MatchResult HlCChar::doMatch(const QString& text, int offset, const QStringList&) const
 {
     if (text.size() < offset + 3)
         return offset;
@@ -450,7 +444,7 @@
 }
 
 
-MatchResult HlCHex::doMatch(const QString& text, int offset, const QStringList&)
+MatchResult HlCHex::doMatch(const QString& text, int offset, const QStringList&) const
 {
     if (offset > 0 && !isWordDelimiter(text.at(offset - 1)))
         return offset;
@@ -474,7 +468,7 @@
 }
 
 
-MatchResult HlCOct::doMatch(const QString& text, int offset, const QStringList&)
+MatchResult HlCOct::doMatch(const QString& text, int offset, const QStringList&) const
 {
     if (offset > 0 && !isWordDelimiter(text.at(offset - 1)))
         return offset;
@@ -496,7 +490,7 @@
 }
 
 
-MatchResult HlCStringChar::doMatch(const QString& text, int offset, const QStringList&)
+MatchResult HlCStringChar::doMatch(const QString& text, int offset, const QStringList&) const
 {
     return matchEscapedChar(text, offset);
 }
@@ -531,15 +525,15 @@
     return !m_contextName.isEmpty() || !m_defName.isEmpty();
 }
 
-MatchResult IncludeRules::doMatch(const QString& text, int offset, const QStringList&)
+MatchResult IncludeRules::doMatch(const QString& text, int offset, const QStringList&) const
 {
     Q_UNUSED(text);
     qCWarning(Log) << "Unresolved include rule for" << m_contextName << "##" << m_defName;
     return offset;
 }
 
 
-MatchResult Int::doMatch(const QString& text, int offset, const QStringList &captures)
+MatchResult Int::doMatch(const QString& text, int offset, const QStringList &captures) const
 {
     if (offset > 0 && !isWordDelimiter(text.at(offset - 1)))
         return offset;
@@ -564,7 +558,7 @@
     return !m_listName.isEmpty();
 }
 
-MatchResult KeywordListRule::doMatch(const QString& text, int offset, const QStringList&)
+MatchResult KeywordListRule::doMatch(const QString& text, int offset, const QStringList&) const
 {
     if (m_keywordList.isEmpty()) {
         const auto def = definition();
@@ -602,7 +596,7 @@
     return true;
 }
 
-MatchResult LineContinue::doMatch(const QString& text, int offset, const QStringList&)
+MatchResult LineContinue::doMatch(const QString& text, int offset, const QStringList&) const
 {
     if (offset == text.size() - 1 && text.at(offset) == m_char)
         return offset + 1;
@@ -621,7 +615,7 @@
     return true;
 }
 
-MatchResult RangeDetect::doMatch(const QString& text, int offset, const QStringList&)
+MatchResult RangeDetect::doMatch(const QString& text, int offset, const QStringList&) const
 {
     if (text.size() - offset < 2)
         return offset;
@@ -639,24 +633,33 @@
 
 bool RegExpr::doLoad(QXmlStreamReader& reader)
 {
-    m_pattern = reader.attributes().value(QStringLiteral("String")).toString();
-    m_regexp.setPattern(m_pattern);
+    m_regexp.setPattern(reader.attributes().value(QStringLiteral("String")).toString());
+
     const auto isMinimal = Xml::attrToBool(reader.attributes().value(QStringLiteral("minimal")));
     const auto isCaseInsensitive = Xml::attrToBool(reader.attributes().value(QStringLiteral("insensitive")));
     m_regexp.setPatternOptions(
         (isMinimal ? QRegularExpression::InvertedGreedinessOption : QRegularExpression::NoPatternOption) |
         (isCaseInsensitive ? QRegularExpression::CaseInsensitiveOption : QRegularExpression::NoPatternOption));
-    return !m_pattern.isEmpty(); // m_regexp.isValid() would be better, but parses the regexp and thus is way too expensive
-}
 
-MatchResult RegExpr::doMatch(const QString& text, int offset, const QStringList &captures)
-{
+    // optimize the pattern for the non-dynamic case, we use them OFTEN
+    m_dynamic = Xml::attrToBool(reader.attributes().value(QStringLiteral("dynamic")));
+    if (!m_dynamic) {
+        m_regexp.optimize();
+    }
+
+    // always using m_regexp.isValid() would be better, but parses the regexp and thus is way too expensive for release builds
     Q_ASSERT(m_regexp.isValid());
+    return !m_regexp.pattern().isEmpty();
+}
 
-    if (isDynamic())
-        m_regexp.setPattern(replaceCaptures(m_pattern, captures, true));
+MatchResult RegExpr::doMatch(const QString& text, int offset, const QStringList &captures) const
+{
+    /**
+     * for dynamic case: create new pattern with right instantiation
+     */
+    const auto &regexp = m_dynamic ? QRegularExpression(replaceCaptures(m_regexp.pattern(), captures, true), m_regexp.patternOptions()) : m_regexp;
 
-    auto result = m_regexp.match(text, offset, QRegularExpression::NormalMatch, QRegularExpression::DontCheckSubjectStringMatchOption);
+    auto result = regexp.match(text, offset, QRegularExpression::NormalMatch, QRegularExpression::DontCheckSubjectStringMatchOption);
     if (result.capturedStart() == offset)
         return MatchResult(offset + result.capturedLength(), result.capturedTexts());
     return MatchResult(offset, result.capturedStart());
@@ -667,14 +670,17 @@
 {
     m_string = reader.attributes().value(QStringLiteral("String")).toString();
     m_caseSensitivity = Xml::attrToBool(reader.attributes().value(QStringLiteral("insensitive"))) ? Qt::CaseInsensitive : Qt::CaseSensitive;
+    m_dynamic = Xml::attrToBool(reader.attributes().value(QStringLiteral("dynamic")));
     return !m_string.isEmpty();
 }
 
-MatchResult StringDetect::doMatch(const QString& text, int offset, const QStringList &captures)
+MatchResult StringDetect::doMatch(const QString& text, int offset, const QStringList &captures) const
 {
-    auto pattern = m_string;
-    if (isDynamic())
-        pattern = replaceCaptures(m_string, captures, false);
+    /**
+     * for dynamic case: create new pattern with right instantiation
+     */
+    const auto &pattern = m_dynamic ? replaceCaptures(m_string, captures, false) : m_string;
+
     if (text.midRef(offset, pattern.size()).compare(pattern, m_caseSensitivity) == 0)
         return offset + pattern.size();
     return offset;
@@ -688,9 +694,8 @@
     return !m_word.isEmpty();
 }
 
-MatchResult WordDetect::doMatch(const QString& text, int offset, const QStringList &captures)
+MatchResult WordDetect::doMatch(const QString& text, int offset, const QStringList &) const
 {
-    Q_UNUSED(captures); // TODO
     if (text.size() - offset < m_word.size())
         return offset;
 
diff --git a/src/lib/rule_p.h b/src/lib/rule_p.h
--- a/src/lib/rule_p.h
+++ b/src/lib/rule_p.h
@@ -60,7 +60,6 @@
 
     ContextSwitch context() const;
     bool isLookAhead() const;
-    bool isDynamic() const;
     bool firstNonSpace() const;
     int requiredColumn() const;
 
@@ -71,13 +70,13 @@
     void resolveContext();
     void resolveAttributeFormat(Context *lookupContext);
 
-    MatchResult match(const QString &text, int offset, const QStringList &captures);
+    MatchResult match(const QString &text, int offset, const QStringList &captures) const;
 
     static Rule::Ptr create(const QStringRef &name);
 
 protected:
     virtual bool doLoad(QXmlStreamReader &reader);
-    virtual MatchResult doMatch(const QString &text, int offset, const QStringList &captures) = 0;
+    virtual MatchResult doMatch(const QString &text, int offset, const QStringList &captures) const = 0;
 
     bool isWordDelimiter(QChar c) const;
 
@@ -94,7 +93,6 @@
     FoldingRegion m_endRegion;
     bool m_firstNonSpace = false;
     bool m_lookAhead = false;
-    bool m_dynamic = false;
 
     // cache for DefinitionData::wordDelimiters, is accessed VERY often
     QStringRef m_wordDelimiter;
@@ -105,7 +103,7 @@
 {
 protected:
     bool doLoad(QXmlStreamReader & reader) override;
-    MatchResult doMatch(const QString & text, int offset, const QStringList&) override;
+    MatchResult doMatch(const QString & text, int offset, const QStringList&) const override;
 
 private:
     QString m_chars;
@@ -115,18 +113,19 @@
 {
 protected:
     bool doLoad(QXmlStreamReader & reader) override;
-    MatchResult doMatch(const QString & text, int offset, const QStringList &captures) override;
+    MatchResult doMatch(const QString & text, int offset, const QStringList &captures) const override;
 
 private:
     QChar m_char;
-    int m_captureIndex;
+    bool m_dynamic = false;
+    int m_captureIndex = 0;
 };
 
 class Detect2Char : public Rule
 {
 protected:
     bool doLoad(QXmlStreamReader & reader) override;
-    MatchResult doMatch(const QString & text, int offset, const QStringList &captures) override;
+    MatchResult doMatch(const QString & text, int offset, const QStringList &captures) const override;
 
 private:
     QChar m_char1;
@@ -136,19 +135,19 @@
 class DetectIdentifier : public Rule
 {
 protected:
-    MatchResult doMatch(const QString & text, int offset, const QStringList&) override;
+    MatchResult doMatch(const QString & text, int offset, const QStringList&) const override;
 };
 
 class DetectSpaces : public Rule
 {
 protected:
-    MatchResult doMatch(const QString & text, int offset, const QStringList&) override;
+    MatchResult doMatch(const QString & text, int offset, const QStringList&) const override;
 };
 
 class Float : public Rule
 {
 protected:
-    MatchResult doMatch(const QString & text, int offset, const QStringList&) override;
+    MatchResult doMatch(const QString & text, int offset, const QStringList&) const override;
 };
 
 class IncludeRules : public Rule
@@ -160,7 +159,7 @@
 
 protected:
     bool doLoad(QXmlStreamReader & reader) override;
-    MatchResult doMatch(const QString & text, int offset, const QStringList&) override;
+    MatchResult doMatch(const QString & text, int offset, const QStringList&) const override;
 
 private:
     QString m_contextName;
@@ -171,51 +170,51 @@
 class Int : public Rule
 {
 protected:
-    MatchResult doMatch(const QString & text, int offset, const QStringList &captures) override;
+    MatchResult doMatch(const QString & text, int offset, const QStringList &captures) const override;
 };
 
 class HlCChar : public Rule
 {
 protected:
-    MatchResult doMatch(const QString & text, int offset, const QStringList&) override;
+    MatchResult doMatch(const QString & text, int offset, const QStringList&) const override;
 };
 
 class HlCHex : public Rule
 {
 protected:
-    MatchResult doMatch(const QString & text, int offset, const QStringList&) override;
+    MatchResult doMatch(const QString & text, int offset, const QStringList&) const override;
 };
 
 class HlCOct : public Rule
 {
 protected:
-    MatchResult doMatch(const QString & text, int offset, const QStringList&) override;
+    MatchResult doMatch(const QString & text, int offset, const QStringList&) const override;
 };
 
 class HlCStringChar : public Rule
 {
 protected:
-    MatchResult doMatch(const QString & text, int offset, const QStringList&) override;
+    MatchResult doMatch(const QString & text, int offset, const QStringList&) const override;
 };
 
 class KeywordListRule : public Rule
 {
 protected:
     bool doLoad(QXmlStreamReader & reader) override;
-    MatchResult doMatch(const QString & text, int offset, const QStringList&) override;
+    MatchResult doMatch(const QString & text, int offset, const QStringList&) const override;
 
 private:
     QString m_listName;
-    KeywordList m_keywordList;
+    mutable KeywordList m_keywordList;
     bool m_hasCaseSensitivityOverride;
     Qt::CaseSensitivity m_caseSensitivityOverride;
 };
 
 class LineContinue : public Rule
 {
 protected:
     bool doLoad(QXmlStreamReader & reader) override;
-    MatchResult doMatch(const QString & text, int offset, const QStringList&) override;
+    MatchResult doMatch(const QString & text, int offset, const QStringList&) const override;
 
 private:
     QChar m_char;
@@ -225,7 +224,7 @@
 {
 protected:
     bool doLoad(QXmlStreamReader & reader) override;
-    MatchResult doMatch(const QString & text, int offset, const QStringList&) override;
+    MatchResult doMatch(const QString & text, int offset, const QStringList&) const override;
 
 private:
     QChar m_begin;
@@ -236,29 +235,30 @@
 {
 protected:
     bool doLoad(QXmlStreamReader & reader) override;
-    MatchResult doMatch(const QString & text, int offset, const QStringList &captures) override;
+    MatchResult doMatch(const QString & text, int offset, const QStringList &captures) const override;
 
 private:
-    QString m_pattern;
     QRegularExpression m_regexp;
+    bool m_dynamic = false;
 };
 
 class StringDetect : public Rule
 {
 protected:
     bool doLoad(QXmlStreamReader & reader) override;
-    MatchResult doMatch(const QString & text, int offset, const QStringList &captures) override;
+    MatchResult doMatch(const QString & text, int offset, const QStringList &captures) const override;
 
 private:
     QString m_string;
     Qt::CaseSensitivity m_caseSensitivity;
+    bool m_dynamic = false;
 };
 
 class WordDetect : public Rule
 {
 protected:
     bool doLoad(QXmlStreamReader & reader) override;
-    MatchResult doMatch(const QString & text, int offset, const QStringList &captures) override;
+    MatchResult doMatch(const QString & text, int offset, const QStringList &captures) const override;
 
 private:
     QString m_word;