diff --git a/_mathfly_main.py b/_mathfly_main.py
index 84b724b..1317210 100644
--- a/_mathfly_main.py
+++ b/_mathfly_main.py
@@ -1,45 +1,48 @@
-from dragonfly import (Function, Grammar, Text, Dictation, Choice, Pause)
+import os
+os.environ['BREATHE_REBUILD_COMMAND'] = "rebuild mathfly"
+
 
-import os, sys
 import logging
-import natlink
 logging.basicConfig()
 
-from mathfly.lib import control, utilities
-from mathfly.lib.merge.mergerule import MergeRule
-from mathfly.lib.merge.mergepair import MergeInf
+from mathfly.imports import *
 
 BASE_PATH = os.path.realpath(__file__).split("\\_mathfly_main.py")[0].replace("\\", "/")
 sys.path.append(BASE_PATH)
 
-CORE = utilities.load_toml_relative("config/core.toml")
+CORE = utilities.load_config("core.toml")
+SETTINGS = utilities.load_toml_relative("config/settings.toml")
 
-MF_NEXUS = control.nexus()
-MF_NEXUS.build(True)
 
-class MainRule(MergeRule):
+def delete_words(words):
+    for word in words:
+        try:
+            natlink.deleteWord(word)
+        except:
+            pass
 
-	mapping = {
-        "configure math fly [settings]":
-            Function(utilities.load_config, config_name="settings.toml"),
+def add_words(words):
+    for word in words:
+        try:
+            natlink.addWord(word)
+        except:
+            pass
 
-        "<enable> <name>": Function(MF_NEXUS.rule_changer),
+delete_words(SETTINGS["delete_words"])
+add_words(SETTINGS["add_words"])
 
-        "reboot dragon": Function(utilities.reboot),
+Breathe.load_modules(
+    {
+        "mathfly.ccr": "global_extras"
+    }
+)
 
-        "rebuild math fly": Function(MF_NEXUS.build),
+Breathe.load_modules(
+    {
+        "mathfly": SETTINGS["modules"]
+    }
+)
 
-        "math fly help": Function(utilities.help),
-	}
-	extras=[
-		MF_NEXUS.generate_ccr_choices("name"),
-        Choice("enable", {
-            "enable": True,
-            "disable": False
-        }),
-	]
+print("*- Starting Mathfly -*")
 
-grammar = Grammar('general')
-main_rule = MainRule()
-grammar.add_rule(main_rule)
-grammar.load()
\ No newline at end of file
+del os.environ['BREATHE_REBUILD_COMMAND']
\ No newline at end of file
diff --git a/mathfly/apps/app_template.py b/mathfly/apps/app_template.py
index 573f3c4..d5dba3c 100644
--- a/mathfly/apps/app_template.py
+++ b/mathfly/apps/app_template.py
@@ -1,9 +1,7 @@
 from mathfly.imports import *
 
-class RuleNameRule(MergeRule):
-	pronunciation = "AppName"
-	mcontext = AppContext(title="AppName")
-
+Breathe.add_commands(
+	context = AppContext(title="AppName"),
 	mapping = {
 		"new file"            : Key("c-n"),
 		"open file"           : Key("c-o"),
@@ -20,10 +18,9 @@ class RuleNameRule(MergeRule):
 
 		"zoom in"             : Key("c-equals"),
 		"zoom out"            : Key("c-minus"),
-	}
-
+	},
 	extras = [
-		IntegerRef("n", 1, 1000),
+		IntegerRefMF("n", 1, 1000),
 		Choice("nth", {
 			"first"         : "1",
 			"second"        : "2",
@@ -35,10 +32,9 @@ class RuleNameRule(MergeRule):
 			"eighth"        : "8",
 			"(last | final)": "9",
 			})
-	]
-
+	],
 	defaults = {
 		"n": 1,
-	}
-
-control.nexus().merger.add_non_ccr_app_rule(RuleNameRule())
+	},
+	ccr=False
+)
diff --git a/mathfly/apps/sublime.py b/mathfly/apps/sublime.py
index a42a8e8..3934c94 100644
--- a/mathfly/apps/sublime.py
+++ b/mathfly/apps/sublime.py
@@ -1,9 +1,7 @@
 from mathfly.imports import *
 
-class SublimeRule(MergeRule):
-    pronunciation = "sublime"
-    mcontext = AppContext(executable="sublime_text", title="Sublime Text")
-
+Breathe.add_commands(
+    context = AppContext(executable="sublime_text", title="Sublime Text"),
     mapping = {
         "new (file | pane)": Key("c-n"),
         # {"keys": ["ctrl+alt+n"], "command": "new_window"},
@@ -86,13 +84,12 @@ class SublimeRule(MergeRule):
 
         "zoom in [<n2>]":   Key("c-equal")*Repeat(extra="n2"),
         "zoom out [<n2>]":   Key("c-minus")*Repeat(extra="n2"),
-
-    }
+    },
     extras = [
-        IntegerRef("n11", 1, 100),
-        IntegerRef("n12", 0, 100),
-        IntegerRef("n2", 1, 9),
-        IntegerRef("n3", 1, 21),
+        IntegerRefMF("n11", 1, 100),
+        IntegerRefMF("n12", 0, 100),
+        IntegerRefMF("n2", 1, 9),
+        IntegerRefMF("n3", 1, 21),
         Choice("nth", {
             "first": "1",
             "second": "2",
@@ -117,14 +114,11 @@ class SublimeRule(MergeRule):
             "two": "2",
             "right": "2",
             }),
-    ]
+    ],
     defaults = {
         "n12": "",
         "n2": 1,
         "n3": 1,
-    }
-
-
-#---------------------------------------------------------------------------
-
-control.nexus().merger.add_non_ccr_app_rule(SublimeRule())
\ No newline at end of file
+    },
+    ccr=False
+)
\ No newline at end of file
diff --git a/mathfly/apps/sumatrapdf.py b/mathfly/apps/sumatrapdf.py
index d896b9d..1d5f42c 100644
--- a/mathfly/apps/sumatrapdf.py
+++ b/mathfly/apps/sumatrapdf.py
@@ -1,9 +1,7 @@
 from mathfly.imports import *
 
-class SumatraPDFRule(MergeRule):
-	pronunciation = "SumatraPDF"
-	mcontext = AppContext(title="SumatraPDF")
-
+Breathe.add_commands(
+	AppContext(title="SumatraPDF"),
 	mapping = {
 		# https://www.sumatrapdfreader.org/manual.html
 		"open file"           : Key("c-o"),
@@ -18,7 +16,7 @@ class SumatraPDFRule(MergeRule):
 		"find"                : Key("c-f"),
 		"find next"           : Key("f3"),
 		"find previous"       : Key("s-f3"),
-		"page <n>"            : Key("c-g") + Text("%(n)s") + Key("enter"),
+		"page <n1000>"        : Key("c-g") + Text("%(n1000)s") + Key("enter"),
 		"table of contents"   : Key("f12"),
 
 		"zoom in"             : Key("c-equals"),
@@ -34,10 +32,9 @@ class SumatraPDFRule(MergeRule):
 		"rotate left"         : Key("c-minus"),
 		"presentation [mode]" : Key("f11"),
 		"full screen"         : Key("s-f11"),
-	}
-
+	},
 	extras = [
-		IntegerRef("n", 1, 1000),
+		IntegerRef("n1000", 1, 1000),
 		Choice("nth", {
 			"first"         : "1",
 			"second"        : "2",
@@ -49,10 +46,6 @@ class SumatraPDFRule(MergeRule):
 			"eighth"        : "8",
 			"(last | final)": "9",
 			})
-	]
-
-	defaults = {
-		"n": 1,
-	}
-
-control.nexus().merger.add_non_ccr_app_rule(SumatraPDFRule())
+	],
+	ccr=False
+)
\ No newline at end of file
diff --git a/mathfly/apps/wordpad.py b/mathfly/apps/wordpad.py
index e964df1..830bb76 100644
--- a/mathfly/apps/wordpad.py
+++ b/mathfly/apps/wordpad.py
@@ -1,9 +1,7 @@
 from mathfly.imports import *
 
-class WordPadRule(MergeRule):
-	pronunciation = "WordPad"
-	mcontext = AppContext(title="WordPad")
-
+Breathe.add_commands(
+	AppContext(title="WordPad"),
 	mapping = {
 		"new file"            : Key("c-n"),
 		"open file"           : Key("c-o"),
@@ -11,14 +9,6 @@ class WordPadRule(MergeRule):
 
 		"page down [<n>]"     : Key("c-pagedown:%(n)s"),
 		"page up [<n>]"       : Key("c-pageup:%(n)s"),
-	}
-
-	extras = [
-		IntegerRef("n", 1, 1000),
-	]
-
-	defaults = {
-		"n": 1,
-	}
-
-control.nexus().merger.add_non_ccr_app_rule(WordPadRule())
+	},
+	ccr=False
+)
diff --git a/mathfly/ccr/LyX.py b/mathfly/ccr/LyX.py
index 85db365..8c586b4 100644
--- a/mathfly/ccr/LyX.py
+++ b/mathfly/ccr/LyX.py
@@ -5,8 +5,8 @@
 '''
 from mathfly.imports import *
 
-BINDINGS = utilities.load_toml_relative("config/lyx.toml")
-CORE     = utilities.load_toml_relative("config/core.toml")
+BINDINGS = utilities.load_config("lyx.toml")
+CORE     = utilities.load_config("core.toml")
 
 def greek(big, greek_letter):
     if big:
@@ -17,125 +17,104 @@ def matrix(rows, cols):
     Text("\\" + BINDINGS["matrix_style"] + " ").execute()
     Key("a-m, w, i, "*(rows-1) + "a-m, c, i, "*(cols-1)).execute()
 
-class lyx_nested(NestedRule):
-    mapping = {
+Breathe.add_commands(
+    AppContext(executable="lyx.exe"),
+    {
+        "<control>": Key("%(control)s"),
+        "<control_repeat> [<n>]": Key("%(control_repeat)s") * Repeat("n"),
+    },
+    [
+        Choice("control", BINDINGS["control"]),
+        Choice("control_repeat", BINDINGS["control_repeat"]),
+    ],
+    ccr=False,
+)
+
+Breathe.add_commands(
+    AppContext(executable="lyx.exe"),
+    {
+        "<numbers>": Text("%(numbers)s"),
+        BINDINGS["symbol1_prefix"] + " <symbol1>": Text("\\%(symbol1)s "),
+        BINDINGS["symbol2_prefix"] + " <symbol2>": Text("\\%(symbol2)s "),
+        BINDINGS["accent_prefix"] + " <accent>": Key("a-m, %(accent)s"),
+        BINDINGS["text_prefix"] + " <text_modes>": Text("\\%(text_modes)s "),
+        BINDINGS["greek_prefix"] + " [<big>] <greek_letter>": Function(greek),
+        "<misc_lyx_keys>": Key("%(misc_lyx_keys)s"),
+        "<command>": Alternating("command"),
+        "matrix <rows> by <cols>": Function(matrix),
+        "<numbers> <denominator>": Key(
+            "a-m, f, %(numbers)s, down, %(denominator)s, right"
+        ),
+    },
+    [
+        IntegerRef("rows", 1, BINDINGS["max_matrix_size"]),
+        IntegerRef("cols", 1, BINDINGS["max_matrix_size"]),
+        IntegerRefMF("numbers", 0, CORE["numbers_max"]),
+        Choice("big", {CORE["capitals_prefix"]: True}, default=False),
+        Choice("greek_letter", BINDINGS["greek_letters"]),
+        Choice("symbol1", BINDINGS["tex_symbols1"]),
+        Choice("symbol2", BINDINGS["tex_symbols2"]),
+        Choice("accent", BINDINGS["accents"]),
+        Choice("text_modes", BINDINGS["text_modes"]),
+        Choice("misc_lyx_keys", BINDINGS["misc_lyx_keys"]),
+        Choice("command", BINDINGS["misc_lyx_commands"]),
+        Choice("denominator", BINDINGS["denominators"]),
+    ],
+)
+
+
+Breathe.add_commands(
+    AppContext(executable="lyx.exe"),
+    {
         "[<before>] integral from <sequence1> to <sequence2>":
-            [Text("\\int _"), Key("right, caret"), Key("right")],
+            Exec("before") + Text("\\int _") + Exec("sequence1")
+            + Key("right, caret") + Exec("sequence2") + Key("right"),
 
         "[<before>] definite from <sequence1> to <sequence2>":
-            [Key("a-m, lbracket, right, underscore"),
-            Key("right, caret"), Key("right, left:2")],
+            Exec("before") + Key("a-m, lbracket, right, underscore")
+            + Exec("sequence1") + Key("right, caret") + Exec("sequence2") + Key("right, left:2"),
 
         "[<before>] differential <sequence1> by <sequence2>":
-            [Key("a-m, f, d"), Key("down, d"), Key("right")],
+            Exec("before") + Key("a-m, f, d") + Exec("sequence1")
+            + Key("down, d") + Exec("sequence2") + Key("right"),
 
         "[<before>] sum from <sequence1> to <sequence2>":
-            [Text("\\stackrelthree ") + Key("down") + Text("\\sum ") + Key("down"),
-            Key("up:2"), Key("right")],
+            Exec("before") + Text("\\stackrelthree ") + Key("down")
+            + Text("\\sum ") + Key("down") + Exec("sequence1") + Key("up:2")
+            + Exec("sequence2") + Key("right"),
 
         "[<before>] limit from <sequence1> to <sequence2>":
-            [Text("\\underset \\lim ") + Key("down"),
-            Text("\\rightarrow "), Key("right")],
+            Exec("before") + Text("\\underset \\lim ") + Key("down")
+            + Exec("sequence1") + Text("\\rightarrow ") + Exec("sequence2") + Key("right"),
 
         "[<before>] argument that <minmax> <sequence1>":
-            [Text("\\underset \\arg \\%(minmax)s ") + Key("down"),
-            Key("right"), None],
+            Exec("before") + Text("\\underset \\arg \\%(minmax)s ")
+            + Key("down") + Exec("sequence1") + Key("right"),
 
         "[<before>] <minmax> by <sequence1>":
-            [Text("\\underset \\%(minmax)s ") + Key("down"),
-            Key("right"), None],
+            Exec("before") + Text("\\underset \\%(minmax)s ")
+            + Key("down") + Exec("sequence1") + Key("right"),
 
         "[<before>] <script1> <singleton1> [<after>]":
-            [Key("%(script1)s"), Key("right"), None],
+            Exec("before") + Key("%(script1)s") + Exec("singleton1") + Key("right") + Exec("after"),
 
         "[<before>] <script1> <singleton1> <script2> <singleton2> [<after>]":
-            [Key("%(script1)s"), Key("right, %(script2)s"), Key("right")],
-    }
-    extras = [
-        Choice("minmax", {
-            "(minimum | minimises)": "min",
-            "(maximum | maximises)": "max",
-            }),
-        Choice("script1", {
-            "sub": "_",
-            "super": "^",
-            }),
-        Choice("script2", {
-            "sub": "_",
-            "super": "^",
-            }),
-    ]
-
-class lyx_mathematicsNon(MergeRule):
-    mapping = {
-        "<control>":
-            Key("%(control)s"),
-        "<control_repeat> [<n>]":
-            Key("%(control_repeat)s")*Repeat(extra="n"),
-    }
-    extras = [
-        IntegerRef("n", 1, 10),
-        Choice("control",        BINDINGS["control"]),
-        Choice("control_repeat", BINDINGS["control_repeat"]),
-    ]
-    defaults = {
-        "n": 1,
-    }
-
-class lyx_mathematics(MergeRule):
-    non = lyx_mathematicsNon
-    nested = lyx_nested
-    mwith = CORE["pronunciation"]
-    mcontext = AppContext(executable="lyx")
-    pronunciation = BINDINGS["pronunciation"]
-
-    mapping = {
-        BINDINGS["symbol1_prefix"] + " <symbol1>":
-            Text("\\%(symbol1)s "),
-
-        BINDINGS["symbol2_prefix"] + " <symbol2>":
-            Text("\\%(symbol2)s "),
-
-        BINDINGS["accent_prefix"] + " <accent>":
-            Key("a-m, %(accent)s"),
-
-        BINDINGS["text_prefix"] + " <text_modes>":
-            Text("\\%(text_modes)s "),
-
-        BINDINGS["greek_prefix"] + " [<big>] <greek_letter>":
-            Function(greek),
-
-        "<misc_lyx_keys>":
-            Key("%(misc_lyx_keys)s"),
-
-        "<command>":
-            Alternating("command"),
-
-        "matrix <rows> by <cols>":
-            Function(matrix),
-
-        "<numbers> <denominator>":
-            Key("a-m, f") + Text("%(numbers)s") + Key("down") + Text("%(denominator)s") + Key("right"),
-
-    }
-
-    extras = [
-        IntegerRef("rows",    1, BINDINGS["max_matrix_size"]),
-        IntegerRef("cols",    1, BINDINGS["max_matrix_size"]),
-        IntegerRef("numbers", 0, CORE["numbers_max"]),
-        Choice("big",           {CORE["capitals_prefix"]: True}),
-        Choice("greek_letter",   BINDINGS["greek_letters"]),
-        Choice("symbol1",        BINDINGS["tex_symbols1"]),
-        Choice("symbol2",        BINDINGS["tex_symbols2"]),
-        Choice("accent",         BINDINGS["accents"]),
-        Choice("text_modes",     BINDINGS["text_modes"]),
-        Choice("misc_lyx_keys",  BINDINGS["misc_lyx_keys"]),
-        Choice("command",        BINDINGS["misc_lyx_commands"]),
-        Choice("denominator",    BINDINGS["denominators"]),
-    ]
-
-    defaults = {
-        "big": False,
-    }
-
-control.nexus().merger.add_app_rule(lyx_mathematics())
+            Exec("before") + Key("%(script1)s") + Exec("singleton1")
+            + Key("right, %(script2)s") + Exec("singleton2") + Key("right") + Exec("after"),
+    },
+    extras=[
+        Choice(
+            "minmax", {"(minimum | minimises)": "min", "(maximum | maximises)": "max"}
+        ),
+        Choice("script1", {"sub": "_", "super": "^"}),
+        Choice("script2", {"sub": "_", "super": "^"}),
+        CommandsRef("before", 8),
+        CommandsRef("after", 8),
+        CommandsRef("singleton1", 1),
+        CommandsRef("singleton2", 1),
+        CommandsRef("sequence1", 4),
+        CommandsRef("sequence2", 4),
+    ],
+    top_level=True,
+)
+
diff --git a/mathfly/ccr/ScientificNotebook55.py b/mathfly/ccr/ScientificNotebook55.py
index dc1062c..1a76e65 100644
--- a/mathfly/ccr/ScientificNotebook55.py
+++ b/mathfly/ccr/ScientificNotebook55.py
@@ -5,141 +5,127 @@
 '''
 from mathfly.imports import *
 
-BINDINGS = utilities.load_toml_relative("config/ScientificNotebook55.toml")
-CORE = utilities.load_toml_relative("config/core.toml")
+BINDINGS = utilities.load_config("ScientificNotebook55.toml")
+CORE = utilities.load_config("core.toml")
 
-#---------------------------------------------------------------------------
+#------------------------------------------------
+
+def TeX(symbol):
+    return Key("ctrl:down") + Text(symbol) + Key("ctrl:up")
 
-def texchar(symbol):
-    keychain = "ctrl:down, "
-    for character in symbol:
-        keychain = keychain + character + ", "
-    keychain=keychain + "ctrl:up"
-    Key(keychain).execute()
 
 def greek(big, greek_letter):
     if big:
         greek_letter = greek_letter.upper()
     Key("c-g, " + greek_letter).execute()
 
+
 def matrix(rows, cols):
     Key("f10/5, i/5, down:8, enter/50").execute()
     Key(str(rows) + "/50, tab, " + str(cols) + "/50, enter").execute()
 
-class sn_nested(NestedRule):
-    mapping = {
+
+#------------------------------------------------
+
+
+Breathe.add_commands(
+    AppContext(executable="scientific notebook"),
+    {
+        "text <text>": Key("c-t")
+        + Function(lambda text: Text(text.capitalize()).execute()),
+        "<control>": Key("%(control)s"),
+    },
+    [
+        Choice("control", BINDINGS["control"]),
+    ],
+    ccr=False,
+)
+
+Breathe.add_commands(
+    AppContext(executable="scientific notebook"),
+    {
+        BINDINGS["symbol_prefix"] + " <symbol>": TeX("%(symbol)s"),
+        #
+        BINDINGS["greek_prefix"] + " [<big>] <greek_letter>": Function(greek),
+        BINDINGS["accent_prefix"] + " <accent>": Key("%(accent)s"),
+        BINDINGS["unit_prefix"] + " <units>": Alternating("units"),
+        "<misc_sn_keys>": Key("%(misc_sn_keys)s"),
+        "<misc_sn_text>": Text("%(misc_sn_text)s"),
+        "matrix <rows> by <cols>": Function(matrix),
+        "<numbers>": Text("%(numbers)s"),
+        "<numbers> <denominator>": Key("c-f")
+        + Text("%(numbers)s")
+        + Key("down")
+        + Text("%(denominator)s")
+        + Key("right"),
+    },
+    [
+        IntegerRef("rows", 1, BINDINGS["max_matrix_size"]),
+        IntegerRef("cols", 1, BINDINGS["max_matrix_size"]),
+        IntegerRefMF("numbers", 0, CORE["numbers_max"]),
+        Choice("big", {CORE["capitals_prefix"]: True}, default=False),
+        Choice("greek_letter", BINDINGS["greek_letters"]),
+        Choice("units", BINDINGS["units"]),
+        Choice("symbol", BINDINGS["tex_symbols"]),
+        Choice("accent", BINDINGS["accents"]),
+        Choice("misc_sn_keys", BINDINGS["misc_sn_keys"]),
+        Choice("misc_sn_text", BINDINGS["misc_sn_text"]),
+        Choice("denominator", BINDINGS["denominators"]),
+    ],
+)
+
+
+Breathe.add_commands(
+    AppContext(executable="scientific notebook"),
+    {
         "[<before>] integral from <sequence1> to <sequence2>":
-            [Function(lambda: texchar("int")) + Key("c-l"),
-            Key("right, c-h"), Key("right")],
+            Exec("before") + TeX("int") + Key("c-l") + Exec("sequence1")
+            + Key("right, c-h") + Exec("sequence2") + Key("right"),
 
         "[<before>] definite from <sequence1> to <sequence2>":
-            [Key("c-6, right, c-l"),
-            Key("right, c-h"), Key("right, c-left, left")],
+            Exec("before") + Key("c-6, right, c-l") + Exec("sequence1")
+            + Key("right, c-h") + Exec("sequence2") + Key("right, c-left, left"),
 
         "[<before>] differential <sequence1> by <sequence2>":
-            [Key("c-f, d"), Key("down, d"), Key("right")],
+            Exec("before") + Key("c-f") + TeX("partial") + Exec("sequence1")
+            + Key("down") + TeX("partial") + Exec("sequence2") + Key("right"),
 
         "[<before>] sum from <sequence1> to <sequence2>":
-            [Key("f10, i, down:11, enter/25, a, enter, f10, i, down:11, enter/25, b, enter") + Function(lambda: texchar("sum")) + Key("down"),
-            Key("up:2"), Key("right")],
+            Exec("before") + Key("f10, i, down:11, enter/25, a, enter, f10, i, down:11, enter/25, b, enter")
+            + TeX("sum") + Key("down") + Exec("sequence1") + Key("up:2") + Exec("sequence2") + Key("right"),
 
         "[<before>] limit from <sequence1> to <sequence2>":
-            [Key("f10, i, down:11, enter/25, b, enter") + Function(lambda: texchar("lim")) + Key("down"),
-            Function(lambda: texchar("rightarrow")),
-            Key("right")],
+            Exec("before") + Key("f10, i, down:11, enter/25, b, enter")
+            + TeX("lim") + Key("down") + Exec("sequence1") + TeX("rightarrow")
+            + Exec("sequence2") + Key("right"),
 
         "[<before>] argument that <minmax> <sequence1>":
-            [Key("f10, i, down:11, enter/25, b, enter") + Text("arg%(minmax)s") + Key("down"),
-            Key("right"), None],
+            Exec("before") + Key("f10, i, down:11, enter/25, b, enter")
+            + Text("arg%(minmax)s") + Key("down") + Exec("sequence1") + Key("right"),
 
         "[<before>] <minmax> by <sequence1>":
-            [Key("f10, i, down:11, enter/25, b, enter") + Text("%(minmax)s") + Key("down"),
-            Key("right"), None],
+            Exec("before") + Key("f10, i, down:11, enter/25, b, enter")
+            + Text("%(minmax)s") + Key("down") + Exec("sequence1") + Key("right"),
 
         "[<before>] <script1> <singleton1> [<after>]":
-            [Key("%(script1)s"), Key("right"), None],
+            Exec("before") + Key("%(script1)s") + Exec("singleton1") + Key("right") + Exec("after"),
 
         "[<before>] <script1> <singleton1> <script2> <singleton2> [<after>]":
-            [Key("%(script1)s"), Key("right, %(script2)s"), Key("right")],
-
-    }
-    extras = [
-        Choice("minmax", {
-            "(minimum | minimises)": "min",
-            "(maximum | maximises)": "max",
-            }),
-        Choice("script1", {
-            "sub": "c-l",
-            "super": "c-h",
-            }),
-        Choice("script2", {
-            "sub": "c-l",
-            "super": "c-h",
-            }),
-    ]
-
-class sn_mathematicsNon(MergeRule):
-    mapping = {
-        "text <dict>":
-            Key("c-t") + Function(lambda dict: Text(str(dict).capitalize()).execute()),
-        "<control>":
-            Key("%(control)s"),
-    }
-    extras = [
-        Dictation("dict"),
-        IntegerRef("n", 1, 10),
-        Choice("control", BINDINGS["control"]),
-    ]
-
-
-class sn_mathematics(MergeRule):
-    non = sn_mathematicsNon
-    mwith = CORE["pronunciation"]
-    mcontext = AppContext(executable="scientific notebook")
-    pronunciation = BINDINGS["pronunciation"]
-
-    nested = sn_nested
-
-    mapping = {
-        BINDINGS["symbol_prefix"] + " <symbol>":
-            Function(texchar),
-        #
-        BINDINGS["greek_prefix"] + " [<big>] <greek_letter>":
-            Function(greek),
-        BINDINGS["accent_prefix"] + " <accent>":
-            Key("%(accent)s"),
-
-        BINDINGS["unit_prefix"] + " <units>":
-            Alternating("units"),
-
-        "<misc_sn_keys>":
-            Key("%(misc_sn_keys)s"),
-        "<misc_sn_text>":
-            Text("%(misc_sn_text)s"),
-
-        "matrix <rows> by <cols>":
-            Function(matrix),
-
-        "<numbers> <denominator>":
-            Key("c-f") + Text("%(numbers)s") + Key("down") + Text("%(denominator)s") + Key("right"),
-    }
-
-    extras = [
-        IntegerRef("rows",    1, BINDINGS["max_matrix_size"]),
-        IntegerRef("cols",    1, BINDINGS["max_matrix_size"]),
-        IntegerRef("numbers", 0, CORE["numbers_max"]),
-        Choice("big",           {CORE["capitals_prefix"]: True}),
-        Choice("greek_letter",   BINDINGS["greek_letters"]),
-        Choice("units",          BINDINGS["units"]),
-        Choice("symbol",         BINDINGS["tex_symbols"]),
-        Choice("accent",         BINDINGS["accents"]),
-        Choice("misc_sn_keys",   BINDINGS["misc_sn_keys"]),
-        Choice("misc_sn_text",   BINDINGS["misc_sn_text"]),
-        Choice("denominator",    BINDINGS["denominators"]),
-    ]
-
-    defaults = {
-        "big": False,
-    }
-
-control.nexus().merger.add_app_rule(sn_mathematics())
+            Exec("before") + Key("%(script1)s") + Exec("singleton1")
+            + Key("right, %(script2)s") + Exec("singleton2") + Key("right") + Exec("after"),
+    },
+    [
+        Choice(
+            "minmax", {"(minimum | minimises)": "min", "(maximum | maximises)": "max"}
+        ),
+        Choice("script1", {"sub": "c-l", "super": "c-h"}),
+        Choice("script2", {"sub": "c-l", "super": "c-h"}),
+        CommandsRef("before", 8),
+        CommandsRef("after", 8),
+        CommandsRef("singleton1", 1),
+        CommandsRef("singleton2", 1),
+        CommandsRef("sequence1", 4),
+        CommandsRef("sequence2", 4),
+    ],
+    top_level=True,
+)
diff --git a/mathfly/ccr/alias.py b/mathfly/ccr/alias.py
index cfb9ceb..031ef62 100644
--- a/mathfly/ccr/alias.py
+++ b/mathfly/ccr/alias.py
@@ -1,36 +1,40 @@
 from mathfly.imports import *
 
-MF_NEXUS = control.nexus()
+aliases = DictList("aliases", utilities.load_toml_relative("config/aliases.toml"))
 
-class Alias(SelfModifyingRule):
-    mapping = {"default command": ""}
-    key = "aliases"
-    pronunciation = "alias"
+def add_alias(spec):
+    _, text = utilities.read_selected(True)
+    if text and spec:
+        aliases[str(spec)] = text
+        utilities.save_toml_relative(dict(aliases), "config/aliases.toml")
 
-    def delete_all(self, key):
-        utilities.save_toml_relative({}, "config/aliases.toml")
-        self.refresh()
+def delete_aliases():
+    aliases.clear()
+    utilities.save_toml_relative(dict(aliases), "config/aliases.toml")
 
-    def alias(self, spec):
-        spec = str(spec)
-        e, text = utilities.read_selected(True)
-        if spec and text:
-            self.refresh(spec, str(text))
+def delete_alias(alias):
+    for k, v in dict(aliases).items():
+        if v == alias:
+            del aliases[k]
+            utilities.save_toml_relative(dict(aliases), "config/aliases.toml")
+            break
 
-    def refresh(self, *args):
-        '''args: spec, text'''
-        aliases = utilities.load_toml_relative("config/aliases.toml")
-        if not Alias.key in aliases:
-            aliases[Alias.key] = {}
-        if len(args) > 0:
-            aliases[Alias.key][args[0]] = args[1]
-            utilities.save_toml_relative(aliases, "config/aliases.toml")
-        mapping = {}
-        for spec in aliases[Alias.key]:
-            mapping[spec] = Function(utilities.paste_string,
-                    content=str(aliases[Alias.key][spec]))
-        mapping["alias <s>"] = Function(lambda s: self.alias(s))
-        mapping["delete aliases"] = Function(self.delete_all, key=Alias.key)
-        self.reset(mapping)
+Breathe.add_commands(
+    None,
+    {
+        "alias <text>": lambda text: add_alias(text),
+        "delete all aliases": delete_aliases,
+    },
+    ccr=False
+)
 
-control.nexus().merger.add_selfmodrule(Alias())
+Breathe.add_commands(
+    None,
+    {
+        "delete alias <alias>": delete_alias,
+        "<alias>": Text("%(alias)s")
+    },
+    [
+        DictListRef("alias", aliases),
+    ]
+)
\ No newline at end of file
diff --git a/mathfly/ccr/core.py b/mathfly/ccr/core.py
index 14a7e20..712ecce 100644
--- a/mathfly/ccr/core.py
+++ b/mathfly/ccr/core.py
@@ -5,8 +5,8 @@
 '''
 from mathfly.imports import *
 
-SETTINGS = utilities.load_toml_relative("config/settings.toml")
-CORE = utilities.load_toml_relative("config/core.toml")
+SETTINGS = utilities.load_settings()
+CORE = utilities.load_config("core.toml")
 
 _LETTERS, _DIRECTIONS = "letters", "directions"
 if SETTINGS["alternative_letters"]:
@@ -15,38 +15,39 @@
 	_DIRECTIONS += "_alt"
 
 def alphabet(big, letter):
-	if big:
-		letter = letter.upper()
-	Key(letter).execute()
+	Key(letter.upper() if big else letter).execute()
 
-class coreNon(MergeRule):
+Breathe.add_commands(
+    context=None,
     mapping = {
         "configure " + CORE["pronunciation"]:
-            Function(utilities.load_config, config_name="core.toml"),
+            Function(utilities.edit_config, fname="core.toml"),
         "configure scientific notebook":
-            Function(utilities.load_config, config_name="ScientificNotebook55.toml"),
+            Function(utilities.edit_config, fname="ScientificNotebook55.toml"),
         "configure (LyX | licks)":
-            Function(utilities.load_config, config_name="lyx.toml"),
+            Function(utilities.edit_config, fname="lyx.toml"),
+
+        "configure math fly [settings]":
+            Function(utilities.load_config, config_name="settings.toml"),
+
+        "reboot dragon": Function(utilities.reboot),
+
+        "math fly help": Function(utilities.help),
 
         "<noCCR_repeatable_key> [<n>]":
             Key("%(noCCR_repeatable_key)s")*Repeat(extra="n"),
         "<noCCR_non_repeatable_key>":
             Key("%(noCCR_non_repeatable_key)s"),
-    }
+    },
     extras = [
-        IntegerRef("n", 1, 10),
         Choice("noCCR_repeatable_key", CORE["noCCR_repeatable_keys"]),
         Choice("noCCR_non_repeatable_key", CORE["noCCR_non_repeatable_keys"]),
-    ]
-    defaults = {
-        "n": 1,
-    }
-
-class core(MergeRule):
-    non = coreNon
-
-    pronunciation = CORE["pronunciation"]
+    ],
+    ccr=False
+)
 
+Breathe.add_commands(
+    context=None,
     mapping = {
     	"[<big>] <letter>":
             Function(alphabet),
@@ -67,31 +68,17 @@ class core(MergeRule):
 
         "shift click":
             Key("shift:down") + Mouse("left") + Key("shift:up"),
-    	}
-
+    },
     extras = [
-        Dictation("text"),
-    	IntegerRef("n", 1, 10),
-        IntegerRef("n50", 1, 50),
+        IntegerRef("n50", 1, 50, 1),
         IntegerRefMF("numbers", 0,   CORE["numbers_max"]),
-        Choice("big",               {CORE["capitals_prefix"]: True}),
+        Choice("big",               {CORE["capitals_prefix"]: True}, default=False),
+        Choice("extreme",           {CORE["extreme"]: True}, default=False),
     	Choice("letter",             CORE[_LETTERS]),
     	Choice("punctuation",        CORE["punctuation"]),
     	Choice("repeatable_key",     CORE["repeatable_keys"]),
     	Choice("non_repeatable_key", CORE["non_repeatable_keys"]),
-    	Choice("direction",          CORE[_DIRECTIONS]),
-    	Choice("modifier",           CORE["modifiers"]),
-        Choice("extreme",           {CORE["extreme"]: True}),
-    ]
-
-    defaults = {
-        "big"      : False,
-        "extreme"  : False,
-        "n"        : 1,
-        "n50"      : 1,
-        "direction": "left",
-        "modifier" : "",
-    }
-
-
-control.nexus().merger.add_global_rule(core())
\ No newline at end of file
+    	Choice("direction",          CORE[_DIRECTIONS], default="left"),
+    	Choice("modifier",           CORE["modifiers"], default=""),
+    ],
+)
diff --git a/mathfly/ccr/global_extras.py b/mathfly/ccr/global_extras.py
new file mode 100644
index 0000000..a8d84a1
--- /dev/null
+++ b/mathfly/ccr/global_extras.py
@@ -0,0 +1,6 @@
+from mathfly.imports import *
+
+Breathe.add_global_extras(
+    Dictation("text", default=""),
+    IntegerRef("n", 1, 20, 1)
+)
diff --git a/mathfly/ccr/latex.py b/mathfly/ccr/latex.py
index 5e16a98..83032ca 100644
--- a/mathfly/ccr/latex.py
+++ b/mathfly/ccr/latex.py
@@ -4,10 +4,11 @@
 '''
 from mathfly.imports import *
 
-BINDINGS = utilities.load_toml_relative("config/latex.toml")
-CORE = utilities.load_toml_relative("config/core.toml")
+BINDINGS = utilities.load_config("latex.toml")
+CORE = utilities.load_config("core.toml")
 
-class LaTeXNon(MergeRule):
+Breathe.add_commands(
+    AppContext(title=BINDINGS["title_contexts"]) | CommandContext(BINDINGS["pronunciation"]),
     mapping = {
         "configure " + BINDINGS["pronunciation"]:
             Function(utilities.load_config, config_name="latex.toml"),
@@ -16,11 +17,11 @@ class LaTeXNon(MergeRule):
             Function(tex_funcs.selection_to_bib, bib_path=BINDINGS["bibliography_path"]),
 
         "(open | edit) bibliography":
-            Function(utilities.load_text_file, path=BINDINGS["bibliography_path"]),
+            Function(utilities.edit_text_file, path=BINDINGS["bibliography_path"]),
 
         BINDINGS["template_prefix"] + " <template>":
             Function(execution.template),
-    }
+    },
     extras = [
         Choice("ref_type", {
                 "book": "book",
@@ -28,13 +29,12 @@ class LaTeXNon(MergeRule):
                 "paper": "paper",
                 }),
         Choice("template", BINDINGS["templates"]),
-    ]
-
-class LaTeX(MergeRule):
-    non = LaTeXNon
-
-    pronunciation = BINDINGS["pronunciation"]
+    ],
+    ccr=False
+)
 
+Breathe.add_commands(
+    AppContext(title=BINDINGS["title_contexts"]) | CommandContext(BINDINGS["pronunciation"]),
     mapping = {
         "insert comment":  Text("% "),
 
@@ -73,13 +73,11 @@ class LaTeX(MergeRule):
         BINDINGS["command_prefix"] + " quote":
             Function(tex_funcs.quote),
         #
-
-    }
-
+    },
     extras = [
-        Choice("big",        {CORE["capitals_prefix"]: True}),
-        Choice("packopts",    BINDINGS["packages"]),
-        Choice("doc_class",   BINDINGS["document_classes"]),
+        Choice("big",        {CORE["capitals_prefix"]: True}, default=False),
+        Choice("packopts",    BINDINGS["packages"], default=""),
+        Choice("doc_class",   BINDINGS["document_classes"], default=""),
         Choice("greek_letter",BINDINGS["greek_letters"]),
         Choice("symbol",      BINDINGS["symbols"]),
         Choice("misc_symbol", BINDINGS["misc_symbols"]),
@@ -89,12 +87,5 @@ class LaTeX(MergeRule):
         Choice("commandnoarg",BINDINGS["commandnoarg"]),
         Choice("commandmisc", BINDINGS["commandmisc"]),
         Choice("environment", BINDINGS["environments"]),
-        ]
-    defaults = {
-        "big"      : False,
-        "packopts" : "",
-        "doc_class": "",
-    }
-
-
-control.nexus().merger.add_global_rule(LaTeX())
+    ]
+)
diff --git a/mathfly/ccr/latex_maths.py b/mathfly/ccr/latex_maths.py
index ffbd9d4..5f327bf 100644
--- a/mathfly/ccr/latex_maths.py
+++ b/mathfly/ccr/latex_maths.py
@@ -5,8 +5,8 @@
 '''
 from mathfly.imports import *
 
-BINDINGS = utilities.load_toml_relative("config/latex.toml")
-CORE = utilities.load_toml_relative("config/core.toml")
+BINDINGS = utilities.load_config("latex.toml")
+CORE = utilities.load_config("core.toml")
 
 def symbol(symbol):
     if type(symbol) in [str, unicode, int]:
@@ -16,23 +16,18 @@ def symbol(symbol):
         Text("{}"*int(symbol[1])).execute()
         Key("left:" + str(2*int(symbol[1])-1)).execute()
 
-class LaTeXmath(MergeRule):
-    pronunciation = BINDINGS["pronunciation"]  +  " maths"
-
+Breathe.add_commands(
+    (AppContext(title=BINDINGS["title_contexts"]) | CommandContext(BINDINGS["pronunciation"]))
+    & CommandContext(BINDINGS["pronunciation"] + " maths"),
     mapping = {
         "<numbers>": Text("%(numbers)s"),
         "<symbol>":  Function(symbol),
         "<misc_symbol>":
             Alternating("misc_symbol"),
-    }
-
+    },
     extras = [
-        IntegerRef("numbers", 0, CORE["numbers_max"]),
+        IntegerRefMF("numbers", 0, CORE["numbers_max"]),
         Choice("symbol", BINDINGS["symbols"]),
         Choice("misc_symbol", BINDINGS["misc_symbols"]),
-        ]
-    defaults = {
-    }
-
-
-control.nexus().merger.add_global_rule(LaTeXmath())
+    ]
+)
diff --git a/mathfly/config/latex.toml b/mathfly/config/latex.toml
index 4780c18..1468c3c 100755
--- a/mathfly/config/latex.toml
+++ b/mathfly/config/latex.toml
@@ -1,6 +1,7 @@
 # Once you have finished making changes, use the "rebuild mathfly"
 # command to enact them.
 "pronunciation"      = "LaTeX"
+"title_contexts"     = [".tex"]
 # Insert your own .bib file here, e.g.
 # "bibliography_path" = "C:/Users/Mike/Documents/bibliography.bib"
 "bibliography_path"  = ""
diff --git a/mathfly/config/nld/lyx.toml b/mathfly/config/nld/lyx.toml
new file mode 100644
index 0000000..9ef197c
--- /dev/null
+++ b/mathfly/config/nld/lyx.toml
@@ -0,0 +1,273 @@
+# Once you have finished making changes, use the "rebuild mathfly"
+# command to enact them.
+"pronunciation"   = "LyX"
+"greek_prefix"    = "greek"
+"symbol1_prefix"  = ""
+"symbol2_prefix"  = "symbol"
+"text_prefix"     = "text"
+"number_prefix"   = ""
+"accent_prefix"   = "accent"
+"matrix_style"    = "matrix"
+"max_matrix_size" = 10
+
+# For a full list of the available key formatting options,
+# see https://pythonhosted.org/dragonfly/actions.html
+[misc_lyx_keys]
+"math mode"                       = "c-m"
+"new math line"                   = "escape:10, end, enter, c-m"
+"fraction"                        = "a-m, f"
+"over"                            = "cs-left, a-m, f, down"
+"(super script | to the power)" = "caret"
+"sub script"                    = "underscore"
+"squared"                         = "caret, 2, right"
+"cubed"                           = "caret, 3, right"
+"inverse"                         = "caret, minus, 1, right"
+"(parens | parentheses)"          = "a-m, lparen"
+"square brackets"                 = "a-m, lbracket"
+"curly brackets"                  = "a-m, lbrace"
+"absolute"                        = "a-m, bar"
+"add matrix row"                  = "a-m, w, i"
+"(delete | remove) matrix row"    = "a-m, w, d"
+"add matrix column"               = "a-m, c, i"
+"(delete | remove) matrix column" = "a-m, c, d"
+
+
+# Alternates between executing as text and executing as keys
+[misc_lyx_commands]
+"summation"              = ["\\stackrelthree ", "down", "\\sum ", "down"]
+"(summation | sum) to N" = ["\\stackrelthree ", "n, down", "\\sum ", "down"]
+"blank product"          = "\\prod "
+"product"                = ["\\stackrelthree ", "down", "\\prod ", "down"]
+"product to N"           = ["\\stackrelthree ", "n, down", "\\prod ", "down"]
+"limit"                  = ["\\underset \\lim ", "down"]
+"blank limit"            = "\\lim "
+"label above"            = "\\overset "
+"label below"            = "\\underset "
+"prime"                  = ["^\\prime ", "right"]
+"degrees"                = ["^\\circ ", "right"]
+"exponential"            = ["\\exp ", "a-m, lparen"]
+"expectation"            = ["E", "a-m, lparen"]
+"variance"               = ["Var", "a-m, lparen"]
+#
+"real numbers"           = ["\\mathbb R", "right"]
+"complex numbers"        = ["\\mathbb C", "right"]
+"integer numbers"        = ["\\mathbb Z", "right"]
+"rational numbers"       = ["\\mathbb Q", "right"]
+"natural numbers"        = ["\\mathbb N", "right"]
+
+
+[greek_letters]
+"alpha"   = "alpha"
+"beater"  = "beta"
+"gamma"   = "gamma"
+"delta"   = "delta"
+"epsilon" = "varepsilon"
+"zita"    = "zeta"
+"eater"   = "eta"
+"theta"   = "theta"
+"iota"    = "iota"
+"kappa"   = "kappa"
+"lambda"  = "lambda"
+"mu"      = "mu"
+"new"     = "nu"
+"zee"     = "xi"
+"pie"     = "pi"
+"row"     = "rho"
+"sigma"   = "sigma"
+"tau"     = "tau"
+"upsilon" = "upsilon"
+"phi"     = "phi"
+"chi"     = "chi"
+"sigh"    = "psi"
+"omega"   = "omega"
+
+
+[tex_symbols1]
+# operators
+"square root"                  = "sqrt"
+"[generic] root"               = "root"
+"integral"                     = "int"
+"double integral"              = "iint"
+"triple integral"              = "iiint"
+"times"                        = "times"
+"divide"                       = "div"
+"stop"                         = "cdot"
+"plus or minus"                = "pm"
+"partial"                      = "partial"
+"infinity"                     = "infty"
+"(nice frack | nice fraction)" = "nicefrac"
+"binomial"                     = "binom"
+"vector nabla"                 = "nabla"
+# trig
+"sine"                         = "sin"
+"cosine"                       = "cos"
+"tangent"                      = "tan"
+"secant"                       = "sec"
+"cosecant"                     = "csc"
+"cotangent"                    = "cot"
+"arc sine"                     = "arcsin"
+"arc cosine"                   = "arccos"
+"arc tan"                      = "arctan"
+"hyperbolic sine"              = "sinh"
+"hyperbolic cosine"            = "cosh"
+"hyperbolic cotangent"         = "coth"
+"hyperbolic tangent"           = "tanh"
+# functions
+"argument"                     = "arg"
+"degree"                       = "deg"
+"determinant"                  = "det"
+"dimension"                    = "dim"
+"(natural (log | logarithm) | log natural)" = "ln"
+"logarithm"                    = "log"
+"maximum"                      = "max"
+"minimum"                      = "min"
+"(modulo | modulus)"           = "bmod"
+"infimum"                      = "inf"
+"supremum"                     = "sup"
+"probability"                  = "Pr"
+# relations
+"there exists"                 = "exists"
+"member"                       = "in"
+"for all"                      = "forall"
+"[is] not equal [to]"          = "neq"
+"[is] greater [than] [or] equal [to]" = "geq"
+"[is] less [than] [or] equal [to]" = "leq"
+"[is] approximately [equal] [to]" = "approx"
+"proportional [to]"            = "propto"
+"preference less [than]"       = "prec"
+"preference less equals"       = "preceq"
+"preference greater [than]"    = "succ"
+"preference greater equal"     = "succeq"
+# sets
+"empty set"                    = "emptyset"
+"subset"                       = "subset"
+"superset"                     = "supset"
+"strict subset"                = "subsetneq"
+"strict superset"              = "supsetneq"
+"intersection"                 = "cap"
+"union"                        = "cup"
+# logic
+"logic and"                    = "land"
+"logic or"                     = "lor"
+"logic not"                    = "lnot"
+#
+"left arrow"                   = "leftarrow"
+"right arrow"                  = "rightarrow"
+"up arrow"                     = "uparrow"
+"down arrow"                   = "downarrow"
+"left right arrow"             = "leftrightarrow"
+"maps to"                      = "mapsto"
+"oh plus"                      = "oplus"
+"oh times"                     = "otimes"
+"big oh plus"                  = "bigoplus"
+"big oh times"                 = "bigotimes"
+#
+"dot dot dot"                  = "dots"
+"diagonal dots"                = "ddots"
+"horizontal dots"              = "cdots"
+"vertical dots"                = "vdots"
+
+# Require a prefix, as these (I think) are fairly uncommon
+# feel free to move this stuff around.
+[tex_symbols2]
+"GCD"                        = "gcd"
+"cat hom"                    = "hom"
+"kernel"                     = "ker"
+"unit"                       = "unitone"
+"unit two"                   = "unittwo"
+"unit fraction "             = "unitfrac"
+"text fraction"              = "tfrac"
+"display fraction"           = "dfrac"
+"continued fraction"         = "cfrac"
+"continued fraction (left)"  = "cfracleft"
+"continued fraction (right)" = "cfracright"
+"text binomial"              = "tbinom"
+"display binomial"           = "dbinom"
+
+[text_modes]
+"roman"      = "mathrm"
+"bold"       = "mathbf"
+"sans serif" = "mathsf"
+"italic"     = "mathit"
+"typewriter" = "mathtt"
+# math fonts
+# "normal" = "textrm"
+"(beebee|blackboard bold | blackboard)" = "mathbb"
+# "bold symbol" = "boldsymbol"
+# "fraktur" = "mathfrak"
+# "calligraphic" = "mathcal"
+# "formal script" = "mathscr"
+
+[accents]
+"hat"        = "h"
+"tilde"      = "ampersand"
+"dot"        = "dot"
+"double dot" = "dquote"
+"bar"        = "minus"
+"vector"     = "v"
+
+[denominators]
+"(half | halves)"      = 2
+"(third | thirds)"     = 3
+"(quarter | quarters | fourth | fourths)" = 4
+"(fifth | fifths)"     = 5
+"(sixth | sixths)"     = 6
+"(seventh | sevenths)" = 7
+"(eighth | eighths)"   = 8
+"(ninth | ninths)"     = 9
+"(tenth | tenths)"     = 10
+
+[control]
+"new file"     = "c-n"
+"open file"    = "c-o"
+"save as"      = "cs-s"
+"math mode"    = "c-m"
+"display mode" = "cs-m"
+"normal mode"  = "a-p, s"
+"view PDF"     = "c-r"
+"update PDF"   = "cs-r"
+#
+"insert (in line formula | in line)"             = "a-i, h, i"
+"insert (numbered formula)"                      = "a-i, h, n"
+"insert (display formula | display)"             = "a-i, h, d"
+"insert equation array"                          = "a-i, h, e"
+"insert (AMS align environment | AMS align)"     = "a-i, h, a"
+"insert AMS align at [environment]"              = "a-i, h, t"
+"insert AMS flalign [environment]"               = "a-i, h, f"
+"insert (AMS gathered environment | AMS gather)" = "a-i, h, g"
+"insert (AMS multline [environment]| multiline)" = "a-i, h, m"
+"insert array [environment]"                     = "a-i, h, y"
+"insert (cases [environment] | piecewise)"       = "a-i, h, c"
+"insert (aligned [environment] | align)"         = "a-i, h, l"
+"insert aligned at [environment]"                = "a-i, h, v"
+"insert gathered [environment]"                  = "a-i, h, h"
+"insert split [environment]"                     = "a-i, h, s"
+"insert delimiters"                              = "a-i, h, r"
+"insert matrix"                                  = "a-i, h, x"
+"insert macro"                                   = "a-i, h, o"
+#
+"insert [bulleted] list"             = "a-p, b"
+"insert numbered list"               = "a-p, e"
+"insert description"                 = "a-p, d"
+"insert part"                        = "a-p, 0"
+"insert (section | heading)"         = "a-p, 2"
+"insert sub (section | heading)"     = "a-p, 3"
+"insert sub sub (section | heading)" = "a-p, 4"
+"insert paragraph"                   = "a-p, 5"
+"insert sub paragraph"               = "a-p, 6"
+"insert title"                       = "a-p, t"
+"insert author"                      = "a-p, s-a"
+"insert date"                        = "a-p, s-d"
+"insert abstract"                    = "a-p, a"
+"insert address"                     = "a-p, a-a"
+"insert bibliography"                = "a-p, s-b"
+"insert quotation"                   = "a-p, a-q"
+"insert quote"                       = "a-p, q"
+"insert verse"                       = "a-p, v"
+
+[control_repeat]
+"next tab"               = "c-pgdown"
+"(prior | previous) tab" = "c-pgup"
+"close tab"              = "c-w/20"
+"move line up"           = "a-up"
+"move line down"         = "a-down"
diff --git a/mathfly/config/settings.toml b/mathfly/config/settings.toml
index e17ca97..4c6fc8d 100644
--- a/mathfly/config/settings.toml
+++ b/mathfly/config/settings.toml
@@ -1,19 +1,8 @@
+language = "nld" # Supported languages: eng, nld
 ccr_path = "config/ccr.toml"
 dragon_path = "C:/Program Files (x86)/Nuance/NaturallySpeaking15/Program/natspeak.exe"
 editor_path = "C:/Program Files/Windows NT/Accessories/wordpad.exe"
 # editor_path = "C:/Program Files/Sublime Text 3/sublime_text.exe"
-ccr_modules = ["core",
-				"ScientificNotebook55",
-				"LyX",
-				"latex",
-				"latex_maths",
-				"alias"
-				]
-app_modules = ["sublime",
-				"sumatrapdf",
-                "wordpad"
-				]
-max_ccr_repetitions = 16
 alternative_letters = false
 alternative_directions = false
 use_aenea = false
@@ -24,4 +13,19 @@ add_words = [
     "heteroscedasticity",
     "homoscedasticity",
     "leptokurtosis"
-    ]
\ No newline at end of file
+    ]
+
+[modules]
+ccr = [
+	"core",
+	"ScientificNotebook55",
+	"LyX",
+	"latex",
+	"latex_maths",
+	"alias"
+	]
+apps = [
+	"sublime",
+	"sumatrapdf",
+	"wordpad"
+	]
\ No newline at end of file
diff --git a/mathfly/imports.py b/mathfly/imports.py
index cb0de93..582df9e 100644
--- a/mathfly/imports.py
+++ b/mathfly/imports.py
@@ -4,17 +4,16 @@
 
 from dragonfly import Dictation, MappingRule, Choice, Function, ContextAction, Repetition, Compound
 from dragonfly import Repeat, Playback, Mimic, Window, Clipboard, IntegerRef, ShortIntegerRef
+from dragonfly import DictList, DictListRef
+
+from breathe import Breathe, CommandContext, CommandsRef, Exec
 
 from mathfly.lib.actions import Text, Key, Mouse, AppContext
 from mathfly.lib.integers import IntegerRefMF
 
-from mathfly.lib import control, utilities, execution, navigation
+from mathfly.lib import utilities, execution, navigation
 from mathfly.lib.latex import tex_funcs
 from mathfly.lib.execution import Alternating
 
-from mathfly.lib.merge.mergerule import MergeRule
-from mathfly.lib.merge.nestedrule import NestedRule
-from mathfly.lib.merge.selfmodrule import SelfModifyingRule
-
 import re, os, datetime, sys
 from subprocess import Popen
\ No newline at end of file
diff --git a/mathfly/lib/actions.py b/mathfly/lib/actions.py
index deeb6b6..d04329d 100644
--- a/mathfly/lib/actions.py
+++ b/mathfly/lib/actions.py
@@ -8,7 +8,7 @@ def __init__(self, spec=None, static=False, pause=_pause_default, autofmt=False,
 
 
 from mathfly.lib import utilities
-SETTINGS = utilities.load_toml_relative("config/settings.toml")
+SETTINGS = utilities.load_settings()
 # Override imported dragonfly actions with aenea's if the 'use_aenea' setting is set to true.
 if "use_aenea" in SETTINGS and SETTINGS["use_aenea"]:
     try:
diff --git a/mathfly/lib/control.py b/mathfly/lib/control.py
deleted file mode 100644
index 5d8807e..0000000
--- a/mathfly/lib/control.py
+++ /dev/null
@@ -1,10 +0,0 @@
-from ctrl.nexus import Nexus
-
-MF_NEXUS = None
-
-
-def nexus():
-    global MF_NEXUS
-    if MF_NEXUS is None:
-        MF_NEXUS = Nexus()
-    return MF_NEXUS
diff --git a/mathfly/lib/ctrl/__init__.py b/mathfly/lib/ctrl/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/mathfly/lib/ctrl/nexus.py b/mathfly/lib/ctrl/nexus.py
index b0d9b67..52e3059 100644
--- a/mathfly/lib/ctrl/nexus.py
+++ b/mathfly/lib/ctrl/nexus.py
@@ -5,6 +5,7 @@
 from mathfly.lib.merge.ccrmerger import CCRMerger
 from mathfly.lib.merge.mergepair import MergeInf
 import sys
+import importlib
 import natlink
 
 class Nexus:
@@ -16,7 +17,7 @@ def __init__(self, real_merger_config=True):
 
 
     def reload_settings(self):
-        self.settings = utilities.load_toml_relative("config/settings.toml")
+        self.settings = utilities.load_settings()
 
     def delete_words(self, words):
         for word in words:
@@ -36,7 +37,7 @@ def load_app_rules(self, apps):
         apploaded = []
         for module_name in apps:
             try:
-                lib = __import__("mathfly.apps." + module_name)
+                lib = importlib.import_module("mathfly.apps." + module_name)
                 apploaded.append(module_name)
             except Exception as e:
                 print("Ignoring rule '{}'. Failed to load with: ".format(module_name))
@@ -57,7 +58,7 @@ def load_ccr_rules(self, rules):
                     print(e)
             else:
                 try:
-                    lib = __import__("mathfly.ccr." + module_name)
+                    lib = importlib.import_module("mathfly.ccr." + module_name)
                     ccrloaded.append(module_name)
                 except Exception as e:
                     print("Ignoring rule '{}'. Failed to load with: ".format(module_name))
@@ -90,7 +91,7 @@ def generate_ccr_choices(self, ref):
         return Choice(ref, {rule: rule for rule in self.merger.global_rule_names()})
 
     def rule_changer(self, enable, name):
-        CORE = utilities.load_toml_relative("config/core.toml")
+        CORE = utilities.load_config("core.toml")
 
         self.merger.global_rule_changer(name=name, enable=enable, save=True)
         if name == CORE["pronunciation"]:
diff --git a/mathfly/lib/integers.py b/mathfly/lib/integers.py
index 1713922..b0f8a0c 100644
--- a/mathfly/lib/integers.py
+++ b/mathfly/lib/integers.py
@@ -1,92 +1,17 @@
-from dragonfly.language.base.integer_internal import MapIntBuilder, MagnitudeIntBuilder, IntegerContentBase, CollectionIntBuilder
 from dragonfly.language.base.integer import Integer
 from dragonfly.grammar.elements_basic import RuleWrap
-
-
-
-
-
-int_0           = MapIntBuilder({
-                                 "zero":       0,
-                               })
-int_1_9         = MapIntBuilder({
-                                 "one":        1,
-                                 "two":        2,
-                                 "three":      3,
-                                 "four":       4,
-                                 "five":       5,
-                                 "six":        6,
-                                 "seven":      7,
-                                 "eight":      8,
-                                 "nine":       9,
-                               })
-int_10_19       = MapIntBuilder({
-                                 "ten":       10,
-                                 "eleven":    11,
-                                 "twelve":    12,
-                                 "thirteen":  13,
-                                 "fourteen":  14,
-                                 "fifteen":   15,
-                                 "sixteen":   16,
-                                 "seventeen": 17,
-                                 "eighteen":  18,
-                                 "nineteen":  19,
-                               })
-int_20_90_10    = MapIntBuilder({
-                                 "twenty":     2,
-                                 "thirty":     3,
-                                 "forty":      4,
-                                 "fifty":      5,
-                                 "sixty":      6,
-                                 "seventy":    7,
-                                 "eighty":     8,
-                                 "ninety":     9,
-                               })
-int_20_99       = MagnitudeIntBuilder(
-                   factor      = 10,
-                   spec        = "<multiplier> [<remainder>]",
-                   multipliers = [int_20_90_10],
-                   remainders  = [int_1_9],
-                  )
-int_and_1_99    = CollectionIntBuilder(
-                   spec        = "[and] <element>",
-                   set         = [int_1_9, int_10_19, int_20_99],
-                  )
-int_100s        = MagnitudeIntBuilder(
-                   factor      = 100,
-                   spec        = "<multiplier> hundred [<remainder>]",
-                   multipliers = [int_1_9],
-                   remainders  = [int_and_1_99],
-                  )
-int_100big      = MagnitudeIntBuilder(
-                   factor      = 100,
-                   spec        = "<multiplier> hundred [<remainder>]",
-                   multipliers = [int_10_19, int_20_99],
-                   remainders  = [int_and_1_99]
-                  )
-int_1000s       = MagnitudeIntBuilder(
-                   factor      = 1000,
-                   spec        = "<multiplier> thousand [<remainder>]",
-                   multipliers = [int_1_9, int_10_19, int_20_99, int_100s],
-                   remainders  = [int_and_1_99, int_100s]
-                  )
-int_1000000s    = MagnitudeIntBuilder(
-                   factor      = 1000000,
-                   spec        = "<multiplier> million [<remainder>]",
-                   multipliers = [int_1_9, int_10_19, int_20_99, int_100s, int_1000s],
-                   remainders  = [int_and_1_99, int_100s, int_1000s],
-                  )
-
-
-#---------------------------------------------------------------------------
-
-class IntegerContent(IntegerContentBase):
-    builders = [int_0, int_1_9, int_10_19, int_20_99,
-                int_100s, int_100big, int_1000s, int_1000000s]
-
-
-#---------------------------------------------------------------------------
-# Integer reference class.
+import utilities
+import importlib
+SETTINGS = utilities.load_settings()
+
+lang = SETTINGS["language"]
+
+try:
+  lib = importlib.import_module("mathfly.lib.numbers.%s" % lang)
+  IntegerContent = lib.IntegerContent
+  print("Numbers from language %s active" % lang)
+except ImportError as e:
+  from mathfly.lib.numbers.eng import IntegerContent
 
 class IntegerRefMF(RuleWrap):
     def __init__(self, name, min, max, default=None):
diff --git a/mathfly/lib/latex/tex_funcs.py b/mathfly/lib/latex/tex_funcs.py
index 02ab8c7..ad8c751 100644
--- a/mathfly/lib/latex/tex_funcs.py
+++ b/mathfly/lib/latex/tex_funcs.py
@@ -1,6 +1,6 @@
 from dragonfly import Function, Clipboard
 from mathfly.lib.actions import Text, Key, Mouse, AppContext
-from mathfly.lib import control, utilities
+from mathfly.lib import utilities
 from mathfly.lib.latex import bibtexer, book_citation_generator
 import codecs
 import sys
diff --git a/mathfly/lib/merge/__init__.py b/mathfly/lib/merge/__init__.py
deleted file mode 100644
index e69de29..0000000
diff --git a/mathfly/lib/merge/ccrmerger.py b/mathfly/lib/merge/ccrmerger.py
deleted file mode 100644
index 577e327..0000000
--- a/mathfly/lib/merge/ccrmerger.py
+++ /dev/null
@@ -1,430 +0,0 @@
-'''
-Created on Sep 12, 2015
-
-@author: synkarius
-Standard merge filter: app_merge'''
-from collections import OrderedDict
-from itertools import izip_longest
-from dragonfly.grammar.elements import RuleRef, Alternative, Repetition
-from dragonfly.grammar.grammar_base import Grammar
-from dragonfly.grammar.rule_compound import CompoundRule
-
-from mathfly.lib import utilities
-from mathfly.lib.merge.mergepair import MergePair, MergeInf
-from mathfly.lib.merge.mergerule import MergeRule
-import os
-
-BASE_PATH = os.path.realpath(__file__).split("\\lib\\")[0].replace("\\", "/")
-
-SETTINGS = utilities.load_toml_file(BASE_PATH + "/config/settings.toml")
-CCR_PATH = BASE_PATH + "/" + SETTINGS["ccr_path"]
-
-def app_merge(mp):
-    '''forces app rules to define which parts of the base rule they will accept'''
-    if mp.type == MergeInf.APP:
-        base = mp.rule1  #base copy, actually
-        if base is None:
-            return
-        app = mp.rule2
-        mw = app.get_merge_with()
-        specs_per_rulename = mp.extras
-        '''flatten acceptable specs into a list'''
-        acceptable_specs = []
-        for rulename in specs_per_rulename:
-            if rulename in mw:
-                acceptable_specs.extend(specs_per_rulename[rulename])
-        '''remove anything the app rule hasn't defined as mergeable'''
-        for spec in base.mapping_actual().keys():
-            if not spec in acceptable_specs:
-                del base.mapping_actual()[spec]
-
-
-class CCRMerger(object):
-    CORE = []
-    _GLOBAL = "global"
-    _APP = "app"
-    _SELFMOD = "selfmod"
-    _ORDER = "enabling_order"
-
-    def __init__(self, use_real_config=True):
-        self._grammars = [
-        ]  # cannot put multiple large rules in a single grammar despite context separation
-        # original copies of rules
-        self._global_rules = {}
-        self._app_rules = {}
-        # self modifying rules (don't make copies)
-        self._self_modifying_rules = {}
-        # filter functions
-        self._filters = []
-        # active rules
-        self._base_global = None
-        self._global_with_apps = []
-        # config
-        self.use_real_config = use_real_config
-        self.load_config()
-        self.add_filter(app_merge)
-
-    '''config file stuff'''
-
-    def save_config(self):
-        if self.use_real_config:
-            utilities.save_toml_file(self._config, CCR_PATH)
-
-    def load_config(self):
-        if self.use_real_config:
-            self._config = utilities.load_toml_file(CCR_PATH)
-        else:
-            self._config = {}
-
-    def update_config(self):
-        '''call this after all rules have been added'''
-        # Rebuild ccr.toml, rules which have not been registered will be removed,
-        # new rules will be added
-        new_config = {}
-        for tag, rules in {CCRMerger._GLOBAL: self.global_rule_names(),
-                    CCRMerger._APP: self.app_rule_names(),
-                    CCRMerger._SELFMOD: self.selfmod_rule_names()}.iteritems():
-            new_config[tag] = {}
-            if not tag in self._config:
-                self._config[tag] = {}
-            for name in rules:
-                if name in self._config[tag]:
-                    new_config[tag][name] = self._config[tag][name]
-                else:
-                    new_config[tag][name] = False
-
-        self._config = new_config
-        self.save_config()
-
-
-    '''setup: adding rules and filters'''
-    def add_global_rule(self, rule):
-        assert rule.get_context(
-        ) is None, "global rules may not have contexts, " + rule.get_pronunciation(
-        ) + " has a context: " + str(rule.get_context())
-        assert isinstance(rule, MergeRule) and not hasattr(rule, "set_merger"), \
-            "only MergeRules may be added as global rules; use add_selfmodrule() or add_app_rule()"
-        self._add_to(rule, self._global_rules)
-
-    def add_app_rule(self, rule, context=None):
-        if context is not None and rule.get_context() is None: rule.set_context(context)
-        assert rule.get_context(
-        ) is not None, "app rules must have contexts, " + rule.get_pronunciation(
-        ) + " has no context"
-        assert rule.get_merge_with(
-        ) is not None, "app rules must define mwith, " + rule.get_pronunciation(
-        ) + " has no mwith"
-        self._add_to(rule, self._app_rules)
-
-    def add_non_ccr_app_rule(self, rule, context=None):
-        if context is not None and rule.get_context() is None: rule.set_context(context)
-        assert rule.get_context() is not None, "app rules must have contexts, " + rule.get_pronunciation() + " has no context"
-        grammar = Grammar(str(rule), context=rule.get_context())
-        grammar.add_rule(rule)
-        if rule.non is not None:
-            grammar.add_rule(rule.non())
-        grammar.load()
-
-    def add_selfmodrule(self, rule):
-        assert hasattr(
-            rule,
-            "set_merger"), "only SelfModifyingRules may be added by add_selfmodrule()"
-        assert not hasattr(rule,
-                           "master_node"), "NodeRules are not permitted in the merger"
-        rule.set_merger(self)
-        self._add_to(rule, self._self_modifying_rules)
-
-    def add_filter(self, filter):
-        if not filter in self._filters:
-            self._filters.append(filter)
-
-    def _add_to(self, rule, group):
-        if rule.get_pronunciation() in \
-        self.global_rule_names()+\
-        self.app_rule_names()+\
-        self.selfmod_rule_names():
-            raise Exception("Rule Naming Conflict: " + rule.get_pronunciation())
-        if isinstance(rule, MergeRule):
-            for name in group.keys():
-                group[name].compatibility_check(
-                    rule)  # calculate compatibility for uncombined rules at boot time
-            group[rule.get_pronunciation()] = rule
-
-    '''getters'''
-
-    def global_rule_names(self):
-        return self._global_rules.keys()
-
-    def app_rule_names(self):
-        return self._app_rules.keys()
-
-    def selfmod_rule_names(self):
-        return self._self_modifying_rules.keys()
-
-    def display_rules(self):
-        for rule in self.global_rule_names():
-            if self._config[CCRMerger._GLOBAL][rule]:
-                print("*" + rule)
-            else:
-                print(rule)
-
-    '''rule change functions'''
-    def global_rule_changer(self, name, enable, save):
-        self._config[CCRMerger._GLOBAL][name] = enable
-        self.merge(MergeInf.RUN, name, enable, save)
-        print(name + " enabled" if enable else name + " disabled")
-
-    def selfmod_rule_changer(self, name2, enable, save):
-        self._config[CCRMerger._SELFMOD][name2] = enable
-        self.merge(MergeInf.SELFMOD, name2, enable, save)
-
-    '''merging'''
-
-    def _get_rules_by_composite(self, composite, original=False):
-        return [rule if original else rule.copy()  \
-                for rule in self._global_rules.values() \
-                if rule.ID in composite]
-
-    def _compatibility_merge(self, merge_pair, base, rule):
-        '''MergeRule.merge always returns a copy, so there's
-        no need to worry about the originals getting modified'''
-        if merge_pair.check_compatibility==False or \
-        base is None or \
-        base.compatibility_check(rule):
-            base = rule if base is None else base.merge(rule)
-        else:
-            # figure out which MergeRules aren't compatible
-            composite = base.composite.copy(
-            )  # composite is a set of the ids of the rules which make up this rule
-            for ID in rule.compatible:
-                if not rule.compatible[ID]: composite.discard(ID)
-            # rebuild a base from remaining MergeRules
-            base = None
-            for _rule in self._get_rules_by_composite(composite):
-                base = _rule if base is None else base.merge(_rule)
-            # merge in the new rule
-            if base is not None:
-                base = base.merge(rule)
-            else:
-                base = rule
-        return base
-
-    def _add_grammar(self, rule, ccr=False, context=None):
-        name = str(rule)
-        grammar = Grammar(name, context=context)
-        self._grammars.append(grammar)
-        if ccr:
-            repeaters = self._create_repeat_rule(rule)
-            for repeater in repeaters:
-                grammar.add_rule(repeater)
-        else:
-            grammar.add_rule(rule)
-
-    def wipe(self):
-        while len(self._grammars) > 0:
-            grammar = self._grammars.pop()
-            for rule in grammar.rules:
-                rule.disable()
-            grammar.disable()
-            del grammar
-
-    def _sync_enabled(self):
-        '''
-        When enabling new rules, conflicting ones get automatically disabled.
-        Throw these out of enabling order as well. Also prevent excessive size.
-        '''
-        if CCRMerger._ORDER not in self._config:
-            self._config[CCRMerger._ORDER] = []
-        enabled = [
-            r for r in self._config[CCRMerger._ORDER]
-            if self._config[CCRMerger._GLOBAL].get(r)][-100:]
-        self._config[CCRMerger._ORDER] = OrderedDict(izip_longest(enabled, [])).keys()
-
-    def merge(self, time, name=None, enable=True, save=False):
-        '''combines MergeRules, SelfModifyingRules;
-        handles CCR for apps;
-        instantiates affiliated rules;
-        adds everything to its grammar
-        ;
-        assumptions made:
-        * SelfModifyingRules have already made changes to themselves
-        * the appropriate activation boolean(s) in the appropriate map has already been set'''
-        current_rule = None
-        self.wipe()
-        base = self._base_global
-        named_rule = None
-        '''get base CCR rule'''
-        if time == MergeInf.BOOT:  # rebuild via config
-            for name, rule in self._global_rules.iteritems():
-                '''we want to be able to make permanent changes at boot time, not just
-                to activated rules, but to everything -- but we dont' want it to interfere
-                with normal merge logic-- hence the introduction of the BOOT_NO_MERGE time'''
-                mp = MergePair(
-                    MergeInf.BOOT_NO_MERGE, MergeInf.GLOBAL, None, rule, False
-                )  # copies not made at boot time, allows user to make permanent changes
-                self._run_filters(mp)
-
-                if self._config[CCRMerger._GLOBAL][name]:
-                    mp = MergePair(
-                        time, MergeInf.GLOBAL, base, rule, False
-                    )  # copies not made at boot time, allows user to make permanent changes
-                    self._run_filters(mp)
-                    if base is None: base = rule
-                    else: base = self._compatibility_merge(mp, base, rule)
-        else:  # rebuild via composite
-            composite = base.composite.copy(
-            )  # IDs of all rules that the composite rule is made of
-            if time != MergeInf.SELFMOD:
-                assert name is not None
-                named_rule = self._global_rules[name]
-                if enable is False:
-                    composite.discard(named_rule.ID)  # throw out rule getting disabled
-                else: # enable CCR rule
-                    self._config[CCRMerger._ORDER].append(name)
-                    current_rule = name
-            base = None
-            for rule in self._get_rules_by_composite(composite):
-                mp = MergePair(time, MergeInf.GLOBAL, base, rule.copy(), False)
-                self._run_filters(mp)
-                if base is None: base = rule
-                else:
-                    base = self._compatibility_merge(
-                        mp, base, mp.rule2)  # mp.rule2 because named_rule got copied
-            if time != MergeInf.SELFMOD and enable == True:
-                mp = MergePair(time, MergeInf.GLOBAL, base, named_rule.copy(), True)
-                self._run_filters(mp)
-                base = self._compatibility_merge(
-                    mp, base, mp.rule2)  # mp.rule2 because named_rule got copied
-        '''compatibility check and filter function active selfmodrules'''
-        for name2, rule in self._self_modifying_rules.iteritems():
-            '''no need to make copies of selfmod rules because even if
-            filter functions trash their mapping, they'll just regenerate
-            it next time they modify themselves;
-            furthermore, they need to preserve state'''
-            if self._config[CCRMerger._SELFMOD][name2]:
-                mp = MergePair(time, MergeInf.SELFMOD, base, rule, False)
-                self._run_filters(mp)
-                base = self._compatibility_merge(mp, base, rule)
-        '''have base, make copies, merge in apps'''
-        active_apps = []
-        for rule in self._app_rules.values():
-            base_copy = base.copy() if base is not None else base
-            # make a copy b/c commands will get stripped out
-            context = rule.get_context()
-            non_copy = rule.non if rule.non else None
-            nested_copy = rule.nested if rule.nested else None
-            mp = MergePair(time, MergeInf.APP, base_copy, rule.copy(), False,
-                           CCRMerger.specs_per_rulename(self._global_rules))
-            self._run_filters(mp)
-            rule = self._compatibility_merge(
-                mp, base_copy, mp.rule2)  # mp.rule2 because named_rule got copied
-            rule.non = non_copy
-            rule.nested = nested_copy
-            rule.set_context(context)
-            active_apps.append(rule)
-        '''negation context for appless version of base rule'''
-        contexts = [app_rule.get_context() for app_rule in self._app_rules.values() \
-                    if app_rule.get_context() is not None]# get all contexts
-        negation_context = None
-        for context in contexts:
-            negate = ~context
-            if negation_context is None: negation_context = negate
-            else: negation_context & negate
-        '''handle empty merge'''
-        if base is None:
-            base = MergeRule()
-        ''' save results for next merge '''
-        self._base_global = base.copy()
-        '''instantiate non-ccr rules affiliated with rules in the base CCR rule'''
-        active_global = self._get_rules_by_composite(base.composite, True)
-        global_non_ccr = [rule.non() for rule in active_global \
-                         if rule.non is not None]
-        '''update grammars'''
-        self._add_grammar(base, True, negation_context)
-        for rule in global_non_ccr:
-            self._add_grammar(rule)
-        for rule in active_apps:
-            self._add_grammar(rule, True, rule.get_context())
-            if rule.non is not None:
-                self._add_grammar(rule.non(), False, rule.get_context())
-        for grammar in self._grammars:
-            grammar.load()
-        '''save if necessary'''
-        if time in [MergeInf.RUN, MergeInf.SELFMOD] and save:
-            # everything in base composite is active, everything in selfmod is active, update the config as such
-            active_global_names = [rule.get_pronunciation() for rule in active_global]
-            for rule_name in self._global_rules:
-                self._config[CCRMerger._GLOBAL][
-                    rule_name] = rule_name in active_global_names
-            active_selfmod_names = [
-                name3 for name3 in self._config[CCRMerger._SELFMOD]
-                if self._config[CCRMerger._SELFMOD][name3]
-            ]  #[rule.get_pronunciation() for rule in selfmod]
-            for rule_name in self._self_modifying_rules:
-                self._config[CCRMerger._SELFMOD][
-                    rule_name] = rule_name in active_selfmod_names
-        self._sync_enabled()
-        if len(self._config[CCRMerger._ORDER]) > 0:
-            current_rule = self._config[CCRMerger._ORDER][-1]
-        # self._apply_format(current_rule)
-        if save:
-            self.save_config()
-
-    @staticmethod
-    def specs_per_rulename(d):
-        result = {}
-        for rulename in d.keys():
-            rule = d[rulename]
-            specs = rule.mapping_actual().keys()
-            result[rulename] = specs
-        return result
-
-    def _run_filters(self, merge_pair):
-        for filter_fn in self._filters:
-            try:
-                filter_fn(merge_pair)
-            except Exception:
-                print("Filter function '" + filter_fn.__name__ + "' failed.")
-
-    def _create_repeat_rule(self, rule):
-        ORIGINAL, SEQ, TERMINAL = "original", "caster_base_sequence", "terminal"
-        alts = [RuleRef(rule=rule)]  #+[RuleRef(rule=sm) for sm in selfmod]
-        single_action = Alternative(alts)
-        max = SETTINGS["max_ccr_repetitions"]
-        sequence = Repetition(single_action, min=1, max=max, name=SEQ)
-        original = Alternative(alts, name=ORIGINAL)
-        terminal = Alternative(alts, name=TERMINAL)
-
-        class RepeatRule(CompoundRule):
-            spec = "[<" + ORIGINAL + "> original] [<" + SEQ + ">] [terminal <" + TERMINAL + ">]"
-            extras = [sequence, original, terminal]
-
-            def _process_recognition(self, node, extras):
-                original = extras[ORIGINAL] if ORIGINAL in extras else None
-                sequence = extras[SEQ] if SEQ in extras else None
-                terminal = extras[TERMINAL] if TERMINAL in extras else None
-                if original is not None: original.execute()
-                if sequence is not None:
-                    for action in sequence:
-                        action.execute()
-                if terminal is not None: terminal.execute()
-
-        rules = []
-        rules.append(RepeatRule(name="Repeater" + MergeRule.get_merge_name()))
-
-        if rule.nested is not None:
-            bef  = Repetition(single_action, min=1, max=8, name="before")
-            aft  = Repetition(single_action, min=1, max=8, name="after")
-            seq1 = Repetition(single_action, min=1, max=6, name="sequence1")
-            seq2 = Repetition(single_action, min=1, max=6, name="sequence2")
-            sing1 = Alternative(alts, name="singleton1")
-            sing2 = Alternative(alts, name="singleton2")
-
-            if rule.nested.extras is None:
-                rule.nested.extras = [bef, aft, seq1, seq2, sing1, sing2]
-            else:
-                rule.nested.extras.extend([bef, aft, seq1, seq2, sing1, sing2])
-            nested = rule.nested()
-            rules.append(nested)
-
-        return rules
\ No newline at end of file
diff --git a/mathfly/lib/merge/mergepair.py b/mathfly/lib/merge/mergepair.py
deleted file mode 100644
index 37cc282..0000000
--- a/mathfly/lib/merge/mergepair.py
+++ /dev/null
@@ -1,20 +0,0 @@
-class MergeInf(object):
-    '''TYPE'''
-    GLOBAL = 0
-    APP = 1
-    SELFMOD = 2
-    '''TIME'''
-    BOOT = 3
-    RUN = 4
-    BOOT_NO_MERGE = 5
-
-
-class MergePair(object):
-    def __init__(self, time, type, rule1, rule2, check_compatibility, extras=None):
-        self.time = time
-        self.type = type
-        self.rule1 = rule1
-        self.rule2 = rule2
-        self.changed = False  # presently unused
-        self.check_compatibility = check_compatibility
-        self.extras = extras
diff --git a/mathfly/lib/merge/mergerule.py b/mathfly/lib/merge/mergerule.py
deleted file mode 100644
index 14b91b4..0000000
--- a/mathfly/lib/merge/mergerule.py
+++ /dev/null
@@ -1,150 +0,0 @@
-'''
-Created on Sep 1, 2015
-
-@author: synkarius
-'''
-from dragonfly import MappingRule, Pause, Function
-
-
-class MergeRule(MappingRule):
-    @staticmethod
-    def _get_next_id():
-        if not hasattr(MergeRule._get_next_id, "id"):
-            MergeRule._get_next_id.id = 0
-        MergeRule._get_next_id.id += 1
-        return MergeRule._get_next_id.id
-
-    @staticmethod
-    def get_merge_name():  # returns unique str(int) for procedural rule names
-        return str(MergeRule._get_next_id())
-
-    mapping = {"hello world default macro": Pause("10")}
-    '''MergeRules which define `pronunciation` will use
-    the pronunciation string rather than their class name
-    for their respective enable/disable commands'''
-    pronunciation = None
-    # Allows for self referencing rules (which include arbitrary sequences of other commands from the rule) to be included
-    nested = None
-    '''MergeRules which define `non` will instantiate
-    their paired non-CCR MergeRule and activate it
-    alongside themselves'''
-    non = None
-    '''MergeRules which define `mcontext` with a
-    Dragonfly AppContext become non-global; this
-    is the same as adding a context to a Grammar'''
-    mcontext = None
-    '''app MergeRules MUST define `mwith` in order to
-    define what else they can merge with -- this is an
-    optimization to prevent pointlessly large global
-    CCR copies; mwith is a list of get_pronunciation()s'''
-    mwith = None
-
-    def __init__(self,
-                 name=None,
-                 mapping=None,
-                 extras=None,
-                 defaults=None,
-                 exported=None,
-                 ID=None,
-                 composite=None,
-                 compatible=None,
-                 mcontext=None,
-                 mwith=None):
-
-        self.ID = ID if ID is not None else MergeRule._get_next_id()
-        self.compatible = {} if compatible is None else compatible
-        '''composite is the IDs of the rules which this MergeRule is composed of: '''
-        self.composite = composite if composite is not None else set([self.ID])
-        self._mcontext = self.__class__.mcontext
-        if self._mcontext is None: self._mcontext = mcontext
-        self._mwith = self.__class__.mwith
-        if self._mwith is None: self._mwith = mwith
-
-        if mapping is not None:
-            mapping["display available commands"] = Function(
-                lambda: self._display_available_commands())
-
-        MappingRule.__init__(self, name, mapping, extras, defaults, exported)
-
-    def __eq__(self, other):
-        if not isinstance(other, MergeRule):
-            return False
-        return self.ID == other.ID
-
-    ''' "copy" getters used for safe merging;
-    "actual" versions used for filter functions'''
-
-    def mapping_copy(self):
-        return self._mapping.copy()
-
-    def mapping_actual(self):
-        return self._mapping
-
-    def extras_copy(self):
-        return self._extras.copy()
-
-    def extras_actual(self):
-        return self._extras
-
-    def defaults_copy(self):
-        return self._defaults.copy()
-
-    def defaults_actual(self):
-        return self._defaults
-
-    def merge(self, other):
-        mapping = self.mapping_copy()
-        mapping.update(other.mapping_copy())
-        extras_dict = self.extras_copy()
-        extras_dict.update(
-            other.extras_copy())  # not just combining lists avoids duplicates
-        extras = extras_dict.values()
-        defaults = self.defaults_copy()
-        defaults.update(other.defaults_copy())
-        context = self._mcontext if self._mcontext is not None else other.get_context(
-        )  # one of these should always be None; contexts don't mix here
-        return MergeRule(
-            "Merged" + MergeRule.get_merge_name() + self.get_pronunciation()[0] +
-            other.get_pronunciation()[0],
-            mapping,
-            extras,
-            defaults,
-            self._exported and other._exported,  # no ID
-            composite=self.composite.union(other.composite),
-            mcontext=context)
-
-    def get_pronunciation(self):
-        return self.pronunciation if self.pronunciation is not None else self.name
-
-    def copy(self):
-        return MergeRule(self.name, self._mapping.copy(), self._extras.values(),
-                         self._defaults.copy(), self._exported, self.ID, self.composite,
-                         self.compatible, self._mcontext, self._mwith)
-
-    def compatibility_check(self, other):
-        if other.ID in self.compatible:
-            return self.compatible[other.ID]  # lazily
-        compatible = True
-        for key in self._mapping.keys():
-            if key in other.mapping_actual().keys():
-                compatible = False
-                break
-        self.compatible[other.ID] = compatible
-        other.compatible[self.ID] = compatible
-        return compatible
-
-    def incompatible_IDs(self):
-        return [ID for ID in self.compatible if not self.compatible[ID]]
-
-    def get_context(self):
-        return self._mcontext
-
-    def set_context(self, context):
-        self._mcontext = context
-
-    def get_merge_with(self):
-        return self._mwith
-
-    def _display_available_commands(self):
-        for spec in self.mapping_actual().keys():
-            print(spec)  # do something fancier when the ui is better
diff --git a/mathfly/lib/merge/nestedrule.py b/mathfly/lib/merge/nestedrule.py
deleted file mode 100644
index a18a3c7..0000000
--- a/mathfly/lib/merge/nestedrule.py
+++ /dev/null
@@ -1,28 +0,0 @@
-'''
-This rule type allows for the creation of rules which can take arbitrary sequences of commands from another rule. They are declared without extras and added in the nested property of a merge rule, the merged form of which will be used to form the extras list in ccrmerger._create_repeat_rule.
-
-The specifications in the rule's mapping must include <sequence1> and <sequence2>, <before> and <after> are optional and allow for other commands to be spoken before or after the rule.
-Example command:
-"[<before>] integral from <sequence1> to <sequence2>":
-            [Text("\\int _"), Key("right, caret"), Key("right")],
-
-Any commands which come before will be executed first, then the first action in the list, then the first sequence, then the second action in the list, then the second sequence, then the final action.  At the moment sequences have a maximum length of 6 commands and before and after 8.
-'''
-
-from dragonfly import MappingRule
-
-class NestedRule(MappingRule):
-    def _process_recognition(self, value, extras):
-        if "before" in extras:
-            for action in extras["before"]: action.execute()
-        if value[0] is not None: value[0].execute(extras)
-        if "sequence1" in extras:
-            for action in extras["sequence1"]: action.execute()
-        if "singleton1" in extras: extras["singleton1"].execute(extras)
-        if value[1] is not None: value[1].execute(extras)
-        if "sequence2" in extras:
-            for action in extras["sequence2"]: action.execute()
-        if "singleton2" in extras: extras["singleton2"].execute(extras)
-        if value[2] is not None: value[2].execute(extras)
-        if "after" in extras:
-            for action in extras["after"]: action.execute()
diff --git a/mathfly/lib/merge/selfmodrule.py b/mathfly/lib/merge/selfmodrule.py
index b65027b..e58dbe0 100644
--- a/mathfly/lib/merge/selfmodrule.py
+++ b/mathfly/lib/merge/selfmodrule.py
@@ -43,7 +43,7 @@ def reset(self, mapping):
             grammar.unload()
             grammar.remove_rule(self)
 
-        extras = self.extras if self.extras else [IntegerRef("n", 1, 50), Dictation("s")]
+        extras = self.extras if self.extras else [IntegerRefMF("n", 1, 50), Dictation("s")]
         defaults = self.defaults if self.defaults else { "n": 1, "s": "" }
         MergeRule.__init__(self, self.name, mapping, extras, defaults, self.exported,
                            self.context)
diff --git a/mathfly/lib/numbers/eng.py b/mathfly/lib/numbers/eng.py
new file mode 100644
index 0000000..1433d6b
--- /dev/null
+++ b/mathfly/lib/numbers/eng.py
@@ -0,0 +1,86 @@
+from dragonfly.language.base.integer_internal import (
+    MapIntBuilder,
+    MagnitudeIntBuilder,
+    IntegerContentBase,
+    CollectionIntBuilder
+)
+
+
+int_0           = MapIntBuilder({
+                                 "zero":       0,
+                               })
+int_1_9         = MapIntBuilder({
+                                 "one":        1,
+                                 "two":        2,
+                                 "three":      3,
+                                 "four":       4,
+                                 "five":       5,
+                                 "six":        6,
+                                 "seven":      7,
+                                 "eight":      8,
+                                 "nine":       9,
+                               })
+int_10_19       = MapIntBuilder({
+                                 "ten":       10,
+                                 "eleven":    11,
+                                 "twelve":    12,
+                                 "thirteen":  13,
+                                 "fourteen":  14,
+                                 "fifteen":   15,
+                                 "sixteen":   16,
+                                 "seventeen": 17,
+                                 "eighteen":  18,
+                                 "nineteen":  19,
+                               })
+int_20_90_10    = MapIntBuilder({
+                                 "twenty":     2,
+                                 "thirty":     3,
+                                 "forty":      4,
+                                 "fifty":      5,
+                                 "sixty":      6,
+                                 "seventy":    7,
+                                 "eighty":     8,
+                                 "ninety":     9,
+                               })
+int_20_99       = MagnitudeIntBuilder(
+                   factor      = 10,
+                   spec        = "<multiplier> [<remainder>]",
+                   multipliers = [int_20_90_10],
+                   remainders  = [int_1_9],
+                  )
+int_and_1_99    = CollectionIntBuilder(
+                   spec        = "[and] <element>",
+                   set         = [int_1_9, int_10_19, int_20_99],
+                  )
+int_100s        = MagnitudeIntBuilder(
+                   factor      = 100,
+                   spec        = "<multiplier> hundred [<remainder>]",
+                   multipliers = [int_1_9],
+                   remainders  = [int_and_1_99],
+                  )
+int_100big      = MagnitudeIntBuilder(
+                   factor      = 100,
+                   spec        = "<multiplier> hundred [<remainder>]",
+                   multipliers = [int_10_19, int_20_99],
+                   remainders  = [int_and_1_99]
+                  )
+int_1000s       = MagnitudeIntBuilder(
+                   factor      = 1000,
+                   spec        = "<multiplier> thousand [<remainder>]",
+                   multipliers = [int_1_9, int_10_19, int_20_99, int_100s],
+                   remainders  = [int_and_1_99, int_100s]
+                  )
+int_1000000s    = MagnitudeIntBuilder(
+                   factor      = 1000000,
+                   spec        = "<multiplier> million [<remainder>]",
+                   multipliers = [int_1_9, int_10_19, int_20_99, int_100s, int_1000s],
+                   remainders  = [int_and_1_99, int_100s, int_1000s],
+                  )
+
+
+#---------------------------------------------------------------------------
+
+class IntegerContent(IntegerContentBase):
+    builders = [int_0, int_1_9, int_10_19, int_20_99,
+                int_100s, int_100big, int_1000s, int_1000000s]
+
diff --git a/mathfly/lib/numbers/nld.py b/mathfly/lib/numbers/nld.py
new file mode 100644
index 0000000..54fb20a
--- /dev/null
+++ b/mathfly/lib/numbers/nld.py
@@ -0,0 +1,2 @@
+
+from dragonfly.language.nl.number import IntegerContent
\ No newline at end of file
diff --git a/mathfly/lib/utilities.py b/mathfly/lib/utilities.py
index 57c7466..d38b5fe 100644
--- a/mathfly/lib/utilities.py
+++ b/mathfly/lib/utilities.py
@@ -77,21 +77,37 @@ def paste_string(content):
 
 SETTINGS = load_toml_relative("config/settings.toml")
 
-def reboot():
-    Popen([BASE_PATH + "/config/bin/reboot.bat", SETTINGS["dragon_path"]])
+def load_settings():
+    return load_toml_relative("config/settings.toml")
 
-def load_config(config_name):
-    parameters = []
-    parameters.append(SETTINGS["editor_path"])
-    parameters.append(get_full_path("config/" + config_name))
-    Popen(parameters)
+def get_config_location(fname):
+    base_directory = "config/"
+    lang = SETTINGS["language"]
+    lang_file_location = base_directory + lang + "/" + fname
+    if lang != "eng" and os.path.exists(get_full_path(lang_file_location)):
+        # E.g. lang is nld and config/nld/lyx.toml exists
+        print("loading %s" % lang_file_location)
+        return lang_file_location
+    else:
+        return base_directory + fname
 
-def load_text_file(path):
+def load_config(fname):
+    path = get_config_location(fname)
+    return load_toml_relative(path)
+
+def edit_text_file(path):
     parameters = []
     parameters.append(SETTINGS["editor_path"])
     parameters.append(path)
     Popen(parameters)
 
+def edit_config(fname):
+    path = get_config_location(fname)
+    edit_text_file(path)
+
+def reboot():
+    Popen([BASE_PATH + "/config/bin/reboot.bat", SETTINGS["dragon_path"]])
+
 def help():
     print(get_full_path("docs"))
     Popen(['C:/Windows/explorer.exe', get_full_path("docs").replace("/", "\\")])