diff --git a/doc-dev/reference-manual.md b/doc-dev/reference-manual.md
index 329ea7558..d8098cee8 100644
--- a/doc-dev/reference-manual.md
+++ b/doc-dev/reference-manual.md
@@ -6,6 +6,8 @@ This file contains (semi)formal documentation of all features of the extended en
 
 - The grammar is meant to be the ultimate information source. Not all commands or parameters are described in the later text.
 
+- Most values in the following text are just recommended ranges. The firmware will usually accept even values outside these ranges.
+
 ### Error handling
 
 Whenever a garbled command is encountered, `ERR` will light up on the display, and details are appended to the error buffer. You can retrieve it by running a `printStatus` macro command over a focused text editor.
@@ -47,22 +49,22 @@ The following grammar is supported:
     BODY = [LABEL:] COMMAND [//<comment, excluding commands taking custom text arguments>]
     COMMAND = [CONDITION|MODIFIER]* COMMAND
     COMMAND = delayUntilRelease
-    COMMAND = delayUntil <timeout (NUMBER)>
-    COMMAND = delayUntilReleaseMax <timeout (NUMBER)>
+    COMMAND = delayUntil <timeout (INT)>
+    COMMAND = delayUntilReleaseMax <timeout (INT)>
     COMMAND = switchKeymap KEYMAPID
     COMMAND = toggleLayer LAYERID
     COMMAND = toggleKeymapLayer KEYMAPID LAYERID
     COMMAND = untoggleLayer
     COMMAND = holdLayer LAYERID
-    COMMAND = holdLayerMax LAYERID <time in ms (NUMBER)>
+    COMMAND = holdLayerMax LAYERID <time in ms (INT)>
     COMMAND = holdKeymapLayer KEYMAPID LAYERID
-    COMMAND = holdKeymapLayerMax KEYMAPID LAYERID <time in ms (NUMBER)>
+    COMMAND = holdKeymapLayerMax KEYMAPID LAYERID <time in ms (INT)>
     COMMAND = overlayKeymap KEYMAPID
     COMMAND = overlayLayer <target layer (LAYERID)> <source keymap (KEYMAPID)> <source layer (LAYERID)>
     COMMAND = replaceLayer <target layer (LAYERID)> <source keymap (KEYMAPID)> <source layer (LAYERID)>
     COMMAND = resolveNextKeyId
     COMMAND = activateKeyPostponed [atLayer LAYERID] [append | prepend]  KEYID
-    COMMAND = consumePending <number of keys (NUMBER)>
+    COMMAND = consumePending <number of keys (INT)>
     COMMAND = postponeNext <number of commands (NUMER)>
     COMMAND = break
     COMMAND = noOp
@@ -70,11 +72,10 @@ The following grammar is supported:
     COMMAND = {exec|call|fork} MACRONAME
     COMMAND = resetTrackpoint
     COMMAND = printStatus
-    COMMAND = setLedTxt <timeout (NUMBER)> <custom text>
-    COMMAND = write <custom text>
-    COMMAND = writeExpr NUMBER
+    COMMAND = setLedTxt <timeout (INT)> { STRING | EXPRESSION }
+    COMMAND = write STRING
     COMMAND = goTo <index (ADDRESS)>
-    COMMAND = repeatFor <register index (NUMBER)> <action adr (ADDRESS)>
+    COMMAND = repeatFor <var name (IDENTIFIER)> <action adr (ADDRESS)>
     COMMAND = progressHue
     COMMAND = recordMacroDelay
     COMMAND = {startRecording | startRecordingBlind} [<slot identifier (MACROID)>]
@@ -82,7 +83,7 @@ The following grammar is supported:
     COMMAND = {stopRecording | stopRecordingBlind}
     COMMAND = playMacro [<slot identifier (MACROID)>]
     COMMAND = {startMouse|stopMouse} {move DIRECTION|scroll DIRECTION|accelerate|decelerate}
-    COMMAND = {setReg|addReg|subReg|mulReg} <register index (NUMBER)> <value (NUMBER)>
+    COMMAND = setVar <var name (IDENTIFIER)> <value (PARENTHESSED_EXPRESSION)>
     COMMAND = {pressKey|holdKey|tapKey|releaseKey} SHORTCUT
     COMMAND = tapKeySeq [SHORTCUT]+
     COMMAND = set module.MODULEID.navigationMode.LAYERID_BASIC NAVIGATION_MODE
@@ -93,47 +94,48 @@ The following grammar is supported:
     COMMAND = set module.MODULEID.scrollSpeedDivisor <1-100 (FLOAT)>
     COMMAND = set module.MODULEID.axisLockSkew <0-2.0 (FLOAT)>
     COMMAND = set module.MODULEID.axisLockFirstTickSkew <0-2.0 (FLOAT)>
-    COMMAND = set module.MODULEID.scrollAxisLock BOOLEAN
-    COMMAND = set module.MODULEID.cursorAxisLock BOOLEAN
-    COMMAND = set module.MODULEID.caretAxisLock BOOLEAN
-    COMMAND = set module.MODULEID.swapAxes BOOLEAN
-    COMMAND = set module.MODULEID.invertScrollDirectionX BOOLEAN
-    COMMAND = set module.MODULEID.invertScrollDirectionY BOOLEAN
+    COMMAND = set module.MODULEID.scrollAxisLock BOOL
+    COMMAND = set module.MODULEID.cursorAxisLock BOOL
+    COMMAND = set module.MODULEID.caretAxisLock BOOL
+    COMMAND = set module.MODULEID.swapAxes BOOL
+    COMMAND = set module.MODULEID.invertScrollDirectionX BOOL
+    COMMAND = set module.MODULEID.invertScrollDirectionY BOOL
     COMMAND = set module.touchpad.pinchZoomDivisor <1-100 (FLOAT)>
     COMMAND = set module.touchpad.pinchZoomMode NAVIGATION_MODE
     COMMAND = set secondaryRole.defaultStrategy { simple | advanced }
-    COMMAND = set secondaryRole.advanced.timeout <ms, 0-500 (NUMBER)>
+    COMMAND = set secondaryRole.advanced.timeout <ms, 0-500 (INT)>
     COMMAND = set secondaryRole.advanced.timeoutAction { primary | secondary }
-    COMMAND = set secondaryRole.advanced.safetyMargin <ms, -50 - 50 (NUMBER)>
-    COMMAND = set secondaryRole.advanced.triggerByRelease BOOLEAN
-    COMMAND = set secondaryRole.advanced.doubletapToPrimary BOOLEAN
-    COMMAND = set secondaryRole.advanced.doubletapTime <ms, 0 - 500 (NUMBER)>
-    COMMAND = set mouseKeys.{move|scroll}.initialSpeed <px/s, -100/20 (NUMBER)>
-    COMMAND = set mouseKeys.{move|scroll}.baseSpeed <px/s, -800/20 (NUMBER)>
-    COMMAND = set mouseKeys.{move|scroll}.initialAcceleration <px/s, ~1700/20 (NUMBER)>
-    COMMAND = set mouseKeys.{move|scroll}.deceleratedSpeed <px/s, ~200/10 (NUMBER)>
-    COMMAND = set mouseKeys.{move|scroll}.acceleratedSpeed <px/s, ~1600/50 (NUMBER)>
+    COMMAND = set secondaryRole.advanced.safetyMargin <ms, -50 - 50 (INT)>
+    COMMAND = set secondaryRole.advanced.triggerByRelease BOOL
+    COMMAND = set secondaryRole.advanced.doubletapToPrimary BOOL
+    COMMAND = set secondaryRole.advanced.doubletapTime <ms, 0 - 500 (INT)>
+    COMMAND = set mouseKeys.{move|scroll}.initialSpeed <px/s, -100/20 (INT)>
+    COMMAND = set mouseKeys.{move|scroll}.baseSpeed <px/s, -800/20 (INT)>
+    COMMAND = set mouseKeys.{move|scroll}.initialAcceleration <px/s, ~1700/20 (INT)>
+    COMMAND = set mouseKeys.{move|scroll}.deceleratedSpeed <px/s, ~200/10 (INT)>
+    COMMAND = set mouseKeys.{move|scroll}.acceleratedSpeed <px/s, ~1600/50 (INT)>
     COMMAND = set mouseKeys.{move|scroll}.axisSkew <multiplier, 0.5-2.0 (FLOAT)>
-    COMMAND = set i2cBaudRate <baud rate, default 100000(NUMBER)>
-    COMMAND = set diagonalSpeedCompensation BOOLEAN
-    COMMAND = set chordingDelay <time in ms (NUMBER)>
-    COMMAND = set autoShiftDelay <time in ms (NUMBER)>
+    COMMAND = set i2cBaudRate <baud rate, default 100000(INT)>
+    COMMAND = set diagonalSpeedCompensation BOOL
+    COMMAND = set chordingDelay <time in ms (INT)>
+    COMMAND = set autoShiftDelay <time in ms (INT)>
     COMMAND = set stickyModifiers {never|smart|always}
-    COMMAND = set debounceDelay <time in ms, at most 250 (NUMBER)>
-    COMMAND = set doubletapTimeout <time in ms, at most 65535 (NUMBER)>
-    COMMAND = set keystrokeDelay <time in ms, at most 65535 (NUMBER)>
-    COMMAND = set autoRepeatDelay <time in ms, at most 65535 (NUMBER)>
-    COMMAND = set autoRepeatRate <time in ms, at most 65535 (NUMBER)>
-    COMMAND = set macroEngine.batchSize <number of commands to execute per one update cycle NUMBER>
+    COMMAND = set debounceDelay <time in ms, at most 250 (INT)>
+    COMMAND = set doubletapTimeout <time in ms, at most 65535 (INT)>
+    COMMAND = set keystrokeDelay <time in ms, at most 65535 (INT)>
+    COMMAND = set autoRepeatDelay <time in ms, at most 65535 (INT)>
+    COMMAND = set autoRepeatRate <time in ms, at most 65535 (INT)>
+    COMMAND = set macroEngine.batchSize <number of commands to execute per one update cycle INT>
     COMMAND = set navigationModeAction.NAVIGATION_MODE_CUSTOM.DIRECTION ACTION
     COMMAND = set keymapAction.LAYERID.KEYID ACTION
     COMMAND = set backlight.strategy { functional | constantRgb | perKeyRgb }
-    COMMAND = set backlight.constantRgb.rgb <number 0-255 (NUMBER)> <number 0-255 (NUMBER)> <number 0-255 (NUMBER)><number 0-255 (NUMBER)>
-    COMMAND = set backlight.keyRgb.LAYERID.KEYID <number 0-255 (NUMBER)> <number 0-255 (NUMBER)> <number 0-255 (NUMBER)>
-    COMMAND = set leds.enabled BOOLEAN
+    COMMAND = set backlight.constantRgb.rgb <number 0-255 (INT)> <number 0-255 (INT)> <number 0-255 (INT)><number 0-255 (INT)>
+    COMMAND = set backlight.keyRgb.LAYERID.KEYID <number 0-255 (INT)> <number 0-255 (INT)> <number 0-255 (INT)>
+    COMMAND = set leds.enabled BOOL
     COMMAND = set leds.brightness <0-1 multiple of default (FLOAT)>
-    COMMAND = set leds.fadeTimeout <seconds to fade after (NUMBER)>
+    COMMAND = set leds.fadeTimeout <seconds to fade after (INT)>
     COMMAND = set modifierLayerTriggers.{shift|alt|super|ctrl} {left|right|both}
+    CONDITION = if (EXPRESSION)
     CONDITION = {ifShortcut | ifNotShortcut} [IFSHORTCUT_OPTIONS]* [KEYID]+
     CONDITION = {ifGesture | ifNotGesture} [IFSHORTCUT_OPTIONS]* [KEYID]+
     CONDITION = {ifPrimary | ifSecondary} [ simpleStrategy | advancedStrategy ]
@@ -142,13 +144,12 @@ The following grammar is supported:
     CONDITION = {ifReleased | ifNotReleased}
     CONDITION = {ifKeyActive | ifNotKeyActive} KEYID
     CONDITION = {ifKeyDefined | ifNotKeyDefined} KEYID
-    CONDITION = {ifKeyPendingAt | ifNotKeyPendingAt} <idx in buffer (NUMBER)> KEYID
-    CONDITION = {ifPending | ifNotPending} <n (NUMBER)>
-    CONDITION = {ifPendingKeyReleased | ifNotPendingKeyReleased} <queue idx (NUMBER)>
-    CONDITION = {ifPlaytime | ifNotPlaytime} <timeout in ms (NUMBER)>
+    CONDITION = {ifKeyPendingAt | ifNotKeyPendingAt} <idx in buffer (INT)> KEYID
+    CONDITION = {ifPending | ifNotPending} <n (INT)>
+    CONDITION = {ifPendingKeyReleased | ifNotPendingKeyReleased} <queue idx (INT)>
+    CONDITION = {ifPlaytime | ifNotPlaytime} <timeout in ms (INT)>
     CONDITION = {ifShift | ifAlt | ifCtrl | ifGui | ifAnyMod | ifNotShift | ifNotAlt | ifNotCtrl | ifNotGui | ifNotAnyMod}
     CONDITION = {ifCapsLockOn | ifNotCapsLockOn | ifScrollLockOn | ifNotScrollLockOn | ifNumLockOn | ifNotNumLockOn}
-    CONDITION = {ifRegEq | ifNotRegEq | ifRegGt | ifRegLt} <register index (NUMBER)> <value (NUMBER)>
     CONDITION = {ifKeymap | ifNotKeymap} KEYMAPID
     CONDITION = {ifLayer | ifNotLayer} LAYERID
     CONDITION = {ifRecording | ifNotRecording}
@@ -158,47 +159,61 @@ The following grammar is supported:
     MODIFIER = final
     MODIFIER = autoRepeat
     MODIFIER = oneShot
-    IFSHORTCUT_OPTIONS = noConsume | transitive | anyOrder | orGate | timeoutIn <time in ms (NUMBER)> | cancelIn <time in ms(NUMBER)>
+    IFSHORTCUT_OPTIONS = noConsume | transitive | anyOrder | orGate | timeoutIn <time in ms (INT)> | cancelIn <time in ms(INT)>
     DIRECTION = {left|right|up|down}
     LAYERID = {fn|mouse|mod|base|fn2|fn3|fn4|fn5|alt|shift|super|ctrl}|last|previous
     LAYERID_BASIC = {fn|mouse|mod|base|fn2|fn3|fn4|fn5}
     KEYMAPID = <abbrev>|last
-    MACROID = last|CHAR|NUMBER
-    NUMBER = [0-9]+ | -[0-9]+ | #<register idx (NUMBER)> | #key | @<relative macro action index(NUMBER)> | %<key idx in postponer queue (NUMBER)>
-    BOOLEAN = 0 | 1
-    FLOAT = [0-9]+{.[0-9]+} | -FLOAT
+    MACROID = last|CHAR|INT
+    OPERATOR = + | - | * | / | % | < | > | <= | >= | == | != 
+    VARIABLE_EXPANSION = $<variable name> | $<config value name> | $currentAddress | $thisKeyId | $queuedKeyId.<queue index (INT)> | $keyId.KEYID_ABBREV
+    EXPRESSION = (EXPRESSION) | INT | BOOL | FLOAT | VARIABLE_EXPANSION | EXPRESSION OPERATOR EXPRESSION | !EXPRESSION | min(EXPRESSION [, EXPRESSION]+) | max(EXPRESSION [, EXPRESSION]+)
+    PARENTHESSED_EXPRESSION = (EXPRESSION)
+    INT = PARENTHESSED_EXPRESSION | VARIABLE_EXPANSION | [0-9]+ | -[0-9]+
+    BOOL = PARENTHESSED_EXPRESSION | VARIABLE_EXPANSION | 0 | 1 
+    FLOAT = PARENTHESSED_EXPRESSION | VARIABLE_EXPANSION | [0-9]*.[0-9]+ | -FLOAT
+    VALUE = INT | BOOL | FLOAT
+    STRING = "<interpolated string>" | '<literal string>'
+    IDENTIFIER = [a-zA-Z0-9_]+
     CHAR = <any nonwhite ascii char>
-    KEYID = <id of hardware key obtained by resolveNextKeyId (NUMBER)>
     LABEL = <string identifier>
-    SHORTCUT = MODMASK- | MODMASK-KEY | KEY | MODMASK
     MODMASK = [MODMASK]+ | [L|R]{S|C|A|G} | {p|r|h|t} | {s|i|o}
     NAVIGATION_MODE = cursor | scroll | caret | media | zoom | zoomPc | zoomMac | none
     NAVIGATION_MODE_CUSTOM = caret | media | zoomPc | zoomMac
     MODULEID = trackball | touchpad | trackpoint | keycluster
-    KEY = CHAR|KEY_ABBREV
-    ADDRESS = LABEL|NUMBER
+    ADDRESS = LABEL | INT
     ACTION = { macro MACROID | keystroke SHORTCUT | none }
-    KEY_ABBREV = enter | escape | backspace | tab | space | minusAndUnderscore | equalAndPlus | openingBracketAndOpeningBrace | closingBracketAndClosingBrace
-    KEY_ABBREV = backslashAndPipeIso | backslashAndPipe | nonUsHashmarkAndTilde | semicolonAndColon | apostropheAndQuote | graveAccentAndTilde | commaAndLessThanSign
-    KEY_ABBREV = dotAndGreaterThanSign | slashAndQuestionMark | capsLock | printScreen | scrollLock | pause | insert | home | pageUp | delete | end | pageDown | numLock
-    KEY_ABBREV = nonUsBackslashAndPipe | application | power | keypadEqualSign |  execute | help | menu | select | stop | again | undo | cut | copy | paste | find | mute
-    KEY_ABBREV = volumeUp | volumeDown | lockingCapsLock | lockingNumLock | lockingScrollLock | keypadComma | keypadEqualSignAs400 | international1 | international2
-    KEY_ABBREV = international3 | international4 | international5 | international6 | international7 | international8 | international9 | lang1 | lang2 | lang3 | lang4 | lang5
-    KEY_ABBREV = lang6 | lang7 | lang8 | lang9 | alternateErase | sysreq | cancel | clear | prior | return | separator | out | oper | clearAndAgain | crselAndProps | exsel
-    KEY_ABBREV = keypad00 | keypad000 | thousandsSeparator | decimalSeparator | currencyUnit | currencySubUnit | keypadOpeningParenthesis | keypadClosingParenthesis
-    KEY_ABBREV = keypadOpeningBrace | keypadClosingBrace | keypadTab | keypadBackspace | keypadA | keypadB | keypadC | keypadD | keypadE | keypadF | keypadXor | keypadCaret
-    KEY_ABBREV = keypadPercentage | keypadLessThanSign | keypadGreaterThanSign | keypadAmp | keypadAmpAmp | keypadPipe | keypadPipePipe | keypadColon | keypadHashmark
-    KEY_ABBREV = keypadSpace | keypadAt | keypadExclamationSign | keypadMemoryStore | keypadMemoryRecall | keypadMemoryClear | keypadMemoryAdd | keypadMemorySubtract
-    KEY_ABBREV = keypadMemoryMultiply | keypadMemoryDivide | keypadPlusAndMinus | keypadClear | keypadClearEntry | keypadBinary | keypadOctal | keypadDecimal
-    KEY_ABBREV = keypadHexadecimal | keypadSlash | keypadAsterisk | keypadMinus | keypadPlus | keypadEnter | keypad1AndEnd | keypad2AndDownArrow | keypad3AndPageDown
-    KEY_ABBREV = keypad4AndLeftArrow | keypad5 | keypad6AndRightArrow | keypad7AndHome | keypad8AndUpArrow | keypad9AndPageUp | keypad0AndInsert | keypadDotAndDelete
-    KEY_ABBREV = leftControl | leftShift | leftAlt | leftGui | rightControl | rightShift | rightAlt | rightGui
-    KEY_ABBREV = up | down | left | right | upArrow | downArrow | leftArrow | rightArrow
-    KEY_ABBREV = np0 | np1 | np2 | np3 | np4 | np5 | np6 | np7 | np8 | np9
-    KEY_ABBREV = f1 | f2 | f3 | f4 | f5 | f6 | f7 | f8 | f9 | f10 | f11 | f12 | f13 | f14 | f15 | f16 | f17 | f18 | f19 | f20 | f21 | f22 | f23 | f24
-    KEY_ABBREV = mediaVolumeMute | mediaVolumeUp | mediaVolumeDown | mediaRecord | mediaFastForward | mediaRewind | mediaNext | mediaPrevious | mediaStop | mediaPlayPause | mediaPause
-    KEY_ABBREV = systemPowerDown | systemSleep | systemWakeUp
-    KEY_ABBREV = mouseBtnLeft | mouseBtnRight | mouseBtnMiddle | mouseBtn4 | mouseBtn5 | mouseBtn6 | mouseBtn7 | mouseBtn8
+    SCANCODE = CHAR | SCANCODE_ABBREV
+    SHORTCUT = MODMASK- | MODMASK-SCANCODE | SCANCODE | MODMASK
+    SCANCODE_ABBREV = enter | escape | backspace | tab | space | minusAndUnderscore | equalAndPlus | openingBracketAndOpeningBrace | closingBracketAndClosingBrace
+    SCANCODE_ABBREV = backslashAndPipeIso | backslashAndPipe | nonUsHashmarkAndTilde | semicolonAndColon | apostropheAndQuote | graveAccentAndTilde | commaAndLessThanSign
+    SCANCODE_ABBREV = dotAndGreaterThanSign | slashAndQuestionMark | capsLock | printScreen | scrollLock | pause | insert | home | pageUp | delete | end | pageDown | numLock
+    SCANCODE_ABBREV = nonUsBackslashAndPipe | application | power | keypadEqualSign |  execute | help | menu | select | stop | again | undo | cut | copy | paste | find | mute
+    SCANCODE_ABBREV = volumeUp | volumeDown | lockingCapsLock | lockingNumLock | lockingScrollLock | keypadComma | keypadEqualSignAs400 | international1 | international2
+    SCANCODE_ABBREV = international3 | international4 | international5 | international6 | international7 | international8 | international9 | lang1 | lang2 | lang3 | lang4 | lang5
+    SCANCODE_ABBREV = lang6 | lang7 | lang8 | lang9 | alternateErase | sysreq | cancel | clear | prior | return | separator | out | oper | clearAndAgain | crselAndProps | exsel
+    SCANCODE_ABBREV = keypad00 | keypad000 | thousandsSeparator | decimalSeparator | currencyUnit | currencySubUnit | keypadOpeningParenthesis | keypadClosingParenthesis
+    SCANCODE_ABBREV = keypadOpeningBrace | keypadClosingBrace | keypadTab | keypadBackspace | keypadA | keypadB | keypadC | keypadD | keypadE | keypadF | keypadXor | keypadCaret
+    SCANCODE_ABBREV = keypadPercentage | keypadLessThanSign | keypadGreaterThanSign | keypadAmp | keypadAmpAmp | keypadPipe | keypadPipePipe | keypadColon | keypadHashmark
+    SCANCODE_ABBREV = keypadSpace | keypadAt | keypadExclamationSign | keypadMemoryStore | keypadMemoryRecall | keypadMemoryClear | keypadMemoryAdd | keypadMemorySubtract
+    SCANCODE_ABBREV = keypadMemoryMultiply | keypadMemoryDivide | keypadPlusAndMinus | keypadClear | keypadClearEntry | keypadBinary | keypadOctal | keypadDecimal
+    SCANCODE_ABBREV = keypadHexadecimal | keypadSlash | keypadAsterisk | keypadMinus | keypadPlus | keypadEnter | keypad1AndEnd | keypad2AndDownArrow | keypad3AndPageDown
+    SCANCODE_ABBREV = keypad4AndLeftArrow | keypad5 | keypad6AndRightArrow | keypad7AndHome | keypad8AndUpArrow | keypad9AndPageUp | keypad0AndInsert | keypadDotAndDelete
+    SCANCODE_ABBREV = leftControl | leftShift | leftAlt | leftGui | rightControl | rightShift | rightAlt | rightGui
+    SCANCODE_ABBREV = up | down | left | right | upArrow | downArrow | leftArrow | rightArrow
+    SCANCODE_ABBREV = np0 | np1 | np2 | np3 | np4 | np5 | np6 | np7 | np8 | np9
+    SCANCODE_ABBREV = f1 | f2 | f3 | f4 | f5 | f6 | f7 | f8 | f9 | f10 | f11 | f12 | f13 | f14 | f15 | f16 | f17 | f18 | f19 | f20 | f21 | f22 | f23 | f24
+    SCANCODE_ABBREV = mediaVolumeMute | mediaVolumeUp | mediaVolumeDown | mediaRecord | mediaFastForward | mediaRewind | mediaNext | mediaPrevious | mediaStop | mediaPlayPause | mediaPause
+    SCANCODE_ABBREV = systemPowerDown | systemSleep | systemWakeUp
+    SCANCODE_ABBREV = mouseBtnLeft | mouseBtnRight | mouseBtnMiddle | mouseBtn4 | mouseBtn5 | mouseBtn6 | mouseBtn7 | mouseBtn8
+    KEYID = INT | KEYID_ABBREV
+    KEYID_ABBREV = ' | , | - | . | / | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | ; | = | [ | ] | ` 
+    KEYID_ABBREV = a | q | w | e | r | t | y | u | i | o | p | a | s | d | f | g | h | j | k | l | z | x | c | v | b | n | m 
+    KEYID_ABBREV = apostropheAndQuote | backspace | capsLock | closingBracketAndClosingBrace | commaAndLessThanSign | dotAndGreaterThanSign | enter 
+    KEYID_ABBREV = equalAndPlus | graveAccentAndTilde | isoKey | semicolonAndColon | slashAndQuestionMark | tab | minusAndUnderscore | openingBracketAndOpeningBrace 
+    KEYID_ABBREV = leftAlt | leftCtrl | leftFn | leftMod | leftMouse | leftShift | leftSpace | leftSuper 
+    KEYID_ABBREV = leftModule.key1 | leftModule.key2 | leftModule.key3 | leftModule.leftButton | leftModule.middleButton | leftModule.rightButton 
+    KEYID_ABBREV = rightAlt | rightCtrl | rightFn | rightMod | rightShift | rightSpace | rightSuper | rightModule.leftButton | rightModule.rightButton 
     MACRONAME = <Case sensitive macro identifier as named in Agent. Identifier shall not contain spaces.>
     ###################
     #DEVELOPMENT TOOLS#
@@ -215,17 +230,23 @@ The following grammar is supported:
     COMMAND = {setStatus  | setStatusPart} <custom text>
     COMMAND = clearStatus
     COMMAND = set setEmergencyKey KEYID
+    COMMAND = validateUserConfig
     ############
     #DEPRECATED#
     ############
-    COMMAND = set module.MODULEID.invertScrollDirection BOOLEAN
+    INT = #<register idx (INT)> | #key | @<relative macro action index(INT)> | %<key idx in postponer queue (INT)>
+    COMMAND = writeExpr INT
+    CONDITION = {ifRegEq | ifNotRegEq | ifRegGt | ifRegLt} <register index (INT)> <value (INT)>
+    COMMAND = setStatusPart <custom text>
+    COMMAND = {setReg|addReg|subReg|mulReg} <register index (INT)> <value (INT)>
+    COMMAND = set module.MODULEID.invertScrollDirection BOOL
     COMMAND = set macroEngine.scheduler {blocking|preemptive}
-    COMMAND = set doubletapDelay <time in ms, at most 65535, alias to doubletapTimeout (NUMBER)>
+    COMMAND = set doubletapDelay <time in ms, at most 65535, alias to doubletapTimeout (INT)>
     COMMAND = switchLayer LAYERID
     COMMAND = switchKeymapLayer KEYMAPID LAYERID
-    COMMAND = resolveNextKeyEq <queue position (NUMBER)> KEYID {<time in ms>|untilRelease} <action adr (ADDRESS)> <action adr (ADDRESS)>
+    COMMAND = resolveNextKeyEq <queue position (INT)> KEYID {<time in ms>|untilRelease} <action adr (ADDRESS)> <action adr (ADDRESS)>
     COMMAND = set modifierLayerTriggers.{control} {left|right|both}
-    COMMAND = resolveSecondary <time in ms (NUMBER)> [<time in ms (NUMBER)>] <primary action macro action index (ADDRESS)> <secondary action macro action index (ADDRESS)>
+    COMMAND = resolveSecondary <time in ms (INT)> [<time in ms (INT)>] <primary action macro action index (ADDRESS)> <secondary action macro action index (ADDRESS)>
     COMMAND = untoggleLayer
     LAYERID = control
     #########
@@ -237,23 +258,23 @@ The following grammar is supported:
     MODIFIER = suppressKeys
     COMMAND = setStickyModsEnabled {0|never|smart|always|1}
     COMMAND = setCompensateDiagonalSpeed {0|1}
-    COMMAND = setDebounceDelay <time in ms, at most 250 (NUMBER)>
-    COMMAND = setKeystrokeDelay <time in ms, at most 65535 (NUMBER)>
-    COMMAND = setReg <register index (NUMBER)> <value (NUMBER)>
+    COMMAND = setDebounceDelay <time in ms, at most 250 (INT)>
+    COMMAND = setKeystrokeDelay <time in ms, at most 65535 (INT)>
+    COMMAND = setReg <register index (INT)> <value (INT)>
     COMMAND = setEmergencyKey KEYID
 
 ### Uncategorized commands:
 
-- `setLedTxt <time> <custom text>` will set led display to supplemented text for the given time. (Blocks for the given time.)
-    - If the given time is zero, i.e. `<time> = 0`, the led text will be set indefinitely (until the display is refreshed by other text) and this command will returns immediately (non-blocking).
+- `setLedTxt <time> { STRING | VALUE }` will set led display to the supplemented text and block for the given time before updating display back to default value.
+    - If the given time is zero, i.e. `<time> = 0`, the led text will be set indefinitely (until the display is refreshed by other text) and this command will return immediately.
+    - If `VALUE` is given (e.g., `$keystrokeDelay`), will be shown in notation that shows first two significant digits and a letter denoting floating point shift. E.g., `A23 = 2.3`, `Y23 = -0.23`, `23B = 2300`...
 - `progressHue` or better `autoRepeat progressHue` will slowly adjust constantRGB value in order to rotate the per-key-RGB backlight through all hues.
 - `resetTrackpoint` resets the internal trackpoint board. Can be used to recover the trackpoint from drift conditions. Drifts usually happen if you keep the cursor moving at slow constant speeds, because of the boards's internal adaptive calibration. Since the board's parameters cannot be altered, the only way around is or you to learn not to do the type of movement which triggers them.
-- `i2cBaudRate <baud rate, default 100000(NUMBER)>` sets i2c baud rate. Lowering this value may improve module reliability, while increasing latency.
+- `i2cBaudRate <baud rate, default 100000(INT)>` sets i2c baud rate. Lowering this value may improve module reliability, while increasing latency.
 
 ### Triggering keyboard actions (pressing keys, clicking, etc.):
 
-- `write <custom text>` will type rest of the string. Same as the plain text command. This is just easier to use with conditionals... If you want to interpolate register values, use (e.g.) `setStatus Register 0 contains #0; printStatus`.
-- `writeExpr NUMBER` serves for writing out contents of registers or otherwise computed numbers. E.g., `writeExpr #5` or `writeExpr @-2`.
+- `write <custom text>` will type rest of the string. Same as the plain text command. Strings are single quote (for literal strings) or double quote (for interpolated strings) enclosed. E.g., `write "keystrokeDelay is $keystrokeDelay, 1+1=$(1+1)\n"`, or `'$ will show as literal dollar sign.'`. 
 - `startMouse/stopMouse` start/stop corresponding mouse action. E.g., `startMouse move left`
 - `pressKey|holdKey|tapKey|releaseKey` Presses/holds/taps/releases the provided scancode. E.g., `pressKey mouseBtnLeft`, `tapKey LC-v` (Left Control + (lowercase) v), `tapKey CS-f5` (Ctrl + Shift + F5), `LS-` (just tap left Shift).
   - **press** means adding the scancode into a list of "active keys" and continuing the macro. The key is released once the macro ends. I.e., if the command is not followed by any sort of delay, the key will be released again almost immediately.
@@ -281,7 +302,7 @@ The following grammar is supported:
 ### Control flow, macro execution (aka "functions"):
 
 - `goTo ADDRESS` will go to action index int. Actions are indexed from zero. See `ADDRESS`
-- `repeatFor <register index> ADDRESS` - abbreviation to simplify cycles. Will decrement the supplemented register and perform `goTo` to `adr` if the value is still greater than zero. Intended usecase - place after command which is to be repeated with the register containing number of repeats and adr `@-1` (or similar).
+- `repeatFor <variable name> ADDRESS` - abbreviation to simplify cycles. Will decrement the supplemented register and perform `goTo` to `adr` if the value is still greater than zero. Intended usecase - place after command which is to be repeated with the register containing number of repeats and adr `($currentAddress-1)` (or similar).
 - `break` will end playback of the current macro
 - `noOp` does nothing - i.e., stops macro for exactly one update cycle and then continues.
 - `yield` forces macro to yield, if blocking scheduler is used. With preemptive scheduler acts just as `noOp`.
@@ -293,7 +314,7 @@ The following grammar is supported:
 ### Status buffer/Debugging tools
 
 - `printStatus` will "type" content of status buffer (256 or 1024 chars, depends on my mood) on the keyboard. Mainly for debug purposes.
-- `{setStatus | setStatusPart} <custom text>` will append <custom text> to the status buffer, if there is enough space for that. This text can then be printed by `printStatus`. This command interpolates register expressions. `setStatus` automatically appends newline, `setStatusPart` does not.
+- `setStatus STRING` will append STRING to the status buffer, if there is enough space for that. This text can then be printed by `printStatus`.
 - `clearStatus` will clear the buffer.
 - `statsRuntime` will output information about runtime of current macro into the status buffer. The time is measured before the printing mechanism is initiated.
 - `statsLayerStack` will output information about layer stack (into the buffer).
@@ -370,8 +391,8 @@ We allow postponing key activations in order to allow deciding between some scen
     - `transitive` makes termination conditions relate to that key of the queue whose result is most permissive (normally, they always refer to the activation key) - e.g., in transitive mode with 3-key shortcut, first key can be released if second key is being held. Timers count time since last performed action in this mode. Both `timeoutIn` and `cancelIn` behave according to this flag. In non-transitive mode, timers are counted since activation key press - i.e., since macro start.
     - `anyOrder` will check only presence of mentioned keyIds in postponer queue.
     - `orGate` will treat the given list of keys as *or-conditions* (rather than as *and-conditions*). Check any presence of mentioned keyIds in postponer queue for the next key press. Implies `anyOrder`.
-    - `timeoutIn <time (NUMBER)>` adds a timeout timer to both `Shortcut` and `Gesture` commands. If the timer times out (i.e., the condition does not suceed or fail earlier), the command continues as if matching KEYIDs failed. Can be used to shorten life of `Shortcut` resolution.
-    - `cancelIn <time (NUMBER)>` adds a timer to both commands. If this timer times out, all related keys are consumed and macro is broken. *"This action has never happened, lets not talk about it anymore."* (Note that this is an only condition which behaves same in both `if` and `ifNot` cases.)
+    - `timeoutIn <time (INT)>` adds a timeout timer to both `Shortcut` and `Gesture` commands. If the timer times out (i.e., the condition does not suceed or fail earlier), the command continues as if matching KEYIDs failed. Can be used to shorten life of `Shortcut` resolution.
+    - `cancelIn <time (INT)>` adds a timer to both commands. If this timer times out, all related keys are consumed and macro is broken. *"This action has never happened, lets not talk about it anymore."* (Note that this is an only condition which behaves same in both `if` and `ifNot` cases.)
 - DEPRECATED (use `ifShortcut/ifGesture` instead) `resolveNextKeyEq <queue idx> <key id> <timeout> <adr1> <adr2>` will wait for next (n) key press(es). When the key press happens, it will compare its id with the `<key id>` argument. If the id equals, it issues goto to adr1. Otherwise, to adr2. See examples. Implicitly applies `postponeKeys` modifier.
   - `arg1 - queue idx` idx of key to compare, indexed from 0. Typically 0, if we want to resolve the key after next key then 1, etc.
   - `arg2 - key id` key id obtained by `resolveNextKeyId`. This is static identifier of the hardware key.
@@ -385,9 +406,10 @@ We allow postponing key activations in order to allow deciding between some scen
 
 Conditions are checked before processing the rest of the command. If the condition does not hold, the rest of the command is skipped entirelly. If the command is evaluated multiple times (i.e., if it internally consists of multiple steps, such as the delay, which is evaluated repeatedly until the desired time has passed), the condition is evaluated only in the first iteration.
 
+- `if BOOL` allows switching based on custom expression. E.g., `if ($keystrokeDelay > 10) ...`
 - `ifDoubletap/ifNotDoubletap` is true if the macro was started at most 300ms after start of another instance of the same macro.
 - `ifInterrupted/ifNotInterrupted` is true if a keystroke action or mouse action was triggered during macro runtime. Allows fake implementation of secondary roles. Also allows interruption of cycles.
-- `ifReleased/ifNotReleased` is true if the key which activated current macro has been released. If the key has been physically released but the release has been postponed by another key, the conditien yields false. If the key has been physically released and the postponing mode was initiated by this macro (e.g., `postponeKeys ifReleased goTo @2`), it returns non-postponed release state (i.e., true if there's a matching release event in the postponing queue).
+- `ifReleased/ifNotReleased` is true if the key which activated current macro has been released. If the key has been physically released but the release has been postponed by another key, the conditien yields false. If the key has been physically released and the postponing mode was initiated by this macro (e.g., `postponeKeys ifReleased goTo ($currentAddress+2)`), it returns non-postponed release state (i.e., true if there's a matching release event in the postponing queue).
 - `ifPending/ifNotPending <n>` is true if there is at least `n` postponed keys in the postponing queue. In context of postponing mechanism, this condition acts similar in place of ifInterrupted.
 - `ifPendingKeyReleased/ifNotPendingKeyReleased <queue idx>` is true if the key pending at `idx` in queue has been released. I.e., if there exists matching release event in the queue.
 - `ifKeyPendingAt/ifNotKeyPendingAt <idx> KEYID` looks into postponing queue at `idx`th waiting key and compares it to the `keyId`. See `resolveNextKeyId`.
@@ -425,7 +447,7 @@ Usage (e.g.): call `recordMacro a`, do some work, end recording by another `reco
 
 Only BasicKeyboard scancodes are available at the moment. These macros are recorded into RAM only. Number of macros is limited by memory (current limit is set to approximately 500 keystrokes (4kb) (maximum is ~1000 if we used all available memory)). If less than 1/4 of dedicated memory is free, oldest macro slot is freed. If currently recorded macro is longer than 1/4 of dedicated memory, recording is stopped and the macro is freed (prevents unwanted deletion of macros).
 
-Macro slots are identified by a single character or a number or `#key` (meaning "this key").
+Macro slots are identified by a single character or a number or `$thisKeyId` (meaning "this key").
 
 - `recordMacroDelay` will measure time until key release (i.e., works like `delayUntilRelease`) and insert delay of that length into the currently recorded macro. This can be used to wait for window manager's reaction etc.
 - `recordMacro [<macro slot id(MACROID)>]` will toggle recording (i.e., either start or stop)
@@ -434,29 +456,30 @@ Macro slots are identified by a single character or a number or `#key` (meaning
 - If the `MACROID` argument is ommited, last id is used.
 - `{startRecordingBlind | stopRecordingBlind | recordMacroBlind} ...` work similarly, except that basic scancode output of keyboard is suppressed.
 
-### Registers:
-For the purpose of toggling functionality on and off, and for global constants management, we provide 32 numeric registers (namely of type int32_t).
+### Named variables:
+
+`setVar <name> <value>` allows setting/creating custom named variable. E.g., `setVar foo ($abc + 3)`. Value then can be accessed via `$foo` in place of numeric argument.
 
-- `setReg <register index> <value>` will set register identified by index to value.
-- `ifRegEq|ifNotRegEq|ifRegGt|ifRegLt` see CONDITION section
-- `{addReg|subReg|mulReg} <register index> <value>` adds value to the register
-- Register values can also be used in place of all numeric arguments by prefixing register index by '#'. E.g., waiting until release or for amount of time defined by reg 1 can be achieved by `delayUntilReleaseMax #1`
+Internally, values are saved in one of the following types, and types are automatically converted as needed in expressions:
+- `INT` - as a int32_t. E.g., `(7/3)` yields 2
+- `FLOA`T - as 32-bit floating point value. E.g., `(7/3.0)` yields 2.333...
+- `BOOL` - 1 or 0 value 
 
 ### Configuration options:
 
 - `set stickyModifiers {never|smart|always}` globally turns on or off sticky modifiers. This affects only standard scancode actions. Macro actions (both gui and command ones) are always nonsticky, unless `sticky` flag is included in `tapKey|holdKey|pressKey` commands. Default value is `smart`, which is the official behaviour - i.e., `<alt/ctrl/gui> + <tab/arrows>` are sticky.
-- `set diagonalSpeedCompensation BOOLEAN` will divide diagonal mouse speed by sqrt(2) if enabled.
-- `set chordingDelay 0 | <time in ms (NUMBER)>` If nonzero, keyboard will delay *all* key actions by the specified time (recommended 50ms). If another key is pressed during this time, pending key actions will be sorted according to their type:
+- `set diagonalSpeedCompensation BOOL` will divide diagonal mouse speed by sqrt(2) if enabled.
+- `set chordingDelay 0 | <time in ms (INT)>` If nonzero, keyboard will delay *all* key actions by the specified time (recommended 50ms). If another key is pressed during this time, pending key actions will be sorted according to their type:
   1) Keymap/layer switches
   2) Macros
   3) Keystrokes and mouse actions
   This allows the user to trigger chorded shortcuts in arbitrary ordrer (all at the "same" time). E.g., if `A+Ctrl` is pressed instead of `Ctrl+A`, keyboard will still send `Ctrl+A` if the two key presses follow within the specified time.
-- `set autoShiftDelay 0 | <time in ms (NUMBER)>` If nonzero, autoshift feature is turned on. This adds shift to a scancode when the key is held for at least `autoShiftDelay` ms. (E.g., tapping a results in 'a', pressing 'a' for a little bit longer results in 'A'.)
+- `set autoShiftDelay 0 | <time in ms (INT)>` If nonzero, autoshift feature is turned on. This adds shift to a scancode when the key is held for at least `autoShiftDelay` ms. (E.g., tapping a results in 'a', pressing 'a' for a little bit longer results in 'A'.)
 - `set debounceDelay <time in ms, at most 250>` prevents key state from changing for some time after every state change. This is needed because contacts of mechanical switches can bounce after contact and therefore change state multiple times in span of a few milliseconds. Official firmware debounce time is 50 ms for both press and release. Recommended value is 10-50, default is 50.
 - `set doubletapTimeout <time in ms, at most 65535>` controls doubletap timeouts for both layer switchers and for the `ifDoubletap` condition.
 - `set keystrokeDelay <time in ms, at most 65535>` allows slowing down keyboard output. This is handy for lousily written RDP clients and other software which just scans keys once a while and processes them in wrong order if multiple keys have been pressed inbetween. In more detail, this setting adds a delay whenever a basic usb report is sent. During this delay, key matrix is still scanned and keys are debounced, but instead of activating, the keys are added into a queue to be replayed later. Recommended value is 10 if you have issues with RDP missing modifier keys, 0 otherwise.
 - `set autoRepeatDelay <time in ms, at most 65535>` and `set autoRepeatRate <time in ms, at most 65535>` allows you to set the initial delay (default: 500 ms) and the repeat delay (default: 50 ms) when using `autoRepeat`. When you run the command `autoRepeat <command>`, the `<command>` is first run without delay. Then, it will waits `autoRepeatDelay` amount of time before running `<command>` again. Then and thereafter, it will waits `autoRepeatRate` amount of time before repeating `<command>` again. This is consistent with typical OS keyrepeat feature.
-- `set mouseKeys.{move|scroll}.{...} NUMBER` please refer to Agent for more details
+- `set mouseKeys.{move|scroll}.{...} INT` please refer to Agent for more details
   - `initialSpeed` - the speed that is active when key is pressed
   - `initialAcceleration,baseSpeed` - when mouse key is held, speed increases until it reaches baseSpeed
   - `deceleratedSpeed` - speed as affected by deceleration modifier
@@ -531,9 +554,9 @@ For the purpose of toggling functionality on and off, and for global constants m
 
   - `axisLockSkew` controls caret axis locking. Defaults to 0.5, valid/reasonable values are 0-100, centered around 1.
   - `axisLockFirstTickSkew` - same meaning as `axisLockSkew`, but controls how axis locking applies on first tick. Nonzero value means that firt tick will require a "push" before cursor starts moving. Or will require less "force" if the value is greater than 1.
-  - `cursorAxisLock BOOLEAN` - turns axis locking on for cursor mode. Not recommended, but possible.
-  - `scrollAxisLock BOOLEAN` - turns axis locking on for scroll mode. Default for keycluster trackball.
-  - `caretAxisLock BOOLEAN` - turns axis locking on for all discrete modes.
+  - `cursorAxisLock BOOL` - turns axis locking on for cursor mode. Not recommended, but possible.
+  - `scrollAxisLock BOOL` - turns axis locking on for scroll mode. Default for keycluster trackball.
+  - `caretAxisLock BOOL` - turns axis locking on for all discrete modes.
 
 - Remapping keys:
   - `set navigationModeAction.{caret|media}.{DIRECTION|none} ACTION` can be used to customize caret or media mode behaviour by binding directions to macros. This action is global and reversible only by powercycling.
@@ -544,12 +567,12 @@ For the purpose of toggling functionality on and off, and for global constants m
   - `set secondaryRole.defaultStrategy [ simple | advanced ]` sets default resolution strategy to be used. Furthermore, `ifPrimary/ifSecondary` can specify explicitly which strategy to use (e.g., `ifPrimary advancedStrategy final tapKey a`).
     - simple strategy listens for other key activations until the dual-role key is released. If there is any such activation, it activates the secondary role and then the action of the other key without any further delays. If there is no such other action, it performs primary role on the dual-role key release.
     - advanced strategy may trigger secondary role depending on timeout, or depending on key release order.
-      - `set secondaryRole.advanced.timeout <timeout in ms, 350 (NUMBER)>` if this timeout is reached, `timeoutAction` (secondary by default) role is activated.
+      - `set secondaryRole.advanced.timeout <timeout in ms, 350 (INT)>` if this timeout is reached, `timeoutAction` (secondary by default) role is activated.
       - `set secondaryRole.advanced.timeoutAction { primary | secondary }` defines whether primary or secondary role should be activated when timeout is reached
-      - `set secondaryRole.advanced.triggerByRelease BOOLEAN` if enabled, secondary role is chosen depending on release order of the keys (`press-A, press-B, release-B, release-A` leads to secondary action; `press-A, press-B, release-A, release-B` leads to primary action).
-      - `set secondaryRole.advanced.safetyMargin <ms, -50 - 50 (NUMBER)>` finetunes sensitivity of the trigger-by-release behaviour by adding the value to the dual-role-key release time. I.e., if both keys are released simultaneously (i.e., at most `safetyMargin` ms from each other), then positive values favor primary role, negative values secondary role.
-      - `set secondaryRole.advanced.doubletapToPrimary BOOLEAN` allows initiating hold of primary action by doubletap. (Useful if you want dual key on space key.)
-      - `set secondaryRole.advanced.doubletapTime <ms, 200 (NUMBER)>` configures the above timeout (measured press-to-press).
+      - `set secondaryRole.advanced.triggerByRelease BOOL` if enabled, secondary role is chosen depending on release order of the keys (`press-A, press-B, release-B, release-A` leads to secondary action; `press-A, press-B, release-A, release-B` leads to primary action).
+      - `set secondaryRole.advanced.safetyMargin <ms, -50 - 50 (INT)>` finetunes sensitivity of the trigger-by-release behaviour by adding the value to the dual-role-key release time. I.e., if both keys are released simultaneously (i.e., at most `safetyMargin` ms from each other), then positive values favor primary role, negative values secondary role.
+      - `set secondaryRole.advanced.doubletapToPrimary BOOL` allows initiating hold of primary action by doubletap. (Useful if you want dual key on space key.)
+      - `set secondaryRole.advanced.doubletapTime <ms, 200 (INT)>` configures the above timeout (measured press-to-press).
 
 - `macroEngine`
   - terminology:
@@ -570,22 +593,34 @@ For the purpose of toggling functionality on and off, and for global constants m
 
 - backlight:
     - `backlight.strategy { functional | constantRgb | perKeyRgb }` sets backlight strategy.
-    - `backlight.constantRgb.rgb NUMBER NUMBER NUMBER` allows setting custom constant colour for entire keyboard. E.g.: `set backlight.strategy constantRgb; set backlight.constantRgb.rgb 255 0 0` to make entire keyboard shine red.
-    - `backlight.keyRgb.LAYERID.KEYID NUMBER NUMBER NUMBER` allows overriding color of the key. This override will last until reload of keymap and will apply to all backlight strategies.
+    - `backlight.constantRgb.rgb INT INT INT` allows setting custom constant colour for entire keyboard. E.g.: `set backlight.strategy constantRgb; set backlight.constantRgb.rgb 255 0 0` to make entire keyboard shine red.
+    - `backlight.keyRgb.LAYERID.KEYID INT INT INT` allows overriding color of the key. This override will last until reload of keymap and will apply to all backlight strategies.
 
 - general led configuration:
-    - `leds.enabled BOOLEAN` turns on/off all keyboard leds: i.e., backlight, indicator leds, segment display
+    - `leds.enabled BOOL` turns on/off all keyboard leds: i.e., backlight, indicator leds, segment display
     - `leds.brightness <0-1 multiple of default (FLOAT)>` allows scaling default brightness. E.g., `0.5` will dim entire keyboard to half of the default values that are configured in Agent
-    - `leds.fadeTimeout <seconds to fade after (NUMBER)>` will turn off leds after configured interval.
+    - `leds.fadeTimeout <seconds to fade after (INT)>` will turn off leds after configured interval.
 
 - modifier layer triggers:
     - `set modifierLayerTriggers.{shift|alt|super|ctrl} {left|right|both}` controls whether modifier layers are triggered by left or right or either of the modifiers.
 
 ### Argument parsing rules:
 
-- `NUMBER` is parsed as a 32 bit signed integer and then assigned into the target variable. However, the target variable is often only 8 or 16 bit unsigned. If a number is prefixed with '#', it is interpretted as a register address (index). If a number is prefixed with '@', current macro index is added to the final value. `#key` returns activation key's hardware id. If prefixed with `%`, returns keyid of nth press event in the postponer queue (e.g., `%0` returns `KEYID` of first key which is postponed but not yet activated).
+- `INT` is parsed as a 32 bit signed integer and then assigned into the target variable. However, the target variable is often only 8 or 16 bit unsigned. 
+- `EXPRESSION` / variables - all numeric/boolean arguments also accept arbitrary expressions. These have to be enclosed in parentheses.
+  - Following operators are accepted:
+    - `+,-,*,/,%` - addition, subtraction, multiplication, division and modulo
+    - `min(),max()` - minimum, maximum, e.g. `min($a, 2, 3, 4)`
+    - `<,<=,>,>=` - less than, less or equal, greater than, greater or equal
+    - `==,!=` - equals, not equals
+    - `!` - unary boolean negation
+  - Following special identifiers are supported:
+    - `$thisKeyId` which stands for keyid of the key which activated the macro.
+    - `$keyId.<keyId abbreviation>` which stands for keyid of the key which activated the macro.
+    - `$currentAddress` which stands for address of the command in which it is found.
+    - `$queuedKeyId.<index (NUMBER)>` which stands for a zero-indexed position in postponer's queue.
 - `KEYMAPID` - is assumed to be 3 characters long abbreviation of a keymap.
-- `MACROID` - macro slot identifier is either a number or a single ascii character (interpretted as a one-byte value). `#key` can be used so that the same macro refers to different slots when assigned to different keys.
+- `MACROID` - macro slot identifier is either a number or a single ascii character (interpretted as a one-byte value). `$thisKeyId` can be used so that the same macro refers to different slots when assigned to different keys.
 - `register index` is an integer in the appropriate range, used as an index to the register array.
 - `custom text` is an arbitrary text starting on next non-space character and ending at the end of the text action. (Yes, this should be refactored in the future.)
 - `KEYID` is a numeric id obtained by `resolveNextKeyId` macro. It can also be constructed manually, as an index (starting at zero) added to an offset of `64*slotid`.  This means that starting offsets are:
@@ -599,7 +634,7 @@ For the purpose of toggling functionality on and off, and for global constants m
 
 - `SHORTCUT` is an abbreviation of a key possibly accompanied by modifiers. Describes at most one scancode action. Can be prefixed by `C/S/A/G` denoting `Control/Shift/Alt/Gui`. Mods can further be prefixed by `L/R`, denoting left or right modifier. If a single ascii character is entered, it is translated into corresponding key combination (shift mask + scancode) according to standard EN-US layout. E.g., `pressKey mouseBtnLeft`, `tapKey LC-v` (Left Control + (lowercase) V (scancode)), `tapKey CS-f5` (Ctrl + Shift + F5), `tapKey v` (V), `tapKey V` (Shift + V).
 - `LABEL` is and identifier marking some lines of the macro. When a string is encountered in a context of an address, UHK looks for a command beginning by `<the string>:` and returns its addres (index). If same label is present multiple times, the next one w.r.t. currently processed command is returned.
-- `ADDRESS` addresses allow jumping between macro instructions. Every action or command has its own address, numbered from zero. Formally, address is either a `NUMBER` (including `#`, `@`, etc syntaxies) or a string which denotes label identifier. Every action consumes at least one address. (Except for command action, exactly one.) Every command (non-empty line of command action) consumes one address. E.g., `goTo 0` (go to beginning), `goTo @-1` (go to previous command, since `@` resolves relative adresses to absolute), `goTo @0` (active waiting), `goTo default` (go to line which begins by `default: ...`).
+- `ADDRESS` addresses allow jumping between macro instructions. Every action or command has its own address, numbered from zero. Formally, address is either a `INT` or a string which denotes label identifier. Every action consumes at least one address. (Except for command action, exactly one.) Every command (non-empty line of command action) consumes one address. E.g., `goTo 0` (go to beginning), `goTo ($currentAddress-1)` (go to previous command), `goTo $currentAddress` (active waiting), `goTo default` (go to line which begins by `default: ...`).
 
 ### Navigation modes:
 
diff --git a/doc-dev/user-guide.md b/doc-dev/user-guide.md
index 1888f9876..2e437d052 100644
--- a/doc-dev/user-guide.md
+++ b/doc-dev/user-guide.md
@@ -236,19 +236,19 @@ One concept which uses this feature is _shortcuts and gestures_.
 You can use `ifShortcut` when you want to map an action to a combination of keys. E.g, if I want z+x to produce Control+x, z+c to produce Control+c, z+v to produce Control+v, I will map following macro on the z key:
 
 ```
-ifShortcut 88 final tapKey C-x
-ifShortcut 89 final tapKey C-c
-ifShortcut 90 final tapKey C-v
+ifShortcut x final tapKey C-x
+ifShortcut c final tapKey C-c
+ifShortcut v final tapKey C-v
 holdKey z
 ```
 
-An `ifShortcut` macro needs to be placed on the first key of the shortcut, and refers to other keys by Their hardware ids. These ids can be obtained by `resolveNextKeyId` command (i.e., activating the command and pressing the key while having a text editor focused). The `final` modifier breaks the command after the "modified" `tapKey` command finishes.
+An `ifShortcut` macro needs to be placed on the first key of the shortcut, and refers to other keys by Their hardware ids. These ids can be entered in numeric form obtained by `resolveNextKeyId` command (i.e., activating the command and pressing the key while having a text editor focused), or abbreviations may be used (as shown above). The `final` modifier breaks the command after the "modified" `tapKey` command finishes.
 
 `ifGesture` can be used to implement "loose gestures" - i.e., shortcuts where the second keypress can follow without continuity of press of the first key. Vim-like gt and gT (g+shift+t) tab switching:
 
 ```
-ifGesture 077 final tapKey C-pageUp
-ifGesture 085 077 final tapKey C-pageDown
+ifGesture t final tapKey C-pageUp
+ifGesture leftShift t final tapKey C-pageDown
 holdKey g
 ```
 
@@ -265,19 +265,28 @@ In order to bind some action to doubletap, you may use two strategies:
 - simple `ifDoubletap` condition, which just checks whether another instance of the same macro was activae lately. Doubletapping this will result in sequence `ab`:
 
 ```
-    ifDoubletap final tapKey b
-    holdKey a
+ifDoubletap final tapKey b
+holdKey a
 ```
 
 - time-machine `ifGesture` condition. Doubletapping this will produce a slight delay and then output just `b`:
 
 ```
-    ifGesture #key final tapKey b
-    holdKey a
+ifGesture #key final tapKey b
+holdKey a
 ```
 
 Another concept which may or may not use our time machine is secondary roles, namely the advanced strategy.
 
+### Keyids vs Scancodes
+
+Please note the difference between key ids and scancodes. Both notation use human-readable abbreviations and are therefore easy to mix up.
+
+- _key ids_ identify specific hardware key. Human readable key id abbreviations are assigned to match the printed key labels according to the default en-US layout. If you wish to use numeric key ids, then be sure that the numbers have always at least two digits (e.g., `ifGesture 03 ...`).
+- _scancode_ abbreviations describe scancodes as communicated to the PC, mapped according to en-US scancode mapping.
+
+For instance, if you rebind your UHK to Dvorak, then the key identified by hardware id `s` will be mapped to the `o` scancode (i.e., will read `o` in Agent, or contain `holdKey o` macro command). That is, issuing `activateKeyPostponed s` will produce the same thing as `holdKey o`. (Of course, if you furthermore choose some non-standard language mapping in your OS, you may end up with yet another character produced on screen.)
+
 ### Secondary roles
 
 Secondary role is a role which becomes active if another key is pressed with this key. It can be implemented in following variants: 
@@ -409,6 +418,36 @@ set keymapAction.base.192 macro TouchpadLeft
 set keymapAction.base.193 macro TouchpadRight
 ```
 
+### Strings, variables and expressions
+
+Write command accepts (not exactly) bash-style interpolated strings. E.g.:
+
+```
+write "Current keystrokeDelay is $keystrokeDelay. One plus one is $(1 + 1).\n"
+write 'This is literal "$" character. And here you have an apostrophe '"'"'.'
+```
+
+You can save values into named variables via following syntax:
+
+```
+setVar foo 42
+write "\$foo value is $foo."
+```
+
+You can use your variables, or configuration values in commands. E.g. to control led brightness, you may:
+
+```
+ifShift set leds.brightness ($leds.brightness * 1.5 + 0.01)
+ifNotShift set leds.brightness ($leds.brightness / 1.5)
+```
+
+Following operators are accepted:
+- `+,-,*,/,%` - addition, subtraction, multiplication, division and modulo
+- `min(),max()` - minimum, maximum, e.g. `min($a, 2, 3, 4)`
+- `<,<=,>,>=` - less than, less or equal, greater than, greater or equal
+- `==,!=` - equals, not equals
+- `!` - unary boolean negation
+
 ### Advanced commands:
 
 You can simplify writing macros by using `#` and `@` characters. The first resolves a number as an index of a register. The second interprets the number as a relative action index. For instance the following macro will write out five "a"s with 50 ms delays
@@ -419,24 +458,24 @@ You can simplify writing macros by using `#` and `@` characters. The first resol
 // yes, this is a totally meaningless example
 ifCtrl goTo default    //goto can also go to labels, absolute adresses and relative adresses
 ifShift final tapKey a //final modifier ends the macro once the command has finished
-setReg 0 50            //store number 50 into register 0
-setReg 1 5
+setVar foo 50            //store number 50 into variable foo
+setVar bar 5
 tapKey a
-delayUntil #0          //the #0 is expanded to content of register 0
-repeatFor 1 @-2        //decrement register 1; if it is non-zero, return by two commands to the tapKey command
-noOp                   //note the @ character - it resolves relative address to absolute (i.e., adds current adr)
+delayUntil $foo
+repeatFor bar $currentAddress-2        //decrement $bar; if it is non-zero, return by two commands to the tapKey command
+noOp                   
 default: tapKey b      //<string>: denotes a label, which can be used as jump target
 ```
 
-You can use `goTo @0` as an active wait loop. Consider following example. If briefly tapped, it produces `@@` (play last vim macro). If held, it prepends any other key tap with a `@` key. E.g., `thisMacro + p + p + p` produces `@p@p@p` (play vim macro in register p, twice).
+You can use `goTo $currentAddress` as an active wait loop. Consider following example. If briefly tapped, it produces `@@` (play last vim macro). If held, it prepends any other key tap with a `@` key. E.g., `thisMacro + p + p + p` produces `@p@p@p` (play vim macro in register p, twice).
 
 ```
-begin: postponeKeys ifNotPending 1 ifNotReleased goTo @0
+begin: postponeKeys ifNotPending 1 ifNotReleased goTo $currentAddress
 postponeKeys ifReleased final ifNotInterrupted ifNotPlaytime 300 tapKeySeq @ @
 postponeKeys ifPending 1 tapKey @
-postponeKeys setReg 0 %0
-ifPending 1 goTo @0
-ifKeyActive #0 goTo @0
+postponeKeys setVar savedKey $queuedKeyId.0
+ifPending 1 goTo $currentAddress
+ifKeyActive $savedKey goTo $currentAddress
 goTo begin
 ```
 
@@ -446,8 +485,8 @@ On activation key:
 
 ```
 pressKey LS-
-setReg 5 1
-ifRegEq 5 1 goTo @0
+setVar capsActive 1
+if ($capsActive) goTo $currentAddress
 #at the end of macro, the shift gets released automatically
 ```
 
@@ -455,7 +494,7 @@ on space:
 
 ```
 holdKey space
-setReg 5 0
+setVar capsActive 0
 ```
 
 ### Macro recorder
@@ -473,20 +512,20 @@ Above examples can be combined into more elaborate setups. Assume we bind follow
 
 ```
 # perKeyMacro
-ifShift final recordMacro #key
-ifRegEq 27 1 final recordMacro #key
-playMacro #key
+ifShift final recordMacro $thisKeyId
+if ($qActive) final recordMacro $thisKeyId
+playMacro $thisKeyId
 ```
 
 ```
 # recordKey
 ifRecording final stopRecording
-ifRegEq 27 1 final setReg 27 0
-setReg 27 1
+if $qActive final setVar qActive 0
+setVar qActive 1
 toggleLayer fn
-ifNotRecording ifNotPlaytime 5000 ifRegEq 27 1 goTo @0
+ifNotRecording ifNotPlaytime 5000 if ($qActive) goTo @0
 untoggleLayer
-setReg 27 0
+setVar qActive 0
 ```
 
 ### Per-key LEDs fun:
@@ -494,18 +533,18 @@ setReg 27 0
 Colour picker for constant colours. Bound on fn+r, fn+r+r turns colour to red, fn+r+v to violet, etc..
 
 ```
-ifGesture 75 final set backlight.constantRgb.rgb 255 32 0  // r - red
-ifGesture 84 final set backlight.constantRgb.rgb 192 255 0  // g - green
-ifGesture 91 final set backlight.constantRgb.rgb 128 192 255 // b - blue
-ifGesture 14 final set backlight.constantRgb.rgb 255 192 0 // y - yellow
-ifGesture 90 final set backlight.constantRgb.rgb 192 64 255 // v - violet
-ifGesture 9  final set backlight.constantRgb.rgb 255 128 0 // o - orange
-ifGesture 73 final set backlight.constantRgb.rgb 192 32 0 // w - wine
-ifGesture 21 final set backlight.constantRgb.rgb 128 48 0 // b - brown
-ifGesture 22 final set backlight.constantRgb.rgb 255 192 32 // n - warm white, as "normal"
-ifGesture 82 final set backlight.strategy functional // f to functional backlight
-ifGesture 72 final set leds.enabled 0 // q - to turn off
-ifGesture 10 final set leds.enabled 1 // p - to turn back on
+ifGesture r final set backlight.constantRgb.rgb 255 32 0  // r - red
+ifGesture g final set backlight.constantRgb.rgb 192 255 0  // g - green
+ifGesture b final set backlight.constantRgb.rgb 128 192 255 // b - blue
+ifGesture y final set backlight.constantRgb.rgb 255 192 0 // y - yellow
+ifGesture v final set backlight.constantRgb.rgb 192 64 255 // v - violet
+ifGesture o final set backlight.constantRgb.rgb 255 128 0 // o - orange
+ifGesture w final set backlight.constantRgb.rgb 192 32 0 // w - wine
+ifGesture b final set backlight.constantRgb.rgb 128 48 0 // b - brown
+ifGesture n final set backlight.constantRgb.rgb 255 192 32 // n - warm white, as "normal"
+ifGesture f final set backlight.strategy functional // f to functional backlight
+ifGesture q final set leds.enabled 0 // q - to turn off
+ifGesture p final set leds.enabled 1 // p - to turn back on
 ```
 
 To see all possible UHK hues (maximum saturation), hold a key with the following macro:
@@ -526,11 +565,11 @@ Above macro will not terminate, not even when ran multiple times. In order to fi
 
 ```
 # prevent the macro from running multiple times via (randomly picked) register 22
-setReg 22 1
+setVar hueStopper 1
 delayUntil 2000
-setReg 22 0
+setVar hueStopper 0
 beginLoop:
-ifRegEq 22 1 break
+if $hueStopper break
 progressHue
 delayUntil 1000
 goTo beginLoop
@@ -542,7 +581,7 @@ You can also start this from `$onInit` by `fork rotateHues` (given you have the
 # put this at the beginning of the picker, to stop rotateHues when another choice is made.
 setReg 22 1
 # start the `rotateHues` macro on 'c' - as "changing"
-ifGesture 89 final fork rotateHues
+ifGesture c final fork rotateHues
 ```
 
 ### Executing commands over USB
diff --git a/right/src/macro_keyid_parser.c b/right/src/macro_keyid_parser.c
new file mode 100644
index 000000000..f7825977b
--- /dev/null
+++ b/right/src/macro_keyid_parser.c
@@ -0,0 +1,148 @@
+#include "macros.h"
+#include "macro_keyid_parser.h"
+#include "str_utils.h"
+#include <stddef.h>
+#include <stdint.h>
+#include "debug.h"
+
+
+typedef struct {
+    const char* id;
+    uint8_t keyId;
+} lookup_record_t;
+
+static const lookup_record_t lookup_table[] = {
+        // ALWAYS keep the array sorted by `LC_ALL=C sort`
+        {"", 255},
+        {"'", 19},
+        {",", 24},
+        {"-", 4},
+        {".", 25},
+        {"/", 26},
+        {"0", 3},
+        {"1", 65},
+        {"2", 66},
+        {"3", 67},
+        {"4", 68},
+        {"5", 69},
+        {"6", 70},
+        {"7", 0},
+        {"8", 1},
+        {"9", 2},
+        {";", 18},
+        {"=", 5},
+        {"[", 11},
+        {"]", 12},
+        {"`", 64},
+        {"a", 79},
+        {"apostropheAndQuote", 19},
+        {"b", 91},
+        {"backspace", 6},
+        {"c", 89},
+        {"capsLock", 78},
+        {"closingBracketAndClosingBrace", 12},
+        {"commaAndLessThanSign", 24},
+        {"d", 81 },
+        {"dotAndGreaterThanSign", 25},
+        {"e", 74 },
+        {"enter", 20},
+        {"equalAndPlus", 5},
+        {"f", 82},
+        {"g", 84},
+        {"graveAccentAndTilde", 63},
+        {"h", 21},
+        {"i", 8},
+        {"isoKey", 86},
+        {"j", 15},
+        {"k", 16},
+        {"l", 17},
+        {"leftAlt", 94},
+        {"leftCtrl", 92},
+        {"leftFn", 95},
+        {"leftMod", 97},
+        {"leftModule.key1", 128},
+        {"leftModule.key2", 129},
+        {"leftModule.key3", 130},
+        {"leftModule.leftButton", 131},
+        {"leftModule.middleButton", 132},
+        {"leftModule.rightButton", 133},
+        {"leftMouse", 78},
+        {"leftShift", 85},
+        {"leftSpace", 96},
+        {"leftSuper", 93},
+        {"m", 23},
+        {"minusAndUnderscore", 4},
+        {"n", 22},
+        {"o", 9},
+        {"openingBracketAndOpeningBrace", 11},
+        {"p", 10},
+        {"q", 72},
+        {"r", 75},
+        {"rightAlt", 32},
+        {"rightCtrl", 34},
+        {"rightFn", 31},
+        {"rightMod", 30},
+        {"rightModule.leftButton", 192},
+        {"rightModule.rightButton", 193},
+        {"rightShift", 27},
+        {"rightSpace", 29},
+        {"rightSuper", 33},
+        {"s", 80},
+        {"semicolonAndColon", 18},
+        {"slashAndQuestionMark", 26},
+        {"t", 77},
+        {"tab", 71},
+        {"u", 7},
+        {"v", 90},
+        {"w", 73},
+        {"x", 88},
+        {"y", 14},
+        {"z", 87},
+        {"|", 13},
+};
+
+static size_t lookup_size = sizeof(lookup_table)/sizeof(lookup_table[0]);
+
+static void testLookup()
+{
+    for (uint8_t i = 0; i < lookup_size - 1; i++) {
+        if (!StrLessOrEqual(lookup_table[i].id, NULL, lookup_table[i+1].id, NULL)) {
+            Macros_ReportError("Keyid table is not properly sorted!", lookup_table[i].id, NULL);
+        }
+    }
+}
+
+void KeyIdParser_initialize()
+{
+    testLookup();
+}
+
+static const lookup_record_t* lookup(uint8_t begin, uint8_t end, const char* str, const char* strEnd)
+{
+    uint8_t pivot = begin + (end-begin)/2;
+    if (begin == end) {
+        if (StrLessOrEqual(str, strEnd, lookup_table[pivot].id, NULL) && StrLessOrEqual(lookup_table[pivot].id, NULL, str, strEnd)) {
+            return &lookup_table[pivot];
+        } else {
+            return NULL;
+        }
+    }
+    else if (StrLessOrEqual(str, strEnd, lookup_table[pivot].id, NULL)) {
+        return lookup(begin, pivot, str, strEnd);
+    } else {
+        return lookup(pivot + 1, end, str, strEnd);
+    }
+}
+
+uint8_t MacroKeyIdParser_TryConsumeKeyId(parser_context_t* ctx)
+{
+    const lookup_record_t* record = lookup(0, lookup_size-1, ctx->at, TokEnd(ctx->at, ctx->end));
+
+    if (record == NULL) {
+        return 255;
+    }
+
+    ConsumeToken(ctx, record->id);
+
+    return record->keyId;
+}
diff --git a/right/src/macro_keyid_parser.h b/right/src/macro_keyid_parser.h
new file mode 100644
index 000000000..5c7b1ee8c
--- /dev/null
+++ b/right/src/macro_keyid_parser.h
@@ -0,0 +1,20 @@
+#ifndef SRC_MACRO_KEYID_PARSER_H_
+#define SRC_MACRO_KEYID_PARSER_H_
+
+
+// Includes:
+
+    #include <stdint.h>
+    #include <stdbool.h>
+    #include "macros.h"
+#include "str_utils.h"
+
+// Typedefs:
+
+    // Functions:
+
+    void KeyIdParser_initialize();
+    uint8_t MacroKeyIdParser_TryConsumeKeyId(parser_context_t* ctx);
+
+
+#endif
diff --git a/right/src/macro_set_command.c b/right/src/macro_set_command.c
index 5485c8511..5ff9dd568 100644
--- a/right/src/macro_set_command.c
+++ b/right/src/macro_set_command.c
@@ -1,5 +1,7 @@
 #include "macro_set_command.h"
 #include "config_parser/parse_config.h"
+#include "config_parser/parse_keymap.h"
+#include "key_states.h"
 #include "layer.h"
 #include "ledmap.h"
 #include "macros.h"
@@ -23,452 +25,363 @@
 #include "config_parser/parse_macro.h"
 #include "slave_drivers/is31fl3xxx_driver.h"
 #include "init_peripherals.h"
+#include "macros_vars.h"
 #include <stdint.h>
 
-static const char* proceedByDot(const char* cmd, const char *cmdEnd)
+typedef enum {
+    SetCommandAction_Write,
+    SetCommandAction_Read,
+} set_command_action_t;
+
+#define ASSIGN_CUSTOM5(TPE, RET, RETPARAM, DST, SRC)           \
+    if (action == SetCommandAction_Read) {                     \
+        return RET(RETPARAM);                                  \
+    }                                                          \
+    TPE res = SRC;                                             \
+    if (Macros_ParserError || Macros_DryRun) {                 \
+        return noneVar();                                      \
+    }                                                          \
+    DST = res;                                                 \
+
+#define ASSIGN_INT_MUL(DST, M)                                 \
+    if (action == SetCommandAction_Read) {                     \
+        return intVar(DST/(M));                                \
+    }                                                          \
+    uint32_t res = Macros_LegacyConsumeInt(ctx)*(M);           \
+    if (Macros_ParserError || Macros_DryRun) {                 \
+        return noneVar();                                      \
+    }                                                          \
+    DST = res;                                                 \
+
+#define ASSIGN_INT2(DST, DST2)                                 \
+    if (action == SetCommandAction_Read) {                     \
+        return intVar(DST);                                    \
+    }                                                          \
+    uint32_t res = Macros_LegacyConsumeInt(ctx);               \
+    if (Macros_ParserError || Macros_DryRun) {                 \
+        return noneVar();                                      \
+    }                                                          \
+    DST = res;                                                 \
+    DST2 = res;                                                \
+
+#define ASSIGN_CUSTOM(TPE, RET, DST, SRC) ASSIGN_CUSTOM5(TPE, RET, DST, DST, SRC)
+#define ASSIGN_ENUM(DST, SRC) ASSIGN_CUSTOM(uint8_t, intVar, DST, SRC)
+#define ASSIGN_FLOAT(DST) ASSIGN_CUSTOM(float, floatVar, DST, Macros_ConsumeFloat(ctx))
+#define ASSIGN_BOOL(DST) ASSIGN_CUSTOM(bool, boolVar, DST, Macros_ConsumeBool(ctx))
+#define ASSIGN_INT(DST) ASSIGN_CUSTOM(int32_t, intVar, DST, Macros_ConsumeInt(ctx))
+
+static macro_variable_t noneVar()
 {
-    while(*cmd > 32 && *cmd != '.' && cmd < cmdEnd)    {
-        cmd++;
-    }
-    if (*cmd != '.') {
-        Macros_ReportError("'.' expected", cmd, cmd);
-    }
-    return cmd+1;
+    return (macro_variable_t) { .asInt = 1, .type = MacroVariableType_None };
+}
+
+static macro_variable_t intVar(int32_t value)
+{
+    return (macro_variable_t) { .asInt = value, .type = MacroVariableType_Int };
+}
+
+static macro_variable_t floatVar(float value)
+{
+    return (macro_variable_t) { .asFloat = value, .type = MacroVariableType_Float };
+}
+
+static macro_variable_t boolVar(bool value)
+{
+    return (macro_variable_t) { .asBool = value, .type = MacroVariableType_Bool };
 }
 
-static void moduleNavigationMode(const char* arg1, const char *textEnd, module_configuration_t* module)
+static macro_variable_t moduleNavigationMode(parser_context_t* ctx, set_command_action_t action, module_configuration_t* module)
 {
-    layer_id_t layerId = Macros_ParseLayerId(arg1, textEnd);
-    navigation_mode_t modeId = ParseNavigationModeId(NextTok(arg1, textEnd), textEnd);
+    parser_context_t layerCtx = *ctx;
+    layer_id_t layerId = Macros_ConsumeLayerId(ctx);
+
+    if (action == SetCommandAction_Read) {
+        return intVar(module->navigationModes[layerId]);
+    }
+
+    navigation_mode_t modeId = ConsumeNavigationModeId(ctx);
 
     if (IS_MODIFIER_LAYER(layerId)) {
-        Macros_ReportError("Navigation mode cannot be changed for modifier layers!", arg1, arg1);
-        return;
+        Macros_ReportError("Navigation mode cannot be changed for modifier layers!", layerCtx.at, layerCtx.at);
+        return noneVar();
     }
 
     if (Macros_ParserError) {
-        return;
+        return noneVar();
     }
     if (Macros_DryRun) {
-        return ;
+        return noneVar();
     }
 
     module->navigationModes[layerId] = modeId;
+    return noneVar();
 }
 
-static void moduleSpeed(const char* arg1, const char *textEnd, module_configuration_t* module, uint8_t moduleId)
+static macro_variable_t moduleSpeed(parser_context_t* ctx, set_command_action_t action, module_configuration_t* module, uint8_t moduleId)
 {
-    const char* arg2 = NextTok(arg1, textEnd);
-
-    if (TokenMatches(arg1, textEnd, "baseSpeed")) {
-        float baseSpeed = ParseFloat(arg2, textEnd);
-        if (Macros_DryRun) {
-            return;
-        }
-        module->baseSpeed = baseSpeed;
+    if (ConsumeToken(ctx, "baseSpeed")) {
+        ASSIGN_FLOAT(module->baseSpeed);
     }
-    else if (TokenMatches(arg1, textEnd, "speed")) {
-        float speed = ParseFloat(arg2, textEnd);
-        if (Macros_DryRun) {
-            return;
-        }
-        module->speed = speed;
+    else if (ConsumeToken(ctx, "speed")) {
+        ASSIGN_FLOAT(module->speed);
     }
-    else if (TokenMatches(arg1, textEnd, "xceleration")) {
-        float xceleration = ParseFloat(arg2, textEnd);
-        if (Macros_DryRun) {
-            return;
-        }
-        module->xceleration = xceleration;
+    else if (ConsumeToken(ctx, "xceleration")) {
+        ASSIGN_FLOAT(module->xceleration);
     }
-    else if (TokenMatches(arg1, textEnd, "caretSpeedDivisor")) {
-        float caretSpeedDivisor = ParseFloat(arg2, textEnd);
-        if (Macros_DryRun) {
-            return;
-        }
-        module->caretSpeedDivisor = caretSpeedDivisor;
+    else if (ConsumeToken(ctx, "caretSpeedDivisor")) {
+        ASSIGN_FLOAT(module->caretSpeedDivisor);
     }
-    else if (TokenMatches(arg1, textEnd, "scrollSpeedDivisor")) {
-        float scrollSpeedDivisor = ParseFloat(arg2, textEnd);
-        if (Macros_DryRun) {
-            return;
-        }
-        module->scrollSpeedDivisor = scrollSpeedDivisor;
+    else if (ConsumeToken(ctx, "scrollSpeedDivisor")) {
+        ASSIGN_FLOAT(module->scrollSpeedDivisor);
     }
-    else if (TokenMatches(arg1, textEnd, "pinchZoomDivisor") && moduleId == ModuleId_TouchpadRight) {
-        float pinchZoomSpeedDivisor = ParseFloat(arg2, textEnd);
-        if (Macros_DryRun) {
-            return;
-        }
-        module->pinchZoomSpeedDivisor = pinchZoomSpeedDivisor;
+    else if (ConsumeToken(ctx, "pinchZoomDivisor") && moduleId == ModuleId_TouchpadRight) {
+        ASSIGN_FLOAT(module->pinchZoomSpeedDivisor);
     }
-    else if (TokenMatches(arg1, textEnd, "pinchZoomMode") && moduleId == ModuleId_TouchpadRight) {
-        navigation_mode_t touchpadPinchZoomMode = ParseNavigationModeId(arg2, textEnd);
-        if (Macros_DryRun) {
-            return;
-        }
-        touchpadPinchZoomMode = touchpadPinchZoomMode;
+    else if (ConsumeToken(ctx, "pinchZoomMode") && moduleId == ModuleId_TouchpadRight) {
+        ASSIGN_CUSTOM(int32_t, intVar, TouchpadPinchZoomMode, ConsumeNavigationModeId(ctx));
     }
-    else if (TokenMatches(arg1, textEnd, "axisLockSkew")) {
-        float axisLockSkew = ParseFloat(arg2, textEnd);
-        if (Macros_DryRun) {
-            return;
-        }
-        module->axisLockSkew = axisLockSkew;
+    else if (ConsumeToken(ctx, "axisLockSkew")) {
+        ASSIGN_FLOAT(module->axisLockSkew);
     }
-    else if (TokenMatches(arg1, textEnd, "axisLockFirstTickSkew")) {
-        float axisLockFirstTickSkew = ParseFloat(arg2, textEnd);
-        if (Macros_DryRun) {
-            return;
-        }
-        module->axisLockFirstTickSkew = axisLockFirstTickSkew;
+    else if (ConsumeToken(ctx, "axisLockFirstTickSkew")) {
+        ASSIGN_FLOAT(module->axisLockFirstTickSkew);
     }
-    else if (TokenMatches(arg1, textEnd, "cursorAxisLock")) {
-        bool cursorAxisLock = Macros_ParseBoolean(arg2, textEnd);
-        if (Macros_DryRun) {
-            return;
-        }
-        module->cursorAxisLock = cursorAxisLock;
+    else if (ConsumeToken(ctx, "cursorAxisLock")) {
+        ASSIGN_BOOL(module->cursorAxisLock);
     }
-    else if (TokenMatches(arg1, textEnd, "scrollAxisLock")) {
-        bool scrollAxisLock = Macros_ParseBoolean(arg2, textEnd);
-        if (Macros_DryRun) {
-            return;
-        }
-        module->scrollAxisLock = scrollAxisLock;
+    else if (ConsumeToken(ctx, "scrollAxisLock")) {
+        ASSIGN_BOOL(module->scrollAxisLock);
     }
-    else if (TokenMatches(arg1, textEnd, "caretAxisLock")) {
-        bool caretAxisLock = Macros_ParseBoolean(arg2, textEnd);
-        if (Macros_DryRun) {
-            return;
-        }
-        module->caretAxisLock = caretAxisLock;
+    else if (ConsumeToken(ctx, "caretAxisLock")) {
+        ASSIGN_BOOL(module->caretAxisLock);
     }
-    else if (TokenMatches(arg1, textEnd, "swapAxes")) {
-        bool swapAxes = Macros_ParseBoolean(arg2, textEnd);
-        if (Macros_DryRun) {
-            return;
-        }
-        module->swapAxes = swapAxes;
+    else if (ConsumeToken(ctx, "swapAxes")) {
+        ASSIGN_BOOL(module->swapAxes);
     }
-    else if (TokenMatches(arg1, textEnd, "invertScrollDirection")) {
-        bool invertScrollDirectionY = Macros_ParseBoolean(arg2, textEnd);
-        if (Macros_DryRun) {
-            Macros_ReportWarn("Command deprecated. Please, replace invertScrollDirection by invertScrollDirectionY.", arg1, arg1);
-            return;
-        }
-        module->invertScrollDirectionY = invertScrollDirectionY;
+    else if (ConsumeToken(ctx, "invertScrollDirection")) {
+        Macros_ReportWarn("Command deprecated. Please, replace invertScrollDirection by invertScrollDirectionY.", ConsumedToken(ctx), ConsumedToken(ctx));
+        ASSIGN_BOOL(module->invertScrollDirectionY);
     }
-    else if (TokenMatches(arg1, textEnd, "invertScrollDirectionY")) {
-        bool invertScrollDirectionY = Macros_ParseBoolean(arg2, textEnd);
-        if (Macros_DryRun) {
-            return;
-        }
-        module->invertScrollDirectionY = invertScrollDirectionY;
+    else if (ConsumeToken(ctx, "invertScrollDirectionY")) {
+        ASSIGN_BOOL(module->invertScrollDirectionY);
     }
-    else if (TokenMatches(arg1, textEnd, "invertScrollDirectionX")) {
-        bool invertScrollDirectionX = Macros_ParseBoolean(arg2, textEnd);
-        if (Macros_DryRun) {
-            return;
-        }
-        module->invertScrollDirectionX = invertScrollDirectionX;
+    else if (ConsumeToken(ctx, "invertScrollDirectionX")) {
+        ASSIGN_BOOL(module->invertScrollDirectionX);
     }
     else {
-        Macros_ReportError("Parameter not recognized:", arg1, textEnd);
+        Macros_ReportError("Parameter not recognized:", ctx->at, ctx->end);
     }
+    return noneVar();
 }
 
-static void module(const char* arg1, const char *textEnd)
+static macro_variable_t module(parser_context_t* ctx, set_command_action_t action)
 {
-    module_id_t moduleId = ParseModuleId(arg1, textEnd);
+    module_id_t moduleId = ConsumeModuleId(ctx);
     module_configuration_t* module = GetModuleConfiguration(moduleId);
 
-    const char* arg2 = proceedByDot(arg1, textEnd);
+    ConsumeUntilDot(ctx);
 
     if (Macros_ParserError) {
-        return;
+        return noneVar();
     }
 
-    if (TokenMatches(arg2, textEnd, "navigationMode")) {
-        const char* arg3 = proceedByDot(arg2, textEnd);
-        moduleNavigationMode(arg3, textEnd, module);
+    if (ConsumeToken(ctx, "navigationMode")) {
+        ConsumeUntilDot(ctx);
+        return moduleNavigationMode(ctx, action, module);
     }
     else {
-        moduleSpeed(arg2, textEnd, module, moduleId);
+        return moduleSpeed(ctx, action, module, moduleId);
     }
 }
 
-static void secondaryRoleAdvanced(const char* arg1, const char *textEnd)
+static macro_variable_t secondaryRoleAdvanced(parser_context_t* ctx, set_command_action_t action)
 {
-    const char* arg2 = NextTok(arg1, textEnd);
-
-    if (TokenMatches(arg1, textEnd, "timeout")) {
-        uint32_t timeout = Macros_ParseInt(arg2, textEnd, NULL);
-        if (Macros_DryRun) {
-            return;
-        }
-        timeout = timeout;
-    }
-    else if (TokenMatches(arg1, textEnd, "timeoutAction")) {
-        if (TokenMatches(arg2, textEnd, "primary")) {
-            if (Macros_DryRun) {
-                return;
-            }
-            SecondaryRoles_AdvancedStrategyTimeoutAction = SecondaryRoleState_Primary;
-        }
-        else if (TokenMatches(arg2, textEnd, "secondary")) {
-            if (Macros_DryRun) {
-                return;
-            }
-            SecondaryRoles_AdvancedStrategyTimeoutAction = SecondaryRoleState_Secondary;
-        }
-        else {
-            Macros_ReportError("Parameter not recognized:", arg2, textEnd);
-        }
+    if (ConsumeToken(ctx, "timeout")) {
+        ASSIGN_INT(SecondaryRoles_AdvancedStrategyTimeout);
     }
-    else if (TokenMatches(arg1, textEnd, "safetyMargin")) {
-        uint32_t safetyMargin = Macros_ParseInt(arg2, textEnd, NULL);
-        if (Macros_DryRun) {
-            return;
-        }
-        safetyMargin = safetyMargin;
+    else if (ConsumeToken(ctx, "timeoutAction")) {
+        ASSIGN_CUSTOM(int32_t, intVar, SecondaryRoles_AdvancedStrategyTimeoutAction, ConsumeSecondaryRoleTimeoutAction(ctx));
     }
-    else if (TokenMatches(arg1, textEnd, "triggerByRelease")) {
-        bool triggerByRelease = Macros_ParseBoolean(arg2, textEnd);
-        if (Macros_DryRun) {
-            return;
-        }
-        SecondaryRoles_AdvancedStrategyTriggerByRelease = triggerByRelease;
+    else if (ConsumeToken(ctx, "safetyMargin")) {
+        ASSIGN_INT(SecondaryRoles_AdvancedStrategySafetyMargin);
     }
-    else if (TokenMatches(arg1, textEnd, "doubletapToPrimary")) {
-        bool doubletapToPrimary = Macros_ParseBoolean(arg2, textEnd);
-        if (Macros_DryRun) {
-            return;
-        }
-        SecondaryRoles_AdvancedStrategyDoubletapToPrimary = doubletapToPrimary;
+    else if (ConsumeToken(ctx, "triggerByRelease")) {
+        ASSIGN_BOOL(SecondaryRoles_AdvancedStrategyTriggerByRelease);
     }
-    else if (TokenMatches(arg1, textEnd, "doubletapTime")) {
-        int32_t doubletapTime = Macros_ParseInt(arg2, textEnd, NULL);
-        if (Macros_DryRun) {
-            return;
-        }
-        SecondaryRoles_AdvancedStrategyDoubletapTime = doubletapTime;
+    else if (ConsumeToken(ctx, "doubletapToPrimary")) {
+        ASSIGN_BOOL(SecondaryRoles_AdvancedStrategyDoubletapToPrimary);
+    }
+    else if (ConsumeToken(ctx, "doubletapTime")) {
+        ASSIGN_INT(SecondaryRoles_AdvancedStrategyDoubletapTime);
     }
     else {
-        Macros_ReportError("Parameter not recognized:", arg1, textEnd);
+        Macros_ReportError("Parameter not recognized:", ctx->at, ctx->end);
     }
+    return noneVar();
 }
 
-static void secondaryRoles(const char* arg1, const char *textEnd)
+static macro_variable_t secondaryRoles(parser_context_t* ctx, set_command_action_t action)
 {
-    if (TokenMatches(arg1, textEnd, "defaultStrategy")) {
-        const char* arg2 = NextTok(arg1, textEnd);
-        if (TokenMatches(arg2, textEnd, "simple")) {
-            if (Macros_DryRun) {
-                return;
-            }
-            SecondaryRoles_Strategy = SecondaryRoleStrategy_Simple;
-        }
-        else if (TokenMatches(arg2, textEnd, "advanced")) {
-            if (Macros_DryRun) {
-                return;
-            }
-            SecondaryRoles_Strategy = SecondaryRoleStrategy_Advanced;
-        }
-        else {
-            Macros_ReportError("Parameter not recognized:", arg2, textEnd);
-        }
+    if (ConsumeToken(ctx, "defaultStrategy")) {
+        ASSIGN_CUSTOM(int32_t, intVar, SecondaryRoles_Strategy, ConsumeSecondaryRoleStrategy(ctx));
     }
-    else if (TokenMatches(arg1, textEnd, "advanced")) {
-        secondaryRoleAdvanced(proceedByDot(arg1, textEnd), textEnd);
+    else if (ConsumeToken(ctx, "advanced")) {
+        ConsumeUntilDot(ctx);
+        return secondaryRoleAdvanced(ctx, action);
     }
     else {
-        Macros_ReportError("Parameter not recognized:", arg1, textEnd);
+        Macros_ReportError("Parameter not recognized:", ctx->at, ctx->end);
     }
+    return noneVar();
 }
 
-static void mouseKeys(const char* arg1, const char *textEnd)
+static macro_variable_t mouseKeys(parser_context_t* ctx, set_command_action_t action)
 {
     mouse_kinetic_state_t* state = &MouseMoveState;
 
-    if (TokenMatches(arg1, textEnd, "move")) {
+    if (ConsumeToken(ctx, "move")) {
         state = &MouseMoveState;
-    } else if (TokenMatches(arg1, textEnd, "scroll")) {
+    } else if (ConsumeToken(ctx, "scroll")) {
         state = &MouseScrollState;
     } else {
-        Macros_ReportError("Scroll or move expected", arg1, arg1);
+        Macros_ReportError("Scroll or move expected!", ctx->at, ctx->at);
+        return noneVar();
     }
 
-    const char* arg2 = proceedByDot(arg1, textEnd);
-    const char* arg3 = NextTok(arg2, textEnd);
+    ConsumeUntilDot(ctx);
 
-    if (TokenMatches(arg2, textEnd, "initialSpeed")) {
-        int32_t initialSpeed = Macros_ParseInt(arg3, textEnd, NULL) / state->intMultiplier;
-        if (Macros_DryRun) {
-            return;
-        }
-        state->initialSpeed = initialSpeed;
+    if (ConsumeToken(ctx, "initialSpeed")) {
+        ASSIGN_INT_MUL(state->initialSpeed, 1.0f/state->intMultiplier);
     }
-    else if (TokenMatches(arg2, textEnd, "baseSpeed")) {
-        int32_t baseSpeed = Macros_ParseInt(arg3, textEnd, NULL) / state->intMultiplier;
-        if (Macros_DryRun) {
-            return;
-        }
-        state->baseSpeed = baseSpeed;
+    else if (ConsumeToken(ctx, "baseSpeed")) {
+        ASSIGN_INT_MUL(state->baseSpeed, 1.0f/state->intMultiplier);
     }
-    else if (TokenMatches(arg2, textEnd, "initialAcceleration")) {
-        int32_t acceleration = Macros_ParseInt(arg3, textEnd, NULL) / state->intMultiplier;
-        if (Macros_DryRun) {
-            return;
-        }
-        state->acceleration = acceleration;
+    else if (ConsumeToken(ctx, "initialAcceleration")) {
+        ASSIGN_INT_MUL(state->acceleration, 1.0f/state->intMultiplier);
     }
-    else if (TokenMatches(arg2, textEnd, "deceleratedSpeed")) {
-        int32_t deceleratedSpeed = Macros_ParseInt(arg3, textEnd, NULL) / state->intMultiplier;
-        if (Macros_DryRun) {
-            return;
-        }
-        state->deceleratedSpeed = deceleratedSpeed;
+    else if (ConsumeToken(ctx, "deceleratedSpeed")) {
+        ASSIGN_INT_MUL(state->deceleratedSpeed, 1.0f/state->intMultiplier);
     }
-    else if (TokenMatches(arg2, textEnd, "acceleratedSpeed")) {
-        int32_t acceleratedSpeed = Macros_ParseInt(arg3, textEnd, NULL) / state->intMultiplier;
-        if (Macros_DryRun) {
-            return;
-        }
-        state->acceleratedSpeed = acceleratedSpeed;
+    else if (ConsumeToken(ctx, "acceleratedSpeed")) {
+        ASSIGN_INT_MUL(state->acceleratedSpeed, 1.0f/state->intMultiplier);
     }
-    else if (TokenMatches(arg2, textEnd, "axisSkew")) {
-        float axisSkew = ParseFloat(arg3, textEnd);
-        if (Macros_DryRun) {
-            return;
-        }
-        state->axisSkew = axisSkew;
+    else if (ConsumeToken(ctx, "axisSkew")) {
+        ASSIGN_FLOAT(state->axisSkew);
     }
     else {
-        Macros_ReportError("Parameter not recognized:", arg1, textEnd);
+        Macros_ReportError("Parameter not recognized:", ctx->at, ctx->end);
     }
+    return noneVar();
 }
 
-static void stickyModifiers(const char* arg1, const char *textEnd)
+static macro_variable_t stickyModifiers(parser_context_t* ctx, set_command_action_t action)
 {
-    if (TokenMatches(arg1, textEnd, "never")) {
-        sticky_strategy_t stickyStrategy = Stick_Never;
-        if (Macros_DryRun) {
-            return;
-        }
-        StickyModifierStrategy = stickyStrategy;
+    if (ConsumeToken(ctx, "never")) {
+        ASSIGN_ENUM(StickyModifierStrategy, Stick_Never);
     }
-    else if (TokenMatches(arg1, textEnd, "smart")) {
-        sticky_strategy_t stickyStrategy = Stick_Smart;
-        if (Macros_DryRun) {
-            return;
-        }
-        StickyModifierStrategy = stickyStrategy;
+    else if (ConsumeToken(ctx, "smart")) {
+        ASSIGN_ENUM(StickyModifierStrategy, Stick_Smart);
     }
-    else if (TokenMatches(arg1, textEnd, "always")) {
-        sticky_strategy_t stickyStrategy = Stick_Always;
-        if (Macros_DryRun) {
-            return;
-        }
-        StickyModifierStrategy = stickyStrategy;
+    else if (ConsumeToken(ctx, "always")) {
+        ASSIGN_ENUM(StickyModifierStrategy, Stick_Always);
     }
     else {
-        Macros_ReportError("Parameter not recognized:", arg1, textEnd);
+        Macros_ReportError("Parameter not recognized:", ctx->at, ctx->end);
     }
+    return noneVar();
 }
 
-static void macroEngineScheduler(const char* arg1, const char *textEnd)
+static macro_variable_t macroEngineScheduler(parser_context_t* ctx, set_command_action_t action)
 {
-    if (TokenMatches(arg1, textEnd, "preemptive")) {
-        macro_scheduler_t scheduler = Scheduler_Preemptive;
-        if (Macros_DryRun) {
-            return;
-        }
-        Macros_Scheduler = scheduler;
+    if (ConsumeToken(ctx, "preemptive")) {
+        ASSIGN_ENUM(Macros_Scheduler, Scheduler_Preemptive);
     }
-    else if (TokenMatches(arg1, textEnd, "blocking")) {
-        macro_scheduler_t scheduler = Scheduler_Blocking;
-        if (Macros_DryRun) {
-            return;
-        }
-        Macros_Scheduler = scheduler;
+    else if (ConsumeToken(ctx, "blocking")) {
+        ASSIGN_ENUM(Macros_Scheduler, Scheduler_Blocking);
     }
     else {
-        Macros_ReportError("Parameter not recognized:", arg1, textEnd);
+        Macros_ReportError("Parameter not recognized:", ctx->at, ctx->end);
     }
+    return noneVar();
 }
 
-static void macroEngine(const char* arg1, const char *textEnd)
+static macro_variable_t macroEngine(parser_context_t* ctx, set_command_action_t action)
 {
-    if (TokenMatches(arg1, textEnd, "scheduler")) {
-        macroEngineScheduler(NextTok(arg1,  textEnd), textEnd);
+    if (ConsumeToken(ctx, "scheduler")) {
+        return macroEngineScheduler(ctx, action);
     }
-    else if (TokenMatches(arg1, textEnd, "batchSize")) {
-        int32_t batchSize = Macros_ParseInt(NextTok(arg1,  textEnd), textEnd, NULL);
-        if (Macros_DryRun) {
-            return;
-        }
-        Macros_MaxBatchSize = batchSize;
+    else if (ConsumeToken(ctx, "batchSize")) {
+        ASSIGN_INT(Macros_MaxBatchSize);
     }
-    else if (TokenMatches(arg1, textEnd, "extendedCommands")) {
+    else if (ConsumeToken(ctx, "extendedCommands")) {
         /* this option was removed -> accept the command & do nothing */
     }
     else {
-        Macros_ReportError("Parameter not recognized:", arg1, textEnd);
+        Macros_ReportError("Parameter not recognized:", ctx->at, ctx->end);
     }
+    return noneVar();
 }
 
-static void backlightStrategy(const char* arg1, const char *textEnd)
+static macro_variable_t backlightStrategy(parser_context_t* ctx, set_command_action_t action)
 {
-    if (TokenMatches(arg1, textEnd, "functional")) {
-        if (Macros_DryRun) {
-            return;
-        }
-        Ledmap_SetLedBacklightingMode(BacklightingMode_Functional);
-        Ledmap_UpdateBacklightLeds();
+    if (action == SetCommandAction_Read) {
+        return intVar(BacklightingMode);
     }
-    else if (TokenMatches(arg1, textEnd, "constantRgb")) {
-        if (Macros_DryRun) {
-            return;
-        }
-        Ledmap_SetLedBacklightingMode(BacklightingMode_ConstantRGB);
-        Ledmap_UpdateBacklightLeds();
+
+    backlighting_mode_t res = 0;
+
+    if (ConsumeToken(ctx, "functional")) {
+        res = BacklightingMode_Functional;
+    }
+    else if (ConsumeToken(ctx, "constantRgb")) {
+        res = BacklightingMode_ConstantRGB;
     }
-    else if (TokenMatches(arg1, textEnd, "perKeyRgb")) {
+    else if (ConsumeToken(ctx, "perKeyRgb")) {
         if (PerKeyRgbPresent) {
-            if (Macros_DryRun) {
-                return;
-            }
-            Ledmap_SetLedBacklightingMode(BacklightingMode_PerKeyRgb);
-            Ledmap_UpdateBacklightLeds();
+            res = BacklightingMode_PerKeyRgb;
         } else {
-            Macros_ReportError("Cannot set perKeyRgb mode when perKeyRgb maps are not available. Please, consult Agent's led section...", arg1, arg1);
+            Macros_ReportError("Cannot set perKeyRgb mode when perKeyRgb maps are not available. Please, consult Agent's led section...", ConsumedToken(ctx), ConsumedToken(ctx));
         }
     }
     else {
-        Macros_ReportError("Parameter not recognized:", arg1, textEnd);
+        Macros_ReportError("Parameter not recognized:", ctx->at, ctx->end);
+    }
+
+    if (Macros_ParserError) {
+        return noneVar();
+    }
+    if (Macros_DryRun) {
+        return noneVar();
     }
+
+    Ledmap_SetLedBacklightingMode(res);
+    Ledmap_UpdateBacklightLeds();
+    return noneVar();
 }
 
-static void keyRgb(const char* arg1, const char *textEnd)
+static macro_variable_t keyRgb(parser_context_t* ctx, set_command_action_t action)
 {
-    const char* arg2 = proceedByDot(arg1, textEnd);
+    layer_id_t layerId = Macros_ConsumeLayerId(ctx);
+
+    ConsumeUntilDot(ctx);
+
+    uint8_t keyId = Macros_LegacyConsumeInt(ctx);
+
+    if (action == SetCommandAction_Read) {
+        Macros_ReportError("Reading RGB values not supported!", ConsumedToken(ctx), ConsumedToken(ctx));
+        return noneVar();
+    }
 
-    layer_id_t layerId = Macros_ParseLayerId(arg1, textEnd);
-    uint8_t keyId = Macros_ParseInt(arg2, textEnd, NULL);
-    const char* r = NextTok(arg2,  textEnd);
-    const char* g = NextTok(r, textEnd);
-    const char* b = NextTok(g, textEnd);
     rgb_t rgb;
-    rgb.red = Macros_ParseInt(r, textEnd, NULL);
-    rgb.green = Macros_ParseInt(g, textEnd, NULL);
-    rgb.blue = Macros_ParseInt(b, textEnd, NULL);
+    rgb.red = Macros_LegacyConsumeInt(ctx);
+    rgb.green = Macros_LegacyConsumeInt(ctx);
+    rgb.blue = Macros_LegacyConsumeInt(ctx);
 
     if (Macros_ParserError) {
-        return;
+        return noneVar();
     }
     if (Macros_DryRun) {
-        return;
+        return noneVar();
     }
 
     uint8_t slotIdx = keyId/64;
@@ -478,186 +391,202 @@ static void keyRgb(const char* arg1, const char *textEnd)
     CurrentKeymap[layerId][slotIdx][inSlotIdx].color = rgb;
 
     Ledmap_UpdateBacklightLeds();
+    return noneVar();
 }
 
 
-static void constantRgb(const char* arg1, const char *textEnd)
+static macro_variable_t constantRgb(parser_context_t* ctx, set_command_action_t action)
 {
-    if (TokenMatches(arg1, textEnd, "rgb")) {
-        const char* r = NextTok(arg1,  textEnd);
-        const char* g = NextTok(r, textEnd);
-        const char* b = NextTok(g, textEnd);
+    if (ConsumeToken(ctx, "rgb")) {
+        if (action == SetCommandAction_Read) {
+            Macros_ReportError("Reading RGB values not supported!", ConsumedToken(ctx), ConsumedToken(ctx));
+            return noneVar();
+        }
+
         rgb_t rgb;
-        rgb.red = Macros_ParseInt(r, textEnd, NULL);
-        rgb.green = Macros_ParseInt(g, textEnd, NULL);
-        rgb.blue = Macros_ParseInt(b, textEnd, NULL);
+        rgb.red = Macros_LegacyConsumeInt(ctx);
+        rgb.green = Macros_LegacyConsumeInt(ctx);
+        rgb.blue = Macros_LegacyConsumeInt(ctx);
 
         if (Macros_DryRun) {
-            return;
+            return noneVar();
         }
 
         LedMap_ConstantRGB = rgb;
         Ledmap_SetLedBacklightingMode(BacklightingMode_ConstantRGB);
         Ledmap_UpdateBacklightLeds();
+
+        return noneVar();
     }
     else {
-        Macros_ReportError("Parameter not recognized:", arg1, textEnd);
+        Macros_ReportError("Parameter not recognized:", ctx->at, ctx->end);
+        return noneVar();
     }
 }
 
-static void leds(const char* arg1, const char *textEnd)
+static macro_variable_t leds(parser_context_t* ctx, set_command_action_t action)
 {
-    const char* value = NextTok(arg1, textEnd);
-    if (TokenMatches(arg1, textEnd, "fadeTimeout")) {
-        int32_t fadeTimeout = 1000*Macros_ParseInt(value, textEnd, NULL);
-        if (Macros_DryRun) {
-            return;
-        }
-        LedsFadeTimeout = fadeTimeout;
-    } else if (TokenMatches(arg1, textEnd, "brightness")) {
-        float brightnessMultiplier = ParseFloat(value, textEnd);
-        if (Macros_DryRun) {
-            return;
-        }
-        LedBrightnessMultiplier = brightnessMultiplier;
-    } else if (TokenMatches(arg1, textEnd, "enabled")) {
-        bool ledsEnabled = Macros_ParseBoolean(value, textEnd);
-        if (Macros_DryRun) {
-            return;
-        }
-        LedsEnabled = ledsEnabled;
+    if (ConsumeToken(ctx, "fadeTimeout")) {
+        ASSIGN_INT_MUL(LedsFadeTimeout, 1000);
+    } else if (ConsumeToken(ctx, "brightness")) {
+        ASSIGN_FLOAT(LedBrightnessMultiplier);
+    } else if (ConsumeToken(ctx, "enabled")) {
+        ASSIGN_BOOL(LedsEnabled);
     } else {
-        Macros_ReportError("Parameter not recognized:", arg1, textEnd);
+        Macros_ReportError("Parameter not recognized:", ctx->at, ctx->end);
     }
 
     LedSlaveDriver_UpdateLeds();
+    return noneVar();
 }
 
-static void backlight(const char* arg1, const char *textEnd)
+static macro_variable_t backlight(parser_context_t* ctx, set_command_action_t action)
 {
-    if (TokenMatches(arg1, textEnd, "strategy")) {
-        backlightStrategy(NextTok(arg1, textEnd), textEnd);
+    if (ConsumeToken(ctx, "strategy")) {
+        return backlightStrategy(ctx, action);
     }
-    else if (TokenMatches(arg1, textEnd, "constantRgb")) {
-        constantRgb(proceedByDot(arg1, textEnd), textEnd);
+    else if (ConsumeToken(ctx, "constantRgb")) {
+        ConsumeUntilDot(ctx);
+        return constantRgb(ctx, action);
     }
-    else if (TokenMatches(arg1, textEnd, "keyRgb")) {
-        keyRgb(proceedByDot(arg1, textEnd), textEnd);
+    else if (ConsumeToken(ctx, "keyRgb")) {
+        ConsumeUntilDot(ctx);
+        return keyRgb(ctx, action);
     }
     else {
-        Macros_ReportError("Parameter not recognized:", arg1, textEnd);
+        Macros_ReportError("Parameter not recognized:", ctx->at, ctx->end);
     }
+    return noneVar();
 }
 
-static key_action_t parseKeyAction(const char* arg1, const char *textEnd) {
-    const char* arg2 = NextTok(arg1, textEnd);
-
+static key_action_t parseKeyAction(parser_context_t* ctx)
+{
     key_action_t action = { .type = KeyActionType_None };
 
-    if (TokenMatches(arg1, textEnd, "macro")) {
-        uint8_t macroIndex = FindMacroIndexByName(arg2, TokEnd(arg2, textEnd), true);
+    if (ConsumeToken(ctx, "macro")) {
+        const char* end = TokEnd(ctx->at, ctx->end);
+        uint8_t macroIndex = FindMacroIndexByName(ctx->at, end, true);
 
         action.type = KeyActionType_PlayMacro;
         action.playMacro.macroId = macroIndex;
+
+        ctx->at = end;
+        ConsumeWhite(ctx);
     }
-    else if (TokenMatches(arg1, textEnd, "keystroke")) {
-        MacroShortcutParser_Parse(arg2, TokEnd(arg2, textEnd), MacroSubAction_Press, NULL, &action);
+    else if (ConsumeToken(ctx, "keystroke")) {
+        const char* end = TokEnd(ctx->at, ctx->end);
+        MacroShortcutParser_Parse(ctx->at, end, MacroSubAction_Press, NULL, &action);
+
+        ctx->at = end;
+        ConsumeWhite(ctx);
     }
-    else if (TokenMatches(arg1, textEnd, "none")) {
+    else if (ConsumeToken(ctx, "none")) {
         action.type = KeyActionType_None;
     }
     else {
-        Macros_ReportError("Parameter not recognized:", arg1, textEnd);
+        Macros_ReportError("Parameter not recognized:", ctx->at, ctx->end);
     }
 
     return action;
 }
 
 
-static void navigationModeAction(const char* arg1, const char *textEnd)
+static macro_variable_t navigationModeAction(parser_context_t* ctx, set_command_action_t action)
 {
     navigation_mode_t navigationMode = NavigationMode_Caret;
     bool positive = true;
     caret_axis_t axis = CaretAxis_Horizontal;
 
-    const char* arg2 = proceedByDot(arg1, textEnd);
-    const char* arg3 = NextTok(arg2, textEnd);
+    navigationMode = ConsumeNavigationModeId(ctx);
 
-    navigationMode = ParseNavigationModeId(arg1, textEnd);
+    ConsumeUntilDot(ctx);
+
+    if (action == SetCommandAction_Read) {
+        Macros_ReportError("Reading actions is not supported!", ctx->at, ctx->at);
+        return noneVar();
+    }
 
     if(navigationMode < NavigationMode_RemappableFirst || navigationMode > NavigationMode_RemappableLast) {
-        Macros_ReportError("Invalid or non-remapable navigation mode:", arg1, textEnd);
+        Macros_ReportError("Invalid or non-remapable navigation mode:", ConsumedToken(ctx), ConsumedToken(ctx));
     }
 
     if (Macros_ParserError) {
-        return;
+        return noneVar();
     }
 
-    if (TokenMatches(arg2, textEnd, "left")) {
+    if (ConsumeToken(ctx, "left")) {
         axis = CaretAxis_Horizontal;
         positive = false;
     }
-    else if (TokenMatches(arg2, textEnd, "up")) {
+    else if (ConsumeToken(ctx, "up")) {
         axis = CaretAxis_Vertical;
         positive = true;
     }
-    else if (TokenMatches(arg2, textEnd, "right")) {
+    else if (ConsumeToken(ctx, "right")) {
         axis = CaretAxis_Horizontal;
         positive = true;
     }
-    else if (TokenMatches(arg2, textEnd, "down")) {
+    else if (ConsumeToken(ctx, "down")) {
         axis = CaretAxis_Vertical;
         positive = false;
     }
     else {
-        Macros_ReportError("Parameter not recognized:", arg1, textEnd);
+        Macros_ReportError("Parameter not recognized:", ctx->at, ctx->end);
+        return noneVar();
     }
 
-    key_action_t action = parseKeyAction(arg3, textEnd);
+    key_action_t keyAction = parseKeyAction(ctx);
 
     if (Macros_ParserError) {
-        return;
+        return noneVar();
     }
     if (Macros_DryRun) {
-        return;
+        return noneVar();
     }
 
-    SetModuleCaretConfiguration(navigationMode, axis, positive, action);
+    SetModuleCaretConfiguration(navigationMode, axis, positive, keyAction);
+    return noneVar();
 }
 
-static void keymapAction(const char* arg1, const char *textEnd)
+static macro_variable_t keymapAction(parser_context_t* ctx, set_command_action_t action)
 {
-    const char* arg2 = proceedByDot(arg1, textEnd);
-    const char* arg3 = NextTok(arg2, textEnd);
+    uint8_t layerId = Macros_ConsumeLayerId(ctx);
+    parser_context_t keyIdPos = *ctx;
 
-    uint8_t layerId = Macros_ParseLayerId(arg1, textEnd);
-    uint16_t keyId = Macros_ParseInt(arg2, textEnd, NULL);
+    ConsumeUntilDot(ctx);
 
-    key_action_t action = parseKeyAction(arg3, textEnd);
+    uint16_t keyId = Macros_LegacyConsumeInt(ctx);
+
+    if (action == SetCommandAction_Read) {
+        Macros_ReportError("Reading actions is not supported!", ctx->at, ctx->at);
+        return noneVar();
+    }
+
+    key_action_t keyAction = parseKeyAction(ctx);
 
     uint8_t slotIdx = keyId/64;
     uint8_t inSlotIdx = keyId%64;
 
     if(slotIdx > SLOT_COUNT || inSlotIdx > MAX_KEY_COUNT_PER_MODULE) {
-        Macros_ReportError("Invalid key id:", arg2, textEnd);
+        Macros_ReportErrorNum("Invalid key id:", keyId, keyIdPos.at);
     }
 
     if (Macros_ParserError) {
-        return;
+        return noneVar();
     }
     if (Macros_DryRun) {
-        return;
+        return noneVar();
     }
 
     key_action_t* actionSlot = &CurrentKeymap[layerId][slotIdx][inSlotIdx];
 
-    *actionSlot = action;
+    *actionSlot = keyAction;
+    return noneVar();
 }
 
-static void modLayerTriggers(const char* arg1, const char *textEnd)
+static macro_variable_t modLayerTriggers(parser_context_t* ctx, set_command_action_t action)
 {
-    const char* specifier = NextTok(arg1, textEnd);
-    uint8_t layerId = Macros_ParseLayerId(arg1, textEnd);
+    uint8_t layerId = Macros_ConsumeLayerId(ctx);
     uint8_t left = 0;
     uint8_t right = 0;
 
@@ -679,143 +608,137 @@ static void modLayerTriggers(const char* arg1, const char *textEnd)
         right = HID_KEYBOARD_MODIFIER_RIGHTGUI ;
         break;
     default:
-        Macros_ReportError("This layer does not allow modifier triggers:", arg1, specifier);
-        return;
+        Macros_ReportError("This layer does not allow modifier triggers:", ConsumedToken(ctx), ConsumedToken(ctx));
+        return noneVar();
     }
 
-    if (Macros_ParserError) {
-        return;
-    }
-    if (Macros_DryRun) {
-        return;
+    if (action == SetCommandAction_Read) {
+        return intVar(LayerConfig[layerId].modifierLayerMask);
     }
 
-    if (TokenMatches(specifier, textEnd, "left")) {
-        LayerConfig[layerId].modifierLayerMask = left;
+    uint8_t mask = 0;
+
+    if (ConsumeToken(ctx, "left")) {
+        mask = left;
     }
-    else if (TokenMatches(specifier, textEnd, "right")) {
-        LayerConfig[layerId].modifierLayerMask = right;
+    else if (ConsumeToken(ctx, "right")) {
+        mask = right;
     }
-    else if (TokenMatches(specifier, textEnd, "both")) {
-        LayerConfig[layerId].modifierLayerMask = left | right;
+    else if (ConsumeToken(ctx, "both")) {
+        mask = left | right;
     }
     else {
-        Macros_ReportError("Specifier not recognized:", specifier, textEnd);
+        Macros_ReportError("Specifier not recognized:", ctx->at, ctx->end);
     }
+
+    if (Macros_ParserError) {
+        return noneVar();
+    }
+    if (Macros_DryRun) {
+        return noneVar();
+    }
+
+    LayerConfig[layerId].modifierLayerMask = mask;
+    return noneVar();
 }
 
 
-macro_result_t Macro_ProcessSetCommand(const char* arg1, const char *textEnd)
+static macro_variable_t root(parser_context_t* ctx, set_command_action_t action)
 {
-    const char* arg2 = NextTok(arg1, textEnd);
-
-    if (TokenMatches(arg1, textEnd, "module")) {
-        module(proceedByDot(arg1, textEnd), textEnd);
+    if (ConsumeToken(ctx, "module")) {
+        ConsumeUntilDot(ctx);
+        return module(ctx, action);
     }
-    else if (TokenMatches(arg1, textEnd, "secondaryRole")) {
-        secondaryRoles(proceedByDot(arg1, textEnd), textEnd);
+    else if (ConsumeToken(ctx, "secondaryRole")) {
+        ConsumeUntilDot(ctx);
+        return secondaryRoles(ctx, action);
     }
-    else if (TokenMatches(arg1, textEnd, "mouseKeys")) {
-        mouseKeys(proceedByDot(arg1, textEnd), textEnd);
+    else if (ConsumeToken(ctx, "mouseKeys")) {
+        ConsumeUntilDot(ctx);
+        return mouseKeys(ctx, action);
     }
-    else if (TokenMatches(arg1, textEnd, "keymapAction")) {
-        keymapAction(proceedByDot(arg1, textEnd), textEnd);
+    else if (ConsumeToken(ctx, "keymapAction")) {
+        ConsumeUntilDot(ctx);
+        return keymapAction(ctx, action);
     }
-    else if (TokenMatches(arg1, textEnd, "navigationModeAction")) {
-        navigationModeAction(proceedByDot(arg1, textEnd), textEnd);
+    else if (ConsumeToken(ctx, "navigationModeAction")) {
+        ConsumeUntilDot(ctx);
+        return navigationModeAction(ctx, action);
     }
-    else if (TokenMatches(arg1, textEnd, "macroEngine")) {
-        macroEngine(proceedByDot(arg1, textEnd), textEnd);
+    else if (ConsumeToken(ctx, "macroEngine")) {
+        ConsumeUntilDot(ctx);
+        return macroEngine(ctx, action);
     }
-    else if (TokenMatches(arg1, textEnd, "backlight")) {
-        backlight(proceedByDot(arg1, textEnd), textEnd);
+    else if (ConsumeToken(ctx, "backlight")) {
+        ConsumeUntilDot(ctx);
+        return backlight(ctx, action);
     }
-    else if (TokenMatches(arg1, textEnd, "leds")) {
-        leds(proceedByDot(arg1, textEnd), textEnd);
+    else if (ConsumeToken(ctx, "leds")) {
+        ConsumeUntilDot(ctx);
+        return leds(ctx, action);
     }
-    else if (TokenMatches(arg1, textEnd, "modifierLayerTriggers")) {
-        modLayerTriggers(proceedByDot(arg1, textEnd), textEnd);
+    else if (ConsumeToken(ctx, "modifierLayerTriggers")) {
+        ConsumeUntilDot(ctx);
+        return modLayerTriggers(ctx, action);
     }
-    else if (TokenMatches(arg1, textEnd, "diagonalSpeedCompensation")) {
-        bool diagonalSpeedCompensation = Macros_ParseBoolean(arg2, textEnd);
-        if (Macros_DryRun) {
-            return MacroResult_Finished;
-        }
-        DiagonalSpeedCompensation = diagonalSpeedCompensation;
+    else if (ConsumeToken(ctx, "diagonalSpeedCompensation")) {
+        ASSIGN_BOOL(DiagonalSpeedCompensation);
     }
-    else if (TokenMatches(arg1, textEnd, "stickyModifiers")) {
-        stickyModifiers(arg2, textEnd);
+    else if (ConsumeToken(ctx, "stickyModifiers")) {
+        return stickyModifiers(ctx, action);
     }
-    else if (TokenMatches(arg1, textEnd, "debounceDelay")) {
-        uint16_t time = Macros_ParseInt(arg2, textEnd, NULL);
-        if (Macros_DryRun) {
-            return MacroResult_Finished;
-        }
-        DebounceTimePress = time;
-        DebounceTimeRelease = time;
+    else if (ConsumeToken(ctx, "debounceDelay")) {
+        ASSIGN_INT2(DebounceTimePress, DebounceTimeRelease);
     }
-    else if (TokenMatches(arg1, textEnd, "keystrokeDelay")) {
-        uint32_t keystrokeDelay = Macros_ParseInt(arg2, textEnd, NULL);
-        if (Macros_DryRun) {
-            return MacroResult_Finished;
-        }
-        KeystrokeDelay = keystrokeDelay;
+    else if (ConsumeToken(ctx, "keystrokeDelay")) {
+        ASSIGN_INT(KeystrokeDelay);
     }
     else if (
-            TokenMatches(arg1, textEnd, "doubletapTimeout")  // new name
-            || (TokenMatches(arg1, textEnd, "doubletapDelay")) // deprecated alias - old name
+            ConsumeToken(ctx, "doubletapTimeout")  // new name
+            || (ConsumeToken(ctx, "doubletapDelay")) // deprecated alias - old name
             ) {
-        uint16_t delay = Macros_ParseInt(arg2, textEnd, NULL);
-        if (Macros_DryRun) {
-            return MacroResult_Finished;
-        }
-        DoubleTapSwitchLayerTimeout = delay;
-        DoubletapConditionTimeout = delay;
+        ASSIGN_INT2(DoubleTapSwitchLayerTimeout, DoubletapConditionTimeout);
     }
-    else if (TokenMatches(arg1, textEnd, "autoRepeatDelay")) {
-        uint16_t delay = Macros_ParseInt(arg2, textEnd, NULL);
-        if (Macros_DryRun) {
-            return MacroResult_Finished;
-        }
-        AutoRepeatInitialDelay = delay;
+    else if (ConsumeToken(ctx, "autoRepeatDelay")) {
+        ASSIGN_INT(AutoRepeatInitialDelay);
     }
-    else if (TokenMatches(arg1, textEnd, "autoRepeatRate")) {
-        uint16_t delay = Macros_ParseInt(arg2, textEnd, NULL);
-        if (Macros_DryRun) {
-            return MacroResult_Finished;
-        }
-        AutoRepeatDelayRate = delay;
+    else if (ConsumeToken(ctx, "autoRepeatRate")) {
+        ASSIGN_INT(AutoRepeatDelayRate);
     }
-    else if (TokenMatches(arg1, textEnd, "chordingDelay")) {
-        uint32_t chordingDelay = Macros_ParseInt(arg2, textEnd, NULL);
-        if (Macros_DryRun) {
-            return MacroResult_Finished;
-        }
-        ChordingDelay = chordingDelay;
+    else if (ConsumeToken(ctx, "chordingDelay")) {
+        ASSIGN_INT(ChordingDelay);
     }
-    else if (TokenMatches(arg1, textEnd, "autoShiftDelay")) {
-        uint32_t chordingDelay = Macros_ParseInt(arg2, textEnd, NULL);
-        if (Macros_DryRun) {
-            return MacroResult_Finished;
-        }
-        AutoShiftDelay = chordingDelay;
+    else if (ConsumeToken(ctx, "autoShiftDelay")) {
+        ASSIGN_INT(AutoShiftDelay);
     }
-    else if (TokenMatches(arg1, textEnd, "i2cBaudRate")) {
-        uint32_t baudRate = Macros_ParseInt(arg2, textEnd, NULL);
+    else if (ConsumeToken(ctx, "i2cBaudRate")) {
+        if (action == SetCommandAction_Read) {
+            return intVar(I2cMainBusRequestedBaudRateBps);
+        }
+
+        uint32_t baudRate = Macros_LegacyConsumeInt(ctx);
         if (Macros_DryRun) {
-            return MacroResult_Finished;
+            return noneVar();
         }
         ChangeI2cBaudRate(baudRate);
     }
-    else if (TokenMatches(arg1, textEnd, "emergencyKey")) {
-        uint16_t key = Macros_ParseInt(arg2, textEnd, NULL);
-        if (Macros_DryRun) {
-            return MacroResult_Finished;
-        }
-        EmergencyKey = Utils_KeyIdToKeyState(key);
+    else if (ConsumeToken(ctx, "emergencyKey")) {
+        ASSIGN_CUSTOM5(key_state_t*, noneVar,, EmergencyKey, Utils_KeyIdToKeyState(Macros_LegacyConsumeInt(ctx)));
     }
-    else {
-        Macros_ReportError("Parameter not recognized:", arg1, textEnd);
+    else if (action == SetCommandAction_Write) {
+        Macros_ReportError("Parameter not recognized:", ctx->at, ctx->end);
     }
+    return noneVar();
+}
+
+macro_result_t Macro_ProcessSetCommand(parser_context_t* ctx)
+{
+    root(ctx, SetCommandAction_Write);
     return MacroResult_Finished;
 }
+
+macro_variable_t Macro_TryReadConfigVal(parser_context_t* ctx)
+{
+    macro_variable_t res = root(ctx, SetCommandAction_Read);
+    return res;
+}
diff --git a/right/src/macro_set_command.h b/right/src/macro_set_command.h
index dfe86a047..9f9650042 100644
--- a/right/src/macro_set_command.h
+++ b/right/src/macro_set_command.h
@@ -8,6 +8,8 @@
     #include "key_action.h"
     #include "usb_device_config.h"
     #include "key_states.h"
+    #include "macros_core.h"
+    #include "macros_vars.h"
     #include "macros.h"
 
 // Macros:
@@ -17,6 +19,7 @@
 // Variables:
 
 // Functions:
-    macro_result_t Macro_ProcessSetCommand(const char* text, const char *textEnd);
+    macro_variable_t Macro_TryReadConfigVal(parser_context_t* ctx);
+    macro_result_t Macro_ProcessSetCommand(parser_context_t* ctx);
 
 #endif /* __MACRO_SET_COMMAND_H__ */
diff --git a/right/src/macro_shortcut_parser.c b/right/src/macro_shortcut_parser.c
index c422e07bd..adc3045c7 100644
--- a/right/src/macro_shortcut_parser.c
+++ b/right/src/macro_shortcut_parser.c
@@ -7,6 +7,19 @@
 #include "macro_shortcut_parser.h"
 #include "str_utils.h"
 
+typedef enum {
+    scType_basic,
+    scType_system,
+    scType_media,
+    scType_mouseBtn
+} shortcut_type_t;
+
+typedef struct {
+    const char* id;
+    uint8_t scancode;
+    shortcut_type_t type;
+} lookup_record_t;
+
 static const lookup_record_t* lookup(uint8_t begin, uint8_t end, const char* str, const char* strEnd);
 
 char MacroShortcutParser_ScancodeToCharacter(uint16_t scancode)
@@ -119,7 +132,7 @@ bool MacroShortcutParser_CharacterToShift(char character)
     return false;
 }
 
-const lookup_record_t lookup_table[] = {
+static const lookup_record_t lookup_table[] = {
         // ALWAYS keep the array sorted by `LC_ALL=C sort`
         {"", 0, scType_basic},
         {"again", HID_KEYBOARD_SC_AGAIN, scType_basic},
@@ -343,9 +356,9 @@ const lookup_record_t lookup_table[] = {
         {"volumeUp", HID_KEYBOARD_SC_VOLUME_UP, scType_basic},
 };
 
-size_t lookup_size = sizeof(lookup_table)/sizeof(lookup_table[0]);
+static size_t lookup_size = sizeof(lookup_table)/sizeof(lookup_table[0]);
 
-void testLookup()
+static void testLookup()
 {
     for (uint8_t i = 0; i < lookup_size - 1; i++) {
         if (!StrLessOrEqual(lookup_table[i].id, NULL, lookup_table[i+1].id, NULL)) {
diff --git a/right/src/macro_shortcut_parser.h b/right/src/macro_shortcut_parser.h
index 8d71c7af1..96af18d7c 100644
--- a/right/src/macro_shortcut_parser.h
+++ b/right/src/macro_shortcut_parser.h
@@ -10,19 +10,6 @@
 
 // Typedefs:
 
-    typedef enum {
-        scType_basic,
-        scType_system,
-        scType_media,
-        scType_mouseBtn
-    } shortcut_type_t;
-
-    typedef struct {
-        const char* id;
-        uint8_t scancode;
-        shortcut_type_t type;
-    } lookup_record_t;
-
     // Functions:
 
     void ShortcutParser_initialize();
diff --git a/right/src/macros.c b/right/src/macros.c
index 0dfbfb859..7c0d09a2c 100644
--- a/right/src/macros.c
+++ b/right/src/macros.c
@@ -1,4 +1,7 @@
 #include "macros.h"
+#include "macro_keyid_parser.h"
+#include "macros_core.h"
+#include "macros_vars.h"
 #include "eeprom.h"
 #include "fsl_rtos_abstraction.h"
 #include "layer_stack.h"
@@ -6,6 +9,7 @@
 #include "event_scheduler.h"
 #include <math.h>
 #include "layer.h"
+#include "macros_vars.h"
 #include "secondary_role_driver.h"
 #include "segment_display.h"
 #include "usb_interfaces/usb_interface_basic_keyboard.h"
@@ -93,8 +97,7 @@ static void checkSchedulerHealth(const char* tag);
 static void wakeMacroInSlot(uint8_t slotIdx);
 static void scheduleSlot(uint8_t slotIdx);
 static void unscheduleCurrentSlot();
-static int32_t parseNUM(const char *a, const char *aEnd);
-static macro_result_t processCommand(const char* cmd, const char* cmdEnd);
+static macro_result_t processCommand(parser_context_t* ctx);
 static macro_result_t processCommandAction(void);
 static macro_result_t continueMacro(void);
 static macro_result_t execMacro(uint8_t macroIndex);
@@ -477,33 +480,47 @@ char Macros_ConsumeStatusChar()
 }
 
 //textEnd is allowed to be null if text is null-terminated
-static void setStatusStringInterpolated(const char* text, const char *textEnd, bool interpolated)
+static void setStatusStringInterpolated(parser_context_t* ctx)
 {
     if (statusBufferPrinting) {
         return;
     }
-    while(*text && statusBufferLen < STATUS_BUFFER_MAX_LENGTH && (text < textEnd || textEnd == NULL)) {
-        if (*text == '#' && interpolated) {
-            int32_t parsed = Macros_ParseInt(text, textEnd, &text);
-            //text should be now set to next character after a number, even if it was e.g., "'#3'"
-            Macros_SetStatusNumSpaced(parsed, false);
-        } else {
-            statusBuffer[statusBufferLen] = *text;
-            text++;
-            statusBufferLen++;
-            Macros_ConsumeStatusCharDirtyFlag = true;
-        }
+    uint16_t stringOffset = 0, textIndex = 0, textSubIndex = 0;
+
+    char c;
+    while (
+            (c = Macros_ConsumeCharOfString(ctx, &stringOffset, &textIndex, &textSubIndex)) != '\0'
+            && statusBufferLen < STATUS_BUFFER_MAX_LENGTH
+          ) {
+        statusBuffer[statusBufferLen] = c;
+        statusBufferLen++;
+        Macros_ConsumeStatusCharDirtyFlag = true;
     }
 }
 
-void Macros_SetStatusString(const char* text, const char *textEnd)
+static void setStatusChar(char n)
 {
-    setStatusStringInterpolated(text, textEnd, false);
+    if (statusBufferPrinting) {
+        return;
+    }
+
+    if (n && statusBufferLen < STATUS_BUFFER_MAX_LENGTH) {
+        statusBuffer[statusBufferLen] = n;
+        statusBufferLen++;
+        Macros_ConsumeStatusCharDirtyFlag = true;
+    }
 }
 
-void Macros_SetStatusStringInterpolated(const char* text, const char *textEnd)
+void Macros_SetStatusString(const char* text, const char *textEnd)
 {
-    setStatusStringInterpolated(text, textEnd, true);
+    if (statusBufferPrinting) {
+        return;
+    }
+
+    while(*text && statusBufferLen < STATUS_BUFFER_MAX_LENGTH && (text < textEnd || textEnd == NULL)) {
+        setStatusChar(*text);
+        text++;
+    }
 }
 
 void Macros_SetStatusBool(bool b)
@@ -550,7 +567,7 @@ void Macros_SetStatusNum(int32_t n)
 
 void Macros_SetStatusChar(char n)
 {
-    Macros_SetStatusString(&n, &n+1);
+    setStatusChar(n);
 }
 
 static uint16_t findCurrentCommandLine()
@@ -636,6 +653,7 @@ static void reportError(
 
 void Macros_ReportError(const char* err, const char* arg, const char *argEnd)
 {
+    //if this line of code already caused an error, don't throw another one
     Macros_ParserError = true;
     SegmentDisplay_SetText(3, "ERR", SegmentDisplaySlot_Error);
     reportErrorHeader("Error");
@@ -689,7 +707,7 @@ static void clearScancodes()
     s->ms.macroBasicKeyboardReport.modifiers = oldMods;
 }
 
-static macro_result_t dispatchText(const char* text, uint16_t textLen)
+static macro_result_t dispatchText(const char* text, uint16_t textLen, bool rawString)
 {
     s->ms.reportsUsed = true;
     static macro_state_t* dispatchMutex = NULL;
@@ -702,9 +720,30 @@ static macro_result_t dispatchText(const char* text, uint16_t textLen)
     uint8_t scancode = 0;
     uint8_t mods = 0;
 
+    uint16_t stringOffsetCopy = s->as.dispatchData.stringOffset;
+    uint16_t textIndexCopy = s->as.dispatchData.textIdx;
+    uint16_t textSubIndexCopy = s->as.dispatchData.subIndex;
+
     // Precompute modifiers and scancode.
     if (s->as.dispatchData.textIdx != textLen) {
-        character = text[s->as.dispatchData.textIdx];
+        if (rawString) {
+            character = text[s->as.dispatchData.textIdx];
+        } else {
+            parser_context_t ctx = { .macroState = s, .begin = text, .at = text, .end = text+textLen };
+            character = Macros_ConsumeCharOfString(&ctx, &stringOffsetCopy, &textIndexCopy, &textSubIndexCopy);
+
+            //make sure we write error only once
+            if (Macros_ParserError) {
+                s->as.dispatchData.textIdx = textIndexCopy;
+                s->as.dispatchData.subIndex = textSubIndexCopy;
+                s->as.dispatchData.stringOffset = stringOffsetCopy;
+                return MacroResult_InProgressFlag;
+            }
+
+            if (character == '\0') {
+                s->as.dispatchData.textIdx = textLen;
+            }
+        }
         scancode = MacroShortcutParser_CharacterToScancode(character);
         mods = MacroShortcutParser_CharacterToShift(character) ? HID_KEYBOARD_MODIFIER_LEFTSHIFT : 0;
     }
@@ -731,6 +770,7 @@ static macro_result_t dispatchText(const char* text, uint16_t textLen)
             return MacroResult_Blocking;
         } else {
             s->as.dispatchData.textIdx = 0;
+            s->as.dispatchData.subIndex = 0;
             dispatchMutex = NULL;
             return MacroResult_Finished;
         }
@@ -755,13 +795,23 @@ static macro_result_t dispatchText(const char* text, uint16_t textLen)
     UsbBasicKeyboard_AddScancode(&s->ms.macroBasicKeyboardReport, scancode);
     s->as.dispatchData.reportState = UsbBasicKeyboard_IsFullScancodes(&s->ms.macroBasicKeyboardReport) ?
             REPORT_FULL : REPORT_PARTIAL;
-    ++s->as.dispatchData.textIdx;
+    if (rawString) {
+        ++s->as.dispatchData.textIdx;
+    } else {
+        if (textIndexCopy == s->as.dispatchData.textIdx && textSubIndexCopy == s->as.dispatchData.subIndex && stringOffsetCopy == s->as.dispatchData.stringOffset) {
+            Macros_ReportError("Text dispatch got stuck! Please report this.", text + textIndexCopy, text+textLen);
+            return MacroResult_Finished;
+        }
+        s->as.dispatchData.textIdx = textIndexCopy;
+        s->as.dispatchData.subIndex = textSubIndexCopy;
+        s->as.dispatchData.stringOffset = stringOffsetCopy;
+    }
     return MacroResult_Blocking;
 }
 
 static macro_result_t processTextAction(void)
 {
-    return dispatchText(s->ms.currentMacroAction.text.text, s->ms.currentMacroAction.text.textLen);
+    return dispatchText(s->ms.currentMacroAction.text.text, s->ms.currentMacroAction.text.textLen, true);
 }
 
 static bool validReg(uint8_t idx, const char* pos)
@@ -777,14 +827,17 @@ static macro_result_t writeNum(uint32_t a)
 {
     char num[11];
     num[10] = '\0';
-    int at = 9;
-    while ((a > 0 || at == 9) && at >= 0) {
+    int at = 10;
+    while ((a > 0 || at == 10) && at > 0) {
+        at--;
         num[at] = a % 10 + 48;
         a = a/10;
-        at--;
     }
+    num[at-1] = '0';
+
+    uint8_t len = MAX(2, 10-at);
 
-    macro_result_t res = dispatchText(&num[at+1], 9 - at);
+    macro_result_t res = dispatchText(&num[10-len], len, true);
     if (res == MacroResult_Finished) {
         PostponerExtended_ConsumePendingKeypresses(1, true);
         return MacroResult_Finished;
@@ -792,14 +845,16 @@ static macro_result_t writeNum(uint32_t a)
     return res;
 }
 
-static bool isNUM(const char *a, const char *aEnd)
+static bool isNUM(parser_context_t* ctx)
 {
-    switch(*a) {
+    switch(*ctx->at) {
     case '0'...'9':
     case '#':
     case '-':
     case '@':
     case '%':
+    case '$':
+    case '(':
         return true;
     default:
         return false;
@@ -809,8 +864,12 @@ static bool isNUM(const char *a, const char *aEnd)
 int32_t Macros_ParseInt(const char *a, const char *aEnd, const char* *parsedTill)
 {
     if (*a == '#') {
+        if (Macros_DryRun) {
+            Macros_ReportWarn("Registers are now deprecated. Please, replace them with named variables. E.g., `setVar foo 1` and `$foo`.", a, a);
+        }
         a++;
         if (TokenMatches(a, aEnd, "key")) {
+            Macros_ReportWarn("Registers are now deprecated. Please, replace #key with $thisKeyId.", a, a);
             if (parsedTill != NULL) {
                 *parsedTill = a+3;
             }
@@ -824,6 +883,7 @@ int32_t Macros_ParseInt(const char *a, const char *aEnd, const char* *parsedTill
         }
     }
     else if (*a == '%') {
+        Macros_ReportWarn("`%` notation is now deprecated. Please, replace it with $queuedKeyId.<index> notation. E.g., `$queuedKeyId.1`.", a, a);
         a++;
         uint8_t idx = Macros_ParseInt(a, aEnd, parsedTill);
         if (idx >= PostponerQuery_PendingKeypressCount()) {
@@ -835,46 +895,53 @@ int32_t Macros_ParseInt(const char *a, const char *aEnd, const char* *parsedTill
         return PostponerExtended_PendingId(idx);
     }
     else if (*a == '@') {
+        Macros_ReportWarn("`@` notation is now deprecated. Please, replace it with $currentAddress. E.g., `@3` with `$($currentAddress + 3)`.", a, a);
         a++;
         return s->ms.commandAddress + Macros_ParseInt(a, aEnd, parsedTill);
     }
     else
     {
-        return ParseInt32_2(a, aEnd, parsedTill);
+        parser_context_t ctx = { .macroState = s, .begin = a, .at = a, .end = aEnd };
+        int32_t res = Macros_ConsumeInt(&ctx);
+        if (parsedTill != NULL) {
+            *parsedTill = ctx.at;
+        }
+        return res;
     }
 }
 
-bool Macros_ParseBoolean(const char *a, const char *aEnd)
+int32_t Macros_LegacyConsumeInt(parser_context_t* ctx)
 {
-    if (TokenMatches(a, aEnd, "1")) {
-        return true;
-    }
-    else if (TokenMatches(a, aEnd, "0")) {
-        return false;
-    } else {
-        Macros_ReportError("Boolean value expected, got:",  a, aEnd);
-        return false;
-    }
+    const char* parsedTill;
+    int32_t res = Macros_ParseInt(ctx->at, ctx->end, &parsedTill);
+    ctx->at = parsedTill;
+    ConsumeWhite(ctx);
+    return res;
 }
 
-static int32_t parseNUM(const char *a, const char *aEnd)
+bool Macros_ParseBoolean(const char *a, const char *aEnd)
 {
-    return Macros_ParseInt(a, aEnd, NULL);
+    parser_context_t ctx = { .macroState = s, .begin = a, .at = a, .end = aEnd };
+    return Macros_ConsumeBool(&ctx);
 }
 
-static int32_t parseRuntimeMacroSlotId(const char *a, const char *aEnd)
+
+static int32_t consumeRuntimeMacroSlotId(parser_context_t* ctx)
 {
-    const char* end = TokEnd(a, aEnd);
+    const char* end = TokEnd(ctx->at, ctx->end);
     static uint16_t lastMacroId = 0;
-    if (TokenMatches(a, aEnd, "last")) {
+    if (ConsumeToken(ctx, "last")) {
         return lastMacroId;
     }
-    else if (a == aEnd) {
+    else if (ctx->at == ctx->end) {
         lastMacroId = Utils_KeyStateToKeyId(s->ms.currentMacroKey);
-    } else if (end == a+1) {
-        lastMacroId = (uint8_t)(*a);
-    } else {
-        lastMacroId = 128 + parseNUM(a, aEnd);
+    }
+    else if (end == ctx->at+1) {
+        lastMacroId = (uint8_t)(*ctx->at);
+        ctx->at++;
+    }
+    else {
+        lastMacroId = 128 + Macros_LegacyConsumeInt(ctx);
     }
     return lastMacroId;
 }
@@ -1047,96 +1114,109 @@ static macro_result_t processDiagnoseCommand()
 }
 
 
-static uint8_t parseKeymapId(const char* arg1, const char* cmdEnd)
+static uint8_t consumeKeymapId(parser_context_t* ctx)
 {
-    if (TokenMatches(arg1, cmdEnd, "last")) {
+    if (ConsumeToken(ctx, "last")) {
         return lastKeymapIdx;
     } else {
-        uint8_t idx = FindKeymapByAbbreviation(TokLen(arg1, cmdEnd), arg1);
+        uint8_t len = TokLen(ctx->at, ctx->end);
+        uint8_t idx = FindKeymapByAbbreviation(len, ctx->at);
         if (idx == 0xFF) {
-            Macros_ReportError("Keymap not recognized:", arg1, cmdEnd);
+            Macros_ReportError("Keymap not recognized:", ctx->at, ctx->at);
         }
+        ctx->at += len;
+        ConsumeWhite(ctx);
         return idx;
     }
 }
 
-uint8_t Macros_ParseLayerId(const char* arg1, const char* cmdEnd)
+
+uint8_t Macros_ConsumeLayerId(parser_context_t* ctx)
 {
-    switch(*arg1) {
+    switch(*ctx->at) {
         case 'a':
-            if (TokenMatches(arg1, cmdEnd, "alt")) {
+            if (ConsumeToken(ctx, "alt")) {
                 return LayerId_Alt;
             }
             break;
         case 'b':
-            if (TokenMatches(arg1, cmdEnd, "base")) {
+            if (ConsumeToken(ctx, "base")) {
                 return LayerId_Base;
             }
             break;
         case 'c':
-            if (TokenMatches(arg1, cmdEnd, "current")) {
+            if (ConsumeToken(ctx, "current")) {
                 return ActiveLayer;
-            } else if (TokenMatches(arg1, cmdEnd, "ctrl")) {
+            } else if (ConsumeToken(ctx, "ctrl")) {
                 return LayerId_Ctrl;
-            } else if (TokenMatches(arg1, cmdEnd, "control")) {
+            } else if (ConsumeToken(ctx, "control")) {
                 return LayerId_Ctrl;
             }
             break;
         case 'f':
-            if (TokenMatches(arg1, cmdEnd, "fn")) {
+            if (ConsumeToken(ctx, "fn")) {
                 return LayerId_Fn;
-            } else if (TokenMatches(arg1, cmdEnd, "fn2")) {
+            } else if (ConsumeToken(ctx, "fn2")) {
                 return LayerId_Fn2;
-            } else if (TokenMatches(arg1, cmdEnd, "fn3")) {
+            } else if (ConsumeToken(ctx, "fn3")) {
                 return LayerId_Fn3;
-            } else if (TokenMatches(arg1, cmdEnd, "fn4")) {
+            } else if (ConsumeToken(ctx, "fn4")) {
                 return LayerId_Fn4;
-            } else if (TokenMatches(arg1, cmdEnd, "fn5")) {
+            } else if (ConsumeToken(ctx, "fn5")) {
                 return LayerId_Fn5;
             }
             break;
         case 'g':
-            if (TokenMatches(arg1, cmdEnd, "gui")) {
+            if (ConsumeToken(ctx, "gui")) {
                 return LayerId_Gui;
             }
             break;
         case 'l':
-            if (TokenMatches(arg1, cmdEnd, "last")) {
+            if (ConsumeToken(ctx, "last")) {
                 return lastLayerIdx;
             }
             break;
         case 'm':
-            if (TokenMatches(arg1, cmdEnd, "mouse")) {
+            if (ConsumeToken(ctx, "mouse")) {
                 return LayerId_Mouse;
-            } else if (TokenMatches(arg1, cmdEnd, "mod")) {
+            } else if (ConsumeToken(ctx, "mod")) {
                 return LayerId_Mod;
             }
             break;
         case 'p':
-            if (TokenMatches(arg1, cmdEnd, "previous")) {
+            if (ConsumeToken(ctx, "previous")) {
                 return LayerStack[LayerStack_FindPreviousLayerRecordIdx()].layer;
             }
             break;
         case 's':
-            if (TokenMatches(arg1, cmdEnd, "shift")) {
+            if (ConsumeToken(ctx, "shift")) {
                 return LayerId_Shift;
-            } else if (TokenMatches(arg1, cmdEnd, "super")) {
+            } else if (ConsumeToken(ctx, "super")) {
                 return LayerId_Gui;
             }
             break;
     }
 
-    Macros_ReportError("Unrecognized layer:", arg1, cmdEnd);
+    Macros_ReportError("Unrecognized layer:", ctx->at, ctx->end);
     return LayerId_Base;
 }
 
 
-static uint8_t parseLayerKeymapId(const char* arg1, const char* cmdEnd)
+uint8_t Macros_ParseLayerId(const char* arg1, const char* cmdEnd)
+{
+    parser_context_t ctx = { .macroState = s, .begin = arg1, .at = arg1, .end = cmdEnd };
+    return Macros_ConsumeLayerId(&ctx);
+}
+
+
+
+static uint8_t parseLayerKeymapId(parser_context_t* ctx)
 {
-    if (TokenMatches(arg1, cmdEnd, "last")) {
+    parser_context_t bakCtx = *ctx;
+    if (ConsumeToken(&bakCtx, "last")) {
         return lastLayerKeymapIdx;
     }
-    else if (TokenMatches(arg1, cmdEnd, "previous")) {
+    else if (ConsumeToken(&bakCtx, "previous")) {
         return LayerStack[LayerStack_FindPreviousLayerRecordIdx()].keymap;
     }
     else {
@@ -1144,11 +1224,11 @@ static uint8_t parseLayerKeymapId(const char* arg1, const char* cmdEnd)
     }
 }
 
-static macro_result_t processSwitchKeymapCommand(const char* arg1, const char* cmdEnd)
+static macro_result_t processSwitchKeymapCommand(parser_context_t* ctx)
 {
     uint8_t tmpKeymapIdx = CurrentKeymapIndex;
     {
-        uint8_t newKeymapIdx = parseKeymapId(arg1, cmdEnd);
+        uint8_t newKeymapIdx = consumeKeymapId(ctx);
 
         if (Macros_ParserError) {
             return MacroResult_Finished;
@@ -1165,13 +1245,13 @@ static macro_result_t processSwitchKeymapCommand(const char* arg1, const char* c
 }
 
 /**DEPRECATED**/
-static macro_result_t processSwitchKeymapLayerCommand(const char* arg1, const char* cmdEnd)
+static macro_result_t processSwitchKeymapLayerCommand(parser_context_t* ctx)
 {
-    Macros_ReportWarn("Command deprecated. Please, replace switchKeymapLayer by toggleKeymapLayer or holdKeymapLayer. Or complain on github that you actually need this command.", arg1, arg1);
+    Macros_ReportWarn("Command deprecated. Please, replace switchKeymapLayer by toggleKeymapLayer or holdKeymapLayer. Or complain on github that you actually need this command.", ctx->at, ctx->at);
     uint8_t tmpLayerIdx = LayerStack_ActiveLayer;
     uint8_t tmpLayerKeymapIdx = CurrentKeymapIndex;
-    uint8_t layer = Macros_ParseLayerId(NextTok(arg1, cmdEnd), cmdEnd);
-    uint8_t keymap = parseKeymapId(arg1, cmdEnd);
+    uint8_t keymap = consumeKeymapId(ctx);
+    uint8_t layer = Macros_ConsumeLayerId(ctx);
 
     if (Macros_ParserError) {
         return MacroResult_Finished;
@@ -1187,20 +1267,20 @@ static macro_result_t processSwitchKeymapLayerCommand(const char* arg1, const ch
 }
 
 /**DEPRECATED**/
-static macro_result_t processSwitchLayerCommand(const char* arg1, const char* cmdEnd)
+static macro_result_t processSwitchLayerCommand(parser_context_t* ctx)
 {
-    Macros_ReportWarn("Command deprecated. Please, replace switchLayer by toggleLayer or holdLayer. Or complain on github that you actually need this command.", arg1, arg1);
+    Macros_ReportWarn("Command deprecated. Please, replace switchLayer by toggleLayer or holdLayer. Or complain on github that you actually need this command.", ctx->at, ctx->at);
     uint8_t tmpLayerIdx = LayerStack_ActiveLayer;
     uint8_t tmpLayerKeymapIdx = CurrentKeymapIndex;
-    if (TokenMatches(arg1, cmdEnd, "previous")) {
+    if (ConsumeToken(ctx, "previous")) {
         if (Macros_DryRun) {
             return MacroResult_Finished;
         }
         LayerStack_Pop(true, false);
     }
     else {
-        uint8_t layer = Macros_ParseLayerId(arg1, cmdEnd);
-        uint8_t keymap = parseKeymapId(arg1, cmdEnd);
+        uint8_t keymap = parseLayerKeymapId(ctx);
+        uint8_t layer = Macros_ConsumeLayerId(ctx);
 
         if (Macros_ParserError) {
             return MacroResult_Finished;
@@ -1217,12 +1297,12 @@ static macro_result_t processSwitchLayerCommand(const char* arg1, const char* cm
 }
 
 
-static macro_result_t processToggleKeymapLayerCommand(const char* arg1, const char* cmdEnd)
+static macro_result_t processToggleKeymapLayerCommand(parser_context_t* ctx)
 {
     uint8_t tmpLayerIdx = LayerStack_ActiveLayer;
     uint8_t tmpLayerKeymapIdx = CurrentKeymapIndex;
-    uint8_t layer = Macros_ParseLayerId(NextTok(arg1, cmdEnd), cmdEnd);
-    uint8_t keymap = parseKeymapId(arg1, cmdEnd);
+    uint8_t keymap = consumeKeymapId(ctx);
+    uint8_t layer = Macros_ConsumeLayerId(ctx);
 
     if (Macros_ParserError) {
         return MacroResult_Finished;
@@ -1237,12 +1317,12 @@ static macro_result_t processToggleKeymapLayerCommand(const char* arg1, const ch
     return MacroResult_Finished;
 }
 
-static macro_result_t processToggleLayerCommand(const char* arg1, const char* cmdEnd)
+static macro_result_t processToggleLayerCommand(parser_context_t* ctx)
 {
     uint8_t tmpLayerIdx = LayerStack_ActiveLayer;
     uint8_t tmpLayerKeymapIdx = CurrentKeymapIndex;
-    uint8_t layer = Macros_ParseLayerId(arg1, cmdEnd);
-    uint8_t keymap = parseLayerKeymapId(arg1, cmdEnd);
+    uint8_t keymap = parseLayerKeymapId(ctx);
+    uint8_t layer = Macros_ConsumeLayerId(ctx);
 
     if (Macros_ParserError) {
         return MacroResult_Finished;
@@ -1297,10 +1377,10 @@ static macro_result_t processHoldLayer(uint8_t layer, uint8_t keymap, uint16_t t
     }
 }
 
-static macro_result_t processHoldLayerCommand(const char* arg1, const char* cmdEnd)
+static macro_result_t processHoldLayerCommand(parser_context_t* ctx)
 {
-    uint8_t layer = Macros_ParseLayerId(arg1, cmdEnd);
-    uint8_t keymap = parseLayerKeymapId(arg1, cmdEnd);
+    uint8_t layer = Macros_ConsumeLayerId(ctx);
+    uint8_t keymap = parseLayerKeymapId(ctx);
 
     if (Macros_ParserError) {
         return MacroResult_Finished;
@@ -1312,13 +1392,11 @@ static macro_result_t processHoldLayerCommand(const char* arg1, const char* cmdE
     return processHoldLayer(layer, keymap, 0xFFFF);
 }
 
-static macro_result_t processHoldLayerMaxCommand(const char* arg1, const char* cmdEnd)
+static macro_result_t processHoldLayerMaxCommand(parser_context_t* ctx)
 {
-    const char* arg2 = NextTok(arg1, cmdEnd);
-
-    uint8_t layer = Macros_ParseLayerId(arg1, cmdEnd);
-    uint8_t keymap = parseLayerKeymapId(arg1, cmdEnd);
-    uint16_t timeout = parseNUM(arg2, cmdEnd);
+    uint8_t keymap = parseLayerKeymapId(ctx);
+    uint8_t layer = Macros_ConsumeLayerId(ctx);
+    uint16_t timeout = Macros_LegacyConsumeInt(ctx);
 
     if (Macros_ParserError) {
         return MacroResult_Finished;
@@ -1330,11 +1408,10 @@ static macro_result_t processHoldLayerMaxCommand(const char* arg1, const char* c
     return processHoldLayer(layer, keymap, timeout);
 }
 
-static macro_result_t processHoldKeymapLayerCommand(const char* arg1, const char* cmdEnd)
+static macro_result_t processHoldKeymapLayerCommand(parser_context_t* ctx)
 {
-    const char* arg2 = NextTok(arg1, cmdEnd);
-    uint8_t layer = Macros_ParseLayerId(arg2, cmdEnd);
-    uint8_t keymap = parseKeymapId(arg1, cmdEnd);
+    uint8_t keymap = consumeKeymapId(ctx);
+    uint8_t layer = Macros_ConsumeLayerId(ctx);
 
     if (Macros_ParserError) {
         return MacroResult_Finished;
@@ -1346,14 +1423,11 @@ static macro_result_t processHoldKeymapLayerCommand(const char* arg1, const char
     return processHoldLayer(layer, keymap, 0xFFFF);
 }
 
-static macro_result_t processHoldKeymapLayerMaxCommand(const char* arg1, const char* cmdEnd)
+static macro_result_t processHoldKeymapLayerMaxCommand(parser_context_t* ctx)
 {
-    const char* arg2 = NextTok(arg1, cmdEnd);
-    const char* arg3 = NextTok(arg2, cmdEnd);
-
-    uint8_t layer = Macros_ParseLayerId(arg2, cmdEnd);
-    uint8_t keymap = parseKeymapId(arg1, cmdEnd);
-    uint16_t timeout = parseNUM(arg3, cmdEnd);
+    uint8_t keymap = consumeKeymapId(ctx);
+    uint8_t layer = Macros_ConsumeLayerId(ctx);
+    uint16_t timeout = Macros_LegacyConsumeInt(ctx);
 
     if (Macros_ParserError) {
         return MacroResult_Finished;
@@ -1365,9 +1439,9 @@ static macro_result_t processHoldKeymapLayerMaxCommand(const char* arg1, const c
     return processHoldLayer(layer, keymap, timeout);
 }
 
-static macro_result_t processDelayUntilReleaseMaxCommand(const char* arg1, const char* cmdEnd)
+static macro_result_t processDelayUntilReleaseMaxCommand(parser_context_t* ctx)
 {
-    uint32_t timeout = parseNUM(arg1, cmdEnd);
+    uint32_t timeout = Macros_LegacyConsumeInt(ctx);
 
     if (Macros_ParserError) {
         return MacroResult_Finished;
@@ -1395,9 +1469,9 @@ static macro_result_t processDelayUntilReleaseCommand()
     return MacroResult_Finished;
 }
 
-static macro_result_t processDelayUntilCommand(const char* arg1, const char* cmdEnd)
+static macro_result_t processDelayUntilCommand(parser_context_t* ctx)
 {
-    uint32_t time = parseNUM(arg1,  cmdEnd);
+    uint32_t time = Macros_LegacyConsumeInt(ctx);
 
     if (Macros_ParserError) {
         return MacroResult_Finished;
@@ -1471,9 +1545,9 @@ static bool processIfRecordingCommand(bool negate)
     return MacroRecorder_IsRecording() != negate;
 }
 
-static bool processIfRecordingIdCommand(bool negate, const char* arg, const char *argEnd)
+static bool processIfRecordingIdCommand(parser_context_t* ctx, bool negate)
 {
-    uint16_t id = parseRuntimeMacroSlotId(arg, argEnd);
+    uint16_t id = consumeRuntimeMacroSlotId(ctx);
     if (Macros_DryRun) {
         return true;
     }
@@ -1481,9 +1555,9 @@ static bool processIfRecordingIdCommand(bool negate, const char* arg, const char
     return res != negate;
 }
 
-static bool processIfPendingCommand(bool negate, const char* arg, const char *argEnd)
+static bool processIfPendingCommand(parser_context_t* ctx, bool negate)
 {
-    uint32_t cnt = parseNUM(arg, argEnd);
+    uint32_t cnt = Macros_LegacyConsumeInt(ctx);
     if (Macros_DryRun) {
         return true;
     }
@@ -1491,9 +1565,9 @@ static bool processIfPendingCommand(bool negate, const char* arg, const char *ar
     return (PostponerQuery_PendingKeypressCount() >= cnt) != negate;
 }
 
-static bool processIfPlaytimeCommand(bool negate, const char* arg, const char *argEnd)
+static bool processIfPlaytimeCommand(parser_context_t* ctx, bool negate)
 {
-    uint32_t timeout = parseNUM(arg, argEnd);
+    uint32_t timeout = Macros_LegacyConsumeInt(ctx);
     if (Macros_DryRun) {
         return true;
     }
@@ -1517,11 +1591,12 @@ static bool processIfReleasedCommand(bool negate)
    return (!currentMacroKeyIsActive()) != negate;
 }
 
-static bool processIfRegEqCommand(bool negate, const char* arg1, const char *argEnd)
+static bool processIfRegEqCommand(parser_context_t* ctx, bool negate)
 {
-    uint8_t address = parseNUM(arg1, argEnd);
-    int32_t param = parseNUM(NextTok(arg1, argEnd), argEnd);
-    bool regIsValid = validReg(address, arg1);
+    Macros_ReportWarn("Command is deprecated, please use command similar to `if ($varName == 1)`.", ctx->at, ctx->at);
+    uint8_t address = Macros_LegacyConsumeInt(ctx);
+    int32_t param = Macros_LegacyConsumeInt(ctx);
+    bool regIsValid = validReg(address, ctx->at);
     if (Macros_DryRun) {
         return true;
     }
@@ -1533,11 +1608,12 @@ static bool processIfRegEqCommand(bool negate, const char* arg1, const char *arg
     }
 }
 
-static bool processIfRegInequalityCommand(bool greaterThan, const char* arg1, const char *argEnd)
+static bool processIfRegInequalityCommand(parser_context_t* ctx, bool greaterThan)
 {
-    uint8_t address = parseNUM(arg1, argEnd);
-    int32_t param = parseNUM(NextTok(arg1, argEnd), argEnd);
-    bool regIsValid = validReg(address, arg1);
+    Macros_ReportWarn("Command is deprecated, please use command similar to `if ($varName >= 1)`.", ctx->at, ctx->at);
+    uint8_t address = Macros_LegacyConsumeInt(ctx);
+    int32_t param = Macros_LegacyConsumeInt(ctx);
+    bool regIsValid = validReg(address, ctx->at);
     if (Macros_DryRun) {
         return true;
     }
@@ -1552,24 +1628,29 @@ static bool processIfRegInequalityCommand(bool greaterThan, const char* arg1, co
     }
 }
 
-static bool processIfKeymapCommand(bool negate, const char* arg1, const char *argEnd)
+static bool processIfKeymapCommand(parser_context_t* ctx, bool negate)
 {
-    uint8_t queryKeymapIdx = parseKeymapId(arg1, argEnd);
+    uint8_t queryKeymapIdx = consumeKeymapId(ctx);
     if (Macros_DryRun) {
         return true;
     }
     return (queryKeymapIdx == CurrentKeymapIndex) != negate;
 }
 
-static bool processIfLayerCommand(bool negate, const char* arg1, const char *argEnd)
+static bool processIfLayerCommand(parser_context_t* ctx, bool negate)
 {
-    uint8_t queryLayerIdx = Macros_ParseLayerId(arg1, argEnd);
+    uint8_t queryLayerIdx = Macros_ConsumeLayerId(ctx);
     if (Macros_DryRun) {
         return true;
     }
     return (queryLayerIdx == LayerStack_ActiveLayer) != negate;
 }
 
+static bool processIfCommand(parser_context_t* ctx)
+{
+    return Macros_ConsumeBool(ctx);
+}
+
 static macro_result_t processBreakCommand()
 {
     if (Macros_DryRun) {
@@ -1585,7 +1666,7 @@ static macro_result_t processPrintStatusCommand()
         return MacroResult_Finished;
     }
     statusBufferPrinting = true;
-    macro_result_t res = dispatchText(statusBuffer, statusBufferLen);
+    macro_result_t res = dispatchText(statusBuffer, statusBufferLen, true);
     if (res == MacroResult_Finished) {
         processClearStatusCommand();
         statusBufferPrinting = false;
@@ -1593,44 +1674,67 @@ static macro_result_t processPrintStatusCommand()
     return res;
 }
 
-static macro_result_t processSetStatusCommand(const char* arg, const char *argEnd, bool addEndline)
+static macro_result_t processSetStatusCommand(parser_context_t* ctx, bool addEndline)
 {
+    Macros_ReportWarn("Command is deprecated, please use string interpolated setStatus.", ctx->at, ctx->at);
     if (Macros_DryRun) {
         return MacroResult_Finished;
     }
-    Macros_SetStatusStringInterpolated(arg, argEnd);
+    setStatusStringInterpolated(ctx);
     if (addEndline) {
         Macros_SetStatusString("\n", NULL);
     }
     return MacroResult_Finished;
 }
 
-static macro_result_t processSetLedTxtCommand(const char* arg1, const char *argEnd)
+static macro_result_t processSetLedTxtCommand(parser_context_t* ctx)
 {
-    int16_t time = parseNUM(arg1, argEnd);
-    if (Macros_DryRun) {
+    int16_t time = Macros_LegacyConsumeInt(ctx);
+    char text[3];
+    uint8_t textLen = 0;
+
+    if (isNUM(ctx)) {
+        macro_variable_t value = Macros_ConsumeAnyValue(ctx);
+        SegmentDisplay_SerializeVar(text, value);
+        textLen = 3;
+    } else if (ctx->at != ctx->end) {
+        uint16_t stringOffset = 0, textIndex = 0, textSubIndex = 0;
+        for (uint8_t i = 0; i < 3; i++) {
+            text[i] = Macros_ConsumeCharOfString(ctx, &stringOffset, &textIndex, &textSubIndex);
+            if (text[i] != '\0') {
+                textLen++;
+            }
+        }
+        ctx->at += stringOffset;
+        ctx->at += textIndex;
+        ConsumeWhite(ctx);
+    } else {
+        Macros_ReportError("Text argument expected.", ctx->at, ctx->at);
+        return MacroResult_Finished;
+    }
+
+    if (Macros_DryRun || Macros_ParserError) {
         return MacroResult_Finished;
     }
+
     macro_result_t res = MacroResult_Finished;
     if (time == 0) {
-        const char* str = NextTok(arg1, argEnd);
-        SegmentDisplay_SetText(TokLen(str, argEnd), str, SegmentDisplaySlot_Macro);
+        SegmentDisplay_SetText(textLen, text, SegmentDisplaySlot_Macro);
         return MacroResult_Finished;
     } else if ((res = processDelay(time)) == MacroResult_Finished) {
         SegmentDisplay_DeactivateSlot(SegmentDisplaySlot_Macro);
         return MacroResult_Finished;
     } else {
-        const char* str = NextTok(arg1, argEnd);
-        SegmentDisplay_SetText(TokLen(str, argEnd), str, SegmentDisplaySlot_Macro);
+        SegmentDisplay_SetText(textLen, text, SegmentDisplaySlot_Macro);
         return res;
     }
 }
 
-static macro_result_t processSetRegCommand(const char* arg1, const char *argEnd)
+static macro_result_t processSetRegCommand(parser_context_t* ctx)
 {
-    uint8_t address = parseNUM(arg1, argEnd);
-    int32_t param = parseNUM(NextTok(arg1, argEnd), argEnd);
-    bool regIsValid = validReg(address, arg1);
+    uint8_t address = Macros_LegacyConsumeInt(ctx);
+    int32_t param = Macros_LegacyConsumeInt(ctx);
+    bool regIsValid = validReg(address, ctx->at);
     if (Macros_DryRun) {
         return MacroResult_Finished;
     }
@@ -1640,11 +1744,12 @@ static macro_result_t processSetRegCommand(const char* arg1, const char *argEnd)
     return MacroResult_Finished;
 }
 
-static macro_result_t processRegAddCommand(const char* arg1, const char *argEnd, bool invert)
+static macro_result_t processRegAddCommand(parser_context_t* ctx, bool invert)
 {
-    uint8_t address = parseNUM(arg1, argEnd);
-    int32_t param = parseNUM(NextTok(arg1, argEnd), argEnd);
-    bool regIsValid = validReg(address, arg1);
+    Macros_ReportWarn("Command is deprecated, please use command similar to `setVar varName ($varName+1)`.", ctx->at, ctx->at);
+    uint8_t address = Macros_LegacyConsumeInt(ctx);
+    int32_t param = Macros_LegacyConsumeInt(ctx);
+    bool regIsValid = validReg(address, ctx->at);
     if (Macros_DryRun) {
         return MacroResult_Finished;
     }
@@ -1658,11 +1763,12 @@ static macro_result_t processRegAddCommand(const char* arg1, const char *argEnd,
     return MacroResult_Finished;
 }
 
-static macro_result_t processRegMulCommand(const char* arg1, const char *argEnd)
+static macro_result_t processRegMulCommand(parser_context_t* ctx)
 {
-    uint8_t address = parseNUM(arg1, argEnd);
-    int32_t param = parseNUM(NextTok(arg1, argEnd), argEnd);
-    bool regIsValid = validReg(address, arg1);
+    Macros_ReportWarn("Command is deprecated, please use command similar to `setVar varName ($varName*2)`.", ctx->at, ctx->at);
+    uint8_t address = Macros_LegacyConsumeInt(ctx);
+    int32_t param = Macros_LegacyConsumeInt(ctx);
+    bool regIsValid = validReg(address, ctx->at);
     if (Macros_DryRun) {
         return MacroResult_Finished;
     }
@@ -1707,7 +1813,7 @@ static macro_result_t goToAddress(uint8_t address)
     return address > oldAddress ? MacroResult_JumpedForward: MacroResult_JumpedBackward;
 }
 
-static macro_result_t goToLabel(const char* arg, const char* argEnd)
+static macro_result_t goToLabel(parser_context_t* ctx)
 {
     uint8_t startedAtAdr = s->ms.commandAddress;
     bool secondPass = false;
@@ -1720,7 +1826,7 @@ static macro_result_t goToLabel(const char* arg, const char* argEnd)
                 const char* cmdEnd = s->ms.currentMacroAction.cmd.text + s->ms.commandEnd;
                 const char* cmdTokEnd = TokEnd(cmd, cmdEnd);
 
-                if(cmdTokEnd[-1] == ':' && TokenMatches2(cmd, cmdTokEnd-1, arg, argEnd)) {
+                if(cmdTokEnd[-1] == ':' && TokenMatches2(cmd, cmdTokEnd-1, ctx->at, ctx->end)) {
                     return s->ms.commandAddress > startedAtAdr ? MacroResult_JumpedForward : MacroResult_JumpedBackward;
                 }
             }
@@ -1735,30 +1841,30 @@ static macro_result_t goToLabel(const char* arg, const char* argEnd)
         }
     }
 
-    Macros_ReportError("Label not found:", arg, argEnd);
+    Macros_ReportError("Label not found:", ctx->at, ctx->end);
     s->ms.macroBroken = true;
 
     return MacroResult_Finished;
 }
 
-static macro_result_t goTo(const char* arg, const char* argEnd)
+static macro_result_t goTo(parser_context_t* ctx)
 {
-    if (isNUM(arg, argEnd)) {
-        return goToAddress(parseNUM(arg, argEnd));
+    if (isNUM(ctx)) {
+        return goToAddress(Macros_LegacyConsumeInt(ctx));
     } else {
-        return goToLabel(arg, argEnd);
+        return goToLabel(ctx);
     }
 }
 
-static macro_result_t processGoToCommand(const char* arg, const char *argEnd)
+static macro_result_t processGoToCommand(parser_context_t* ctx)
 {
     if (Macros_DryRun) {
         return MacroResult_Finished;
     }
-    return goTo(arg, argEnd);
+    return goTo(ctx);
 }
 
-static macro_result_t processYieldCommand(const char* arg, const char *argEnd)
+static macro_result_t processYieldCommand(parser_context_t* ctx)
 {
     if (Macros_DryRun) {
         return MacroResult_Finished;
@@ -1775,44 +1881,45 @@ static macro_result_t processStopRecordingCommand()
     return MacroResult_Finished;
 }
 
-static macro_result_t processMouseCommand(bool enable, const char* arg1, const char *argEnd)
+static macro_result_t processMouseCommand(parser_context_t* ctx, bool enable)
 {
-    const char* arg2 = NextTok(arg1, argEnd);
     uint8_t dirOffset = 0;
 
     serialized_mouse_action_t baseAction = SerializedMouseAction_LeftClick;
 
-    if (TokenMatches(arg1, argEnd, "move")) {
+    if (ConsumeToken(ctx, "move")) {
         baseAction = SerializedMouseAction_MoveUp;
     }
-    else if (TokenMatches(arg1, argEnd, "scroll")) {
+    else if (ConsumeToken(ctx, "scroll")) {
         baseAction = SerializedMouseAction_ScrollUp;
     }
-    else if (TokenMatches(arg1, argEnd, "accelerate")) {
+    else if (ConsumeToken(ctx, "accelerate")) {
         baseAction = SerializedMouseAction_Accelerate;
     }
-    else if (TokenMatches(arg1, argEnd, "decelerate")) {
+    else if (ConsumeToken(ctx, "decelerate")) {
         baseAction = SerializedMouseAction_Decelerate;
     }
     else {
-        Macros_ReportError("Unrecognized argument:", arg1, argEnd);
+        Macros_ReportError("Unrecognized argument:", ctx->at, ctx->end);
+        return MacroResult_Finished;
     }
 
     if (baseAction == SerializedMouseAction_MoveUp || baseAction == SerializedMouseAction_ScrollUp) {
-        if (TokenMatches(arg2, argEnd, "up")) {
+        if (ConsumeToken(ctx, "up")) {
             dirOffset = 0;
         }
-        else if (TokenMatches(arg2, argEnd, "down")) {
+        else if (ConsumeToken(ctx, "down")) {
             dirOffset = 1;
         }
-        else if (TokenMatches(arg2, argEnd, "left")) {
+        else if (ConsumeToken(ctx, "left")) {
             dirOffset = 2;
         }
-        else if (TokenMatches(arg2, argEnd, "right")) {
+        else if (ConsumeToken(ctx, "right")) {
             dirOffset = 3;
         }
         else {
-            Macros_ReportError("Unrecognized argument:", arg2, argEnd);
+            Macros_ReportError("Unrecognized argument:", ctx->at, ctx->end);
+            return MacroResult_Finished;
         }
     }
 
@@ -1826,9 +1933,9 @@ static macro_result_t processMouseCommand(bool enable, const char* arg1, const c
     return MacroResult_Finished;
 }
 
-static macro_result_t processRecordMacroCommand(const char* arg, const char *argEnd, bool blind)
+static macro_result_t processRecordMacroCommand(parser_context_t* ctx, bool blind)
 {
-    uint16_t id = parseRuntimeMacroSlotId(arg, argEnd);
+    uint16_t id = consumeRuntimeMacroSlotId(ctx);
     if (Macros_DryRun) {
         return MacroResult_Finished;
     }
@@ -1836,9 +1943,9 @@ static macro_result_t processRecordMacroCommand(const char* arg, const char *arg
     return MacroResult_Finished;
 }
 
-static macro_result_t processStartRecordingCommand(const char* arg, const char *argEnd, bool blind)
+static macro_result_t processStartRecordingCommand(parser_context_t* ctx, bool blind)
 {
-    uint16_t id = parseRuntimeMacroSlotId(arg, argEnd);
+    uint16_t id = consumeRuntimeMacroSlotId(ctx);
     if (Macros_DryRun) {
         return MacroResult_Finished;
     }
@@ -1846,10 +1953,10 @@ static macro_result_t processStartRecordingCommand(const char* arg, const char *
     return MacroResult_Finished;
 }
 
-static macro_result_t processPlayMacroCommand(const char* arg, const char *argEnd)
+static macro_result_t processPlayMacroCommand(parser_context_t* ctx)
 {
     s->ms.reportsUsed = true;
-    uint16_t id = parseRuntimeMacroSlotId(arg, argEnd);
+    uint16_t id = consumeRuntimeMacroSlotId(ctx);
     if (Macros_DryRun) {
         return MacroResult_Finished;
     }
@@ -1857,18 +1964,24 @@ static macro_result_t processPlayMacroCommand(const char* arg, const char *argEn
     return res ? MacroResult_Blocking : MacroResult_Finished;
 }
 
-static macro_result_t processWriteCommand(const char* arg, const char *argEnd)
+static macro_result_t processWriteCommand(parser_context_t* ctx)
 {
     if (Macros_DryRun) {
+        uint16_t stringOffset = 0;
+        uint16_t textIndex = 0;
+        uint16_t textSubIndex = 0;
+
+        while (Macros_ConsumeCharOfString(ctx, &stringOffset, &textIndex, &textSubIndex) != '\0') {};
+
         return MacroResult_Finished;
     }
-    return dispatchText(arg, argEnd - arg);
+    return dispatchText(ctx->at, ctx->end - ctx->at, false);
 }
 
-
-static macro_result_t processWriteExprCommand(const char* arg, const char *argEnd)
+static macro_result_t processWriteExprCommand(parser_context_t* ctx)
 {
-    uint32_t num = parseNUM(arg, argEnd);
+    Macros_ReportWarn("writeExpr is now deprecated, please migrate to interpolated strings", ctx->at, ctx->at);
+    uint32_t num = Macros_LegacyConsumeInt(ctx);
     if (Macros_DryRun) {
         return MacroResult_Finished;
     }
@@ -1964,9 +2077,10 @@ static uint8_t processResolveSecondary(uint16_t timeout1, uint16_t timeout2)
 
 }
 
-static macro_result_t processResolveSecondaryCommand(const char* arg1, const char* argEnd)
+static macro_result_t processResolveSecondaryCommand(parser_context_t* ctx)
 {
-
+    const char* argEnd = ctx->end;
+    const char* arg1 = ctx->at;
     const char* arg2 = NextTok(arg1, argEnd);
     const char* arg3 = NextTok(arg2, argEnd);
     const char* arg4 = NextTok(arg3, argEnd);
@@ -1977,13 +2091,13 @@ static macro_result_t processResolveSecondaryCommand(const char* arg1, const cha
     uint16_t timeout2;
 
     if (arg4 == argEnd) {
-        timeout1 = parseNUM(arg1, argEnd);
+        timeout1 = Macros_ParseInt(arg1, argEnd, NULL);
         timeout2 = timeout1;
         primaryAdr = arg2;
         secondaryAdr = arg3;
     } else {
-        timeout1 = parseNUM(arg1, argEnd);
-        timeout2 = parseNUM(arg2, argEnd);
+        timeout1 = Macros_ParseInt(arg1, argEnd, NULL);
+        timeout2 = Macros_ParseInt(arg2, argEnd, NULL);
         primaryAdr = arg3;
         secondaryAdr = arg4;
     }
@@ -1992,6 +2106,7 @@ static macro_result_t processResolveSecondaryCommand(const char* arg1, const cha
         return MacroResult_Finished;
     }
     if (Macros_DryRun) {
+        Macros_ReportWarn("Command deprecated. Please, replace resolveSecondary by `ifPrimary advancedStrategy goTo ...` or `ifSecondary advancedStrategy goTo ...`.", NULL, NULL);
         return MacroResult_Finished;
     }
 
@@ -2000,12 +2115,15 @@ static macro_result_t processResolveSecondaryCommand(const char* arg1, const cha
     switch(res) {
     case RESOLVESEC_RESULT_DONTKNOWYET:
         return MacroResult_Waiting;
-    case RESOLVESEC_RESULT_PRIMARY:
-        postponeNextN(1);
-        Macros_ReportWarn("Command deprecated. Please, replace resolveSecondary by `ifPrimary advancedStrategy goTo ...` or `ifSecondary advancedStrategy goTo ...`.", NULL, NULL);
-        return goTo(primaryAdr, argEnd);
-    case RESOLVESEC_RESULT_SECONDARY:
-        return goTo(secondaryAdr, argEnd);
+    case RESOLVESEC_RESULT_PRIMARY: {
+            postponeNextN(1);
+            parser_context_t ctx2 = { .macroState = s, .begin = arg1, .at = primaryAdr, .end = argEnd};
+            return goTo(&ctx2);
+        }
+    case RESOLVESEC_RESULT_SECONDARY: {
+            parser_context_t ctx2 = { .macroState = s, .begin = arg1, .at = secondaryAdr, .end = argEnd};
+            return goTo(&ctx2);
+        }
     }
     //this is unreachable, prevents warning
     return MacroResult_Finished;
@@ -2013,16 +2131,14 @@ static macro_result_t processResolveSecondaryCommand(const char* arg1, const cha
 
 
 
-static macro_result_t processIfSecondaryCommand(bool negate, const char* arg, const char* argEnd)
+static macro_result_t processIfSecondaryCommand(parser_context_t* ctx, bool negate)
 {
     secondary_role_strategy_t strategy = SecondaryRoles_Strategy;
 
-    if (TokenMatches(arg, argEnd, "simpleStrategy")) {
-        arg = NextTok(arg, argEnd);
+    if (ConsumeToken(ctx, "simpleStrategy")) {
         strategy = SecondaryRoleStrategy_Simple;
     }
-    if (TokenMatches(arg, argEnd, "advancedStrategy")) {
-        arg = NextTok(arg, argEnd);
+    else if (ConsumeToken(ctx, "advancedStrategy")) {
         strategy = SecondaryRoleStrategy_Advanced;
     }
 
@@ -2063,20 +2179,23 @@ static macro_result_t processIfSecondaryCommand(bool negate, const char* arg, co
 conditionPassed:
     s->as.currentIfSecondaryConditionPassed = true;
     s->as.currentConditionPassed = false; //otherwise following conditions would be skipped
-    return processCommand(arg, argEnd);
+    return processCommand(ctx);
 }
 
-static macro_action_t decodeKey(const char* arg1, const char* argEnd, macro_sub_action_t defaultSubAction)
+static macro_action_t decodeKeyAndConsume(parser_context_t* ctx, macro_sub_action_t defaultSubAction)
 {
     macro_action_t action;
-    MacroShortcutParser_Parse(arg1, TokEnd(arg1, argEnd), defaultSubAction, &action, NULL);
+    const char* end = TokEnd(ctx->at, ctx->end);
+    MacroShortcutParser_Parse(ctx->at, end, defaultSubAction, &action, NULL);
+    ctx->at = end;
+    ConsumeWhite(ctx);
 
     return action;
 }
 
-static macro_result_t processKeyCommand(macro_sub_action_t type, const char* arg1, const char* argEnd)
+static macro_result_t processKeyCommandAndConsume(parser_context_t* ctx, macro_sub_action_t type)
 {
-    macro_action_t action = decodeKey(arg1, argEnd, type);
+    macro_action_t action = decodeKeyAndConsume(ctx, type);
 
     if (Macros_DryRun) {
         return MacroResult_Finished;
@@ -2092,26 +2211,25 @@ static macro_result_t processKeyCommand(macro_sub_action_t type, const char* arg
     }
 }
 
-static macro_result_t processTapKeySeqCommand(const char* arg1, const char* argEnd)
+static macro_result_t processTapKeySeqCommand(parser_context_t* ctx)
 {
     if (Macros_DryRun) {
-        while(arg1 != argEnd) {
-            processKeyCommand(MacroSubAction_Tap, arg1, argEnd);
-            arg1 = NextTok(arg1, argEnd);
+        while(ctx->at != ctx->end) {
+            processKeyCommandAndConsume(ctx, MacroSubAction_Tap);
         }
         return MacroResult_Finished;
     }
 
     for(uint8_t i = 0; i < s->as.keySeqData.atKeyIdx; i++) {
-        arg1 = NextTok(arg1, argEnd);
+        ctx->at = NextTok(ctx->at, ctx->end);
 
-        if(arg1 == argEnd) {
+        if(ctx->at == ctx->end) {
             s->as.keySeqData.atKeyIdx = 0;
             return MacroResult_Finished;
         };
     }
 
-    macro_result_t res = processKeyCommand(MacroSubAction_Tap, arg1, argEnd);
+    macro_result_t res = processKeyCommandAndConsume(ctx, MacroSubAction_Tap);
 
     if(res == MacroResult_Finished) {
         s->as.keySeqData.atKeyIdx++;
@@ -2137,21 +2255,23 @@ static macro_result_t processResolveNextKeyIdCommand()
     return res;
 }
 
-static macro_result_t processResolveNextKeyEqCommand(const char* arg1, const char* argEnd)
+static macro_result_t processResolveNextKeyEqCommand(parser_context_t* ctx)
 {
     Macros_ReportWarn("Command deprecated. Please, replace resolveNextKeyEq by ifShortcut or ifGesture, or complain at github that you actually need this.", NULL, NULL);
+    const char* argEnd = ctx->end;
+    const char* arg1 = ctx->at;
     const char* arg2 = NextTok(arg1, argEnd);
     const char* arg3 = NextTok(arg2, argEnd);
     const char* arg4 = NextTok(arg3, argEnd);
     const char* arg5 = NextTok(arg4, argEnd);
-    uint16_t idx = parseNUM(arg1, argEnd);
-    uint16_t key = parseNUM(arg2, argEnd);
+    uint16_t idx = Macros_ParseInt(arg1, argEnd, NULL);
+    uint16_t key = Macros_ParseInt(arg2, argEnd, NULL);
     uint16_t timeout = 0;
     bool untilRelease = false;
     if (TokenMatches(arg3, argEnd, "untilRelease")) {
        untilRelease = true;
     } else {
-       timeout = parseNUM(arg3, argEnd);
+       timeout = Macros_ParseInt(arg3, argEnd, NULL);
     }
     const char* adr1 = arg4;
     const char* adr2 = arg5;
@@ -2171,20 +2291,23 @@ static macro_result_t processResolveNextKeyEqCommand(const char* arg1, const cha
     postponeCurrentCycle();
 
     if (untilRelease ? !currentMacroKeyIsActive() : Timer_GetElapsedTime(&s->ms.currentMacroStartTime) >= timeout) {
-        return goTo(adr2, argEnd);
+        ctx->at = adr2;
+        return goTo(ctx);
     }
     if (PostponerQuery_PendingKeypressCount() < idx + 1) {
         return MacroResult_Waiting;
     }
 
     if (PostponerExtended_PendingId(idx) == key) {
-        return goTo(adr1, argEnd);
+        ctx->at = adr1;
+        return goTo(ctx);
     } else {
-        return goTo(adr2, argEnd);
+        ctx->at = adr2;
+        return goTo(ctx);
     }
 }
 
-static macro_result_t processIfShortcutCommand(bool negate, const char* arg, const char* argEnd, bool untilRelease)
+static macro_result_t processIfShortcutCommand(parser_context_t* ctx, bool negate, bool untilRelease)
 {
     //parse optional flags
     bool consume = true;
@@ -2193,30 +2316,23 @@ static macro_result_t processIfShortcutCommand(bool negate, const char* arg, con
     bool orGate = false;
     uint16_t cancelIn = 0;
     uint16_t timeoutIn= 0;
-    while(arg < argEnd && !isNUM(arg, argEnd)) {
-        if (TokenMatches(arg, argEnd, "noConsume")) {
-            arg = NextTok(arg, argEnd);
+
+    bool parsingOptions = true;
+    while(parsingOptions) {
+        if (ConsumeToken(ctx, "noConsume")) {
             consume = false;
-        } else if (TokenMatches(arg, argEnd, "transitive")) {
-            arg = NextTok(arg, argEnd);
+        } else if (ConsumeToken(ctx, "transitive")) {
             transitive = true;
-        } else if (TokenMatches(arg, argEnd, "timeoutIn")) {
-            arg = NextTok(arg, argEnd);
-            timeoutIn = parseNUM(arg, argEnd);
-            arg = NextTok(arg, argEnd);
-        } else if (TokenMatches(arg, argEnd, "cancelIn")) {
-            arg = NextTok(arg, argEnd);
-            cancelIn = parseNUM(arg, argEnd);
-            arg = NextTok(arg, argEnd);
-        } else if (TokenMatches(arg, argEnd, "anyOrder")) {
-            arg = NextTok(arg, argEnd);
+        } else if (ConsumeToken(ctx, "timeoutIn")) {
+            timeoutIn = Macros_LegacyConsumeInt(ctx);
+        } else if (ConsumeToken(ctx, "cancelIn")) {
+            cancelIn = Macros_LegacyConsumeInt(ctx);
+        } else if (ConsumeToken(ctx, "anyOrder")) {
             fixedOrder = false;
-        } else if (TokenMatches(arg, argEnd, "orGate")) {
-            arg = NextTok(arg, argEnd);
+        } else if (ConsumeToken(ctx, "orGate")) {
             orGate = true;
         } else {
-            Macros_ReportError("Unrecognized option:", arg, argEnd);
-            arg = NextTok(arg, argEnd);
+            parsingOptions = false;
         }
     }
 
@@ -2237,10 +2353,9 @@ static macro_result_t processIfShortcutCommand(bool negate, const char* arg, con
     uint8_t pendingCount = PostponerQuery_PendingKeypressCount();
     uint8_t numArgs = 0;
     bool someoneNotReleased = false;
-    while(isNUM(arg, argEnd) && arg < argEnd) {
+    uint8_t argKeyId = 255;
+    while((argKeyId = Macros_TryConsumeKeyId(ctx)) != 255 && ctx->at < ctx->end) {
         numArgs++;
-        uint8_t argKeyid = parseNUM(arg, argEnd);
-        arg = NextTok(arg, argEnd);
         if (pendingCount < numArgs) {
             uint32_t referenceTime = transitive && pendingCount > 0 ? PostponerExtended_LastPressTime() : s->ms.currentMacroStartTime;
             uint16_t elapsedSinceReference = Timer_GetElapsedTime(&referenceTime);
@@ -2279,18 +2394,16 @@ static macro_result_t processIfShortcutCommand(bool negate, const char* arg, con
             // go through all canidates all at once
             while (true) {
                 // first keyid had already been processed.
-                if (PostponerQuery_ContainsKeyId(argKeyid)) {
+                if (PostponerQuery_ContainsKeyId(argKeyId)) {
                     if (negate) {
                         return MacroResult_Finished;
                     } else {
                         goto conditionPassed;
                     }
                 }
-                if (!(isNUM(arg, argEnd) && arg < argEnd)) {
+                if ((argKeyId = Macros_TryConsumeKeyId(ctx)) == 255 || ctx->at == ctx->end) {
                     break;
                 }
-                argKeyid = parseNUM(arg, argEnd);
-                arg = NextTok(arg, argEnd);
             }
             // none is matched
             if (negate) {
@@ -2299,14 +2412,14 @@ static macro_result_t processIfShortcutCommand(bool negate, const char* arg, con
                 return MacroResult_Finished;
             }
         }
-        else if (fixedOrder && PostponerExtended_PendingId(numArgs - 1) != argKeyid) {
+        else if (fixedOrder && PostponerExtended_PendingId(numArgs - 1) != argKeyId) {
             if (negate) {
                 goto conditionPassed;
             } else {
                 return MacroResult_Finished;
             }
         }
-        else if (!fixedOrder && !PostponerQuery_ContainsKeyId(argKeyid)) {
+        else if (!fixedOrder && !PostponerQuery_ContainsKeyId(argKeyId)) {
             if (negate) {
                 goto conditionPassed;
             } else {
@@ -2314,7 +2427,7 @@ static macro_result_t processIfShortcutCommand(bool negate, const char* arg, con
             }
         }
         else {
-            someoneNotReleased |= !PostponerQuery_IsKeyReleased(Utils_KeyIdToKeyState(argKeyid));
+            someoneNotReleased |= !PostponerQuery_IsKeyReleased(Utils_KeyIdToKeyState(argKeyId));
         }
     }
     //all keys match
@@ -2327,17 +2440,26 @@ static macro_result_t processIfShortcutCommand(bool negate, const char* arg, con
         goto conditionPassed;
     }
 conditionPassed:
-    while(isNUM(arg, argEnd) && arg < argEnd) {
-        arg = NextTok(arg, argEnd);
-    }
+    while(Macros_TryConsumeKeyId(ctx) != 255) { };
     s->as.currentIfShortcutConditionPassed = true;
     s->as.currentConditionPassed = false; //otherwise following conditions would be skipped
-    return processCommand(arg, argEnd);
+    return processCommand(ctx);
+}
+
+uint8_t Macros_TryConsumeKeyId(parser_context_t* ctx)
+{
+    uint8_t keyId = MacroKeyIdParser_TryConsumeKeyId(ctx);
+
+    if (keyId == 255 && isNUM(ctx)) {
+        return Macros_LegacyConsumeInt(ctx);
+    } else {
+        return keyId;
+    }
 }
 
-static macro_result_t processAutoRepeatCommand(const char* arg1, const char* argEnd) {
+static macro_result_t processAutoRepeatCommand(parser_context_t* ctx) {
     if (Macros_DryRun) {
-        return processCommand(arg1, argEnd);;
+        return processCommand(ctx);;
     }
 
     switch (s->ms.autoRepeatPhase) {
@@ -2373,7 +2495,7 @@ process_delay:;
 
 
 run_command:;
-    macro_result_t res = processCommand(arg1, argEnd);
+    macro_result_t res = processCommand(ctx);
     if (res & MacroResult_ActionFinishedFlag) {
         s->ms.autoRepeatPhase = AutoRepeatState_Waiting;
         //tidy the state in case someone left it dirty
@@ -2390,9 +2512,9 @@ run_command:;
 }
 
 
-static macro_result_t processOneShotCommand(const char* arg1, const char* argEnd) {
+static macro_result_t processOneShotCommand(parser_context_t* ctx) {
     if (Macros_DryRun) {
-        return processCommand(arg1, argEnd);
+        return processCommand(ctx);
     }
 
     /* In order for modifiers of a scancode action to be applied properly, we need to
@@ -2408,7 +2530,7 @@ static macro_result_t processOneShotCommand(const char* arg1, const char* argEnd
     } else {
         s->ms.oneShotState = 0;
     }
-    macro_result_t res = processCommand(arg1, argEnd);
+    macro_result_t res = processCommand(ctx);
     if (res & MacroResult_ActionFinishedFlag || res & MacroResult_DoneFlag) {
         s->ms.oneShotState = 0;
     }
@@ -2419,9 +2541,9 @@ static macro_result_t processOneShotCommand(const char* arg1, const char* argEnd
     }
 }
 
-static macro_result_t processOverlayKeymapCommand(const char* arg1, const char* argEnd)
+static macro_result_t processOverlayKeymapCommand(parser_context_t* ctx)
 {
-    uint8_t srcKeymapId = parseKeymapId(arg1, argEnd);
+    uint8_t srcKeymapId = consumeKeymapId(ctx);
 
     if (Macros_ParserError) {
         return MacroResult_Finished;
@@ -2434,13 +2556,11 @@ static macro_result_t processOverlayKeymapCommand(const char* arg1, const char*
     return MacroResult_Finished;
 }
 
-static macro_result_t processReplaceLayerCommand(const char* arg1, const char* argEnd)
+static macro_result_t processReplaceLayerCommand(parser_context_t* ctx)
 {
-    const char* arg2 = NextTok(arg1, argEnd);
-    const char* arg3 = NextTok(arg2, argEnd);
-    layer_id_t dstLayerId = Macros_ParseLayerId(arg1, argEnd);
-    uint8_t srcKeymapId = parseKeymapId(arg2, argEnd);
-    layer_id_t srcLayerId = Macros_ParseLayerId(arg3, argEnd);
+    layer_id_t dstLayerId = Macros_ConsumeLayerId(ctx);
+    uint8_t srcKeymapId = consumeKeymapId(ctx);
+    layer_id_t srcLayerId = Macros_ConsumeLayerId(ctx);
 
     if (Macros_ParserError) {
         return MacroResult_Finished;
@@ -2453,13 +2573,11 @@ static macro_result_t processReplaceLayerCommand(const char* arg1, const char* a
     return MacroResult_Finished;
 }
 
-static macro_result_t processOverlayLayerCommand(const char* arg1, const char* argEnd)
+static macro_result_t processOverlayLayerCommand(parser_context_t* ctx)
 {
-    const char* arg2 = NextTok(arg1, argEnd);
-    const char* arg3 = NextTok(arg2, argEnd);
-    layer_id_t dstLayerId = Macros_ParseLayerId(arg1, argEnd);
-    uint8_t srcKeymapId = parseKeymapId(arg2, argEnd);
-    layer_id_t srcLayerId = Macros_ParseLayerId(arg3, argEnd);
+    layer_id_t dstLayerId = Macros_ConsumeLayerId(ctx);
+    uint8_t srcKeymapId = consumeKeymapId(ctx);
+    layer_id_t srcLayerId = Macros_ConsumeLayerId(ctx);
 
     if (Macros_ParserError) {
         return MacroResult_Finished;
@@ -2472,11 +2590,10 @@ static macro_result_t processOverlayLayerCommand(const char* arg1, const char* a
     return MacroResult_Finished;
 }
 
-static bool processIfKeyPendingAtCommand(bool negate, const char* arg1, const char* argEnd)
+static bool processIfKeyPendingAtCommand(parser_context_t* ctx, bool negate)
 {
-    const char* arg2 = NextTok(arg1, argEnd);
-    uint16_t idx = parseNUM(arg1, argEnd);
-    uint16_t key = parseNUM(arg2, argEnd);
+    uint16_t idx = Macros_LegacyConsumeInt(ctx);
+    uint16_t key = Macros_LegacyConsumeInt(ctx);
 
     if (Macros_DryRun) {
         return true;
@@ -2485,9 +2602,9 @@ static bool processIfKeyPendingAtCommand(bool negate, const char* arg1, const ch
     return (PostponerExtended_PendingId(idx) == key) != negate;
 }
 
-static bool processIfKeyActiveCommand(bool negate, const char* arg1, const char* argEnd)
+static bool processIfKeyActiveCommand(parser_context_t* ctx, bool negate)
 {
-    uint16_t keyid = parseNUM(arg1, argEnd);
+    uint16_t keyid = Macros_LegacyConsumeInt(ctx);
     key_state_t* key = Utils_KeyIdToKeyState(keyid);
     if (Macros_DryRun) {
         return true;
@@ -2495,18 +2612,18 @@ static bool processIfKeyActiveCommand(bool negate, const char* arg1, const char*
     return KeyState_Active(key) != negate;
 }
 
-static bool processIfPendingKeyReleasedCommand(bool negate, const char* arg1, const char* argEnd)
+static bool processIfPendingKeyReleasedCommand(parser_context_t* ctx, bool negate)
 {
-    uint16_t idx = parseNUM(arg1, argEnd);
+    uint16_t idx = Macros_LegacyConsumeInt(ctx);
     if (Macros_DryRun) {
         return true;
     }
     return PostponerExtended_IsPendingKeyReleased(idx) != negate;
 }
 
-static bool processIfKeyDefinedCommand(bool negate, const char* arg1, const char* argEnd)
+static bool processIfKeyDefinedCommand(parser_context_t* ctx, bool negate)
 {
-    uint16_t keyid = parseNUM(arg1, argEnd);
+    uint16_t keyid = Macros_LegacyConsumeInt(ctx);
     if (Macros_DryRun) {
         return true;
     }
@@ -2517,7 +2634,7 @@ static bool processIfKeyDefinedCommand(bool negate, const char* arg1, const char
     return (action->type != KeyActionType_None) != negate;
 }
 
-static macro_result_t processActivateKeyPostponedCommand(const char* arg1, const char* argEnd)
+static macro_result_t processActivateKeyPostponedCommand(parser_context_t* ctx)
 {
     uint8_t layer = 255;
     bool options = true;
@@ -2525,25 +2642,21 @@ static macro_result_t processActivateKeyPostponedCommand(const char* arg1, const
 
     while (options) {
         options = false;
-        if (TokenMatches(arg1, argEnd, "atLayer")) {
-            const char* arg2 = NextTok(arg1, argEnd);
-            layer = Macros_ParseLayerId(arg2, argEnd);
-            arg1 = NextTok(arg2, argEnd);
+        if (ConsumeToken(ctx, "atLayer")) {
+            layer = Macros_ConsumeLayerId(ctx);
             options = true;
         }
-        if (TokenMatches(arg1, argEnd, "append")) {
-            arg1 = NextTok(arg1, argEnd);
+        if (ConsumeToken(ctx, "append")) {
             append = true;
             options = true;
         }
-        if (TokenMatches(arg1, argEnd, "prepend")) {
-            arg1 = NextTok(arg1, argEnd);
+        if (ConsumeToken(ctx, "prepend")) {
             append = false;
             options = true;
         }
     }
 
-    uint16_t keyid = parseNUM(arg1, argEnd);
+    uint16_t keyid = Macros_LegacyConsumeInt(ctx);
     key_state_t* key = Utils_KeyIdToKeyState(keyid);
 
     if (Macros_ParserError) {
@@ -2574,9 +2687,9 @@ static macro_result_t processActivateKeyPostponedCommand(const char* arg1, const
     return MacroResult_Finished;
 }
 
-static macro_result_t processConsumePendingCommand(const char* arg1, const char* argEnd)
+static macro_result_t processConsumePendingCommand(parser_context_t* ctx)
 {
-    uint16_t cnt = parseNUM(arg1, argEnd);
+    uint16_t cnt = Macros_LegacyConsumeInt(ctx);
     if (Macros_DryRun) {
         return MacroResult_Finished;
     }
@@ -2584,9 +2697,9 @@ static macro_result_t processConsumePendingCommand(const char* arg1, const char*
     return MacroResult_Finished;
 }
 
-static macro_result_t processPostponeNextNCommand(const char* arg1, const char* argEnd)
+static macro_result_t processPostponeNextNCommand(parser_context_t* ctx)
 {
-    uint16_t cnt = parseNUM(arg1, argEnd);
+    uint16_t cnt = Macros_LegacyConsumeInt(ctx);
     if (Macros_DryRun) {
         return MacroResult_Finished;
     }
@@ -2596,19 +2709,30 @@ static macro_result_t processPostponeNextNCommand(const char* arg1, const char*
 }
 
 
-static macro_result_t processRepeatForCommand(const char* arg1, const char* argEnd)
+static macro_result_t processRepeatForCommand(parser_context_t* ctx)
 {
-    uint8_t idx = parseNUM(arg1, argEnd);
-    const char* adr = NextTok(arg1, argEnd);
-    bool regIsValid = validReg(idx, arg1);
-    if (Macros_DryRun) {
-        return MacroResult_Finished;
-    }
-    if (regIsValid) {
-        if (regs[idx] > 0) {
-            regs[idx]--;
+    if (isNUM(ctx)) {
+        uint8_t idx = Macros_LegacyConsumeInt(ctx);
+        bool regIsValid = validReg(idx, ctx->at);
+        if (Macros_DryRun) {
+            return MacroResult_Finished;
+        }
+        if (regIsValid) {
             if (regs[idx] > 0) {
-                return goTo(adr, argEnd);
+                regs[idx]--;
+                if (regs[idx] > 0) {
+                    return goTo(ctx);
+                }
+            }
+        }
+    } else {
+        macro_variable_t* v = Macros_ConsumeExistingWritableVariable(ctx);
+        if (v != NULL) {
+            if (v->asInt > 0) {
+                v->asInt--;
+                if (v->asInt > 0) {
+                    return goTo(ctx);
+                }
             }
         }
     }
@@ -2624,37 +2748,45 @@ static macro_result_t processResetTrackpointCommand()
     return MacroResult_Finished;
 }
 
-static macro_result_t processExecCommand(const char* arg1, const char* cmdEnd)
+static uint8_t consumeMacroIndexByName(parser_context_t* ctx)
+{
+    const char* end = TokEnd(ctx->at, ctx->end);
+    uint8_t macroIndex = FindMacroIndexByName(ctx->at, end, true);
+    ctx->at = end;
+    ConsumeWhite(ctx);
+    return macroIndex;
+}
+
+static macro_result_t processExecCommand(parser_context_t* ctx)
 {
-    uint8_t macroIndex = FindMacroIndexByName(arg1, TokEnd(arg1, cmdEnd), true);
+    uint8_t macroIndex = consumeMacroIndexByName(ctx);
     if (Macros_DryRun) {
         return MacroResult_Finished;
     }
     return execMacro(macroIndex);
 }
 
-static macro_result_t processCallCommand(const char* arg1, const char* cmdEnd)
+static macro_result_t processCallCommand(parser_context_t* ctx)
 {
-    uint8_t macroIndex = FindMacroIndexByName(arg1, TokEnd(arg1, cmdEnd), true);
+    uint8_t macroIndex = consumeMacroIndexByName(ctx);
     if (Macros_DryRun) {
         return MacroResult_Finished;
     }
     return callMacro(macroIndex);
 }
 
-static macro_result_t processForkCommand(const char* arg1, const char* cmdEnd)
+static macro_result_t processForkCommand(parser_context_t* ctx)
 {
-    uint8_t macroIndex = FindMacroIndexByName(arg1, TokEnd(arg1, cmdEnd), true);
+    uint8_t macroIndex = consumeMacroIndexByName(ctx);
     if (Macros_DryRun) {
         return MacroResult_Finished;
     }
     return forkMacro(macroIndex);
 }
 
-
-static macro_result_t processFinalCommand(const char* arg1, const char* cmdEnd)
+static macro_result_t processFinalCommand(parser_context_t* ctx)
 {
-    macro_result_t res = processCommand(arg1, cmdEnd);
+    macro_result_t res = processCommand(ctx);
 
     if (Macros_DryRun) {
         return MacroResult_Finished;
@@ -2706,39 +2838,48 @@ static macro_result_t processProgressHueCommand()
 #undef C
 }
 
-static macro_result_t processCommand(const char* cmd, const char* cmdEnd)
+static macro_result_t processValidateUserConfigCommand(parser_context_t* ctx)
+{
+    if (Macros_DryRun) {
+        return MacroResult_Finished;
+    }
+
+    Macros_ValidateAllMacros();
+    return MacroResult_Finished;
+}
+
+static macro_result_t processCommand(parser_context_t* ctx)
 {
-    if (*cmd == '$') {
-        cmd++;
+    if (*ctx->at == '$') {
+        ctx->at++;
     }
 
-    const char* cmdTokEnd = TokEnd(cmd, cmdEnd);
-    if (cmdTokEnd > cmd && cmdTokEnd[-1] == ':') {
+    const char* cmdTokEnd = TokEnd(ctx->at, ctx->end);
+    if (cmdTokEnd > ctx->at && cmdTokEnd[-1] == ':') {
         //skip labels
-        cmd = NextTok(cmd, cmdEnd);
-        if (cmd == cmdEnd) {
+        ctx->at = NextTok(ctx->at, ctx->end);
+        if (ctx->at == ctx->end) {
             return MacroResult_Finished;
         }
     }
-    while(*cmd && cmd < cmdEnd) {
-        const char* arg1 = NextTok(cmd, cmdEnd);
-        switch(*cmd) {
+    while(ctx->at < ctx->end) {
+        switch(*ctx->at) {
         case 'a':
-            if (TokenMatches(cmd, cmdEnd, "addReg")) {
-                return processRegAddCommand(arg1, cmdEnd, false);
+            if (ConsumeToken(ctx, "addReg")) {
+                return processRegAddCommand(ctx, false);
             }
-            else if (TokenMatches(cmd, cmdEnd, "activateKeyPostponed")) {
-                return processActivateKeyPostponedCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "activateKeyPostponed")) {
+                return processActivateKeyPostponedCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "autoRepeat")) {
-                return processAutoRepeatCommand(NextTok(cmd, cmdEnd), cmdEnd);
+            else if (ConsumeToken(ctx, "autoRepeat")) {
+                return processAutoRepeatCommand(ctx);
             }
             else {
                 goto failed;
             }
             break;
         case 'b':
-            if (TokenMatches(cmd, cmdEnd, "break")) {
+            if (ConsumeToken(ctx, "break")) {
                 return processBreakCommand();
             }
             else {
@@ -2746,30 +2887,30 @@ static macro_result_t processCommand(const char* cmd, const char* cmdEnd)
             }
             break;
         case 'c':
-            if (TokenMatches(cmd, cmdEnd, "consumePending")) {
-                return processConsumePendingCommand(arg1, cmdEnd);
+            if (ConsumeToken(ctx, "consumePending")) {
+                return processConsumePendingCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "clearStatus")) {
+            else if (ConsumeToken(ctx, "clearStatus")) {
                 return processClearStatusCommand();
             }
-            else if (TokenMatches(cmd, cmdEnd, "call")) {
-                return processCallCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "call")) {
+                return processCallCommand(ctx);
             }
             else {
                 goto failed;
             }
             break;
         case 'd':
-            if (TokenMatches(cmd, cmdEnd, "delayUntilRelease")) {
+            if (ConsumeToken(ctx, "delayUntilRelease")) {
                 return processDelayUntilReleaseCommand();
             }
-            else if (TokenMatches(cmd, cmdEnd, "delayUntilReleaseMax")) {
-                return processDelayUntilReleaseMaxCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "delayUntilReleaseMax")) {
+                return processDelayUntilReleaseMaxCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "delayUntil")) {
-                return processDelayUntilCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "delayUntil")) {
+                return processDelayUntilCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "diagnose")) {
+            else if (ConsumeToken(ctx, "diagnose")) {
                 return processDiagnoseCommand();
             }
             else {
@@ -2777,361 +2918,320 @@ static macro_result_t processCommand(const char* cmd, const char* cmdEnd)
             }
             break;
         case 'e':
-            if (TokenMatches(cmd, cmdEnd, "exec")) {
-                return processExecCommand(arg1, cmdEnd);
+            if (ConsumeToken(ctx, "exec")) {
+                return processExecCommand(ctx);
             }
             else {
                 goto failed;
             }
             break;
         case 'f':
-            if (TokenMatches(cmd, cmdEnd, "final")) {
-                return processFinalCommand(arg1, cmdEnd);
+            if (ConsumeToken(ctx, "final")) {
+                return processFinalCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "fork")) {
-                return processForkCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "fork")) {
+                return processForkCommand(ctx);
             }
             else {
                 goto failed;
             }
             break;
         case 'g':
-            if (TokenMatches(cmd, cmdEnd, "goTo")) {
-                return processGoToCommand(arg1, cmdEnd);
+            if (ConsumeToken(ctx, "goTo")) {
+                return processGoToCommand(ctx);
             }
             else {
                 goto failed;
             }
             break;
         case 'h':
-            if (TokenMatches(cmd, cmdEnd, "holdLayer")) {
-                return processHoldLayerCommand(arg1, cmdEnd);
+            if (ConsumeToken(ctx, "holdLayer")) {
+                return processHoldLayerCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "holdLayerMax")) {
-                return processHoldLayerMaxCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "holdLayerMax")) {
+                return processHoldLayerMaxCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "holdKeymapLayer")) {
-                return processHoldKeymapLayerCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "holdKeymapLayer")) {
+                return processHoldKeymapLayerCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "holdKeymapLayerMax")) {
-                return processHoldKeymapLayerMaxCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "holdKeymapLayerMax")) {
+                return processHoldKeymapLayerMaxCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "holdKey")) {
-                return processKeyCommand(MacroSubAction_Hold, arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "holdKey")) {
+                return processKeyCommandAndConsume(ctx, MacroSubAction_Hold);
             }
             else {
                 goto failed;
             }
             break;
         case 'i':
-            if (TokenMatches(cmd, cmdEnd, "ifDoubletap")) {
+            if (ConsumeToken(ctx, "if")) {
+                if (!processIfCommand(ctx) && !s->as.currentConditionPassed) {
+                    return MacroResult_Finished;
+                }
+            }
+            else if (ConsumeToken(ctx, "ifDoubletap")) {
                 if (!processIfDoubletapCommand(false) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotDoubletap")) {
+            else if (ConsumeToken(ctx, "ifNotDoubletap")) {
                 if (!processIfDoubletapCommand(true) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifInterrupted")) {
+            else if (ConsumeToken(ctx, "ifInterrupted")) {
                 if (!processIfInterruptedCommand(false) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotInterrupted")) {
+            else if (ConsumeToken(ctx, "ifNotInterrupted")) {
                 if (!processIfInterruptedCommand(true) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifReleased")) {
+            else if (ConsumeToken(ctx, "ifReleased")) {
                 if (!processIfReleasedCommand(false) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotReleased")) {
+            else if (ConsumeToken(ctx, "ifNotReleased")) {
                 if (!processIfReleasedCommand(true) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifRegEq")) {
-                if (!processIfRegEqCommand(false, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifRegEq")) {
+                if (!processIfRegEqCommand(ctx, false) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                cmd = NextTok(arg1, cmdEnd); //shift by 2
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotRegEq")) {
-                if (!processIfRegEqCommand(true, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifNotRegEq")) {
+                if (!processIfRegEqCommand(ctx, true) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                cmd = NextTok(arg1, cmdEnd); //shift by 2
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifRegGt")) {
-                if (!processIfRegInequalityCommand(true, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifRegGt")) {
+                if (!processIfRegInequalityCommand(ctx, true) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                cmd = NextTok(arg1, cmdEnd); //shift by 2
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifRegLt")) {
-                if (!processIfRegInequalityCommand(false, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifRegLt")) {
+                if (!processIfRegInequalityCommand(ctx, false) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                cmd = NextTok(arg1, cmdEnd); //shift by 2
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifKeymap")) {
-                if (!processIfKeymapCommand(false, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifKeymap")) {
+                if (!processIfKeymapCommand(ctx, false) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                cmd = arg1; //shift by 1
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotKeymap")) {
-                if (!processIfKeymapCommand(true, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifNotKeymap")) {
+                if (!processIfKeymapCommand(ctx, true) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                cmd = arg1; //shift by 1
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifLayer")) {
-                if (!processIfLayerCommand(false, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifLayer")) {
+                if (!processIfLayerCommand(ctx, false) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                cmd = arg1; //shift by 1
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotLayer")) {
-                if (!processIfLayerCommand(true, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifNotLayer")) {
+                if (!processIfLayerCommand(ctx, true) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                cmd = arg1; //shift by 1
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifPlaytime")) {
-                if (!processIfPlaytimeCommand(false, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifPlaytime")) {
+                if (!processIfPlaytimeCommand(ctx, false) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                cmd = arg1;  //shift by 1
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotPlaytime")) {
-                if (!processIfPlaytimeCommand(true, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifNotPlaytime")) {
+                if (!processIfPlaytimeCommand(ctx, true) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                cmd = arg1;
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifAnyMod")) {
+            else if (ConsumeToken(ctx, "ifAnyMod")) {
                 if (!processIfModifierCommand(false, 0xFF)  && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotAnyMod")) {
+            else if (ConsumeToken(ctx, "ifNotAnyMod")) {
                 if (!processIfModifierCommand(true, 0xFF)  && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifShift")) {
+            else if (ConsumeToken(ctx, "ifShift")) {
                 if (!processIfModifierCommand(false, SHIFTMASK)  && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotShift")) {
+            else if (ConsumeToken(ctx, "ifNotShift")) {
                 if (!processIfModifierCommand(true, SHIFTMASK) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifCtrl")) {
+            else if (ConsumeToken(ctx, "ifCtrl")) {
                 if (!processIfModifierCommand(false, CTRLMASK) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotCtrl")) {
+            else if (ConsumeToken(ctx, "ifNotCtrl")) {
                 if (!processIfModifierCommand(true, CTRLMASK) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifAlt")) {
+            else if (ConsumeToken(ctx, "ifAlt")) {
                 if (!processIfModifierCommand(false, ALTMASK) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotAlt")) {
+            else if (ConsumeToken(ctx, "ifNotAlt")) {
                 if (!processIfModifierCommand(true, ALTMASK) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifGui")) {
+            else if (ConsumeToken(ctx, "ifGui")) {
                 if (!processIfModifierCommand(false, GUIMASK)  && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotGui")) {
+            else if (ConsumeToken(ctx, "ifNotGui")) {
                 if (!processIfModifierCommand(true, GUIMASK) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifCapsLockOn")) {
+            else if (ConsumeToken(ctx, "ifCapsLockOn")) {
                 if (!processIfStateKeyCommand(false, &UsbBasicKeyboard_CapsLockOn) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotCapsLockOn")) {
+            else if (ConsumeToken(ctx, "ifNotCapsLockOn")) {
                 if (!processIfStateKeyCommand(true, &UsbBasicKeyboard_CapsLockOn) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNumLockOn")) {
+            else if (ConsumeToken(ctx, "ifNumLockOn")) {
                 if (!processIfStateKeyCommand(false, &UsbBasicKeyboard_NumLockOn) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotNumLockOn")) {
+            else if (ConsumeToken(ctx, "ifNotNumLockOn")) {
                 if (!processIfStateKeyCommand(true, &UsbBasicKeyboard_NumLockOn) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifScrollLockOn")) {
+            else if (ConsumeToken(ctx, "ifScrollLockOn")) {
                 if (!processIfStateKeyCommand(false, &UsbBasicKeyboard_ScrollLockOn) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotScrollLockOn")) {
+            else if (ConsumeToken(ctx, "ifNotScrollLockOn")) {
                 if (!processIfStateKeyCommand(true, &UsbBasicKeyboard_ScrollLockOn) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifRecording")) {
+            else if (ConsumeToken(ctx, "ifRecording")) {
                 if (!processIfRecordingCommand(false) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotRecording")) {
+            else if (ConsumeToken(ctx, "ifNotRecording")) {
                 if (!processIfRecordingCommand(true) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifRecordingId")) {
-                if (!processIfRecordingIdCommand(false, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifRecordingId")) {
+                if (!processIfRecordingIdCommand(ctx, false) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                cmd = arg1;
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotRecordingId")) {
-                if (!processIfRecordingIdCommand(true, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifNotRecordingId")) {
+                if (!processIfRecordingIdCommand(ctx, true) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                cmd = arg1;
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotPending")) {
-                if (!processIfPendingCommand(true, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifNotPending")) {
+                if (!processIfPendingCommand(ctx, true) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                cmd = arg1;
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifPending")) {
-                if (!processIfPendingCommand(false, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifPending")) {
+                if (!processIfPendingCommand(ctx, false) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                cmd = arg1;
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifKeyPendingAt")) {
-                if (!processIfKeyPendingAtCommand(false, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifKeyPendingAt")) {
+                if (!processIfKeyPendingAtCommand(ctx, false) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                //shift by two
-                cmd = NextTok(arg1, cmdEnd);
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotKeyPendingAt")) {
-                if (!processIfKeyPendingAtCommand(true, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifNotKeyPendingAt")) {
+                if (!processIfKeyPendingAtCommand(ctx, true) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                //shift by two
-                cmd = NextTok(arg1, cmdEnd);
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifKeyActive")) {
-                if (!processIfKeyActiveCommand(false, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifKeyActive")) {
+                if (!processIfKeyActiveCommand(ctx, false) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                cmd = arg1;
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotKeyActive")) {
-                if (!processIfKeyActiveCommand(true, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifNotKeyActive")) {
+                if (!processIfKeyActiveCommand(ctx, true) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                cmd = arg1;
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifPendingKeyReleased")) {
-                if (!processIfPendingKeyReleasedCommand(false, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifPendingKeyReleased")) {
+                if (!processIfPendingKeyReleasedCommand(ctx, false) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                cmd = arg1;
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotPendingKeyReleased")) {
-                if (!processIfPendingKeyReleasedCommand(true, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifNotPendingKeyReleased")) {
+                if (!processIfPendingKeyReleasedCommand(ctx, true) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                cmd = arg1;
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifKeyDefined")) {
-                if (!processIfKeyDefinedCommand(false, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifKeyDefined")) {
+                if (!processIfKeyDefinedCommand(ctx, false) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                cmd = arg1;
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotKeyDefined")) {
-                if (!processIfKeyDefinedCommand(true, arg1, cmdEnd) && !s->as.currentConditionPassed) {
+            else if (ConsumeToken(ctx, "ifNotKeyDefined")) {
+                if (!processIfKeyDefinedCommand(ctx, true) && !s->as.currentConditionPassed) {
                     return MacroResult_Finished;
                 }
-                cmd = arg1;
-                arg1 = NextTok(cmd, cmdEnd);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifSecondary")) {
-                return processIfSecondaryCommand(false, arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "ifSecondary")) {
+                return processIfSecondaryCommand(ctx, false);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifPrimary")) {
-                return processIfSecondaryCommand(true, arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "ifPrimary")) {
+                return processIfSecondaryCommand(ctx, true);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifShortcut")) {
-                return processIfShortcutCommand(false, arg1, cmdEnd, true);
+            else if (ConsumeToken(ctx, "ifShortcut")) {
+                return processIfShortcutCommand(ctx, false, true);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotShortcut")) {
-                return processIfShortcutCommand(true, arg1, cmdEnd, true);
+            else if (ConsumeToken(ctx, "ifNotShortcut")) {
+                return processIfShortcutCommand(ctx, true, true);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifGesture")) {
-                return processIfShortcutCommand(false, arg1, cmdEnd, false);
+            else if (ConsumeToken(ctx, "ifGesture")) {
+                return processIfShortcutCommand(ctx, false, false);
             }
-            else if (TokenMatches(cmd, cmdEnd, "ifNotGesture")) {
-                return processIfShortcutCommand(true, arg1, cmdEnd, false);
+            else if (ConsumeToken(ctx, "ifNotGesture")) {
+                return processIfShortcutCommand(ctx, true, false);
             }
             else {
                 goto failed;
             }
             break;
         case 'm':
-            if (TokenMatches(cmd, cmdEnd, "mulReg")) {
-                return processRegMulCommand(arg1, cmdEnd);
+            if (ConsumeToken(ctx, "mulReg")) {
+                return processRegMulCommand(ctx);
             }
             else {
                 goto failed;
             }
             break;
         case 'n':
-            if (TokenMatches(cmd, cmdEnd, "noOp")) {
+            if (ConsumeToken(ctx, "noOp")) {
                 return processNoOpCommand();
             }
             else {
@@ -3139,36 +3239,36 @@ static macro_result_t processCommand(const char* cmd, const char* cmdEnd)
             }
             break;
         case 'o':
-            if (TokenMatches(cmd, cmdEnd, "oneShot")) {
-                return processOneShotCommand(arg1, cmdEnd);
+            if (ConsumeToken(ctx, "oneShot")) {
+                return processOneShotCommand(ctx);
             }
-            if (TokenMatches(cmd, cmdEnd, "overlayLayer")) {
-                return processOverlayLayerCommand(arg1, cmdEnd);
+            if (ConsumeToken(ctx, "overlayLayer")) {
+                return processOverlayLayerCommand(ctx);
             }
-            if (TokenMatches(cmd, cmdEnd, "overlayKeymap")) {
-                return processOverlayKeymapCommand(arg1, cmdEnd);
+            if (ConsumeToken(ctx, "overlayKeymap")) {
+                return processOverlayKeymapCommand(ctx);
             }
             else {
                 goto failed;
             }
             break;
         case 'p':
-            if (TokenMatches(cmd, cmdEnd, "printStatus")) {
+            if (ConsumeToken(ctx, "printStatus")) {
                 return processPrintStatusCommand();
             }
-            else if (TokenMatches(cmd, cmdEnd, "playMacro")) {
-                return processPlayMacroCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "playMacro")) {
+                return processPlayMacroCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "pressKey")) {
-                return processKeyCommand(MacroSubAction_Press, arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "pressKey")) {
+                return processKeyCommandAndConsume(ctx, MacroSubAction_Press);
             }
-            else if (TokenMatches(cmd, cmdEnd, "postponeKeys")) {
+            else if (ConsumeToken(ctx, "postponeKeys")) {
                 processPostponeKeysCommand();
             }
-            else if (TokenMatches(cmd, cmdEnd, "postponeNext")) {
-                return processPostponeNextNCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "postponeNext")) {
+                return processPostponeNextNCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "progressHue")) {
+            else if (ConsumeToken(ctx, "progressHue")) {
                 return processProgressHueCommand();
             }
             else {
@@ -3176,111 +3276,114 @@ static macro_result_t processCommand(const char* cmd, const char* cmdEnd)
             }
             break;
         case 'r':
-            if (TokenMatches(cmd, cmdEnd, "recordMacro")) {
-                return processRecordMacroCommand(arg1, cmdEnd, false);
+            if (ConsumeToken(ctx, "recordMacro")) {
+                return processRecordMacroCommand(ctx, false);
             }
-            else if (TokenMatches(cmd, cmdEnd, "recordMacroBlind")) {
-                return processRecordMacroCommand(arg1, cmdEnd, true);
+            else if (ConsumeToken(ctx, "recordMacroBlind")) {
+                return processRecordMacroCommand(ctx, true);
             }
-            else if (TokenMatches(cmd, cmdEnd, "recordMacroDelay")) {
+            else if (ConsumeToken(ctx, "recordMacroDelay")) {
                 return processRecordMacroDelayCommand();
             }
-            else if (TokenMatches(cmd, cmdEnd, "resolveSecondary")) {
-                return processResolveSecondaryCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "resolveSecondary")) {
+                return processResolveSecondaryCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "resolveNextKeyId")) {
+            else if (ConsumeToken(ctx, "resolveNextKeyId")) {
                 return processResolveNextKeyIdCommand();
             }
-            else if (TokenMatches(cmd, cmdEnd, "resolveNextKeyEq")) {
-                return processResolveNextKeyEqCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "resolveNextKeyEq")) {
+                return processResolveNextKeyEqCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "releaseKey")) {
-                return processKeyCommand(MacroSubAction_Release, arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "releaseKey")) {
+                return processKeyCommandAndConsume(ctx, MacroSubAction_Release);
             }
-            else if (TokenMatches(cmd, cmdEnd, "repeatFor")) {
-                return processRepeatForCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "repeatFor")) {
+                return processRepeatForCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "resetTrackpoint")) {
+            else if (ConsumeToken(ctx, "resetTrackpoint")) {
                 return processResetTrackpointCommand();
             }
-            else if (TokenMatches(cmd, cmdEnd, "replaceLayer")) {
-                return processReplaceLayerCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "replaceLayer")) {
+                return processReplaceLayerCommand(ctx);
             }
             else {
                 goto failed;
             }
             break;
         case 's':
-            if (TokenMatches(cmd, cmdEnd, "setStatusPart")) {
-                return processSetStatusCommand(arg1, cmdEnd, false);
+            if (ConsumeToken(ctx, "setStatusPart")) {
+                return processSetStatusCommand(ctx, false);
+            }
+            else if (ConsumeToken(ctx, "set")) {
+                return Macro_ProcessSetCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "set")) {
-                return Macro_ProcessSetCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "setVar")) {
+                return Macros_ProcessSetVarCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "setStatus")) {
-                return processSetStatusCommand(arg1, cmdEnd, true);
+            else if (ConsumeToken(ctx, "setStatus")) {
+                return processSetStatusCommand(ctx, true);
             }
-            else if (TokenMatches(cmd, cmdEnd, "startRecording")) {
-                return processStartRecordingCommand(arg1, cmdEnd, false);
+            else if (ConsumeToken(ctx, "startRecording")) {
+                return processStartRecordingCommand(ctx, false);
             }
-            else if (TokenMatches(cmd, cmdEnd, "startRecordingBlind")) {
-                return processStartRecordingCommand(arg1, cmdEnd, true);
+            else if (ConsumeToken(ctx, "startRecordingBlind")) {
+                return processStartRecordingCommand(ctx, true);
             }
-            else if (TokenMatches(cmd, cmdEnd, "setLedTxt")) {
-                return processSetLedTxtCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "setLedTxt")) {
+                return processSetLedTxtCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "setReg")) {
-                return processSetRegCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "setReg")) {
+                return processSetRegCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "statsRuntime")) {
+            else if (ConsumeToken(ctx, "statsRuntime")) {
                 return processStatsRuntimeCommand();
             }
-            else if (TokenMatches(cmd, cmdEnd, "statsRecordKeyTiming")) {
+            else if (ConsumeToken(ctx, "statsRecordKeyTiming")) {
                 return processStatsRecordKeyTimingCommand();
             }
-            else if (TokenMatches(cmd, cmdEnd, "statsLayerStack")) {
+            else if (ConsumeToken(ctx, "statsLayerStack")) {
                 return processStatsLayerStackCommand();
             }
-            else if (TokenMatches(cmd, cmdEnd, "statsActiveKeys")) {
+            else if (ConsumeToken(ctx, "statsActiveKeys")) {
                 return processStatsActiveKeysCommand();
             }
-            else if (TokenMatches(cmd, cmdEnd, "statsActiveMacros")) {
+            else if (ConsumeToken(ctx, "statsActiveMacros")) {
                 return processStatsActiveMacrosCommand();
             }
-            else if (TokenMatches(cmd, cmdEnd, "statsRegs")) {
+            else if (ConsumeToken(ctx, "statsRegs")) {
                 return processStatsRegsCommand();
             }
-            else if (TokenMatches(cmd, cmdEnd, "statsPostponerStack")) {
+            else if (ConsumeToken(ctx, "statsPostponerStack")) {
                 return processStatsPostponerStackCommand();
             }
-            else if (TokenMatches(cmd, cmdEnd, "subReg")) {
-                return processRegAddCommand(arg1, cmdEnd, true);
+            else if (ConsumeToken(ctx, "subReg")) {
+                return processRegAddCommand(ctx, true);
             }
-            else if (TokenMatches(cmd, cmdEnd, "switchKeymap")) {
-                return processSwitchKeymapCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "switchKeymap")) {
+                return processSwitchKeymapCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "switchKeymapLayer")) {
-                return processSwitchKeymapLayerCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "switchKeymapLayer")) {
+                return processSwitchKeymapLayerCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "switchLayer")) {
-                return processSwitchLayerCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "switchLayer")) {
+                return processSwitchLayerCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "startMouse")) {
-                return processMouseCommand(true, arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "startMouse")) {
+                return processMouseCommand(ctx, true);
             }
-            else if (TokenMatches(cmd, cmdEnd, "stopMouse")) {
-                return processMouseCommand(false, arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "stopMouse")) {
+                return processMouseCommand(ctx, false);
             }
-            else if (TokenMatches(cmd, cmdEnd, "stopRecording")) {
+            else if (ConsumeToken(ctx, "stopRecording")) {
                 return processStopRecordingCommand();
             }
-            else if (TokenMatches(cmd, cmdEnd, "stopAllMacros")) {
+            else if (ConsumeToken(ctx, "stopAllMacros")) {
                 return processStopAllMacrosCommand();
             }
-            else if (TokenMatches(cmd, cmdEnd, "stopRecordingBlind")) {
+            else if (ConsumeToken(ctx, "stopRecordingBlind")) {
                 return processStopRecordingCommand();
             }
-            else if (TokenMatches(cmd, cmdEnd, "suppressMods")) {
+            else if (ConsumeToken(ctx, "suppressMods")) {
                 processSuppressModsCommand();
             }
             else {
@@ -3288,47 +3391,55 @@ static macro_result_t processCommand(const char* cmd, const char* cmdEnd)
             }
             break;
         case 't':
-            if (TokenMatches(cmd, cmdEnd, "toggleKeymapLayer")) {
-                return processToggleKeymapLayerCommand(arg1, cmdEnd);
+            if (ConsumeToken(ctx, "toggleKeymapLayer")) {
+                return processToggleKeymapLayerCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "toggleLayer")) {
-                return processToggleLayerCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "toggleLayer")) {
+                return processToggleLayerCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "tapKey")) {
-                return processKeyCommand(MacroSubAction_Tap, arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "tapKey")) {
+                return processKeyCommandAndConsume(ctx, MacroSubAction_Tap);
             }
-            else if (TokenMatches(cmd, cmdEnd, "tapKeySeq")) {
-                return processTapKeySeqCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "tapKeySeq")) {
+                return processTapKeySeqCommand(ctx);
             }
             else {
                 goto failed;
             }
             break;
         case 'u':
-            if (TokenMatches(cmd, cmdEnd, "unToggleLayer")) {
+            if (ConsumeToken(ctx, "unToggleLayer")) {
                 return processUnToggleLayerCommand();
             }
-            else if (TokenMatches(cmd, cmdEnd, "untoggleLayer")) {
+            else if (ConsumeToken(ctx, "untoggleLayer")) {
                 return processUnToggleLayerCommand();
             }
             else {
                 goto failed;
             }
             break;
+        case 'v':
+            if (ConsumeToken(ctx, "validateUserConfig")) {
+                return processValidateUserConfigCommand(ctx);
+            }
+            else {
+                goto failed;
+            }
+            break;
         case 'w':
-            if (TokenMatches(cmd, cmdEnd, "write")) {
-                return processWriteCommand(arg1, cmdEnd);
+            if (ConsumeToken(ctx, "write")) {
+                return processWriteCommand(ctx);
             }
-            else if (TokenMatches(cmd, cmdEnd, "writeExpr")) {
-                return processWriteExprCommand(arg1, cmdEnd);
+            else if (ConsumeToken(ctx, "writeExpr")) {
+                return processWriteExprCommand(ctx);
             }
             else {
                 goto failed;
             }
             break;
         case 'y':
-            if (TokenMatches(cmd, cmdEnd, "yield")) {
-                return processYieldCommand(arg1, cmdEnd);
+            if (ConsumeToken(ctx, "yield")) {
+                return processYieldCommand(ctx);
             }
             else {
                 goto failed;
@@ -3336,11 +3447,10 @@ static macro_result_t processCommand(const char* cmd, const char* cmdEnd)
             break;
         default:
         failed:
-            Macros_ReportError("Unrecognized command:", cmd, cmdEnd);
+            Macros_ReportError("Unrecognized command:", ctx->at, ctx->end);
             return MacroResult_Finished;
             break;
         }
-        cmd = arg1;
     }
     //this is reachable if there is a train of conditions/modifiers/labels without any command
     return MacroResult_Finished;
@@ -3359,7 +3469,9 @@ static macro_result_t processCommandAction(void)
     }
 
     macro_result_t actionInProgress;
-    actionInProgress = processCommand(cmd, cmdEnd);
+
+    parser_context_t ctx = { .macroState = s, .begin = cmd, .at = cmd, .end = cmdEnd };
+    actionInProgress = processCommand(&ctx);
 
     s->as.currentConditionPassed = actionInProgress & MacroResult_InProgressFlag;
     return actionInProgress;
@@ -3600,6 +3712,9 @@ uint8_t Macros_StartMacro(uint8_t index, key_state_t *keyState, uint8_t parentMa
 
 void Macros_ValidateAllMacros()
 {
+    macro_state_t* oldS = s;
+    scheduler_state_t schedulerState = scheduler;
+    memset(&scheduler, 0, sizeof scheduler);
     Macros_DryRun = true;
     for (uint8_t macroIndex = 0; macroIndex < AllMacrosCount; macroIndex++) {
         uint8_t slotIndex = initMacro(macroIndex, NULL, 255);
@@ -3624,6 +3739,8 @@ void Macros_ValidateAllMacros()
         s = NULL;
     }
     Macros_DryRun = false;
+    scheduler = schedulerState;
+    s = oldS;
 }
 
 uint8_t Macros_QueueMacro(uint8_t index, key_state_t *keyState, uint8_t queueAfterSlot)
diff --git a/right/src/macros.h b/right/src/macros.h
index 09e4c1571..5756eb8a3 100644
--- a/right/src/macros.h
+++ b/right/src/macros.h
@@ -5,15 +5,18 @@
 
     #include <stdint.h>
     #include <stdbool.h>
+    #include "attributes.h"
     #include "key_action.h"
     #include "usb_device_config.h"
     #include "key_states.h"
+    #include "str_utils.h"
+    #include "macros_core.h"
 
 // Macros:
     #define MACRO_CYCLES_TO_POSTPONE 4
 
     #define MAX_MACRO_NUM 255
-    #define STATUS_BUFFER_MAX_LENGTH 5000
+    #define STATUS_BUFFER_MAX_LENGTH 2000
     #define MACRO_STATE_POOL_SIZE 16
     #define MAX_REG_COUNT 32
 
@@ -60,20 +63,6 @@
         MacroActionType_Command,
     } macro_action_type_t;
 
-    typedef enum {
-        MacroResult_InProgressFlag = 1,
-        MacroResult_ActionFinishedFlag = 2,
-        MacroResult_DoneFlag = 4,
-        MacroResult_YieldFlag = 8,
-        MacroResult_BlockingFlag = 16,
-        MacroResult_Blocking = MacroResult_InProgressFlag | MacroResult_BlockingFlag,
-        MacroResult_Waiting = MacroResult_InProgressFlag | MacroResult_YieldFlag,
-        MacroResult_Sleeping = MacroResult_InProgressFlag | MacroResult_YieldFlag,
-        MacroResult_Finished = MacroResult_ActionFinishedFlag,
-        MacroResult_JumpedForward = MacroResult_DoneFlag,
-        MacroResult_JumpedBackward = MacroResult_DoneFlag | MacroResult_YieldFlag,
-    } macro_result_t;
-
     typedef struct {
         union {
             struct {
@@ -117,7 +106,10 @@
         AutoRepeatState_Waiting = 1
     } macro_autorepeat_state_t;
 
-    typedef struct {
+
+    typedef struct macro_state_t macro_state_t;
+
+    struct macro_state_t {
         // persistent scope data
         // these need to live in between macro calls
         struct {
@@ -165,6 +157,8 @@
             union {
                 struct {
                     uint16_t textIdx;
+                    uint16_t subIndex;
+                    uint16_t stringOffset;
                     enum {
                         REPORT_EMPTY = 0,
                         REPORT_PARTIAL,
@@ -199,7 +193,7 @@
             bool modifierSuppressMods : 1;
 
         } as;
-    }  macro_state_t;
+    };
 
     // Schedule is given by a single-linked circular list.
     typedef struct {
@@ -266,7 +260,10 @@
     bool Macros_IsLayerHeld();
     bool Macros_MacroHasActiveInstance(macro_index_t macroIdx);
     uint8_t Macros_ParseLayerId(const char* arg1, const char* cmdEnd);
+    uint8_t Macros_ConsumeLayerId(parser_context_t* ctx);
     int32_t Macros_ParseInt(const char *a, const char *aEnd, const char* *parsedTill);
+    int32_t Macros_LegacyConsumeInt(parser_context_t* ctx);
+    uint8_t Macros_TryConsumeKeyId(parser_context_t* ctx);
     bool Macros_ParseBoolean(const char *a, const char *aEnd);
     void Macros_ResetBasicKeyboardReports();
     char Macros_ConsumeStatusChar();
diff --git a/right/src/macros_core.h b/right/src/macros_core.h
new file mode 100644
index 000000000..7315c1dfd
--- /dev/null
+++ b/right/src/macros_core.h
@@ -0,0 +1,28 @@
+#ifndef __MACROS_CORE_H__
+#define __MACROS_CORE_H__
+
+// Includes:
+
+// Macros:
+
+// Typedefs:
+
+    typedef enum {
+        MacroResult_InProgressFlag = 1,
+        MacroResult_ActionFinishedFlag = 2,
+        MacroResult_DoneFlag = 4,
+        MacroResult_YieldFlag = 8,
+        MacroResult_BlockingFlag = 16,
+        MacroResult_Blocking = MacroResult_InProgressFlag | MacroResult_BlockingFlag,
+        MacroResult_Waiting = MacroResult_InProgressFlag | MacroResult_YieldFlag,
+        MacroResult_Sleeping = MacroResult_InProgressFlag | MacroResult_YieldFlag,
+        MacroResult_Finished = MacroResult_ActionFinishedFlag,
+        MacroResult_JumpedForward = MacroResult_DoneFlag,
+        MacroResult_JumpedBackward = MacroResult_DoneFlag | MacroResult_YieldFlag,
+    } macro_result_t;
+
+// Variables:
+
+// Functions:
+
+#endif
diff --git a/right/src/macros_string_reader.c b/right/src/macros_string_reader.c
new file mode 100644
index 000000000..dca90fcc2
--- /dev/null
+++ b/right/src/macros_string_reader.c
@@ -0,0 +1,228 @@
+#include "macros_string_reader.h"
+#include "macros.h"
+#include <stdint.h>
+#include <stdio.h>
+#include "macros_vars.h"
+
+typedef enum {
+   StringType_Raw,
+   StringType_DoubleQuote,
+   StringType_SingleQuote,
+} string_type_t;
+
+
+static char consumeExpressionCharOfInt(const macro_variable_t* variable, uint16_t* idx)
+{
+    char buffer[20];
+    sprintf(buffer, "%ld", variable->asInt);
+    char res = buffer[*idx];
+    if (buffer[*idx+1] == '\0') {
+        *idx = 0;
+    } else {
+        (*idx)++;
+    }
+    return res;
+}
+
+static char consumeExpressionCharOfFloat(const macro_variable_t* variable, uint16_t* idx)
+{
+    // printf in our library does not handle floats... so lets handle it manually
+    char buffer[20];
+    float value = variable->asFloat;
+
+    int integerPart = (int)value;
+    float fractionalPart = value - integerPart;
+    int8_t remainingPrecision = 3;
+    bool firstSignificantEncountered = false;
+
+    // Convert integer part to string
+    int index = 0;
+    do {
+        buffer[index++] = '0' + integerPart % 10;
+        firstSignificantEncountered |= integerPart;
+        integerPart /= 10;
+        remainingPrecision -= firstSignificantEncountered ? 1 : 0;
+    } while (integerPart > 0);
+
+    // Reverse the integer part in the buffer
+    for (int i = 0; i < index / 2; i++) {
+        char temp = buffer[i];
+        buffer[i] = buffer[index - i - 1];
+        buffer[index - i - 1] = temp;
+    }
+
+    // Add decimal point
+    buffer[index++] = '.';
+
+    remainingPrecision = MAX(1, remainingPrecision);
+
+    // Convert fractional part
+    while (remainingPrecision > 0) {
+        fractionalPart *= 10;
+        firstSignificantEncountered |= fractionalPart >= 1.0f;
+        int digit = (int)fractionalPart;
+        buffer[index++] = '0' + digit;
+        fractionalPart -= digit;
+        remainingPrecision -= firstSignificantEncountered ? 1 : 0;
+    }
+
+    // Null-terminate the string
+    buffer[index] = '\0';
+
+    char res = buffer[*idx];
+    if (buffer[*idx+1] == '\0') {
+        *idx = 0;
+    } else {
+        (*idx)++;
+    }
+    return res;
+}
+
+static char consumeExpressionCharOfBool(const macro_variable_t* variable, uint16_t* idx)
+{
+    if (variable->asBool) {
+        return '1';
+    } else {
+        return '0';
+    }
+}
+
+static char consumeExpressionChar(parser_context_t* ctx, uint16_t* index)
+{
+    macro_variable_t res = Macros_ConsumeAnyValue(ctx);
+    UnconsumeWhite(ctx);
+    char c;
+
+    switch (res.type) {
+        case MacroVariableType_Int:
+            c = consumeExpressionCharOfInt(&res, index);
+            break;
+        case MacroVariableType_Float:
+            c = consumeExpressionCharOfFloat(&res, index);
+            break;
+        case MacroVariableType_Bool:
+            c = consumeExpressionCharOfBool(&res, index);
+            break;
+        case MacroVariableType_None:
+            c = '?';
+            break;
+        default:
+            Macros_ReportErrorNum("Unrecognized variable type", res.type, ctx->at);
+            return '\0';
+    }
+
+    if (Macros_ParserError) {
+        ctx->at++;
+        *index = 0;
+    }
+    return c;
+}
+
+static char tryConsumeAnotherStringLiteral(parser_context_t* ctx, uint16_t* stringOffset, uint16_t* index, uint16_t* subIndex)
+{
+    const char* a = ctx->at;
+    const char* aEnd = ctx->end;
+    a += *stringOffset;
+    a += *index;
+
+    if (a == aEnd) {
+        return '\0';
+    }
+
+    switch (*a) {
+        case '\'':
+        case '"':
+            *stringOffset = *stringOffset + *index;
+            *index = 0;
+            return Macros_ConsumeCharOfString(ctx, stringOffset, index, subIndex);
+        default:
+            ctx->at = a;
+            ConsumeWhite(ctx);
+            *index = 0;
+            *stringOffset = 0;
+            *subIndex = 0;
+            return '\0';
+    }
+}
+
+char Macros_ConsumeCharOfString(parser_context_t* ctx, uint16_t* stringOffset, uint16_t* index, uint16_t* subIndex)
+{
+    const char* a = ctx->at;
+    const char* aEnd = ctx->end;
+
+    a += *stringOffset;
+
+    string_type_t stringType;
+    switch (*a) {
+        case '\'':
+            stringType = StringType_SingleQuote;
+            break;
+        case '"':
+            stringType = StringType_DoubleQuote;
+            break;
+        default:
+            stringType = StringType_Raw;
+            break;
+    }
+
+    if (*index == 0 && stringType != StringType_Raw) {
+        (*index)++;
+    }
+
+    a += *index;
+
+    if (a == aEnd) {
+        return '\0';
+    }
+
+    switch(*a) {
+        case '\\':
+            if (stringType == StringType_SingleQuote || a+1 == aEnd) {
+                goto normalChar;
+            } else {
+                (*index)++;
+                a++;
+                switch (*a) {
+                    case 'n':
+                        (*index)++;
+                        return '\n';
+                    default:
+                        (*index)++;
+                        return *a;
+                }
+            }
+        case '"':
+            if (stringType == StringType_DoubleQuote) {
+                a++;
+                (*index)++;
+                return tryConsumeAnotherStringLiteral(ctx, stringOffset, index, subIndex);
+            } else {
+                goto normalChar;
+            }
+        case '\'':
+            if (stringType == StringType_SingleQuote) {
+                a++;
+                (*index)++;
+                return tryConsumeAnotherStringLiteral(ctx, stringOffset, index, subIndex);
+            } else {
+                goto normalChar;
+            }
+        case '\n':
+            return '\0';
+        case '$':
+            if (stringType == StringType_SingleQuote) {
+                goto normalChar;
+            } else {
+                parser_context_t ctx2 = { .macroState = ctx->macroState, .begin = ctx->begin, .at = a, .end = aEnd };
+                char res = consumeExpressionChar(&ctx2, subIndex);
+                if (*subIndex == 0) {
+                    *index += ctx2.at - a;
+                }
+                return res;
+            }
+        default:
+        normalChar:
+            (*index)++;
+            return *a;
+    }
+}
diff --git a/right/src/macros_string_reader.h b/right/src/macros_string_reader.h
new file mode 100644
index 000000000..ce55a993c
--- /dev/null
+++ b/right/src/macros_string_reader.h
@@ -0,0 +1,31 @@
+#ifndef __MACROS_STRING_READER_H__
+#define __MACROS_STRING_READER_H__
+
+
+// Includes:
+
+    #include <stdint.h>
+    #include <stdbool.h>
+    #include "attributes.h"
+    #include "key_action.h"
+    #include "usb_device_config.h"
+    #include "key_states.h"
+    #include "str_utils.h"
+    #include "macros_core.h"
+
+// Macros:
+
+    #define MACRO_VARIABLE_COUNT_MAX 32
+
+// Typedefs:
+
+
+
+// Variables:
+
+// Functions:
+
+    char Macros_ConsumeCharOfString(parser_context_t* ctx, uint16_t* stringOffset, uint16_t* index, uint16_t* subIndex);
+
+#endif
+
diff --git a/right/src/macros_vars.c b/right/src/macros_vars.c
new file mode 100644
index 000000000..42e4beb74
--- /dev/null
+++ b/right/src/macros_vars.c
@@ -0,0 +1,787 @@
+#include "macros_vars.h"
+#include "postponer.h"
+#include "macro_keyid_parser.h"
+#include "utils.h"
+#include "str_utils.h"
+#include "macros.h"
+#include <stdint.h>
+#include <stdio.h>
+#include "config_parser/config_globals.h"
+#include "debug.h"
+#include "macro_set_command.h"
+
+typedef enum {
+    Operator_Add,
+    Operator_Sub,
+    Operator_Mul,
+    Operator_Div,
+    Operator_Mod,
+    Operator_And,
+    Operator_Or,
+    Operator_Gt,
+    Operator_Ge,
+    Operator_Lt,
+    Operator_Le,
+    Operator_Eq,
+    Operator_Ne,
+    Operator_Min,
+    Operator_Max,
+
+} operator_t;
+
+macro_variable_t macroVariables[MACRO_VARIABLE_COUNT_MAX];
+uint8_t macroVariableCount = 0;
+
+static macro_variable_t consumeParenthessExpression(parser_context_t* ctx);
+static macro_variable_t consumeValue(parser_context_t* ctx);
+static macro_variable_t negate(parser_context_t *ctx, macro_variable_t res);
+static macro_variable_t consumeMinMaxOperation(parser_context_t* ctx, operator_t op);
+static macro_variable_t negateBool(parser_context_t *ctx, macro_variable_t res);
+
+static macro_variable_t intVar(int32_t value)
+{
+    return (macro_variable_t) { .asInt = value, .type = MacroVariableType_Int };
+}
+
+static macro_variable_t boolVar(bool value)
+{
+    return (macro_variable_t) { .asBool = value, .type = MacroVariableType_Bool };
+}
+
+static macro_variable_t noneVar()
+{
+    return (macro_variable_t) { .asInt = 1, .type = MacroVariableType_None };
+}
+
+static macro_variable_t consumeNumericValue(parser_context_t* ctx)
+{
+    macro_variable_t res = { .type = MacroVariableType_Int, .asInt = 0 };
+
+    bool numFound = false;
+    while(*ctx->at > 47 && *ctx->at < 58 && ctx->at < ctx->end) {
+        res.asInt = res.asInt*10 + ((uint8_t)(*ctx->at))-48;
+        ctx->at++;
+        numFound = true;
+    }
+    if (*ctx->at == '.') {
+        res.type = MacroVariableType_Float;
+        res.asFloat = (float) res.asInt;
+        ctx->at++;
+
+        float b = 0.1;
+        while(*ctx->at > 47 && *ctx->at < 58 && ctx->at < ctx->end) {
+            res.asFloat += (((uint8_t)(*ctx->at))-48)*b;
+            b = b*0.1f;
+            ctx->at++;
+            numFound = true;
+        }
+    }
+    if (!numFound) {
+        Macros_ReportError("Numeric value expected", ctx->at, ctx->end);
+        return noneVar();
+    }
+
+    ConsumeWhite(ctx);
+    return res;
+}
+
+
+macro_variable_t* Macros_ConsumeExistingWritableVariable(parser_context_t* ctx)
+{
+    //TODO: optimize this!
+    for (uint8_t i = 0; i < macroVariableCount; i++) {
+        if (ConsumeIdentifierByRef(ctx, macroVariables[i].name)) {
+            return &macroVariables[i];
+        }
+    }
+    Macros_ReportError("Variable not found!", ctx->at, ctx->end);
+    return NULL;
+}
+
+// Expects <variable name>
+static macro_variable_t consumeVariable(parser_context_t* ctx)
+{
+    //TODO: handle indirection, e.g., `$$<variable name>`
+
+    if (Macros_DryRun) {
+        if (!IsIdentifierChar(*ctx->at)) {
+            Macros_ReportError("Identifier expected here:", ctx->at, ctx->at);
+            return noneVar();
+        }
+        ConsumeAnyIdentifier(ctx);
+        return (macro_variable_t){ .type = MacroVariableType_Int, .asInt = 1 };
+    }
+
+    //TODO: optimize this!
+    for (uint8_t i = 0; i < macroVariableCount; i++) {
+        if (ConsumeIdentifierByRef(ctx, macroVariables[i].name)) {
+            return macroVariables[i];
+        }
+    }
+
+    Macros_ReportError("Variable not found!", ctx->at, ctx->end);
+    ConsumeAnyIdentifier(ctx);
+    return (macro_variable_t){};
+}
+
+// Expects <variable name>
+static macro_variable_t* consumeVarAndAllocate(parser_context_t* ctx)
+{
+    //TODO: optimize this!
+    for (uint8_t i = 0; i < macroVariableCount; i++) {
+        if (ConsumeIdentifierByRef(ctx, macroVariables[i].name)) {
+            return &macroVariables[i];
+        }
+    }
+
+    parser_context_t bakCtx = *ctx;
+    macro_variable_t configVal = Macro_TryReadConfigVal(ctx);
+
+    if (configVal.type != MacroVariableType_None) {
+        Macros_ReportError("Name already taken by configuration value:", bakCtx.at,  bakCtx.end);
+        return NULL;
+    }
+
+    uint16_t len = IdentifierEnd(ctx) - ctx->at;
+    if (len > 255) {
+        Macros_ReportError("Variable name too long:", ctx->at,  ctx->end);
+        return NULL;
+    }
+
+    if (Macros_DryRun) {
+        ConsumeAnyIdentifier(ctx);
+        return NULL;
+    }
+
+    if (macroVariableCount == MACRO_VARIABLE_COUNT_MAX) {
+        Macros_ReportError("Too many variables. Can't allocate:", ctx->at, ctx->end);
+        ConsumeAnyIdentifier(ctx);
+        return NULL;
+    }
+
+
+    macro_variable_t* res = &macroVariables[macroVariableCount];
+    macroVariables[macroVariableCount].name = (string_ref_t) {
+        .offset = ctx->at - (const char*)ValidatedUserConfigBuffer.buffer,
+        .len = len
+    };
+    macroVariableCount++;
+    ctx->at += len;
+
+    ConsumeWhite(ctx);
+    return res;
+}
+
+static macro_variable_t coalesceType(parser_context_t* ctx, macro_variable_t value, macro_variable_type_t dstType)
+{
+    if (value.type == dstType) {
+        return value;
+    }
+
+    switch (dstType) {
+        case MacroVariableType_Int:
+            switch (value.type) {
+                case MacroVariableType_Int:
+                    value.asInt = value.asInt;
+                    break;
+                case MacroVariableType_Float:
+                    value.asInt = (int32_t)value.asFloat;
+                    break;
+                case MacroVariableType_Bool:
+                    value.asInt = value.asBool ? 1 : 0;
+                    break;
+                case MacroVariableType_None:
+                    break;
+                default:
+                    Macros_ReportErrorNum("Unexpected variable type:", value.type, NULL);
+                    break;
+            }
+            break;
+        case MacroVariableType_Float:
+            switch (value.type) {
+                case MacroVariableType_Int:
+                    value.asFloat = (float)value.asInt;
+                    break;
+                case MacroVariableType_Float:
+                    value.asFloat = value.asFloat;
+                    break;
+                case MacroVariableType_Bool:
+                    value.asFloat = value.asBool ? 1.0 : 0.0;
+                    break;
+                case MacroVariableType_None:
+                    break;
+                default:
+                    Macros_ReportErrorNum("Unexpected variable type:", value.type, NULL);
+                    break;
+            }
+            break;
+        case MacroVariableType_Bool:
+            switch (value.type) {
+                case MacroVariableType_Int:
+                    value.asBool = value.asInt != 0;
+                    break;
+                case MacroVariableType_Float:
+                    value.asBool = value.asFloat != 0.0f;
+                    break;
+                case MacroVariableType_Bool:
+                    value.asBool = !!value.asBool;
+                    break;
+                case MacroVariableType_None:
+                    break;
+                default:
+                    Macros_ReportErrorNum("Unexpected variable type:", value.type, NULL);
+                    break;
+            }
+            break;
+        case MacroVariableType_None:
+            break;
+        default:
+            Macros_ReportErrorNum("Unexpected variable type:", dstType, NULL);
+            break;
+    }
+    value.type = dstType;
+    return value;
+}
+
+static macro_variable_t consumeDollarExpression(parser_context_t* ctx)
+{
+    macro_variable_t res;
+    if (*ctx->at == '(') {
+        return consumeParenthessExpression(ctx);
+    }
+    else if (ConsumeToken(ctx, "thisKeyId")) {
+        return intVar(Utils_KeyStateToKeyId(ctx->macroState->ms.currentMacroKey));
+    }
+    else if (ConsumeToken(ctx, "currentAddress")) {
+        return intVar(ctx->macroState->ms.commandAddress);
+    }
+    else if (ConsumeToken(ctx, "queuedKeyId")) {
+        ConsumeUntilDot(ctx);
+        int8_t queueIdx = Macros_LegacyConsumeInt(ctx);
+        if (queueIdx >= PostponerQuery_PendingKeypressCount()) {
+            if (!Macros_DryRun) {
+                Macros_ReportError("Not enough pending keys! Note that this is zero-indexed!",  ConsumedToken(ctx), ConsumedToken(ctx));
+                return noneVar();
+            }
+            return intVar(0);
+        }
+        return intVar(PostponerExtended_PendingId(queueIdx));
+    }
+    else if (ConsumeToken(ctx, "keyId")) {
+        ConsumeUntilDot(ctx);
+        uint8_t keyId = MacroKeyIdParser_TryConsumeKeyId(ctx);
+        if (keyId == 255) {
+            Macros_ReportError("KeyId abbreviation expected", ctx->at, ctx->end);
+            return noneVar();
+        }
+        return intVar(keyId);
+    }
+    else if ((res = Macro_TryReadConfigVal(ctx)).type != MacroVariableType_None) {
+        return res;
+    } else {
+        return consumeVariable(ctx);
+    }
+}
+
+static macro_variable_t consumeValue(parser_context_t* ctx)
+{
+    switch (*ctx->at) {
+        case '+':
+            ConsumeWhiteAt(ctx, ctx->at+1);
+            return consumeValue(ctx);
+        case '-':
+            ConsumeWhiteAt(ctx, ctx->at+1);
+            return negate(ctx, consumeValue(ctx));
+        case '!':
+            ConsumeWhiteAt(ctx, ctx->at+1);
+            return negateBool(ctx, consumeValue(ctx));
+        case '.':
+        case '0' ... '9':
+            return consumeNumericValue(ctx);
+        case 'f':
+            if (ConsumeToken(ctx, "false")) {
+                return (macro_variable_t){ .type = MacroVariableType_Bool, .asBool = false };
+            }
+            else {
+                goto failed;
+            }
+        case 'm':
+            if (ConsumeToken(ctx, "min")) {
+                return consumeMinMaxOperation(ctx, Operator_Min);
+            }
+            else  if (ConsumeToken(ctx, "max")) {
+                return consumeMinMaxOperation(ctx, Operator_Max);
+            }
+            else {
+                goto failed;
+            }
+
+        case 't':
+            if (ConsumeToken(ctx, "true")) {
+                return (macro_variable_t){ .type = MacroVariableType_Bool, .asBool = true };
+            }
+            else {
+                goto failed;
+            }
+
+        case '$':
+            ctx->at++;
+            return consumeDollarExpression(ctx);
+        case '(':
+            return consumeParenthessExpression(ctx);
+        default:
+            goto failed;
+    }
+
+failed:
+    if (IsIdentifierChar(*ctx->at)) {
+        Macros_ReportErrorPrintf(ctx->at, "Parsing failed, did you mean '$%s'?", OneWord(ctx));
+    } else {
+        Macros_ReportError("Could not parse", ctx->at, ctx->end);
+    }
+    return noneVar();
+}
+
+static macro_variable_t negate(parser_context_t *ctx, macro_variable_t res)
+{
+    switch (res.type) {
+        case MacroVariableType_Int:
+            res.asInt = -res.asInt;
+            break;
+        case MacroVariableType_Float:
+            res.asFloat = -res.asFloat;
+            break;
+        case MacroVariableType_Bool:
+            res.asInt = -res.asBool;
+            res.type = MacroVariableType_Int;
+            break;
+        case MacroVariableType_None:
+            break;
+        default:
+            Macros_ReportErrorNum("Unexpected variable type:", res.type, ctx->at);
+            break;
+    }
+    return res;
+}
+
+
+static macro_variable_t negateBool(parser_context_t *ctx, macro_variable_t res)
+{
+    res = coalesceType(ctx, res, MacroVariableType_Bool);
+    res.asBool = !res.asBool;
+    return res;
+}
+
+static macro_variable_type_t determineCommonType(macro_variable_type_t a, macro_variable_type_t b)
+{
+    if (a == MacroVariableType_None || b == MacroVariableType_None) {
+        return MacroVariableType_None;
+    } else if (a == MacroVariableType_Float || b == MacroVariableType_Float) {
+        return MacroVariableType_Float;
+    } else if (a == MacroVariableType_Int || b == MacroVariableType_Int) {
+        return MacroVariableType_Int;
+    } else {
+        return MacroVariableType_Int;
+    }
+}
+
+static float computeFloatOperation(float a, operator_t op, parser_context_t* opCtx, float b)
+{
+    switch (op) {
+        case Operator_Add:
+            return a+b;
+        case Operator_Sub:
+            return a-b;
+        case Operator_Mul:
+            return a*b;
+        case Operator_Div:
+            if (b == 0.0f) {
+                Macros_ReportError("Division by zero attempted!", opCtx->at, opCtx->at);
+                return 0;
+            }
+            return a/b;
+        case Operator_Mod:
+            Macros_ReportError("Modulo is not supported for floats!", opCtx->at, opCtx->at);
+            return 1.0f;
+        case Operator_Min:
+            return MIN(a, b);
+        case Operator_Max:
+            return MAX(a, b);
+        default:
+            Macros_ReportError("Unexpected operation: ", opCtx->at, opCtx->end);
+            return 1.0f;
+    }
+}
+
+static int32_t computeIntOperation(int32_t a, operator_t op, parser_context_t* opCtx, int32_t b)
+{
+    switch (op) {
+        case Operator_Add:
+            return a+b;
+        case Operator_Sub:
+            return a-b;
+        case Operator_Mul:
+            return a*b;
+        case Operator_Div:
+            if (b == 0) {
+                Macros_ReportError("Division by zero attempted!", opCtx->at, opCtx->at);
+                return 0;
+            }
+            return a/b;
+        case Operator_Mod:
+            if (b == 0) {
+                Macros_ReportError("Modulo by zero attempted!", opCtx->at, opCtx->at);
+                return 0;
+            }
+            return a%b;
+        case Operator_Min:
+            return MIN(a, b);
+        case Operator_Max:
+            return MAX(a, b);
+        default:
+            Macros_ReportError("Unexpected operation: ", opCtx->at, opCtx->end);
+            return 1;
+    }
+}
+
+static bool computeFloatEqOperation(float a, operator_t op, parser_context_t* opCtx, float b)
+{
+    switch(op) {
+        case Operator_Eq:
+            return a == b;
+        case Operator_Ne:
+            return a != b;
+        case Operator_Gt:
+            return a > b;
+        case Operator_Ge:
+            return a >= b;
+        case Operator_Lt:
+            return a < b;
+        case Operator_Le:
+            return a <= b;
+        default:
+            Macros_ReportError("Unexpected operation: ", opCtx->at, opCtx->end);
+            return false;
+    }
+}
+
+
+static bool computeIntEqOperation(int32_t a, operator_t op, parser_context_t* opCtx, int32_t b)
+{
+    switch(op) {
+        case Operator_Eq:
+            return a == b;
+        case Operator_Ne:
+            return a != b;
+        case Operator_Gt:
+            return a > b;
+        case Operator_Ge:
+            return a >= b;
+        case Operator_Lt:
+            return a < b;
+        case Operator_Le:
+            return a <= b;
+        default:
+            Macros_ReportError("Unexpected operation: ", opCtx->at, opCtx->end);
+            return false;
+    }
+}
+
+
+static macro_variable_t computeBoolOperation(macro_variable_t a, operator_t op, parser_context_t* opCtx, macro_variable_t b)
+{
+    a = coalesceType(opCtx, a, MacroVariableType_Bool);
+    b = coalesceType(opCtx, b, MacroVariableType_Bool);
+
+    switch(op) {
+        case Operator_And:
+            return boolVar(a.asBool && b.asBool);
+        case Operator_Or:
+            return boolVar(a.asBool || b.asBool);
+        default:
+            Macros_ReportError("Unexpected operation: ", opCtx->at, opCtx->end);
+            return noneVar();
+    }
+}
+
+static macro_variable_t computeOperation(macro_variable_t a, operator_t op, parser_context_t* opCtx, macro_variable_t b)
+{
+    macro_variable_type_t dstType = determineCommonType(a.type, b.type);
+    a = coalesceType(opCtx, a, dstType);
+    b = coalesceType(opCtx, b, dstType);
+
+    switch (dstType) {
+        case MacroVariableType_Int:
+            a.asInt = computeIntOperation(a.asInt, op, opCtx, b.asInt);
+            break;
+        case MacroVariableType_Float:
+            a.asFloat = computeFloatOperation(a.asFloat, op, opCtx, b.asFloat);
+            break;
+        case MacroVariableType_Bool:
+            a.asInt = computeIntOperation(a.asInt, op, opCtx, b.asInt);
+            return noneVar();
+        case MacroVariableType_None:
+            return noneVar();
+        default:
+            Macros_ReportErrorNum("Unexpected variable type:", dstType, NULL);
+            return noneVar();
+    }
+    if (Macros_ParserError) {
+        a.type = MacroVariableType_None;
+    }
+    return a;
+}
+
+
+static macro_variable_t computeEqOperation(macro_variable_t a, operator_t op, parser_context_t* opCtx, macro_variable_t b)
+{
+    macro_variable_type_t dstType = determineCommonType(a.type, b.type);
+    a = coalesceType(opCtx, a, dstType);
+    b = coalesceType(opCtx, b, dstType);
+
+    switch (dstType) {
+        case MacroVariableType_Int:
+            a.asBool = computeIntEqOperation(a.asInt, op, opCtx, b.asInt);
+            a.type = MacroVariableType_Bool;
+            break;
+        case MacroVariableType_Float:
+            a.asBool = computeFloatEqOperation(a.asFloat, op, opCtx, b.asFloat);
+            a.type = MacroVariableType_Bool;
+            break;
+        case MacroVariableType_Bool:
+            a.asBool = computeIntEqOperation(a.asBool, op, opCtx, b.asBool);
+            a.type = MacroVariableType_Bool;
+            return noneVar();
+        case MacroVariableType_None:
+            return noneVar();
+        default:
+            Macros_ReportErrorNum("Unexpected variable type:", dstType, NULL);
+            return noneVar();
+    }
+    if (Macros_ParserError) {
+        a.type = MacroVariableType_None;
+    }
+    return a;
+}
+
+static macro_variable_t consumeMinMaxOperation(parser_context_t* ctx, operator_t op)
+{
+    if (!ConsumeToken(ctx, "("))
+    {
+        Macros_ReportError("Expected parameter list.", ctx->at, ctx->at);
+        return noneVar();
+    }
+    macro_variable_t accumulator = consumeValue(ctx);
+
+    while (ConsumeToken(ctx, ",")) {
+        macro_variable_t var = consumeValue(ctx);
+        accumulator = computeOperation(accumulator, op, ctx, var);
+    }
+
+    if (!ConsumeToken(ctx, ")"))
+    {
+        Macros_ReportError("Expected closing parenthess at the end of parameter list.", ctx->at, ctx->at);
+        return noneVar();
+    }
+
+    return accumulator;
+}
+
+static macro_variable_t consumeMultiplicativeExpression(parser_context_t* ctx)
+{
+    macro_variable_t accumulator = consumeValue(ctx);
+    operator_t op;
+
+    ConsumeWhite(ctx);
+
+    while (true) {
+        parser_context_t opCtx = *ctx;
+        switch (*ctx->at) {
+            case '*':
+                ConsumeWhiteAt(ctx, ctx->at+1);
+                op = Operator_Mul;
+                break;
+            case '/':
+                ConsumeWhiteAt(ctx, ctx->at+1);
+                op = Operator_Div;
+                break;
+            case '%':
+                ConsumeWhiteAt(ctx, ctx->at+1);
+                op = Operator_Mod;
+                break;
+            break;
+            default:
+                return accumulator;
+        }
+        macro_variable_t var = consumeValue(ctx);
+        accumulator = computeOperation(accumulator, op, &opCtx, var);
+    }
+}
+
+static macro_variable_t consumeAdditiveExpression(parser_context_t* ctx)
+{
+    macro_variable_t accumulator = consumeMultiplicativeExpression(ctx);
+    operator_t op;
+
+    while (true) {
+        parser_context_t opCtx = *ctx;
+        switch (*ctx->at) {
+            case '+':
+                ConsumeWhiteAt(ctx, ctx->at+1);
+                op = Operator_Add;
+                break;
+            case '-':
+                ConsumeWhiteAt(ctx, ctx->at+1);
+                op = Operator_Sub;
+                break;
+            default:
+                return accumulator;
+        }
+        macro_variable_t var = consumeMultiplicativeExpression(ctx);
+        accumulator = computeOperation(accumulator, op, &opCtx, var);
+    }
+}
+
+
+static macro_variable_t consumeEqExpression(parser_context_t* ctx)
+{
+    macro_variable_t accumulator = consumeAdditiveExpression(ctx);
+    parser_context_t opCtx = *ctx;
+    operator_t op;
+
+    switch (*ctx->at) {
+        case '<':
+            if (ConsumeToken(ctx, "<=")) {
+                op = Operator_Le;
+            } else if (ConsumeToken(ctx, "<")) {
+                op = Operator_Lt;
+            } else {
+                goto def;
+            }
+            break;
+        case '>':
+            if (ConsumeToken(ctx, ">=")) {
+                op = Operator_Ge;
+            } else if (ConsumeToken(ctx, ">")) {
+                op = Operator_Gt;
+            } else {
+                goto def;
+            }
+            break;
+        case '!':
+            if (ConsumeToken(ctx, "!=")) {
+                op = Operator_Ne;
+            } else {
+                goto def;
+            }
+            break;
+        case '=':
+            if (ConsumeToken(ctx, "==")) {
+                op = Operator_Eq;
+            } else {
+                goto def;
+            }
+            break;
+        def:
+        default:
+            return accumulator;
+    }
+
+    macro_variable_t var = consumeAdditiveExpression(ctx);
+    accumulator = computeEqOperation(accumulator, op, &opCtx, var);
+    return accumulator;
+}
+
+static macro_variable_t consumeAndExpression(parser_context_t* ctx)
+{
+    macro_variable_t accumulator = consumeEqExpression(ctx);
+    operator_t op;
+
+    while (true) {
+        parser_context_t opCtx = *ctx;
+        if (ConsumeToken(ctx, "&&")) {
+            op = Operator_Or;
+        } else {
+            return accumulator;
+        }
+        macro_variable_t var = consumeEqExpression(ctx);
+        accumulator = computeBoolOperation(accumulator, op, &opCtx, var);
+    }
+}
+
+static macro_variable_t consumeOrExpression(parser_context_t* ctx)
+{
+    macro_variable_t accumulator = consumeAndExpression(ctx);
+    operator_t op;
+
+    while (true) {
+        parser_context_t opCtx = *ctx;
+        if (ConsumeToken(ctx, "||")) {
+            op = Operator_Or;
+        } else {
+            return accumulator;
+        }
+        macro_variable_t var = consumeAndExpression(ctx);
+        accumulator = computeBoolOperation(accumulator, op, &opCtx, var);
+    }
+}
+
+static macro_variable_t consumeParenthessExpression(parser_context_t* ctx)
+{
+    ConsumeWhiteAt(ctx, ctx->at+1);
+
+    macro_variable_t value = consumeOrExpression(ctx);
+
+    switch (*ctx->at) {
+        case ')':
+            ConsumeWhiteAt(ctx, ctx->at+1);
+            return value;
+        default:
+            if (!Macros_ParserError) {
+                Macros_ReportError("Failed to parse expression, closing parenthess expected.", ctx->at, ctx->at);
+            }
+            return noneVar();
+    }
+}
+
+int32_t Macros_ConsumeInt(parser_context_t* ctx)
+{
+
+    macro_variable_t res = consumeValue(ctx);
+    return coalesceType(ctx, res, MacroVariableType_Int).asInt;
+}
+
+float Macros_ConsumeFloat(parser_context_t* ctx)
+{
+    macro_variable_t res = consumeValue(ctx);
+    return coalesceType(ctx, res, MacroVariableType_Float).asFloat;
+}
+
+bool Macros_ConsumeBool(parser_context_t* ctx)
+{
+    macro_variable_t res = consumeValue(ctx);
+    return coalesceType(ctx, res, MacroVariableType_Bool).asBool;
+}
+
+macro_variable_t Macros_ConsumeAnyValue(parser_context_t *ctx)
+{
+    return consumeValue(ctx);
+}
+
+macro_result_t Macros_ProcessSetVarCommand(parser_context_t* ctx)
+{
+    macro_variable_t* dst = consumeVarAndAllocate(ctx);
+    macro_variable_t src = consumeValue(ctx);
+
+    if (Macros_DryRun) {
+        return MacroResult_Finished;
+    }
+
+    if (dst != NULL) {
+        dst->type = src.type;
+        dst->asInt = src.asInt;
+    }
+
+    return MacroResult_Finished;
+}
+
diff --git a/right/src/macros_vars.h b/right/src/macros_vars.h
new file mode 100644
index 000000000..dde0b28a4
--- /dev/null
+++ b/right/src/macros_vars.h
@@ -0,0 +1,53 @@
+#ifndef __MACROS_VARS_H__
+#define __MACROS_VARS_H__
+
+
+// Includes:
+
+    #include <stdint.h>
+    #include <stdbool.h>
+    #include "attributes.h"
+    #include "key_action.h"
+    #include "usb_device_config.h"
+    #include "key_states.h"
+    #include "str_utils.h"
+    #include "macros_core.h"
+
+// Macros:
+
+    #define MACRO_VARIABLE_COUNT_MAX 32
+
+// Typedefs:
+
+    typedef enum {
+        MacroVariableType_Int,
+        MacroVariableType_Float,
+        MacroVariableType_Bool,
+        MacroVariableType_None,
+    } macro_variable_type_t;
+
+    typedef struct {
+        union {
+            int32_t asInt;
+            float asFloat;
+            bool asBool;
+        };
+        string_ref_t name;
+        macro_variable_type_t type;
+    } ATTR_PACKED macro_variable_t;
+
+
+// Variables:
+
+// Functions:
+
+    char Macros_ConsumeCharOfString(parser_context_t* ctx, uint16_t* stringOffset, uint16_t* index, uint16_t* subIndex);
+    macro_result_t Macros_ProcessSetVarCommand(parser_context_t* ctx);
+    macro_variable_t* Macros_ConsumeExistingWritableVariable(parser_context_t* ctx);
+    int32_t Macros_ConsumeInt(parser_context_t* ctx);
+    float Macros_ConsumeFloat(parser_context_t* ctx);
+    bool Macros_ConsumeBool(parser_context_t* ctx);
+    macro_variable_t Macros_ConsumeAnyValue(parser_context_t* ctx);
+
+#endif
+
diff --git a/right/src/main.c b/right/src/main.c
index 504a64995..6809c3bf9 100644
--- a/right/src/main.c
+++ b/right/src/main.c
@@ -21,6 +21,7 @@
 #include "ledmap.h"
 #include "debug.h"
 #include "event_scheduler.h"
+#include "macro_keyid_parser.h"
 
 static bool IsEepromInitialized = false;
 static bool IsConfigInitialized = false;
@@ -46,6 +47,7 @@ static void initConfig()
         if (IsEepromInitialized) {
             UsbCommand_ApplyConfig();
             ShortcutParser_initialize();
+            KeyIdParser_initialize();
             Macros_Initialize();
             IsConfigInitialized = true;
         } else {
diff --git a/right/src/segment_display.c b/right/src/segment_display.c
index 1e6483104..b625db220 100644
--- a/right/src/segment_display.c
+++ b/right/src/segment_display.c
@@ -2,6 +2,7 @@
 #include "event_scheduler.h"
 #include "led_display.h"
 #include "macros.h"
+#include "macros_vars.h"
 #include "timer.h"
 #include <string.h>
 #include "keymap.h"
@@ -93,31 +94,89 @@ void SegmentDisplay_UpdateKeymapText()
     SegmentDisplay_SetText(currentKeymap->abbreviationLen, currentKeymap->abbreviation, SegmentDisplaySlot_Keymap);
 }
 
-void SegmentDisplay_SetInt(int32_t a, segment_display_slot_t slot)
+void SegmentDisplay_SerializeVar(char* buffer, macro_variable_t var)
+{
+    switch (var.type) {
+        case MacroVariableType_Float:
+            SegmentDisplay_SerializeFloat(buffer, var.asFloat);
+            break;
+        case MacroVariableType_Int:
+            SegmentDisplay_SerializeInt(buffer, var.asInt);
+            break;
+        case MacroVariableType_Bool:
+            SegmentDisplay_SerializeInt(buffer, var.asBool);
+            break;
+        default:
+            Macros_ReportErrorNum("Unexpected variable type:", var.type, NULL);
+            break;
+    }
+}
+
+void SegmentDisplay_SerializeFloat(char* buffer, float num)
+{
+    if (num <= -10.0f || 10.0f <= num ) {
+        SegmentDisplay_SerializeInt(buffer, num);
+    }
+
+    int mag = 0;
+    bool negative = false;
+
+    if (num < 0.0f) {
+        num = -num;
+        negative = true;
+    }
+
+    while (num < 10.0f) {
+        mag++;
+        num *= 10;
+    }
+    if (negative) {
+        buffer[0] = 'Z' - mag + 1;
+    } else {
+        buffer[0] = 'A' + mag - 1;
+    }
+    buffer[1] = '0' + (uint8_t)(num / 10.0f);
+    buffer[2] = '0' + (uint8_t)(num) % 10;
+}
+
+void SegmentDisplay_SerializeInt(char* buffer, int32_t a)
 {
-    char b[3];
     int mag = 0;
     int num = a;
+    bool negative = false;
+
     if (num < 0) {
-        SegmentDisplay_SetText(3, "NEG", slot);
+        num = -num;
+        negative = true;
+    }
+
+    if (num < 1000 && !negative) {
+        buffer[0] = '0' + num / 100;
+        buffer[1] = '0' + num % 100 / 10;
+        buffer[2] = '0' + num % 10;
     } else {
-        if (num < 1000) {
-            b[0] = '0' + num / 100;
-            b[1] = '0' + num % 100 / 10;
-            b[2] = '0' + num % 10;
+        while (num >= 100) {
+            mag++;
+            num /= 10;
+        }
+        buffer[0] = '0' + num / 10;
+        buffer[1] = '0' + num % 10;
+
+        if (negative) {
+            buffer[2] = mag == 0 ? '-' : ('Z' + 1 - mag);
         } else {
-            while (num >= 100) {
-                mag++;
-                num /= 10;
-            }
-            b[0] = '0' + num / 10;
-            b[1] = '0' + num % 10;
-            b[2] = mag == 0 ? '0' : ('A' - 2 + mag);
+            buffer[2] = mag == 0 ? '0' : ('A' - 1 + mag);
         }
-        SegmentDisplay_SetText(3, b, slot);
     }
 }
 
+void SegmentDisplay_SetInt(int32_t a, segment_display_slot_t slot)
+{
+    char b[3];
+    SegmentDisplay_SerializeInt(b, a);
+    SegmentDisplay_SetText(3, b, slot);
+}
+
 bool SegmentDisplay_SlotIsActive(segment_display_slot_t slot)
 {
     return slots[slot].active;
diff --git a/right/src/segment_display.h b/right/src/segment_display.h
index 44bfa8eca..3ebc0db06 100644
--- a/right/src/segment_display.h
+++ b/right/src/segment_display.h
@@ -6,6 +6,7 @@
     #include <stdint.h>
     #include <stdbool.h>
     #include "timer.h"
+    #include "macros_vars.h"
 
 // Macros:
 
@@ -36,6 +37,9 @@
     void SegmentDisplay_Update();
     void SegmentDisplay_SetText(uint8_t len, const char* text, segment_display_slot_t slot);
     void SegmentDisplay_SetInt(int32_t a, segment_display_slot_t slot);
+    void SegmentDisplay_SerializeInt(char* buffer, int32_t a);
+    void SegmentDisplay_SerializeFloat(char* buffer, float f);
+    void SegmentDisplay_SerializeVar(char* buffer, macro_variable_t var);
     void SegmentDisplay_DeactivateSlot(segment_display_slot_t slot);
     void SegmentDisplay_UpdateKeymapText();
     bool SegmentDisplay_SlotIsActive(segment_display_slot_t slot);
diff --git a/right/src/str_utils.c b/right/src/str_utils.c
index 99693cd09..5ffb7d0e7 100644
--- a/right/src/str_utils.c
+++ b/right/src/str_utils.c
@@ -1,75 +1,19 @@
 #include "str_utils.h"
+#include "debug.h"
+#include "config_parser/config_globals.h"
 #include "config_parser/parse_keymap.h"
 #include "macros.h"
+#include "macros_vars.h"
+#include "module.h"
 #include "slave_protocol.h"
 
-float ParseFloat(const char *a, const char *aEnd)
-{
-    bool negate = false;
-    if (*a == '-')
-    {
-        negate = !negate;
-        a++;
-    }
-    float n = 0;
-    bool numFound = false;
-    while(*a > 47 && *a < 58 && a < aEnd) {
-        n = n*10 + ((uint8_t)(*a))-48;
-        a++;
-        numFound = true;
-    }
-    if (*a == '.') {
-        a++;
-    }
-    float b = 0.1;
-    float d = 0.0f;
-    while(*a > 47 && *a < 58 && a < aEnd) {
-        d = d + (((uint8_t)(*a))-48)*b;
-        b = b/10.0f;
-        a++;
-    }
-    n += d;
-    if (negate)
-    {
-        n = -n;
-    }
-    if (!numFound) {
-        Macros_ReportError("Float expected", NULL, NULL);
-    }
-    return n;
-}
 
-int32_t ParseInt32_2(const char *a, const char *aEnd, const char* *parsedTill)
-{
-    bool negate = false;
-    if (*a == '-')
-    {
-        negate = !negate;
-        a++;
-    }
-    int32_t n = 0;
-    bool numFound = false;
-    while(*a > 47 && *a < 58 && a < aEnd) {
-        n = n*10 + ((uint8_t)(*a))-48;
-        a++;
-        numFound = true;
-    }
-    if (negate)
-    {
-        n = -n;
-    }
-    if (!numFound) {
-        Macros_ReportError("Integer expected", NULL, NULL);
-    }
-    if (parsedTill != NULL) {
-        *parsedTill = a;
-    }
-    return n;
-}
+static bool isIdentifierChar(char c);
 
-int32_t ParseInt32(const char *a, const char *aEnd)
+float ParseFloat(const char *a, const char *aEnd)
 {
-    return ParseInt32_2(a, aEnd, NULL);
+    parser_context_t ctx = { .at = a, .end = aEnd };
+    return Macros_ConsumeFloat(&ctx);
 }
 
 bool StrLessOrEqual(const char* a, const char* aEnd, const char* b, const char* bEnd)
@@ -132,6 +76,179 @@ const char* FindChar(char c, const char* str, const char* strEnd)
 }
 
 
+static void consumeWhite(parser_context_t* ctx)
+{
+    while (*ctx->at <= 32 && ctx->at < ctx->end) {
+        ctx->at++;
+    }
+}
+
+void ConsumeWhite(parser_context_t* ctx)
+{
+    consumeWhite(ctx);
+}
+
+void ConsumeWhiteAt(parser_context_t* ctx, const char* at)
+{
+    ctx->at = at;
+    consumeWhite(ctx);
+}
+
+void UnconsumeWhite(parser_context_t* ctx)
+{
+    while (ctx->at > ctx->begin && *(ctx->at-1) <= 32) {
+        ctx->at--;
+    }
+}
+
+const char* OneWord(parser_context_t* ctx)
+{
+    static char buffer[20];
+    uint8_t len = MIN(19, TokEnd(ctx->at, ctx->end) - ctx->at);
+    memcpy(&buffer, ctx->at, len);
+    buffer[len] = '\0';
+    return buffer;
+}
+
+const char* ConsumedToken(parser_context_t* ctx)
+{
+    const char* at = ctx->at;
+
+    at--;
+
+    while (*at <= 32) {
+        at--;
+    }
+    while (*at > 32 && *at != '.') {
+        at--;
+    }
+
+    return at;
+}
+
+bool ConsumeToken(parser_context_t* ctx, const char *b)
+{
+    const char* at = ctx->at;
+    while(at < ctx->end && *b) {
+        if (*at <= 32 || at == ctx->end || *b <= 32) {
+            bool res = (*at <= 32 || at == ctx->end) && *b <= 32;
+            if (res) {
+                ctx->at = at;
+                consumeWhite(ctx);
+            }
+            return res;
+        }
+        if (*at++ != *b++) {
+            return false;
+        }
+    }
+    bool res = (*at <= 32 || at == ctx->end || !isIdentifierChar(*at) || !isIdentifierChar(*(at-1))) && *b <= 32;
+    if (res) {
+        ctx->at = at;
+        consumeWhite(ctx);
+    }
+    return res;
+}
+
+bool ConsumeTokenByRef(parser_context_t* ctx, string_ref_t ref)
+{
+    const char* at = ctx->at;
+    const char* b = (const char*)(ValidatedUserConfigBuffer.buffer + ref.offset);
+    const char* bEnd = (const char*)(ValidatedUserConfigBuffer.buffer + ref.offset + ref.len);
+    while(at < ctx->end && b < bEnd) {
+        if (*at <= 32 || at == ctx->end || *b <= 32 || b == bEnd) {
+            bool res = (*at <= 32 || at == ctx->end) && *b <= 32;
+            if (res) {
+                ctx->at = at;
+                consumeWhite(ctx);
+            }
+            return res;
+        }
+        if (*at++ != *b++) {
+            return false;
+        }
+    }
+    bool res = (*at <= 32 || at == ctx->end || *at == '.') && (*b <= 32 || b == bEnd);
+    if (res) {
+        ctx->at = at;
+        consumeWhite(ctx);
+    }
+    return res;
+}
+
+static bool isIdentifierChar(char c)
+{
+    switch (c) {
+        case 'a' ... 'z':
+        case 'A' ... 'Z':
+        case '0' ... '9':
+        case '_':
+            return true;
+        default:
+            return false;
+    }
+}
+
+
+bool IsIdentifierChar(char c)
+{
+    return isIdentifierChar(c);
+}
+
+
+bool ConsumeIdentifierByRef(parser_context_t* ctx, string_ref_t ref)
+{
+    const char* at = ctx->at;
+    const char* b = (const char*)(ValidatedUserConfigBuffer.buffer + ref.offset);
+    const char* bEnd = (const char*)(ValidatedUserConfigBuffer.buffer + ref.offset + ref.len);
+    while(at < ctx->end && b < bEnd) {
+        if (!isIdentifierChar(*at) || at == ctx->end || !isIdentifierChar(*b) || b == bEnd) {
+            bool res = (!isIdentifierChar(*at) || at == ctx->end) && (!isIdentifierChar(*b) || b == bEnd);
+            if (res) {
+                ctx->at = at;
+                consumeWhite(ctx);
+            }
+            return res;
+        }
+        if (*at++ != *b++) {
+            return false;
+        }
+    }
+
+    bool res = (!isIdentifierChar(*at) || at == ctx->end) && (!isIdentifierChar(*b) || b == bEnd);
+    if (res) {
+        ctx->at = at;
+        consumeWhite(ctx);
+    }
+    return res;
+}
+
+const char* IdentifierEnd(parser_context_t* ctx)
+{
+    const char* at = ctx->at;
+    while (isIdentifierChar(*at) && at < ctx->end) {
+        at++;
+    }
+    return at;
+}
+
+void ConsumeAnyIdentifier(parser_context_t* ctx)
+{
+    ctx->at = IdentifierEnd(ctx);
+    consumeWhite(ctx);
+}
+
+void ConsumeUntilDot(parser_context_t* ctx)
+{
+    while(*ctx->at > 32 && *ctx->at != '.' && ctx->at < ctx->end)    {
+        ctx->at++;
+    }
+    if (*ctx->at != '.') {
+        Macros_ReportError("'.' expected", ctx->at, ctx->at);
+    }
+    ctx->at++;
+}
+
 bool TokenMatches(const char *a, const char *aEnd, const char *b)
 {
     while(a < aEnd && *b) {
@@ -218,54 +335,96 @@ const char* SkipWhite(const char* cmd, const char *cmdEnd)
     return cmd;
 }
 
-module_id_t ParseModuleId(const char* arg1, const char* cmdEnd)
+module_id_t ConsumeModuleId(parser_context_t* ctx)
 {
-    if (TokenMatches(arg1, cmdEnd, "keycluster")) {
+    if (ConsumeToken(ctx, "keycluster")) {
         return ModuleId_KeyClusterLeft;
     }
-    else if (TokenMatches(arg1, cmdEnd, "trackball")) {
+    else if (ConsumeToken(ctx, "trackball")) {
         return ModuleId_TrackballRight;
     }
-    else if (TokenMatches(arg1, cmdEnd, "trackpoint")) {
+    else if (ConsumeToken(ctx, "trackpoint")) {
         return ModuleId_TrackpointRight;
     }
-    else if (TokenMatches(arg1, cmdEnd, "touchpad")) {
+    else if (ConsumeToken(ctx, "touchpad")) {
         return ModuleId_TouchpadRight;
     }
-    Macros_ReportError("Module not recognized: ", arg1, cmdEnd);
+    Macros_ReportError("Module not recognized: ", ctx->at, ctx->end);
     return 0;
 }
 
-navigation_mode_t ParseNavigationModeId(const char* arg1, const char* cmdEnd)
+module_id_t ParseModuleId(const char* arg1, const char* cmdEnd)
 {
-    if (TokenMatches(arg1, cmdEnd, "cursor")) {
+    parser_context_t ctx = { .at = arg1, .end = cmdEnd };
+    return ConsumeModuleId(&ctx);
+}
+
+navigation_mode_t ConsumeNavigationModeId(parser_context_t* ctx)
+{
+    if (ConsumeToken(ctx, "cursor")) {
         return NavigationMode_Cursor;
     }
-    else if (TokenMatches(arg1, cmdEnd, "scroll")) {
+    else if (ConsumeToken(ctx, "scroll")) {
         return NavigationMode_Scroll;
     }
-    else if (TokenMatches(arg1, cmdEnd, "caret")) {
+    else if (ConsumeToken(ctx, "caret")) {
         return NavigationMode_Caret;
     }
-    else if (TokenMatches(arg1, cmdEnd, "media")) {
+    else if (ConsumeToken(ctx, "media")) {
         return NavigationMode_Media;
     }
-    else if (TokenMatches(arg1, cmdEnd, "zoom")) {
+    else if (ConsumeToken(ctx, "zoom")) {
         return NavigationMode_Zoom;
     }
-    else if (TokenMatches(arg1, cmdEnd, "zoomPc")) {
+    else if (ConsumeToken(ctx, "zoomPc")) {
         return NavigationMode_ZoomPc;
     }
-    else if (TokenMatches(arg1, cmdEnd, "zoomMac")) {
+    else if (ConsumeToken(ctx, "zoomMac")) {
         return NavigationMode_ZoomMac;
     }
-    else if (TokenMatches(arg1, cmdEnd, "none")) {
+    else if (ConsumeToken(ctx, "none")) {
         return NavigationMode_None;
     }
-    Macros_ReportError("Mode not recognized: ", arg1, cmdEnd);
+    Macros_ReportError("Mode not recognized: ", ctx->at, ctx->end);
     return 0;
 }
 
+
+navigation_mode_t ParseNavigationModeId(const char* arg1, const char* cmdEnd)
+{
+    parser_context_t ctx = { .at = arg1, .end = cmdEnd };
+    return ConsumeNavigationModeId(&ctx);
+}
+
+secondary_role_state_t ConsumeSecondaryRoleTimeoutAction(parser_context_t* ctx)
+{
+    if (ConsumeToken(ctx, "primary")) {
+        return SecondaryRoleState_Primary;
+    }
+    else if (ConsumeToken(ctx, "secondary")) {
+        return SecondaryRoleState_Secondary;
+    }
+    else {
+        Macros_ReportError("Parameter not recognized:", ctx->at, ctx->end);
+        return SecondaryRoleState_DontKnowYet;
+    }
+}
+
+secondary_role_strategy_t ConsumeSecondaryRoleStrategy(parser_context_t* ctx)
+{
+    if (ConsumeToken(ctx, "simple")) {
+        return SecondaryRoleStrategy_Simple;
+    }
+    else if (ConsumeToken(ctx, "advanced")) {
+        return SecondaryRoleStrategy_Advanced;
+    }
+    else {
+        Macros_ReportError("Parameter not recognized:", ctx->at, ctx->end);
+        return SecondaryRoleStrategy_Simple;
+    }
+}
+
+
 uint8_t CountCommands(const char* text, uint16_t textLen)
 {
     uint8_t count = 1;
@@ -285,3 +444,5 @@ uint8_t CountCommands(const char* text, uint16_t textLen)
         }
     }
 }
+
+
diff --git a/right/src/str_utils.h b/right/src/str_utils.h
index f10879980..aeb9a1ccc 100644
--- a/right/src/str_utils.h
+++ b/right/src/str_utils.h
@@ -7,27 +7,58 @@
     #include <stdbool.h>
     #include "layer.h"
     #include "module.h"
-    #include "macros.h"
+    #include "secondary_role_driver.h"
+    #include "macros_core.h"
+
+// Typedefs:
+
+    typedef struct macro_state_t macro_state_t;
+
+    typedef struct {
+        const macro_state_t* macroState;
+        const char* begin;
+        const char* at;
+        const char* end;
+    } parser_context_t;
+
+    typedef struct {
+        uint16_t offset;
+        uint8_t len;
+    } ATTR_PACKED string_ref_t;
 
 // Functions:
 
     float ParseFloat(const char *a, const char *aEnd);
-    int32_t ParseInt32(const char *a, const char *aEnd);
-    int32_t ParseInt32_2(const char *a, const char *aEnd, const char* *parsedTill);
     bool StrLessOrEqual(const char* a, const char* aEnd, const char* b, const char* bEnd);
     bool StrEqual(const char* a, const char* aEnd, const char* b, const char* bEnd);
     const char* FindChar(char c, const char* str, const char* strEnd);
+    bool ConsumeToken(parser_context_t* ctx, const char *b);
+    bool ConsumeTokenByRef(parser_context_t* ctx, string_ref_t ref);
+    bool ConsumeIdentifierByRef(parser_context_t* ctx, string_ref_t ref);
+    void ConsumeAnyIdentifier(parser_context_t* ctx);
+    void UnconsumeWhite(parser_context_t* ctx);
+    const char* ConsumedToken(parser_context_t* ctx);
+    bool IsIdentifierChar(char c);
+    const char* IdentifierEnd(parser_context_t* ctx);
+    const char* OneWord(parser_context_t* ctx);
+    void ConsumeWhite(parser_context_t* ctx);
     bool TokenMatches(const char *a, const char *aEnd, const char *b);
     bool TokenMatches2(const char *a, const char *aEnd, const char *b, const char *bEnd);
     uint8_t TokLen(const char *a, const char *aEnd);
     const char* NextTok(const char* cmd, const char *cmdEnd);
     const char* NextCmd(const char* cmd, const char *cmdEnd);
     const char* CmdEnd(const char* cmd, const char *cmdEnd);
+    void ConsumeUntilDot(parser_context_t* ctx);
+    void ConsumeWhiteAt(parser_context_t* ctx, const char* at);
     const char* SkipWhite(const char* cmd, const char *cmdEnd);
     uint8_t CountCommands(const char* text, uint16_t textLen);
     const char* TokEnd(const char* cmd, const char *cmdEnd);
     module_id_t ParseModuleId(const char* arg1, const char* cmdEnd);
     navigation_mode_t ParseNavigationModeId(const char* arg1, const char* cmdEnd);
+    module_id_t ConsumeModuleId(parser_context_t* ctx);
+    secondary_role_state_t ConsumeSecondaryRoleTimeoutAction(parser_context_t* ctx);
+    secondary_role_strategy_t ConsumeSecondaryRoleStrategy(parser_context_t* ctx);
+    navigation_mode_t ConsumeNavigationModeId(parser_context_t* ctx);
 
 
 #endif /* SRC_STR_UTILS_H_ */