2021-01-17 21:42:00

91 files changed, 4756 insertions, 1804 deletions

diff --git a/context/data/scite/context/lexers/data/scite-context-data-metafun.lua b/context/data/scite/context/lexers/data/scite-context-data-metafun.lua
index d02ed5332..edbf39a57 100644
--- a/context/data/scite/context/lexers/data/scite-context-data-metafun.lua
+++ b/context/data/scite/context/lexers/data/scite-context-data-metafun.lua
@@ -1,4 +1,4 @@
 return {
- ["commands"]={ "loadfile", "loadimage", "loadmodule", "dispose", "nothing", "transparency", "tolist", "topath", "tocycle", "sqr", "log", "ln", "exp", "inv", "pow", "pi", "radian", "tand", "cotd", "sin", "cos", "tan", "cot", "atan", "asin", "acos", "invsin", "invcos", "invtan", "acosh", "asinh", "sinh", "cosh", "tanh", "zmod", "paired", "tripled", "unitcircle", "fulldiamond", "unitdiamond", "fullsquare", "unittriangle", "fulltriangle", "llcircle", "lrcircle", "urcircle", "ulcircle", "tcircle", "bcircle", "lcircle", "rcircle", "lltriangle", "lrtriangle", "urtriangle", "ultriangle", "uptriangle", "downtriangle", "lefttriangle", "righttriangle", "triangle", "smoothed", "cornered", "superellipsed", "randomized", "randomizedcontrols", "squeezed", "enlonged", "shortened", "punked", "curved", "unspiked", "simplified", "blownup", "stretched", "enlarged", "leftenlarged", "topenlarged", "rightenlarged", "bottomenlarged", "crossed", "laddered", "randomshifted", "interpolated", "perpendicular", "paralleled", "cutends", "peepholed", "llenlarged", "lrenlarged", "urenlarged", "ulenlarged", "llmoved", "lrmoved", "urmoved", "ulmoved", "rightarrow", "leftarrow", "centerarrow", "drawdoublearrows", "boundingbox", "innerboundingbox", "outerboundingbox", "pushboundingbox", "popboundingbox", "boundingradius", "boundingcircle", "boundingpoint", "crossingunder", "insideof", "outsideof", "bottomboundary", "leftboundary", "topboundary", "rightboundary", "xsized", "ysized", "xysized", "sized", "xyscaled", "intersection_point", "intersection_found", "penpoint", "bbwidth", "bbheight", "withshade", "withcircularshade", "withlinearshade", "defineshade", "shaded", "shadedinto", "withshadecolors", "withshadedomain", "withshademethod", "withshadefactor", "withshadevector", "withshadecenter", "withshadedirection", "withshaderadius", "withshadetransform", "withshadestep", "withshadefraction", "withshadeorigin", "shownshadevector", "shownshadeorigin", "shownshadedirection", "shownshadecenter", "cmyk", "spotcolor", "multitonecolor", "namedcolor", "drawfill", "undrawfill", "inverted", "uncolored", "softened", "grayed", "greyed", "onlayer", "along", "graphictext", "loadfigure", "externalfigure", "figure", "register", "outlinetext", "filloutlinetext", "drawoutlinetext", "outlinetexttopath", "checkedbounds", "checkbounds", "strut", "rule", "withmask", "bitmapimage", "colordecimals", "ddecimal", "dddecimal", "ddddecimal", "colordecimalslist", "textext", "thetextext", "rawtextext", "textextoffset", "texbox", "thetexbox", "rawtexbox", "istextext", "rawmadetext", "validtexbox", "onetimetextext", "rawfmttext", "thefmttext", "fmttext", "onetimefmttext", "notcached", "keepcached", "verbatim", "thelabel", "label", "autoalign", "transparent", "withtransparency", "withopacity", "property", "properties", "withproperties", "asgroup", "infont", "space", "crlf", "dquote", "percent", "SPACE", "CRLF", "DQUOTE", "PERCENT", "grayscale", "greyscale", "withgray", "withgrey", "colorpart", "colorlike", "readfile", "clearxy", "unitvector", "center", "epsed", "anchored", "originpath", "infinite", "break", "xstretched", "ystretched", "snapped", "pathconnectors", "function", "constructedfunction", "constructedpath", "constructedpairs", "straightfunction", "straightpath", "straightpairs", "curvedfunction", "curvedpath", "curvedpairs", "evenly", "oddly", "condition", "pushcurrentpicture", "popcurrentpicture", "arrowpath", "resetarrows", "tensecircle", "roundedsquare", "colortype", "whitecolor", "blackcolor", "basiccolors", "complementary", "complemented", "resolvedcolor", "normalfill", "normaldraw", "visualizepaths", "detailpaths", "naturalizepaths", "drawboundary", "drawwholepath", "drawpathonly", "visualizeddraw", "visualizedfill", "detaileddraw", "draworigin", "drawboundingbox", "drawpath", "drawpoint", "drawpoints", "drawcontrolpoints", "drawcontrollines", "drawpointlabels", "drawlineoptions", "drawpointoptions", "drawcontroloptions", "drawlabeloptions", "draworiginoptions", "drawboundoptions", "drawpathoptions", "resetdrawoptions", "undashed", "pencilled", "decorated", "redecorated", "undecorated", "passvariable", "passarrayvariable", "tostring", "topair", "format", "formatted", "quotation", "quote", "startpassingvariable", "stoppassingvariable", "eofill", "eoclip", "nofill", "dofill", "fillup", "eofillup", "nodraw", "dodraw", "area", "addbackground", "shadedup", "shadeddown", "shadedleft", "shadedright", "sortlist", "copylist", "shapedlist", "listtocurves", "listtolines", "listsize", "listlast", "uniquelist", "circularpath", "squarepath", "linearpath", "theoffset", "texmode", "systemmode", "texvar", "texstr", "isarray", "prefix", "dimension", "getmacro", "getdimen", "getcount", "gettoks", "setmacro", "setdimen", "setcount", "settoks", "positionpath", "positioncurve", "positionxy", "positionpxy", "positionwhd", "positionpage", "positionregion", "positionbox", "positionanchor", "positioninregion", "positionatanchor", "wdpart", "htpart", "dppart", "texvar", "texstr", "inpath", "pointof", "leftof", "rightof", "utflen", "utfsub", "newhash", "disposehash", "inhash", "tohash", "isarray", "prefix", "isobject", "comment", "report", "lua", "lualist", "mp", "MP", "luacall", "mirrored", "mirroredabout", "scriptindex", "newscriptindex", "newcolor", "newrgbcolor", "newcmykcolor", "newnumeric", "newboolean", "newtransform", "newpath", "newpicture", "newstring", "newpair" },
+ ["commands"]={ "loadfile", "loadimage", "loadmodule", "dispose", "nothing", "transparency", "tolist", "topath", "tocycle", "sqr", "log", "ln", "exp", "inv", "pow", "pi", "radian", "tand", "cotd", "sin", "cos", "tan", "cot", "atan", "asin", "acos", "invsin", "invcos", "invtan", "acosh", "asinh", "sinh", "cosh", "tanh", "zmod", "paired", "tripled", "unitcircle", "fulldiamond", "unitdiamond", "fullsquare", "unittriangle", "fulltriangle", "llcircle", "lrcircle", "urcircle", "ulcircle", "tcircle", "bcircle", "lcircle", "rcircle", "lltriangle", "lrtriangle", "urtriangle", "ultriangle", "uptriangle", "downtriangle", "lefttriangle", "righttriangle", "triangle", "smoothed", "cornered", "superellipsed", "randomized", "randomizedcontrols", "squeezed", "enlonged", "shortened", "punked", "curved", "unspiked", "simplified", "blownup", "stretched", "enlarged", "leftenlarged", "topenlarged", "rightenlarged", "bottomenlarged", "crossed", "laddered", "randomshifted", "interpolated", "perpendicular", "paralleled", "cutends", "peepholed", "llenlarged", "lrenlarged", "urenlarged", "ulenlarged", "llmoved", "lrmoved", "urmoved", "ulmoved", "rightarrow", "leftarrow", "centerarrow", "drawdoublearrows", "boundingbox", "innerboundingbox", "outerboundingbox", "pushboundingbox", "popboundingbox", "boundingradius", "boundingcircle", "boundingpoint", "crossingunder", "insideof", "outsideof", "bottomboundary", "leftboundary", "topboundary", "rightboundary", "xsized", "ysized", "xysized", "sized", "xyscaled", "intersection_point", "intersection_found", "penpoint", "bbwidth", "bbheight", "withshade", "withcircularshade", "withlinearshade", "defineshade", "shaded", "shadedinto", "withshadecolors", "withshadedomain", "withshademethod", "withshadefactor", "withshadevector", "withshadecenter", "withshadedirection", "withshaderadius", "withshadetransform", "withshadestep", "withshadefraction", "withshadeorigin", "shownshadevector", "shownshadeorigin", "shownshadedirection", "shownshadecenter", "cmyk", "spotcolor", "multitonecolor", "namedcolor", "drawfill", "undrawfill", "inverted", "uncolored", "softened", "grayed", "greyed", "onlayer", "along", "graphictext", "loadfigure", "externalfigure", "figure", "register", "outlinetext", "filloutlinetext", "drawoutlinetext", "outlinetexttopath", "checkedbounds", "checkbounds", "strut", "rule", "withmask", "bitmapimage", "colordecimals", "ddecimal", "dddecimal", "ddddecimal", "colordecimalslist", "textext", "thetextext", "rawtextext", "textextoffset", "texbox", "thetexbox", "rawtexbox", "istextext", "rawmadetext", "validtexbox", "onetimetextext", "rawfmttext", "thefmttext", "fmttext", "onetimefmttext", "notcached", "keepcached", "verbatim", "thelabel", "label", "autoalign", "transparent", "withtransparency", "withopacity", "property", "properties", "withproperties", "asgroup", "infont", "space", "crlf", "dquote", "percent", "SPACE", "CRLF", "DQUOTE", "PERCENT", "grayscale", "greyscale", "withgray", "withgrey", "colorpart", "colorlike", "readfile", "clearxy", "unitvector", "center", "epsed", "anchored", "originpath", "infinite", "break", "xstretched", "ystretched", "snapped", "pathconnectors", "function", "constructedfunction", "constructedpath", "constructedpairs", "straightfunction", "straightpath", "straightpairs", "curvedfunction", "curvedpath", "curvedpairs", "evenly", "oddly", "condition", "pushcurrentpicture", "popcurrentpicture", "arrowpath", "resetarrows", "tensecircle", "roundedsquare", "colortype", "whitecolor", "blackcolor", "basiccolors", "complementary", "complemented", "resolvedcolor", "normalfill", "normaldraw", "visualizepaths", "detailpaths", "naturalizepaths", "drawboundary", "drawwholepath", "drawpathonly", "visualizeddraw", "visualizedfill", "detaileddraw", "draworigin", "drawboundingbox", "drawpath", "drawpoint", "drawpoints", "drawcontrolpoints", "drawcontrollines", "drawpointlabels", "drawlineoptions", "drawpointoptions", "drawcontroloptions", "drawlabeloptions", "draworiginoptions", "drawboundoptions", "drawpathoptions", "resetdrawoptions", "undashed", "pencilled", "decorated", "redecorated", "undecorated", "passvariable", "passarrayvariable", "tostring", "topair", "format", "formatted", "quotation", "quote", "startpassingvariable", "stoppassingvariable", "eofill", "eoclip", "nofill", "dofill", "fillup", "eofillup", "nodraw", "dodraw", "area", "addbackground", "shadedup", "shadeddown", "shadedleft", "shadedright", "sortlist", "copylist", "shapedlist", "listtocurves", "listtolines", "listsize", "listlast", "uniquelist", "circularpath", "squarepath", "linearpath", "theoffset", "texmode", "systemmode", "texvar", "texstr", "isarray", "prefix", "dimension", "getmacro", "getdimen", "getcount", "gettoks", "setmacro", "setdimen", "setcount", "settoks", "positionpath", "positioncurve", "positionxy", "positionpxy", "positionwhd", "positionpage", "positionregion", "positionbox", "positionanchor", "positioninregion", "positionatanchor", "wdpart", "htpart", "dppart", "texvar", "texstr", "inpath", "pointof", "leftof", "rightof", "utfnum", "utflen", "utfsub", "newhash", "disposehash", "inhash", "tohash", "isarray", "prefix", "isobject", "comment", "report", "lua", "lualist", "mp", "MP", "luacall", "mirrored", "mirroredabout", "scriptindex", "newscriptindex", "newcolor", "newrgbcolor", "newcmykcolor", "newnumeric", "newboolean", "newtransform", "newpath", "newpicture", "newstring", "newpair" },
  ["internals"]={ "nocolormodel", "greycolormodel", "graycolormodel", "rgbcolormodel", "cmykcolormodel", "shadefactor", "shadeoffset", "textextoffset", "textextanchor", "normaltransparent", "multiplytransparent", "screentransparent", "overlaytransparent", "softlighttransparent", "hardlighttransparent", "colordodgetransparent", "colorburntransparent", "darkentransparent", "lightentransparent", "differencetransparent", "exclusiontransparent", "huetransparent", "saturationtransparent", "colortransparent", "luminositytransparent", "ahvariant", "ahdimple", "ahfactor", "ahscale", "metapostversion", "maxdimensions", "drawoptionsfactor", "dq", "sq", "crossingscale", "crossingoption", "contextlmtxmode", "metafunversion", "minifunversion", "getparameters", "presetparameters", "hasparameter", "hasoption", "getparameter", "getparameterdefault", "getparametercount", "getmaxparametercount", "getparameterpath", "getparameterpen", "getparametertext", "applyparameters", "pushparameters", "popparameters", "definecolor" },
 }
\ No newline at end of file
diff --git a/context/data/scite/context/scite-context-data-metafun.properties b/context/data/scite/context/scite-context-data-metafun.properties
index ac2a048df..79f8b5087 100644
--- a/context/data/scite/context/scite-context-data-metafun.properties
+++ b/context/data/scite/context/scite-context-data-metafun.properties
@@ -72,12 +72,13 @@ positionpath positioncurve positionxy positionpxy positionwhd \
 positionpage positionregion positionbox positionanchor positioninregion \
 positionatanchor wdpart htpart dppart texvar \
 texstr inpath pointof leftof rightof \
-utflen utfsub newhash disposehash inhash \
-tohash isarray prefix isobject comment \
-report lua lualist mp MP \
-luacall mirrored mirroredabout scriptindex newscriptindex \
-newcolor newrgbcolor newcmykcolor newnumeric newboolean \
-newtransform newpath newpicture newstring newpair 
+utfnum utflen utfsub newhash disposehash \
+inhash tohash isarray prefix isobject \
+comment report lua lualist mp \
+MP luacall mirrored mirroredabout scriptindex \
+newscriptindex newcolor newrgbcolor newcmykcolor newnumeric \
+newboolean newtransform newpath newpicture newstring \
+newpair 
 
 keywordclass.metafun.internals=\
 nocolormodel greycolormodel graycolormodel rgbcolormodel \
diff --git a/context/data/textadept/context/data/scite-context-data-metafun.lua b/context/data/textadept/context/data/scite-context-data-metafun.lua
index d02ed5332..edbf39a57 100644
--- a/context/data/textadept/context/data/scite-context-data-metafun.lua
+++ b/context/data/textadept/context/data/scite-context-data-metafun.lua
@@ -1,4 +1,4 @@
 return {
- ["commands"]={ "loadfile", "loadimage", "loadmodule", "dispose", "nothing", "transparency", "tolist", "topath", "tocycle", "sqr", "log", "ln", "exp", "inv", "pow", "pi", "radian", "tand", "cotd", "sin", "cos", "tan", "cot", "atan", "asin", "acos", "invsin", "invcos", "invtan", "acosh", "asinh", "sinh", "cosh", "tanh", "zmod", "paired", "tripled", "unitcircle", "fulldiamond", "unitdiamond", "fullsquare", "unittriangle", "fulltriangle", "llcircle", "lrcircle", "urcircle", "ulcircle", "tcircle", "bcircle", "lcircle", "rcircle", "lltriangle", "lrtriangle", "urtriangle", "ultriangle", "uptriangle", "downtriangle", "lefttriangle", "righttriangle", "triangle", "smoothed", "cornered", "superellipsed", "randomized", "randomizedcontrols", "squeezed", "enlonged", "shortened", "punked", "curved", "unspiked", "simplified", "blownup", "stretched", "enlarged", "leftenlarged", "topenlarged", "rightenlarged", "bottomenlarged", "crossed", "laddered", "randomshifted", "interpolated", "perpendicular", "paralleled", "cutends", "peepholed", "llenlarged", "lrenlarged", "urenlarged", "ulenlarged", "llmoved", "lrmoved", "urmoved", "ulmoved", "rightarrow", "leftarrow", "centerarrow", "drawdoublearrows", "boundingbox", "innerboundingbox", "outerboundingbox", "pushboundingbox", "popboundingbox", "boundingradius", "boundingcircle", "boundingpoint", "crossingunder", "insideof", "outsideof", "bottomboundary", "leftboundary", "topboundary", "rightboundary", "xsized", "ysized", "xysized", "sized", "xyscaled", "intersection_point", "intersection_found", "penpoint", "bbwidth", "bbheight", "withshade", "withcircularshade", "withlinearshade", "defineshade", "shaded", "shadedinto", "withshadecolors", "withshadedomain", "withshademethod", "withshadefactor", "withshadevector", "withshadecenter", "withshadedirection", "withshaderadius", "withshadetransform", "withshadestep", "withshadefraction", "withshadeorigin", "shownshadevector", "shownshadeorigin", "shownshadedirection", "shownshadecenter", "cmyk", "spotcolor", "multitonecolor", "namedcolor", "drawfill", "undrawfill", "inverted", "uncolored", "softened", "grayed", "greyed", "onlayer", "along", "graphictext", "loadfigure", "externalfigure", "figure", "register", "outlinetext", "filloutlinetext", "drawoutlinetext", "outlinetexttopath", "checkedbounds", "checkbounds", "strut", "rule", "withmask", "bitmapimage", "colordecimals", "ddecimal", "dddecimal", "ddddecimal", "colordecimalslist", "textext", "thetextext", "rawtextext", "textextoffset", "texbox", "thetexbox", "rawtexbox", "istextext", "rawmadetext", "validtexbox", "onetimetextext", "rawfmttext", "thefmttext", "fmttext", "onetimefmttext", "notcached", "keepcached", "verbatim", "thelabel", "label", "autoalign", "transparent", "withtransparency", "withopacity", "property", "properties", "withproperties", "asgroup", "infont", "space", "crlf", "dquote", "percent", "SPACE", "CRLF", "DQUOTE", "PERCENT", "grayscale", "greyscale", "withgray", "withgrey", "colorpart", "colorlike", "readfile", "clearxy", "unitvector", "center", "epsed", "anchored", "originpath", "infinite", "break", "xstretched", "ystretched", "snapped", "pathconnectors", "function", "constructedfunction", "constructedpath", "constructedpairs", "straightfunction", "straightpath", "straightpairs", "curvedfunction", "curvedpath", "curvedpairs", "evenly", "oddly", "condition", "pushcurrentpicture", "popcurrentpicture", "arrowpath", "resetarrows", "tensecircle", "roundedsquare", "colortype", "whitecolor", "blackcolor", "basiccolors", "complementary", "complemented", "resolvedcolor", "normalfill", "normaldraw", "visualizepaths", "detailpaths", "naturalizepaths", "drawboundary", "drawwholepath", "drawpathonly", "visualizeddraw", "visualizedfill", "detaileddraw", "draworigin", "drawboundingbox", "drawpath", "drawpoint", "drawpoints", "drawcontrolpoints", "drawcontrollines", "drawpointlabels", "drawlineoptions", "drawpointoptions", "drawcontroloptions", "drawlabeloptions", "draworiginoptions", "drawboundoptions", "drawpathoptions", "resetdrawoptions", "undashed", "pencilled", "decorated", "redecorated", "undecorated", "passvariable", "passarrayvariable", "tostring", "topair", "format", "formatted", "quotation", "quote", "startpassingvariable", "stoppassingvariable", "eofill", "eoclip", "nofill", "dofill", "fillup", "eofillup", "nodraw", "dodraw", "area", "addbackground", "shadedup", "shadeddown", "shadedleft", "shadedright", "sortlist", "copylist", "shapedlist", "listtocurves", "listtolines", "listsize", "listlast", "uniquelist", "circularpath", "squarepath", "linearpath", "theoffset", "texmode", "systemmode", "texvar", "texstr", "isarray", "prefix", "dimension", "getmacro", "getdimen", "getcount", "gettoks", "setmacro", "setdimen", "setcount", "settoks", "positionpath", "positioncurve", "positionxy", "positionpxy", "positionwhd", "positionpage", "positionregion", "positionbox", "positionanchor", "positioninregion", "positionatanchor", "wdpart", "htpart", "dppart", "texvar", "texstr", "inpath", "pointof", "leftof", "rightof", "utflen", "utfsub", "newhash", "disposehash", "inhash", "tohash", "isarray", "prefix", "isobject", "comment", "report", "lua", "lualist", "mp", "MP", "luacall", "mirrored", "mirroredabout", "scriptindex", "newscriptindex", "newcolor", "newrgbcolor", "newcmykcolor", "newnumeric", "newboolean", "newtransform", "newpath", "newpicture", "newstring", "newpair" },
+ ["commands"]={ "loadfile", "loadimage", "loadmodule", "dispose", "nothing", "transparency", "tolist", "topath", "tocycle", "sqr", "log", "ln", "exp", "inv", "pow", "pi", "radian", "tand", "cotd", "sin", "cos", "tan", "cot", "atan", "asin", "acos", "invsin", "invcos", "invtan", "acosh", "asinh", "sinh", "cosh", "tanh", "zmod", "paired", "tripled", "unitcircle", "fulldiamond", "unitdiamond", "fullsquare", "unittriangle", "fulltriangle", "llcircle", "lrcircle", "urcircle", "ulcircle", "tcircle", "bcircle", "lcircle", "rcircle", "lltriangle", "lrtriangle", "urtriangle", "ultriangle", "uptriangle", "downtriangle", "lefttriangle", "righttriangle", "triangle", "smoothed", "cornered", "superellipsed", "randomized", "randomizedcontrols", "squeezed", "enlonged", "shortened", "punked", "curved", "unspiked", "simplified", "blownup", "stretched", "enlarged", "leftenlarged", "topenlarged", "rightenlarged", "bottomenlarged", "crossed", "laddered", "randomshifted", "interpolated", "perpendicular", "paralleled", "cutends", "peepholed", "llenlarged", "lrenlarged", "urenlarged", "ulenlarged", "llmoved", "lrmoved", "urmoved", "ulmoved", "rightarrow", "leftarrow", "centerarrow", "drawdoublearrows", "boundingbox", "innerboundingbox", "outerboundingbox", "pushboundingbox", "popboundingbox", "boundingradius", "boundingcircle", "boundingpoint", "crossingunder", "insideof", "outsideof", "bottomboundary", "leftboundary", "topboundary", "rightboundary", "xsized", "ysized", "xysized", "sized", "xyscaled", "intersection_point", "intersection_found", "penpoint", "bbwidth", "bbheight", "withshade", "withcircularshade", "withlinearshade", "defineshade", "shaded", "shadedinto", "withshadecolors", "withshadedomain", "withshademethod", "withshadefactor", "withshadevector", "withshadecenter", "withshadedirection", "withshaderadius", "withshadetransform", "withshadestep", "withshadefraction", "withshadeorigin", "shownshadevector", "shownshadeorigin", "shownshadedirection", "shownshadecenter", "cmyk", "spotcolor", "multitonecolor", "namedcolor", "drawfill", "undrawfill", "inverted", "uncolored", "softened", "grayed", "greyed", "onlayer", "along", "graphictext", "loadfigure", "externalfigure", "figure", "register", "outlinetext", "filloutlinetext", "drawoutlinetext", "outlinetexttopath", "checkedbounds", "checkbounds", "strut", "rule", "withmask", "bitmapimage", "colordecimals", "ddecimal", "dddecimal", "ddddecimal", "colordecimalslist", "textext", "thetextext", "rawtextext", "textextoffset", "texbox", "thetexbox", "rawtexbox", "istextext", "rawmadetext", "validtexbox", "onetimetextext", "rawfmttext", "thefmttext", "fmttext", "onetimefmttext", "notcached", "keepcached", "verbatim", "thelabel", "label", "autoalign", "transparent", "withtransparency", "withopacity", "property", "properties", "withproperties", "asgroup", "infont", "space", "crlf", "dquote", "percent", "SPACE", "CRLF", "DQUOTE", "PERCENT", "grayscale", "greyscale", "withgray", "withgrey", "colorpart", "colorlike", "readfile", "clearxy", "unitvector", "center", "epsed", "anchored", "originpath", "infinite", "break", "xstretched", "ystretched", "snapped", "pathconnectors", "function", "constructedfunction", "constructedpath", "constructedpairs", "straightfunction", "straightpath", "straightpairs", "curvedfunction", "curvedpath", "curvedpairs", "evenly", "oddly", "condition", "pushcurrentpicture", "popcurrentpicture", "arrowpath", "resetarrows", "tensecircle", "roundedsquare", "colortype", "whitecolor", "blackcolor", "basiccolors", "complementary", "complemented", "resolvedcolor", "normalfill", "normaldraw", "visualizepaths", "detailpaths", "naturalizepaths", "drawboundary", "drawwholepath", "drawpathonly", "visualizeddraw", "visualizedfill", "detaileddraw", "draworigin", "drawboundingbox", "drawpath", "drawpoint", "drawpoints", "drawcontrolpoints", "drawcontrollines", "drawpointlabels", "drawlineoptions", "drawpointoptions", "drawcontroloptions", "drawlabeloptions", "draworiginoptions", "drawboundoptions", "drawpathoptions", "resetdrawoptions", "undashed", "pencilled", "decorated", "redecorated", "undecorated", "passvariable", "passarrayvariable", "tostring", "topair", "format", "formatted", "quotation", "quote", "startpassingvariable", "stoppassingvariable", "eofill", "eoclip", "nofill", "dofill", "fillup", "eofillup", "nodraw", "dodraw", "area", "addbackground", "shadedup", "shadeddown", "shadedleft", "shadedright", "sortlist", "copylist", "shapedlist", "listtocurves", "listtolines", "listsize", "listlast", "uniquelist", "circularpath", "squarepath", "linearpath", "theoffset", "texmode", "systemmode", "texvar", "texstr", "isarray", "prefix", "dimension", "getmacro", "getdimen", "getcount", "gettoks", "setmacro", "setdimen", "setcount", "settoks", "positionpath", "positioncurve", "positionxy", "positionpxy", "positionwhd", "positionpage", "positionregion", "positionbox", "positionanchor", "positioninregion", "positionatanchor", "wdpart", "htpart", "dppart", "texvar", "texstr", "inpath", "pointof", "leftof", "rightof", "utfnum", "utflen", "utfsub", "newhash", "disposehash", "inhash", "tohash", "isarray", "prefix", "isobject", "comment", "report", "lua", "lualist", "mp", "MP", "luacall", "mirrored", "mirroredabout", "scriptindex", "newscriptindex", "newcolor", "newrgbcolor", "newcmykcolor", "newnumeric", "newboolean", "newtransform", "newpath", "newpicture", "newstring", "newpair" },
  ["internals"]={ "nocolormodel", "greycolormodel", "graycolormodel", "rgbcolormodel", "cmykcolormodel", "shadefactor", "shadeoffset", "textextoffset", "textextanchor", "normaltransparent", "multiplytransparent", "screentransparent", "overlaytransparent", "softlighttransparent", "hardlighttransparent", "colordodgetransparent", "colorburntransparent", "darkentransparent", "lightentransparent", "differencetransparent", "exclusiontransparent", "huetransparent", "saturationtransparent", "colortransparent", "luminositytransparent", "ahvariant", "ahdimple", "ahfactor", "ahscale", "metapostversion", "maxdimensions", "drawoptionsfactor", "dq", "sq", "crossingscale", "crossingoption", "contextlmtxmode", "metafunversion", "minifunversion", "getparameters", "presetparameters", "hasparameter", "hasoption", "getparameter", "getparameterdefault", "getparametercount", "getmaxparametercount", "getparameterpath", "getparameterpen", "getparametertext", "applyparameters", "pushparameters", "popparameters", "definecolor" },
 }
\ No newline at end of file
diff --git a/context/data/vscode/extensions/context/syntaxes/context-syntax-mps.json b/context/data/vscode/extensions/context/syntaxes/context-syntax-mps.json
index 9000bd62f..29bb24058 100644
--- a/context/data/vscode/extensions/context/syntaxes/context-syntax-mps.json
+++ b/context/data/vscode/extensions/context/syntaxes/context-syntax-mps.json
@@ -60,7 +60,7 @@
    "name" : "context.extra"
   },
   "helper" : {
-   "match" : "(zmod|ystretched|ysized|xysized|xyscaled|xstretched|xsized|withtransparency|withshadevector|withshadetransform|withshadestep|withshaderadius|withshadeorigin|withshademethod|withshadefraction|withshadefactor|withshadedomain|withshadedirection|withshadecolors|withshadecenter|withshade|withproperties|withopacity|withmask|withlinearshade|withgrey|withgray|withcircularshade|whitecolor|wdpart|visualizepaths|visualizedfill|visualizeddraw|verbatim|validtexbox|utfsub|utflen|urtriangle|urmoved|urenlarged|urcircle|uptriangle|unspiked|unitvector|unittriangle|unitdiamond|unitcircle|uniquelist|undrawfill|undecorated|undashed|uncolored|ultriangle|ulmoved|ulenlarged|ulcircle|tripled|triangle|transparent|transparency|tostring|topenlarged|topboundary|topath|topair|tolist|tohash|tocycle|thetextext|thetexbox|theoffset|thelabel|thefmttext|texvar|texvar|textextoffset|textext|texstr|texstr|texmode|texbox|tensecircle|tcircle|tanh|tand|tan|systemmode|superellipsed|strut|stretched|straightpath|straightpairs|straightfunction|stoppassingvariable|startpassingvariable|squeezed|squarepath|sqr|spotcolor|space|sortlist|softened|snapped|smoothed|sized|sinh|sin|simplified|shownshadevector|shownshadeorigin|shownshadedirection|shownshadecenter|shortened|shapedlist|shadedup|shadedright|shadedleft|shadedinto|shadeddown|shaded|settoks|setmacro|setdimen|setcount|scriptindex|rule|roundedsquare|righttriangle|rightof|rightenlarged|rightboundary|rightarrow|resolvedcolor|resetdrawoptions|resetarrows|report|register|redecorated|readfile|rcircle|rawtextext|rawtexbox|rawmadetext|rawfmttext|randomshifted|randomizedcontrols|randomized|radian|quote|quotation|pushcurrentpicture|pushboundingbox|punked|property|properties|prefix|prefix|pow|positionxy|positionwhd|positionregion|positionpxy|positionpath|positionpage|positioninregion|positioncurve|positionbox|positionatanchor|positionanchor|popcurrentpicture|popboundingbox|pointof|pi|perpendicular|percent|penpoint|pencilled|peepholed|pathconnectors|passvariable|passarrayvariable|paralleled|paired|outsideof|outlinetexttopath|outlinetext|outerboundingbox|originpath|onlayer|onetimetextext|onetimefmttext|oddly|nothing|notcached|normalfill|normaldraw|nofill|nodraw|newtransform|newstring|newscriptindex|newrgbcolor|newpicture|newpath|newpair|newnumeric|newhash|newcolor|newcmykcolor|newboolean|naturalizepaths|namedcolor|multitonecolor|mp|mirroredabout|mirrored|lualist|luacall|lua|lrtriangle|lrmoved|lrenlarged|lrcircle|log|loadmodule|loadimage|loadfile|loadfigure|ln|lltriangle|llmoved|llenlarged|llcircle|listtolines|listtocurves|listsize|listlast|linearpath|lefttriangle|leftof|leftenlarged|leftboundary|leftarrow|lcircle|laddered|label|keepcached|istextext|isobject|isarray|isarray|invtan|invsin|inverted|invcos|inv|intersection_point|intersection_found|interpolated|insideof|inpath|innerboundingbox|inhash|infont|infinite|htpart|greyscale|greyed|grayscale|grayed|graphictext|gettoks|getmacro|getdimen|getcount|function|fulltriangle|fullsquare|fulldiamond|formatted|format|fmttext|fillup|filloutlinetext|figure|externalfigure|exp|evenly|epsed|eofillup|eofill|eoclip|enlonged|enlarged|drawwholepath|drawpoints|drawpointoptions|drawpointlabels|drawpoint|drawpathoptions|drawpathonly|drawpath|drawoutlinetext|draworiginoptions|draworigin|drawlineoptions|drawlabeloptions|drawfill|drawdoublearrows|drawcontrolpoints|drawcontroloptions|drawcontrollines|drawboundoptions|drawboundingbox|drawboundary|dquote|dppart|downtriangle|dofill|dodraw|disposehash|dispose|dimension|detailpaths|detaileddraw|defineshade|decorated|ddecimal|dddecimal|ddddecimal|cutends|curvedpath|curvedpairs|curvedfunction|curved|crossingunder|crossed|crlf|cotd|cot|cosh|cos|cornered|copylist|constructedpath|constructedpairs|constructedfunction|condition|complemented|complementary|comment|colortype|colorpart|colorlike|colordecimalslist|colordecimals|cmyk|clearxy|circularpath|checkedbounds|checkbounds|centerarrow|center|break|boundingradius|boundingpoint|boundingcircle|boundingbox|bottomenlarged|bottomboundary|blownup|blackcolor|bitmapimage|bcircle|bbwidth|bbheight|basiccolors|autoalign|atan|asinh|asin|asgroup|arrowpath|area|anchored|along|addbackground|acosh|acos|SPACE|PERCENT|MP|DQUOTE|CRLF)(?=[^a-zA-Z\u005C_@!?-ÿ])",
+   "match" : "(zmod|ystretched|ysized|xysized|xyscaled|xstretched|xsized|withtransparency|withshadevector|withshadetransform|withshadestep|withshaderadius|withshadeorigin|withshademethod|withshadefraction|withshadefactor|withshadedomain|withshadedirection|withshadecolors|withshadecenter|withshade|withproperties|withopacity|withmask|withlinearshade|withgrey|withgray|withcircularshade|whitecolor|wdpart|visualizepaths|visualizedfill|visualizeddraw|verbatim|validtexbox|utfsub|utfnum|utflen|urtriangle|urmoved|urenlarged|urcircle|uptriangle|unspiked|unitvector|unittriangle|unitdiamond|unitcircle|uniquelist|undrawfill|undecorated|undashed|uncolored|ultriangle|ulmoved|ulenlarged|ulcircle|tripled|triangle|transparent|transparency|tostring|topenlarged|topboundary|topath|topair|tolist|tohash|tocycle|thetextext|thetexbox|theoffset|thelabel|thefmttext|texvar|texvar|textextoffset|textext|texstr|texstr|texmode|texbox|tensecircle|tcircle|tanh|tand|tan|systemmode|superellipsed|strut|stretched|straightpath|straightpairs|straightfunction|stoppassingvariable|startpassingvariable|squeezed|squarepath|sqr|spotcolor|space|sortlist|softened|snapped|smoothed|sized|sinh|sin|simplified|shownshadevector|shownshadeorigin|shownshadedirection|shownshadecenter|shortened|shapedlist|shadedup|shadedright|shadedleft|shadedinto|shadeddown|shaded|settoks|setmacro|setdimen|setcount|scriptindex|rule|roundedsquare|righttriangle|rightof|rightenlarged|rightboundary|rightarrow|resolvedcolor|resetdrawoptions|resetarrows|report|register|redecorated|readfile|rcircle|rawtextext|rawtexbox|rawmadetext|rawfmttext|randomshifted|randomizedcontrols|randomized|radian|quote|quotation|pushcurrentpicture|pushboundingbox|punked|property|properties|prefix|prefix|pow|positionxy|positionwhd|positionregion|positionpxy|positionpath|positionpage|positioninregion|positioncurve|positionbox|positionatanchor|positionanchor|popcurrentpicture|popboundingbox|pointof|pi|perpendicular|percent|penpoint|pencilled|peepholed|pathconnectors|passvariable|passarrayvariable|paralleled|paired|outsideof|outlinetexttopath|outlinetext|outerboundingbox|originpath|onlayer|onetimetextext|onetimefmttext|oddly|nothing|notcached|normalfill|normaldraw|nofill|nodraw|newtransform|newstring|newscriptindex|newrgbcolor|newpicture|newpath|newpair|newnumeric|newhash|newcolor|newcmykcolor|newboolean|naturalizepaths|namedcolor|multitonecolor|mp|mirroredabout|mirrored|lualist|luacall|lua|lrtriangle|lrmoved|lrenlarged|lrcircle|log|loadmodule|loadimage|loadfile|loadfigure|ln|lltriangle|llmoved|llenlarged|llcircle|listtolines|listtocurves|listsize|listlast|linearpath|lefttriangle|leftof|leftenlarged|leftboundary|leftarrow|lcircle|laddered|label|keepcached|istextext|isobject|isarray|isarray|invtan|invsin|inverted|invcos|inv|intersection_point|intersection_found|interpolated|insideof|inpath|innerboundingbox|inhash|infont|infinite|htpart|greyscale|greyed|grayscale|grayed|graphictext|gettoks|getmacro|getdimen|getcount|function|fulltriangle|fullsquare|fulldiamond|formatted|format|fmttext|fillup|filloutlinetext|figure|externalfigure|exp|evenly|epsed|eofillup|eofill|eoclip|enlonged|enlarged|drawwholepath|drawpoints|drawpointoptions|drawpointlabels|drawpoint|drawpathoptions|drawpathonly|drawpath|drawoutlinetext|draworiginoptions|draworigin|drawlineoptions|drawlabeloptions|drawfill|drawdoublearrows|drawcontrolpoints|drawcontroloptions|drawcontrollines|drawboundoptions|drawboundingbox|drawboundary|dquote|dppart|downtriangle|dofill|dodraw|disposehash|dispose|dimension|detailpaths|detaileddraw|defineshade|decorated|ddecimal|dddecimal|ddddecimal|cutends|curvedpath|curvedpairs|curvedfunction|curved|crossingunder|crossed|crlf|cotd|cot|cosh|cos|cornered|copylist|constructedpath|constructedpairs|constructedfunction|condition|complemented|complementary|comment|colortype|colorpart|colorlike|colordecimalslist|colordecimals|cmyk|clearxy|circularpath|checkedbounds|checkbounds|centerarrow|center|break|boundingradius|boundingpoint|boundingcircle|boundingbox|bottomenlarged|bottomboundary|blownup|blackcolor|bitmapimage|bcircle|bbwidth|bbheight|basiccolors|autoalign|atan|asinh|asin|asgroup|arrowpath|area|anchored|along|addbackground|acosh|acos|SPACE|PERCENT|MP|DQUOTE|CRLF)(?=[^a-zA-Z\u005C_@!?-ÿ])",
    "name" : "context.command.metafun.helper.mps"
   },
   "identifier" : {
diff --git a/doc/context/documents/general/manuals/luametatex.pdf b/doc/context/documents/general/manuals/luametatex.pdf
index 635e56000..f5ece94d6 100644
--- a/doc/context/documents/general/manuals/luametatex.pdf
+++ b/doc/context/documents/general/manuals/luametatex.pdf
diff --git a/doc/context/sources/general/manuals/followingup/followingup-fonts.tex b/doc/context/sources/general/manuals/followingup/followingup-fonts.tex
index 2f7320b12..6bc10e929 100644
--- a/doc/context/sources/general/manuals/followingup/followingup-fonts.tex
+++ b/doc/context/sources/general/manuals/followingup/followingup-fonts.tex
@@ -23,7 +23,24 @@ Fonts come in sizes, and for instance Latin Modern has quite a few variants wher
 the shapes are adapted to the size. This means that when you need a 9pt regular
 shape alongside a 12pt one, two fonts have to be loaded. This is quite visible in
 math where we have three related sizes: text, script and scriptscript, grouped in
-so called families.
+so called families. When we scale the digit~2 to the same height you will notice
+that the text, script and scriptscript sizes look different (the last three are
+unscaled):
+
+\startlinecorrection
+\dontleavehmode\scale[frame=on,height=5ex]{$\textstyle         2$}\quad
+\dontleavehmode\scale[frame=on,height=5ex]{$\scriptstyle       2$}\quad
+\dontleavehmode\scale[frame=on,height=5ex]{$\scriptscriptstyle 2$}\quad\quad
+\dontleavehmode\scale[frame=on,height=2ex]{$\textstyle         2$}\quad
+\dontleavehmode\scale[frame=on,height=2ex]{$\scriptstyle       2$}\quad
+\dontleavehmode\scale[frame=on,height=2ex]{$\scriptscriptstyle 2$}\quad\quad
+\dontleavehmode\scale[frame=on,width=4em]{\colored[r=.6,a=1,t=.5]{$\textstyle         2$}}\hskip-4em
+\dontleavehmode\scale[frame=on,width=4em]{\colored[g=.6,a=1,t=.5]{$\scriptstyle       2$}}\hskip-4em
+\dontleavehmode\scale[frame=on,width=4em]{\colored[b=.6,a=1,t=.5]{$\scriptscriptstyle 2$}}\quad\quad
+\dontleavehmode{$\textstyle         2$}\quad
+\dontleavehmode{$\scriptstyle       2$}\quad
+\dontleavehmode{$\scriptscriptstyle 2$}\quad
+\stoplinecorrection
 
 Plenty has been written (in various documents that come with \CONTEXT) about how
 this all works together and how it impacts the design of the system, so here I
@@ -34,62 +51,82 @@ just give a short summary of what a font system has to deal with.
     In a bodyfont setup different sizes (9pt, 10pt, 12pt) can have their own
     specific set of fonts. This can result in quite some definitions that relate
     to the style, like regular, bold, italic, bolditalic, slanted and
-    boldslanted, etc. When possible loading the fonts is delayed.
+    boldslanted, etc. When possible loading the fonts is delayed. But in
+    \CONTEXT\ often the number of actually loaded fonts is not that large.
 \stopitem
 \startitem
     Some font designs have different shapes per bodyfont size. A minor
-    complication is that when one is missing some heuristic best match choice
-    might be needed.
+    complication is that when one is missing some heuristic best|-|match choice
+    might be needed. Okay, in practice only Latin Modern falls into this
+    category. Maybe \OPENTYPE\ variable fonts can be seen this way, but, although
+    we supported that right from the start, I haven't noticed much interest in
+    the \TEX\ community.
 \stopitem
 \startitem
     Within a bodyfont size we distinguish size variants. We can go smaller (x and
     xx), for instance when we use sub- and superscripts in text, or we can go
-    larger, for instance in titling (a, b, c, d, \unknown). Fortunately most of
+    larger, for instance in titles (a, b, c, d, \unknown). Fortunately most of
     the loading of these can be delayed too.
 \stopitem
 \startitem
     When instances are not available, scaling can be used, as happens for
     instance with 11pt in Computer Modern. Actually, this is why in \CONTEXT\ we
     default to 12pt, because the scaled versions didn't look as nice as the
-    others.
+    others (keep in mind that we started in the age of bitmaps).
 \stopitem
 \startitem
     Special features, like smallcaps or oldstyle numerals, can demand their own
     definitions. More loading and automatic definitions can be triggered by sizes
-    needed in for instance scripts and titling.
+    needed in for instance scripts and titles.
 \stopitem
 \startitem
     A document can have a mixed setup, that is: use different font designs in one
     document, so some kind of namespace subsystem is needed.
 \stopitem
 \startitem
-    In traditional eight bit engine the dependency of hyphenation on the encoding
-    of a font can result in the necessity to load a font multiple times in
-    different encodings, something that depends on the language mix used.
+    In an eight bit font world, we not only have text fonts but also collections
+    of symbols, and even in math there are additional symbol collections. In
+    \OPENTYPE\ symbols end up in text fonts, but there we have tons of emoji's
+    and color fonts. All has to be dealt with in an integrated way. And we're
+    not even talking of virtual fonts, (runtime) \METAPOST\ generated fonts, and
+    so on.
+\stopitem
+\startitem
+    In traditional eight bit engines the dependency of hyphenation on the
+    encoding of a font can result in the necessity to load a font multiple times
+    in different encodings, something that depends on the language mix used.
+    Interesting is that coming up with an European encoding (covering most Latin
+    languages) was not that hard, especially when one keeps in mind that many
+    eight bit encodings waste slots on seldom used symbols, but by that time
+    \OPENTYPE\ and and \UNICODE\ input started to dominate.
 \stopitem
 \startitem
     In the more modern \OPENTYPE\ fonts combinations of features can demand
-    additional instances (one can thing of language|/|script combinations,
+    additional instances (one can think of language|/|script combinations,
     substitutions in base mode, special effects like boldening, color fonts,
     etc.).
 \stopitem
 \startitem
-    Math is complicated by the fact that alphabets come from different fonts
-    (sometimes a font has several alphabets which means that some mapping can be
-    needed). Operating on the size, shape, encoding and style axes puts some
-    demands on the font system. Add to this (often) partial (due to lack of
-    fonts) bold support and it gets even more complicated.
+    Math is complicated by the fact that in traditional \TEX\ alphabets come from
+    different fonts which is why we have many so called families; sometimes a
+    font has several alphabets which means that some mapping can be needed.
+    Operating on the size, shape, encoding and style axes puts some demands on
+    the font system. Add to this (often) partial (due to lack of fonts) bold
+    support and it gets even more complicated. In \OPENTYPE\ all the alphabets
+    come from one font.
 \stopitem
 \startitem
     There is additional math auto|-|definition and loading code for the sizes
-    used in text scripts and titling.
+    used in text scripts and titles.
 \stopitem
 \stopitemize
 
 All this has resulted in a pretty complex subsystem. Although going \OPENTYPE\
 (and emulated \OPENTYPE\ with \TYPEONE\ fonts as we do in \MKIV) removes some
 complications, like encodings, it does also add complexity because of the many
-possible font features, either or not dependent on script and language.
+possible font features, either or not dependent on script and language. Text as
+well as math got simpler at the \TEX\ end (but that is compensated by quite a bit
+\LUA\ code that deals with new features).
 
 Also, in order to let a font subsystem not impact performance to much, let alone
 extensive memory usage, the \CONTEXT\ font subsystem is rather optimized. The
@@ -102,26 +139,27 @@ always been rather fast.
 \startsection[title={Reality}]
 
 In \MKIV\ and therefore also in \LMTX\ more font magic happens. The initial node
-lists that makes up a box or paragraph can get manipulated in several ways and
-often fonts are involved. The mentioned font features can be defines static (as
-part of the definition) or dynamic (resolved on the spot at the cost of some
-overhead). Characters can be remapped, fonts can be replaced. The math subsystem
-in \MKIV\ was different right from the start: we use a limited number of families
-(regular, bold, l2r and r2l), and stay abstract till the moment we need to deal
-with the specific alphabets. But still, in \MKIV, we have the families with three
-fonts.
+lists that make up a box or paragraph can get manipulated in several ways and
+often fonts are involved. The font features (smallcaps, oldstyle, alternates,
+etc.) can be defined static (as part of the definition) or dynamic (resolved on
+the spot at the cost of some overhead). Characters can be remapped, fonts can be
+replaced. The math subsystem in \MKIV\ was different right from the start: we use
+a limited number of families (regular, bold, l2r and r2l), and stay abstract till
+the moment we need to deal with the specific alphabets. But still, in \MKIV, we
+have the families with three fonts.
 
 In the \LUAMETATEX\ manual we show some math magic and we do so for different
-fonts. As a side effect, we set up half a dozen bodyfont collections. Even with
-delayed and shared font loading, we end up with 158 instances but quite a bit of
-them are math fonts, at least six per bodyfont size: regular and bold (boldened)
-text, script and scriptscript. Of course most are just copies with different
-scaling that reuse already loaded resources.
+fonts. As a side effect, we set up half a dozen bodyfont collections: Lucida,
+Pagella, Latin Modern, Dejavu, the math standard Cambria, etc. Even with delayed
+and shared font loading, we end up with 158 instances but quite a bit of them are
+math fonts, at least six per bodyfont size: regular and bold (boldened) text,
+script and scriptscript. Of course most are just copies with different scaling
+that reuse already loaded resources. In the final\PDF\ we have 21 subset fonts.
 
 If we look at the math fonts that we use today, there is however quite some
 overlap. It starts with a text font. From that script and scriptscript variants
 are derived, but often these variants use many text size related shapes too. Some
-shapes get alternatives (from the \type {ssty} feature), and the whole clone get
+shapes get alternatives (from the \type {ssty} feature), and the whole clone gets
 scaled. But, much of the logic of for instance extensibles is the same.
 
 A similar situation happens with for instance large \CJK\ fonts: there are hardly
@@ -130,19 +168,25 @@ dimensions, and these fonts can be real huge!
 
 Actually, when we talk about features, in many cases in \CONTEXT\ you don't
 define them as part of the font. For instance small caps can best be triggered by
-using a dynamic feature: applied to a specific stretch of text. When the font
-handler does its work there are actually four cases: no features get applied,
-something that for instance happens with most monospaced fonts, base mode is
-used, which means that the \TEX\ machinery takes care of constructing ligatures
-and injecting kerns, and node mode, where \LUA\ handles the features. The fourth
-case is a special case of node mode where a different features set is applied.
-\footnote {We also have so called plug mode where an external rendered can do the
-work but that one is only around for some experiments during Idris' font
-development.} At the cost of some extra overhead (for each node mode run) dynamic
-features are quite powerful and save quite some memory and definitions. The
-overhead comes from much more testing regarding the font we deal with because
-suddenly the same font can demand different treatments, depending on what dynamic
-features is active.
+using a dynamic feature: applied to a specific stretch of text. In fact, often
+features like superiors of fractions only work well on characters that fit the
+bill and produce weird side effects otherwise (a matter of design completeness).
+When the font handler does its work there are actually four cases: no features
+get applied, something that for instance happens with most mono spaced fonts,
+base mode is used, which means that the \TEX\ machinery takes care of
+constructing ligatures and injecting kerns, and node mode, where \LUA\ handles
+the features. The fourth case is a special case of node mode where a different
+feature set is applied. \footnote {We also have so called plug mode where an
+external renderer can do the work but that one is only around for some
+experiments during Idris Hamid's font development.} At the cost of some extra
+overhead (for each node mode run) dynamic features are quite powerful and save
+quite some memory and definitions. \footnote {The generic font handler that is
+derived from the \CONTEXT\ one doesn't implement this so it runs a little
+faster.} The overhead comes from much more testing regarding the font we deal
+with because suddenly the same font can demand different treatments, depending on
+what dynamic features are active. \footnote {Originally this model was introduced
+for a dynamic paragraph optimization subsystem for Arabic but no one really uses
+it because there there are no suitable fonts.}
 
 Although the font handling is responsible for much of the time spent in \LUA, it is
 still reasonable given what has to be done. Actually, because we have an extensible
@@ -183,8 +227,8 @@ e{\glyphxscale 2500 ffi}cient
 
 So, in order to deal with this kind of scaling, we now operate not only on the
 font (id) and dynamic feature axes, but also on the scales of which we have three
-variants: glyph scale, glyph xscale and glyph y scale). There is actually also a
-state dimension but we leave that for now. Think of flagging glyphs as initial or
+variants: glyph scale, glyph xscale and glyph yscale). There is actually also a
+state dimension but we leave that for now; think of flagging glyphs as initial or
 final. This brings the number of axis to six. It is important to stress that in
 these examples the same font instance is used!
 
@@ -197,22 +241,22 @@ go together but for now I see no real gain in that.
 
 \startsection[title={Math}]
 
-Given what is written in the previous sections, a logical question is if we can
-apply scaling to math and the answer is \quotation {yes, we can}. But we actually
-go a bit further and that is partly due to some other properties of the engine.
+Given what is written in the previous sections, a logical question would be
+\quotation {Can we apply scaling to math?} and the answer is \quotation {Yes, we
+can!}. But we actually go a bit further and that is partly due to some other
+properties of the engine.
 
 From \PDFTEX\ the \LUATEX\ engines inherited character protrusion and glyph
 expansions, aka hz. However, where in \PDFTEX\ copies of the font are made that
 carry the expanded dimensions, in \LUATEX\ at some point this was replaced by an
 expansion field in the glyph and kern nodes. So, instead of changing the font id
 of expanded glyphs, the same id is used but with the applied expansion factor set
-in the glyph. A side effect was that in places where dimensions are needed, calls
-to functions that calculate the expanded widths on request (as these can change
-during linebreak calculations) in combination with accessing font dimensions
-directly, we now always use accessor functions. This level of abstraction is even
-more present in \LUAMETATEX. This means that we have an uniform interface to
-fonts and as a side effect scaling is to be dealt with in only a few places in
-the code.
+in the glyph. A side effect was that in places where dimensions are needed, we
+call functions that calculate the expanded widths on request (as these can
+change during linebreak calculations) in combination with accessing font
+dimensions directly. This level of abstraction is even more present in
+\LUAMETATEX. This means that we have an uniform interface to fonts and as a side
+effect scaling is to be dealt with in only a few places in the code.
 
 Now, in math we have a few more complications. First of all, we have three sizes
 to consider and we also have lots of parameters that depend on the size. But, as
@@ -236,9 +280,9 @@ the math engine needs a specific character at a given size (text, script,
 scriptscript) we just follow that chain.
 
 In an \OPENTYPE\ math font the script and scriptscript sizes are specified as
-percentages of the text size. So, when the dimensions of a glyph are needed, we
-just scale on the fly. Again this adds some overhead but I'm pretty sure that no
-user will notice this.
+percentages of the text size. When the dimensions of a glyph are needed, we just
+scale on the fly. Again this adds some overhead but I'm pretty sure that no user
+will notice this.
 
 So, to summarize: if we need a character at scriptscript size, we access the text
 size glyph, check for a pointer to a script size, go there, and again check for a
@@ -246,8 +290,11 @@ smaller size. We just use what fits the bill. And, when we need dimensions we
 just scale. In order to scale we need the relative size, so we need to set that
 up when we load the font. Because in \CONTEXT\ we also can assemble a virtual
 \OPENTYPE\ font from \TYPEONE\ fonts, it was actually that (old) compatibility
-feature that took most time to adapt, not so much because it is complicates but
-because in \LMTX\ we have to bypass some advanced loading mechanisms.
+feature, the one that implements \TYPEONE\ bases \OPENTYPE\ math, that took most
+time to adapt, not so much because it is complicates but because in \LMTX\ we
+have to bypass some advanced loading mechanisms. Because we can scale in two
+dimensions the many (font related) math parameters also need to be dealt with
+accordingly.
 
 The end result is that for math we now only need to define two fonts per bodyfont
 setup: regular and bold at the natural scale (normally 10pt) and we share these
@@ -283,12 +330,12 @@ manual we get these stats:
 \stoptyping
 
 So, we win on all fronts when we use this glyph scale mechanism. The magic
-primitive that deals with this is \type {\glyphscale} which accepts a number,
-where \type {1200} and \type {1.2} both mean scaling to 20\percent\ more than
-normal. But one can best not use this primitive directly.
+primitive that deals with this is \type {\glyphscale} primitive that accepts a
+number, where \type {1200} and \type {1.2} both mean scaling to 20\percent\ more
+than normal. But one can best not use this primitive directly.
 
 A specific font can be defined using the \type {\definefont} command. In \LMTX\ a
-regular scaler can be followed by two scale factors. The nest example
+regular scaler can be followed by two scale factors. The next example
 demonstrates this:
 
 \startbuffer
@@ -311,11 +358,10 @@ only shows the two scales but also introduces the offset.
 
 \getbuffer
 
-Here is another one:
+In compact mode this is one font. Here is another example:
 
 \startbuffer
-\definetweakedfont[squeezed] [xscale=0.9]
-\definetweakedfont[squeezed] [xscale=0.9]
+\definetweakedfont[squeezed][xscale=0.9]
 
 \startlines
 $a = b^2 + \sqrt{c}$
@@ -330,13 +376,13 @@ $a = b^2 + \sqrt{c}$
 Watch this:
 
 \startbuffer
-\startcombination[4*1]
+\startcombination[3*1]
     {\bTABLE
         \bTR \bTD foo \eTD \bTD[style=\squeezed] $x = 1$ \eTD \eTR
         \bTR \bTD oof \eTD \bTD[style=\squeezed] $x = 2$ \eTD \eTR
      \eTABLE}
     {local}
-    {\bTABLE[style=squeezed]
+    {\bTABLE[style=\squeezed]
         \bTR \bTD $x = 1$ \eTD \bTD  $x = 3$ \eTD \eTR
         \bTR \bTD $x = 2$ \eTD \bTD  $x = 4$ \eTD \eTR
      \eTABLE}
@@ -404,20 +450,28 @@ gives:
 \stoplinecorrection
 
 Glyphs can have offsets and these are used for implementing \OPENTYPE\ features.
-However, they are also available at the \TEX\ end. Take this
+However, they are also available at the \TEX\ end. Take this example where we use
+the new \type {\glyph} primitive (a variant of \type {\char} that takes
+keywords):
 
 \startbuffer
 \ruledhbox{
-    \ruledhbox{\glyph yoffset 1ex options 0 123}
+    \ruledhbox{\glyph yoffset 1ex options 0 123} % left curly brace
     \ruledhbox{\glyph xoffset .5em yoffset 1ex options "C0 123}
-    \ruledhbox{oeps{\glyphyoffset 1ex \glyphxscale 800 \glyphyscale\glyphxscale oeps}oeps}
+    \ruledhbox{oeps{\glyphyoffset 1ex \glyphxscale 800
+                    \glyphyscale\glyphxscale oeps}oeps}
 }
 \stopbuffer
 
-This example demonstrates that the \type {\glyph} primitive takes keywords: \type
-{xoffset}, \type {yoffset}, \type {xscale}, \type {yscale}, \type {options},
-\type {font} and \type {id} where the last two take a font identifier or font id
-(an positive number).
+\typebuffer \getbuffer
+
+This example demonstrates that the \type {\glyph} primitive takes quite some
+keywords: \type {xoffset}, \type {yoffset}, \type {xscale}, \type {yscale}, \type
+{left}, \type {right}, \type {raise}, \type {options}, \type {font} and \type {id}
+where the last two take a font identifier or font id (an positive number). For
+this article it's enough to know that the option indicates that glyph dimension
+should include the offset. In a moment we will see an alternative that doesn't
+need that.
 
 \startbuffer
 \samplefile{jojomayer}
@@ -441,7 +495,7 @@ To quote Jojo Mayer:
 \stopnarrower
 
 Keep in mind that this can interfere badly with font feature processing which also
-used offsets. It might work out okay, or not.
+used offsets. It might often work out okay vertically, but less well horizontally.
 
 The scales, as mentioned, works with pseudo scales but that is sometimes a bit
 cumbersome. This is why a special \type {\numericscale} primitive has been
@@ -477,8 +531,8 @@ the slanted version could use some more left shifting of the E.
 
 \typebuffer[definition,example]
 
-This gives is the \TEX\ logos (but of course we normally use the real ones
-instead).
+This gives the \TEX\ logos but of course we normally use the more official
+definitions instead.
 
 \startnarrower
     \darkred \getbuffer[definition,example]
@@ -490,7 +544,7 @@ suboptimal. Here is a better alternative:
 
 \startbuffer[definition]
 \def\UnKernedTeX
-  {T\glyph left .2ex raise -.4ex `E\glyph left .4ex `X\relax}
+  {T\glyph left .2ex raise -.4ex `E\glyph left .2ex `X\relax}
 \stopbuffer
 
 \typebuffer[definition]
@@ -501,7 +555,7 @@ The result is the same:
     \darkgreen \getbuffer[definition,example]
 \stopnarrower
 
-But anyway: don't over|-|do it. We could deal with such cases for decades without
+But anyway: don't over|-|do it. We have dealt with such cases for decades without
 these fancy new features. The next example show margins in action:
 
 \startlinecorrection
@@ -565,23 +619,25 @@ dimensions of a glyph.
 
 Discussing the implementation in the engine makes no sense here, also because
 details might change. However, it is good to know that quite some properties
-travel with the glyph nodes, for instance the scales and offsets. The dimensions
-(width, height and depth) are not stored in the glyph node but calculated from
-the font, scales and optionally the offsets and expansion factor. One problem is
-that the more clever (and nice) solutions we cook up, the more it might impact
-performance. So, I will delay some experiments till I have a more powerful
-machine.
+travel with the glyph nodes, for instance the scales, margins, offsets, language,
+script and state properties, control over kerning, ligaturing, expansion and
+protrusion, etc. The dimensions (width, height and depth) are not stored in the
+glyph node but calculated from the font, scales and optionally the offsets and
+expansion factor. One problem is that the more clever (and nice) solutions we
+cook up, the more it might impact performance. So, I will delay some experiments
+till I have a more powerful machine.
 
 One reason for {\em not} storing the dimensions in a glyph node is that we often
 copy those nodes or change character fields in the font handler and we definitely
 don't want the wrong dimensions there. At that moment, offsets and margin fields
-don't reflect features yet, so copying them is no big deal. However, dimensions
-are rather character bound so every time a character is set, we also would have
-to set the dimensions. Even worse, when we can set them, the question arises if
-they actually were already set explicitly. So, this is a can of worms we're not
-going to open: the basic width, height and depth of the glyph as specified in the
-font is used and combines with actual dimensions (likely already scaled according
-the glyph scales) in offset and margin fields.
+don't reflect features yet, so copying them is no big deal because at that moment
+these are still zero. However, dimensions are rather character bound so every
+time a character is set, we also would have to set the dimensions. Even worse,
+when we can set them, the question arises if they actually were already set
+explicitly. So, this is a can of worms we're not going to open: the basic width,
+height and depth of the glyph as specified in the font is used and combined with
+actual dimensions (likely already scaled according the glyph scales) in offset
+and margin fields.
 
 Now, I have to admit that especially playing with using margins to glyphs instead
 of font kerns is more of an experiment to see what the consequences are than a
diff --git a/doc/context/sources/general/manuals/luatex/luatex-modifications.tex b/doc/context/sources/general/manuals/luatex/luatex-modifications.tex
index 747945f55..bf4233165 100644
--- a/doc/context/sources/general/manuals/luatex/luatex-modifications.tex
+++ b/doc/context/sources/general/manuals/luatex/luatex-modifications.tex
@@ -615,6 +615,8 @@ primitives (for as far their functionality is still around) you now can do this:
 \protected\def\pdfmapline             {\pdfextension mapline }
 \protected\def\pdftrailer             {\pdfextension trailer }
 \protected\def\pdfglyphtounicode      {\pdfextension glyphtounicode }
+\protected\def\pdfrunninglinkoff      {\pdfextension linkstate 1 }
+\protected\def\pdfrunninglinkon       {\pdfextension linkstate 0 }
 \stoptyping
 
 The introspective primitives can be defined as:
diff --git a/metapost/context/base/mpxl/mp-lmtx.mpxl b/metapost/context/base/mpxl/mp-lmtx.mpxl
index 28fdb1417..88a0450d6 100644
--- a/metapost/context/base/mpxl/mp-lmtx.mpxl
+++ b/metapost/context/base/mpxl/mp-lmtx.mpxl
@@ -2219,10 +2219,7 @@ def lmt_registerglyphs = applyparameters "mpsglyphs" "lmt_do_registerglyphs" end
 def lmt_registerglyph  = applyparameters "mpsglyph"  "lmt_do_registerglyph"  enddef ;
 
 newscriptindex mfid_registerglyphs ; mfid_registerglyphs := scriptindex "registerglyphs" ; def lmt_do_registerglyphs = runscript mfid_registerglyphs enddef ;
-newscriptindex mfid_registerglyph  ; mfid_registerglyph  := scriptindex "registerglyph " ; def lmt_do_registerglyph  = runscript mfid_registerglyph  enddef ;
-
-% vardef lmt_do_registerglyphs = lua.mp.lmt_register_glyphs() ; enddef ;
-% vardef lmt_do_registerglyph  = lua.mp.lmt_register_glyph () ; enddef ;
+newscriptindex mfid_registerglyph  ; mfid_registerglyph  := scriptindex "registerglyph"  ; def lmt_do_registerglyph  = runscript mfid_registerglyph  enddef ;
 
 % Again an experiment (todo: the faster method):
 
diff --git a/metapost/context/base/mpxl/mp-luas.mpxl b/metapost/context/base/mpxl/mp-luas.mpxl
index c13db4d59..9ea130d35 100644
--- a/metapost/context/base/mpxl/mp-luas.mpxl
+++ b/metapost/context/base/mpxl/mp-luas.mpxl
@@ -215,16 +215,19 @@ permanent inpath, pointof, leftof, rightof ;
 
 extra_endfig := extra_endfig & " runscript mfid_path_reset ; " ;
 
+newscriptindex mfid_utfnum ; mfid_utfnum := scriptindex "utfnum" ;
 newscriptindex mfid_utflen ; mfid_utflen := scriptindex "utflen" ;
 newscriptindex mfid_utfsub ; mfid_utfsub := scriptindex "utfsub" ;
 
+% def utfnum = runscript mfid_utfnum enddef ;
 % def utflen = runscript mfid_utflen enddef ;
 % def utfsub = runscript mfid_utfsub enddef ;
 
+vardef utfnum(expr s) = runscript mfid_utfnum s enddef ; % str
 vardef utflen(expr s) = runscript mfid_utflen s enddef ; % str
 vardef utfsub(text t) = runscript mfid_utfsub t enddef ; % str, first, (optional) last
 
-permanent utflen, utfsub ;
+permanent utfnum, utflen, utfsub ;
 
 newscriptindex mfid_getparameters        ; mfid_getparameters        := scriptindex "getparameters" ;
 newscriptindex mfid_presetparameters     ; mfid_presetparameters     := scriptindex "presetparameters" ;
diff --git a/metapost/context/base/mpxl/mp-math.mpxl b/metapost/context/base/mpxl/mp-math.mpxl
index c2723b0f6..cfe9e55e6 100644
--- a/metapost/context/base/mpxl/mp-math.mpxl
+++ b/metapost/context/base/mpxl/mp-math.mpxl
@@ -79,27 +79,27 @@ newscriptindex mfid_m_yz         ; mfid_m_yz         := scriptindex "m_y0"
 newscriptindex mfid_m_y          ; mfid_m_y          := scriptindex "m_y1"         ; def m_y         = runscript mfid_m_y         enddef ; % y1
 newscriptindex mfid_m_yn         ; mfid_m_yn         := scriptindex "m_yn"         ; def m_yn        = runscript mfid_m_yn        enddef ;
 
-newscriptindex mfid_c_sin        ; mfid_c_asin       := scriptindex "c_sin"        ; def c_sin       = runscript mfid_c_sin       enddef ;
-newscriptindex mfid_c_cos        ; mfid_c_acos       := scriptindex "c_cos"        ; def c_cos       = runscript mfid_c_cos       enddef ;
-newscriptindex mfid_c_tan        ; mfid_c_acos       := scriptindex "c_tan"        ; def c_tan       = runscript mfid_c_tan       enddef ;
-newscriptindex mfid_c_sinh       ; mfid_c_acos       := scriptindex "c_sinh"       ; def c_sinh      = runscript mfid_c_sinh      enddef ;
-newscriptindex mfid_c_cosh       ; mfid_c_acos       := scriptindex "c_cosh"       ; def c_cosh      = runscript mfid_c_cosh      enddef ;
-newscriptindex mfid_c_tanh       ; mfid_c_acos       := scriptindex "c_tanh"       ; def c_tanh      = runscript mfid_c_tanh      enddef ;
-
-newscriptindex mfid_c_asin       ; mfid_c_acos       := scriptindex "c_asin"       ; def c_asin      = runscript mfid_c_asin      enddef ;
+newscriptindex mfid_c_sin        ; mfid_c_sin        := scriptindex "c_sin"        ; def c_sin       = runscript mfid_c_sin       enddef ;
+newscriptindex mfid_c_cos        ; mfid_c_cos        := scriptindex "c_cos"        ; def c_cos       = runscript mfid_c_cos       enddef ;
+newscriptindex mfid_c_tan        ; mfid_c_tan        := scriptindex "c_tan"        ; def c_tan       = runscript mfid_c_tan       enddef ;
+newscriptindex mfid_c_sinh       ; mfid_c_sinh       := scriptindex "c_sinh"       ; def c_sinh      = runscript mfid_c_sinh      enddef ;
+newscriptindex mfid_c_cosh       ; mfid_c_cosh       := scriptindex "c_cosh"       ; def c_cosh      = runscript mfid_c_cosh      enddef ;
+newscriptindex mfid_c_tanh       ; mfid_c_tanh       := scriptindex "c_tanh"       ; def c_tanh      = runscript mfid_c_tanh      enddef ;
+
+newscriptindex mfid_c_asin       ; mfid_c_asin       := scriptindex "c_asin"       ; def c_asin      = runscript mfid_c_asin      enddef ;
 newscriptindex mfid_c_acos       ; mfid_c_acos       := scriptindex "c_acos"       ; def c_acos      = runscript mfid_c_acos      enddef ;
-newscriptindex mfid_c_atan       ; mfid_c_acos       := scriptindex "c_atan"       ; def c_atan      = runscript mfid_c_atan      enddef ;
-newscriptindex mfid_c_asinh      ; mfid_c_acos       := scriptindex "c_asinh"      ; def c_asinh     = runscript mfid_c_asinh     enddef ;
-newscriptindex mfid_c_acosh      ; mfid_c_acos       := scriptindex "c_acosh"      ; def c_acosh     = runscript mfid_c_acosh     enddef ;
-newscriptindex mfid_c_atanh      ; mfid_c_acos       := scriptindex "c_atanh"      ; def c_atanh     = runscript mfid_c_atanh     enddef ;
-
-newscriptindex mfid_c_sqrt       ; mfid_c_acos       := scriptindex "c_sqrt"       ; def c_sqrt      = runscript mfid_c_sqrt      enddef ;
-newscriptindex mfid_c_abs        ; mfid_c_acos       := scriptindex "c_abs"        ; def c_abs       = runscript mfid_c_abs       enddef ;
-newscriptindex mfid_c_arg        ; mfid_c_acos       := scriptindex "c_arg"        ; def c_arg       = runscript mfid_c_arg       enddef ;
-newscriptindex mfid_c_conj       ; mfid_c_acos       := scriptindex "c_conj"       ; def c_conj      = runscript mfid_c_conj      enddef ;
-newscriptindex mfid_c_exp        ; mfid_c_acos       := scriptindex "c_exp"        ; def c_exp       = runscript mfid_c_exp       enddef ;
-newscriptindex mfid_c_log        ; mfid_c_acos       := scriptindex "c_log"        ; def c_log       = runscript mfid_c_log       enddef ;
-newscriptindex mfid_c_proj       ; mfid_c_acos       := scriptindex "c_proj"       ; def c_proj      = runscript mfid_c_proj      enddef ;
+newscriptindex mfid_c_atan       ; mfid_c_atan       := scriptindex "c_atan"       ; def c_atan      = runscript mfid_c_atan      enddef ;
+newscriptindex mfid_c_asinh      ; mfid_c_asinh      := scriptindex "c_asinh"      ; def c_asinh     = runscript mfid_c_asinh     enddef ;
+newscriptindex mfid_c_acosh      ; mfid_c_acosh      := scriptindex "c_acosh"      ; def c_acosh     = runscript mfid_c_acosh     enddef ;
+newscriptindex mfid_c_atanh      ; mfid_c_atanh      := scriptindex "c_atanh"      ; def c_atanh     = runscript mfid_c_atanh     enddef ;
+
+newscriptindex mfid_c_sqrt       ; mfid_c_sqrt       := scriptindex "c_sqrt"       ; def c_sqrt      = runscript mfid_c_sqrt      enddef ;
+newscriptindex mfid_c_abs        ; mfid_c_abs        := scriptindex "c_abs"        ; def c_abs       = runscript mfid_c_abs       enddef ;
+newscriptindex mfid_c_arg        ; mfid_c_arg        := scriptindex "c_arg"        ; def c_arg       = runscript mfid_c_arg       enddef ;
+newscriptindex mfid_c_conj       ; mfid_c_conj       := scriptindex "c_conj"       ; def c_conj      = runscript mfid_c_conj      enddef ;
+newscriptindex mfid_c_exp        ; mfid_c_exp        := scriptindex "c_exp"        ; def c_exp       = runscript mfid_c_exp       enddef ;
+newscriptindex mfid_c_log        ; mfid_c_log        := scriptindex "c_log"        ; def c_log       = runscript mfid_c_log       enddef ;
+newscriptindex mfid_c_proj       ; mfid_c_proj       := scriptindex "c_proj"       ; def c_proj      = runscript mfid_c_proj      enddef ;
 
 newscriptindex mfid_c_erf        ; mfid_c_erf        := scriptindex "c_erf"        ; def c_erf       = runscript mfid_c_erf       enddef ;
 newscriptindex mfid_c_erfc       ; mfid_c_erfc       := scriptindex "c_erfc"       ; def c_erfc      = runscript mfid_c_erfc      enddef ;
diff --git a/metapost/context/fonts/mpiv/punkfont-characters.mp b/metapost/context/fonts/mpiv/punkfont-characters.mp
index da0015b02..5ba7a8a21 100644
--- a/metapost/context/fonts/mpiv/punkfont-characters.mp
+++ b/metapost/context/fonts/mpiv/punkfont-characters.mp
@@ -592,9 +592,19 @@ pd z1; pd z2; pd z3; pd z4; draw z1--z2; draw flex(z3,z6,z4); % stems
 pd z5; draw z5--z6;  % crossbar
 endchar;
 
-beginpunkchar("i",5,1,2);
-z1=pp(.5w,0); z2=(.5w,1/3h); z3=(.5w,2/3h); z4=(.5w,h);
-pd z1; pd z4; draw flex(z1,z2,z3,z4);  % stem
+% beginpunkchar("i",5,1,2);
+% z1=pp(.5w,0); z2=(.5w,1/3h); z3=(.5w,2/3h); z4=(.5w,h);
+% pd z1; pd z4; draw flex(z1,z2,z3,z4);  % stem
+% endchar;
+
+% beginpunkchar("i",9,1,2);
+%     z1=pp(.5w,0); z2=(.5w,.1h); z3=(.5w,2/3h); z4=(.5w,h);
+%     pd z1; pd z4; draw flex(z1,z2,z3,z4) withcolor red;  % stem
+% endchar;
+
+beginpunkchar("i",9,1,2);
+z1=pp(.5w,0); z4=(.5w,h);
+pd z1; pd z4; draw z1--z4;  % stem
 endchar;
 
 beginpunkchar("j",9,1,2);
@@ -642,7 +652,8 @@ z5=pp(.4w,.2h); z6=pp(w-u,-.1h); z7=pp(.5[x5,x6],-.2h);
 pd z5; pd z6; draw z5--z7--z6;  % tail
 endchar;
 
-beginpunkchar("r",16,1,2);
+% beginpunkchar("r",16,1,2);
+beginpunkchar("r",13,1,2);
 z1=pp(2u,0); z2=pp(2u,h); z3=pp(w-u,.6[y2,y4]); z4=pp(2u,.5h); z5=pp(w-1.5u,0);
 pd z1; pd z2; pd z5; draw z1--flex(z2,z3,z4)--z5; % stem, bowl, and diagonal
 endchar;
diff --git a/tex/context/base/mkii/cont-new.mkii b/tex/context/base/mkii/cont-new.mkii
index d06fbe463..6c1dca8a2 100644
--- a/tex/context/base/mkii/cont-new.mkii
+++ b/tex/context/base/mkii/cont-new.mkii
@@ -11,7 +11,7 @@
 %C therefore copyrighted by \PRAGMA. See mreadme.pdf for
 %C details.
 
-\newcontextversion{2021.01.11 16:28}
+\newcontextversion{2021.01.17 21:39}
 
 %D This file is loaded at runtime, thereby providing an
 %D excellent place for hacks, patches, extensions and new
diff --git a/tex/context/base/mkii/context.mkii b/tex/context/base/mkii/context.mkii
index c36274955..dbe4e4249 100644
--- a/tex/context/base/mkii/context.mkii
+++ b/tex/context/base/mkii/context.mkii
@@ -20,7 +20,7 @@
 %D your styles an modules.
 
 \edef\contextformat {\jobname}
-\edef\contextversion{2021.01.11 16:28}
+\edef\contextversion{2021.01.17 21:39}
 
 %D For those who want to use this:
 
diff --git a/tex/context/base/mkiv/cont-new.mkiv b/tex/context/base/mkiv/cont-new.mkiv
index 49c850c9b..d8dfa0fa2 100644
--- a/tex/context/base/mkiv/cont-new.mkiv
+++ b/tex/context/base/mkiv/cont-new.mkiv
@@ -13,7 +13,7 @@
 
 % \normalend % uncomment this to get the real base runtime
 
-\newcontextversion{2021.01.11 16:28}
+\newcontextversion{2021.01.17 21:39}
 
 %D This file is loaded at runtime, thereby providing an excellent place for hacks,
 %D patches, extensions and new features. There can be local overloads in cont-loc
diff --git a/tex/context/base/mkiv/context.mkiv b/tex/context/base/mkiv/context.mkiv
index 93744dfda..8e697e850 100644
--- a/tex/context/base/mkiv/context.mkiv
+++ b/tex/context/base/mkiv/context.mkiv
@@ -45,7 +45,7 @@
 %D {YYYY.MM.DD HH:MM} format.
 
 \edef\contextformat {\jobname}
-\edef\contextversion{2021.01.11 16:28}
+\edef\contextversion{2021.01.17 21:39}
 
 %D Kind of special:
 
diff --git a/tex/context/base/mkiv/font-imp-math.lua b/tex/context/base/mkiv/font-imp-math.lua
index ed82fcc48..d2294e93c 100644
--- a/tex/context/base/mkiv/font-imp-math.lua
+++ b/tex/context/base/mkiv/font-imp-math.lua
@@ -80,6 +80,34 @@ registerotffeature {
     }
 }
 
+function fonts.helpers.mathscriptslots(tfmdata,textcode)
+    local rawdata           = tfmdata.shared.rawdata
+    local rawresources      = rawdata and rawdata.resources
+    local rawfeatures       = rawresources and rawresources.features
+    local basesubstitutions = rawfeatures and rawfeatures.gsub
+    local sequences         = basesubstitutions and tfmdata.resources.sequences
+    if sequences then
+        local characters = tfmdata.characters
+        if characters[textcode] then
+            for s=1,#sequences do
+                local sequence  = sequences[s]
+                local sfeatures = sequence.features
+                if sfeatures and sfeatures.ssty then
+                    local steps = sequence.steps
+                    for i=1,#steps do
+                        local coverage = steps[i].coverage
+                        if coverage then
+                            local okay = coverage[textcode]
+                            if okay then
+                                return okay
+                            end
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
 local function initialize(tfmdata,key,value)
     if value then
         local rawdata       = tfmdata.shared.rawdata
diff --git a/tex/context/base/mkiv/font-imp-tracing.lua b/tex/context/base/mkiv/font-imp-tracing.lua
index 1acf14558..255b4cdf0 100644
--- a/tex/context/base/mkiv/font-imp-tracing.lua
+++ b/tex/context/base/mkiv/font-imp-tracing.lua
@@ -139,107 +139,3 @@ local specification = {
 
 registerotffeature(specification)
 registerafmfeature(specification)
-
-local f_m = formatters["%F %F m"]
-local f_l = formatters["%F %F l"]
-local f_b = formatters["[] 0 d 0 J %.6F w"]
-local f_e = formatters["s"]
-
-local function ladder(list,docolor,nocolor,lst,offset,sign,default)
-    local l  = lst[1]
-    local x1 = bp * (offset + l.kern) * sign
-    local y1 = bp * l.height
-    local t  = { f_b(r,r/2), f_m(x1,y1) }
-    local n  = 2
-    local m  = #lst
-    if default > 0 then
-        default = default * bp + r
-    else
-        default = default * bp - r
-    end
-    if m == 1 then
-        n = n + 1 t[n] = f_l(x1,default)
-    else
-        for i=1,m do
-            local l  = lst[i]
-            local x2 = bp * (offset + l.kern) * sign
-            local y2 = bp * l.height
-            if i > 1 and y2 == 0 then
-                y2 = default
-            end
-            n = n + 1 t[n] = f_l(x2,y1)
-            n = n + 1 t[n] = f_l(x2,y2)
-            x1, y1 = x2, y2
-        end
-    end
-    n = n + 1 t[n] = f_e()
-    list[#list+1] = docolor
-    list[#list+1] = { "pdf", "origin", concat(t," ") }
-    list[#list+1] = nocolor
-end
-
-local function initialize(tfmdata,key,value)
-    if value then
-        if not backcolors then
-            local vfspecials = backends.pdf.tables.vfspecials
-            startcolor = vfspecials.startcolor
-            stopcolor  = vfspecials.stopcolor
-        end
-        local characters = tfmdata.characters
-        local brcolor    = startcolor("darkred")
-        local trcolor    = startcolor("darkgreen")
-        local blcolor    = startcolor("darkblue")
-        local tlcolor    = startcolor("darkyellow")
-        local black      = stopcolor
-        for unicode, character in next, characters do
-            local mathkern = character.mathkern
-            if mathkern then
-                -- more efficient would be co collect more in one pdf
-                -- directive but this is hardly used so not worth the
-                -- effort
-                local width  = character.width  or 0
-                local height = character.height or 0
-                local depth  = character.depth  or 0
-                local list   = { }
-                local br     = mathkern.bottom_right
-                local tr     = mathkern.top_right
-                local bl     = mathkern.bottom_left
-                local tl     = mathkern.top_left
-                if br then
-                    ladder(list,brcolor,black,br,width,1,height)
-                end
-                if tr then
-                    ladder(list,trcolor,black,tr,width,1,-depth)
-                end
-                if bl then
-                    ladder(list,blcolor,black,bl,0,-1,height)
-                end
-                if tl then
-                    ladder(list,tlcolor,black,tl,0,-1,-depth)
-                end
-                if #list > 0 then
-                    local commands = character.commands
-                    if commands then
-                        character.commands = appendcommandtable(commands,list)
-                    else
-                        list[#list+1] = charcommand[unicode]
-                        character.commands = list
-                    end
-                end
-            end
-        end
-    end
-end
-
-local specification = {
-    name        = "staircase",
-    description = "show staircase kerns",
-    position=1,
-    manipulators = {
-        base = initialize,
-        node = initialize,
-    }
-}
-
-registerotffeature(specification)
-registerafmfeature(specification)
diff --git a/tex/context/base/mkiv/font-pre.mkiv b/tex/context/base/mkiv/font-pre.mkiv
index c32690375..445dedd25 100644
--- a/tex/context/base/mkiv/font-pre.mkiv
+++ b/tex/context/base/mkiv/font-pre.mkiv
@@ -405,6 +405,7 @@
    mathalternates=yes,
    mathitalics=yes, % we pass them
    mathdimensions=all,
+ % mathkerns=yes,
  % mathgaps=yes,
    language=dflt,
    script=math]
diff --git a/tex/context/base/mkiv/good-mth.lua b/tex/context/base/mkiv/good-mth.lua
index b85e680cc..3473cc205 100644
--- a/tex/context/base/mkiv/good-mth.lua
+++ b/tex/context/base/mkiv/good-mth.lua
@@ -6,8 +6,9 @@ if not modules then modules = { } end modules ['good-mth'] = {
     license   = "see context related readme files"
 }
 
-local type, next = type, next
+local type, next, tonumber, unpack = type, next, tonumber, unpack
 local ceil = math.ceil
+local match = string.match
 
 local fonts = fonts
 
@@ -20,6 +21,10 @@ local fontgoodies        = fonts.goodies or { }
 
 local fontcharacters     = fonts.hashes.characters
 
+local trace_defining     = false  trackers.register("math.defining",   function(v) trace_defining   = v end)
+
+local report_math        = logs.reporter("mathematics","initializing")
+
 local nuts               = nodes.nuts
 
 local setlink            = nuts.setlink
@@ -33,11 +38,149 @@ local new_vlist          = nodepool.vlist
 
 local insert_node_after  = nuts.insert_after
 
+local helpers            = fonts.helpers
+local upcommand          = helpers.commands.up
+local rightcommand       = helpers.commands.right
+local charcommand        = helpers.commands.char
+local prependcommands    = helpers.prependcommands
+
 -- experiment, we have to load the definitions immediately as they precede
 -- the definition so they need to be initialized in the typescript
 
+local function withscriptcode(tfmdata,unicode,data,action)
+    if type(unicode) == "string" then
+        local p, u = match(unicode,"^(.-):(.-)$")
+        if u then
+            u = tonumber(u)
+            if u then
+                local slots = fonts.helpers.mathscriptslots(tfmdata,u)
+                if slots then
+                    if p == "*" then
+                        action(u,data)
+                        for i=1,#slots do
+                            action(slots[i],data)
+                        end
+                    else
+                        p = tonumber(p)
+                        if p then
+                            action(slots[p],data)
+                        end
+                    end
+                end
+            end
+        end
+    else
+        action(unicode,data)
+    end
+end
+
 local function finalize(tfmdata,feature,value)
-    mathematics.overloaddimensions(tfmdata,tfmdata,value)
+--     if tfmdata.mathparameters then -- funny, cambria text has this
+    local goodies = tfmdata.goodies
+    if goodies then
+        local virtualized = mathematics.virtualized
+        for i=1,#goodies do
+            local goodie = goodies[i]
+            local mathematics = goodie.mathematics
+            local dimensions  = mathematics and mathematics.dimensions
+            if dimensions then
+                if trace_defining then
+                    report_math("overloading dimensions in %a @ %p",tfmdata.properties.fullname,tfmdata.parameters.size)
+                end
+                local characters   = tfmdata.characters
+                local descriptions = tfmdata.descriptions
+                local parameters   = tfmdata.parameters
+                local factor       = parameters.factor
+                local hfactor      = parameters.hfactor
+                local vfactor      = parameters.vfactor
+                local function overloadone(unicode,data)
+                    local character = characters[unicode]
+                    if not character then
+                        local c = virtualized[unicode]
+                        if c then
+                            character = characters[c]
+                        end
+                    end
+                    if character then
+                        local width  = data.width
+                        local height = data.height
+                        local depth  = data.depth
+                        if trace_defining and (width or height or depth) then
+                            report_math("overloading dimensions of %C, width %p, height %p, depth %p",
+                                unicode,width or 0,height or 0,depth or 0)
+                        end
+                        if width  then character.width  = width  * hfactor end
+                        if height then character.height = height * vfactor end
+                        if depth  then character.depth  = depth  * vfactor end
+                        --
+                        local xoffset = data.xoffset
+                        local yoffset = data.yoffset
+                        if xoffset == "llx" then
+                            local d = descriptions[unicode]
+                            if d then
+                                xoffset         = - d.boundingbox[1] * hfactor
+                                character.width = character.width + xoffset
+                                xoffset         = rightcommand[xoffset]
+                            else
+                                xoffset = nil
+                            end
+                        elseif xoffset and xoffset ~= 0 then
+                            xoffset = rightcommand[xoffset * hfactor]
+                        else
+                            xoffset = nil
+                        end
+                        if yoffset and yoffset ~= 0 then
+                            yoffset = upcommand[yoffset * vfactor]
+                        else
+                            yoffset = nil
+                        end
+                        if xoffset or yoffset then
+                            local commands = characters.commands
+                            if commands then
+                                prependcommands(commands,yoffset,xoffset)
+                            else
+                                local slot = charcommand[unicode]
+                                if xoffset and yoffset then
+                                    character.commands = { xoffset, yoffset, slot }
+                                elseif xoffset then
+                                    character.commands = { xoffset, slot }
+                                else
+                                    character.commands = { yoffset, slot }
+                                end
+                            end
+                        end
+                    elseif trace_defining then
+                        report_math("no overloading dimensions of %C, not in font",unicode)
+                    end
+                end
+                local function overload(dimensions)
+                    for unicode, data in next, dimensions do
+                        withscriptcode(tfmdata,unicode,data,overloadone)
+                    end
+                end
+                if value == nil then
+                    value = { "default" }
+                end
+                if value == "all" or value == true then
+                    for name, value in next, dimensions do
+                        overload(value)
+                    end
+                else
+                    if type(value) == "string" then
+                        value = utilities.parsers.settings_to_array(value)
+                    end
+                    if type(value) == "table" then
+                        for i=1,#value do
+                            local d = dimensions[value[i]]
+                            if d then
+                                overload(d)
+                            end
+                        end
+                    end
+                end
+            end
+        end
+    end
 end
 
 registerotffeature {
@@ -77,10 +220,11 @@ end
 
 fontgoodies.register("mathematics", initialize)
 
-local enabled = false   directives.register("fontgoodies.mathkerning",function(v) enabled = v end)
+-- local enabled = false   directives.register("fontgoodies.mathkerning",function(v) enabled = v end)
 
 local function initialize(tfmdata)
-    if enabled and tfmdata.mathparameters then -- funny, cambria text has this
+--     if enabled and tfmdata.mathparameters then -- funny, cambria text has this
+    if tfmdata.mathparameters then -- funny, cambria text has this
         local goodies = tfmdata.goodies
         if goodies then
             local characters = tfmdata.characters
@@ -91,12 +235,15 @@ local function initialize(tfmdata)
                     if mathgoodies then
                         local kerns = mathgoodies.kerns
                         if kerns then
-                            for unicode, specification in next, kerns do
+                            local function kernone(unicode,data)
                                 local chardata = characters[unicode]
-                                if chardata and (not chardata.mathkerns or specification.force) then
-                                    chardata.mathkerns = specification
+                                if chardata and (not chardata.mathkerns or data.force) then
+                                    chardata.mathkerns = data
                                 end
                             end
+                            for unicode, data in next, kerns do
+                                withscriptcode(tfmdata,unicode,data,kernone)
+                            end
                             return
                         end
                     end
@@ -109,9 +256,9 @@ local function initialize(tfmdata)
 end
 
 registerotffeature {
-    name        = "mathkerns",
-    description = "math kerns",
-    default     = true,
+    name         = "mathkerns",
+    description  = "math kerns",
+ -- default      = true,
     initializers = {
         base = initialize,
         node = initialize,
diff --git a/tex/context/base/mkiv/math-act.lua b/tex/context/base/mkiv/math-act.lua
index 4f38b4195..a5cfa82de 100644
--- a/tex/context/base/mkiv/math-act.lua
+++ b/tex/context/base/mkiv/math-act.lua
@@ -230,115 +230,6 @@ sequencers.appendaction("aftercopyingcharacters", "system","mathematics.tweakaft
 
 local virtualized = mathematics.virtualized
 
-function mathematics.overloaddimensions(target,original,set)
-    local goodies = target.goodies
-    if goodies then
-        for i=1,#goodies do
-            local goodie = goodies[i]
-            local mathematics = goodie.mathematics
-            local dimensions  = mathematics and mathematics.dimensions
-            if dimensions then
-                if trace_defining then
-                    report_math("overloading dimensions in %a @ %p",target.properties.fullname,target.parameters.size)
-                end
-                local characters   = target.characters
-                local descriptions = target.descriptions
-                local parameters   = target.parameters
-                local factor       = parameters.factor
-                local hfactor      = parameters.hfactor
-                local vfactor      = parameters.vfactor
-if not CONTEXTLMTXMODE or CONTEXTLMTXMODE == 0 then
-                target.type = "virtual"
-                target.properties.virtualized = true
-end
-                local function overload(dimensions)
-                    for unicode, data in next, dimensions do
-                        local character = characters[unicode]
-                        if not character then
-                            local c = virtualized[unicode]
-                            if c then
-                                character = characters[c]
-                            end
-                        end
-                        if character then
-                            --
-                            local width  = data.width
-                            local height = data.height
-                            local depth  = data.depth
-                            if trace_defining and (width or height or depth) then
-                                report_math("overloading dimensions of %C, width %p, height %p, depth %p",
-                                    unicode,width or 0,height or 0,depth or 0)
-                            end
-                            if width  then character.width  = width  * hfactor end
-                            if height then character.height = height * vfactor end
-                            if depth  then character.depth  = depth  * vfactor end
-                            --
-                            local xoffset = data.xoffset
-                            local yoffset = data.yoffset
-                            if xoffset == "llx" then
-                                local d = descriptions[unicode]
-                                if d then
-                                    xoffset         = - d.boundingbox[1] * hfactor
-                                    character.width = character.width + xoffset
-                                    xoffset         = rightcommand[xoffset]
-                                else
-                                    xoffset = nil
-                                end
-                            elseif xoffset and xoffset ~= 0 then
-                                xoffset = rightcommand[xoffset * hfactor]
-                            else
-                                xoffset = nil
-                            end
-                            if yoffset and yoffset ~= 0 then
-                                yoffset = upcommand[yoffset * vfactor]
-                            else
-                                yoffset = nil
-                            end
-                            if xoffset or yoffset then
-                                local commands = characters.commands
-                                if commands then
-                                    prependcommands(commands,yoffset,xoffset)
-                                else
-                                    local slot = charcommand[unicode]
-                                    if xoffset and yoffset then
-                                        character.commands = { xoffset, yoffset, slot }
-                                    elseif xoffset then
-                                        character.commands = { xoffset, slot }
-                                    else
-                                        character.commands = { yoffset, slot }
-                                    end
-                                end
-                            end
-                        elseif trace_defining then
-                            report_math("no overloading dimensions of %C, not in font",unicode)
-                        end
-                    end
-                end
-                if set == nil then
-                    set = { "default" }
-                end
-                if set == "all" or set == true then
-                    for name, set in next, dimensions do
-                        overload(set)
-                    end
-                else
-                    if type(set) == "string" then
-                        set = utilities.parsers.settings_to_array(set)
-                    end
-                    if type(set) == "table" then
-                        for i=1,#set do
-                            local d = dimensions[set[i]]
-                            if d then
-                                overload(d)
-                            end
-                        end
-                    end
-                end
-            end
-        end
-    end
-end
-
 -- no, it's a feature now (see good-mth):
 --
 -- sequencers.appendaction("aftercopyingcharacters", "system","mathematics.overloaddimensions")
@@ -711,10 +602,10 @@ function mathematics.finishfallbacks(target,specification,fallbacks)
                 fonts = { }
                 target.fonts = fonts
             end
-if not CONTEXTLMTXMODE or CONTEXTLMTXMODE == 0 then
+            -- 
             target.type = "virtual"
             target.properties.virtualized = true
-end
+            -- 
             if #fonts == 0 then
                 fonts[1] = { id = 0, size = size } -- self, will be resolved later
             end
diff --git a/tex/context/base/mkiv/mult-fun.lua b/tex/context/base/mkiv/mult-fun.lua
index 4d99e8320..4e4a901c0 100644
--- a/tex/context/base/mkiv/mult-fun.lua
+++ b/tex/context/base/mkiv/mult-fun.lua
@@ -187,7 +187,7 @@ return {
         --
         "inpath", "pointof", "leftof", "rightof",
         --
-        "utflen", "utfsub",
+        "utfnum", "utflen", "utfsub",
         --
         "newhash", "disposehash", "inhash", "tohash",
         --
diff --git a/tex/context/base/mkiv/status-files.pdf b/tex/context/base/mkiv/status-files.pdf
index d55bfa411..605d8e1f1 100644
--- a/tex/context/base/mkiv/status-files.pdf
+++ b/tex/context/base/mkiv/status-files.pdf
diff --git a/tex/context/base/mkiv/status-lua.pdf b/tex/context/base/mkiv/status-lua.pdf
index 78ade839c..3c5c26cb3 100644
--- a/tex/context/base/mkiv/status-lua.pdf
+++ b/tex/context/base/mkiv/status-lua.pdf
diff --git a/tex/context/base/mkiv/strc-mar.lua b/tex/context/base/mkiv/strc-mar.lua
index b5fd2667b..f7953c416 100644
--- a/tex/context/base/mkiv/strc-mar.lua
+++ b/tex/context/base/mkiv/strc-mar.lua
@@ -122,7 +122,7 @@ end
 local function sweep(head,first,last)
     for n, id, subtype in nextnode, head do
         -- we need to handle empty heads so we test for latelua
-        if id == glyph_code or (id == whatsit_code and subtype == lateluawhatsit_code) then
+        if id == glyph_code or (id == whatsit_code and subtype == lateluawhatsit_code) then -- brrr
             local a = getattr(n,a_marks)
             if not a then
                 -- next
diff --git a/tex/context/base/mkiv/task-ini.lua b/tex/context/base/mkiv/task-ini.lua
index c06e32df3..3e78fb2f9 100644
--- a/tex/context/base/mkiv/task-ini.lua
+++ b/tex/context/base/mkiv/task-ini.lua
@@ -95,6 +95,7 @@ appendaction("shipouts",     "finishers",   "attributes.transparencies.handler",
 appendaction("shipouts",     "finishers",   "attributes.colorintents.handler",                  nil, "nut",    "disabled"  )
 appendaction("shipouts",     "finishers",   "attributes.negatives.handler",                     nil, "nut",    "disabled"  )
 appendaction("shipouts",     "finishers",   "attributes.effects.handler",                       nil, "nut",    "disabled"  )
+appendaction("shipouts",     "finishers",   "attributes.alternates.handler",                    nil, "nut",    "disabled"  )
 appendaction("shipouts",     "finishers",   "attributes.viewerlayers.handler",                  nil, "nut",    "disabled"  )
 
 appendaction("shipouts",     "wrapup",      "nodes.handlers.export",                            nil, "nut",    "disabled"  )  -- always last
diff --git a/tex/context/base/mkxl/anch-pos.lmt b/tex/context/base/mkxl/anch-pos.lmt
index e804dbdf6..67d1657f2 100644
--- a/tex/context/base/mkxl/anch-pos.lmt
+++ b/tex/context/base/mkxl/anch-pos.lmt
@@ -1628,6 +1628,9 @@ end)
 
 local newsavepos = nodes.pool.savepos
 
+jobpositions.lastx = 0
+jobpositions.lasty = 0
+
 implement { name = "savepos",  actions = function() context(newsavepos()) end }
-implement { name = "lastxpos", actions = function() context(gethpos()) end }
-implement { name = "lastypos", actions = function() context(getvpos()) end }
+implement { name = "lastxpos", actions = function() context(jobpositions.lastx) end }
+implement { name = "lastypos", actions = function() context(jobpositions.lasty) end }
diff --git a/tex/context/base/mkxl/attr-alt.lmt b/tex/context/base/mkxl/attr-alt.lmt
new file mode 100644
index 000000000..9d8592074
--- /dev/null
+++ b/tex/context/base/mkxl/attr-alt.lmt
@@ -0,0 +1,111 @@
+if not modules then modules = { } end modules ['attr-eff'] = {
+    version   = 1.001,
+    comment   = "companion to attr-eff.mkiv",
+    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
+    copyright = "PRAGMA ADE / ConTeXt Development Team",
+    license   = "see context related readme files"
+}
+
+local attributes, nodes, backends, utilities = attributes, nodes, backends, utilities
+local tex = tex
+
+local states            = attributes.states
+local enableaction      = nodes.tasks.enableaction
+local nodeinjections    = backends.nodeinjections
+local texsetattribute   = tex.setattribute
+local allocate          = utilities.storage.allocate
+local setmetatableindex = table.setmetatableindex
+
+local interfaces        = interfaces
+local implement         = interfaces.implement
+
+attributes.alternates   = attributes.alternates or { }
+local alternates        = attributes.alternates
+
+local a_alternate       = attributes.private('alternate')
+
+alternates.data         = allocate()
+alternates.values       = alternates.values     or { }
+alternates.registered   = alternates.registered or { }
+alternates.attribute    = a_alternate
+
+local data              = alternates.data
+local registered        = alternates.registered
+local values            = alternates.values
+
+storage.register("attributes/alternates/registered", registered, "attributes.alternates.registered")
+storage.register("attributes/alternates/values",     values,     "attributes.alternates.values")
+
+local function extender(alternates,key)
+    if key == "none" then
+        local d = nodeinjections.stopalternate()
+        alternates.none = d
+        return d
+    end
+end
+
+local function reviver(data,n)
+    local d = values[n] and nodeinjections.startalternate(values[n]) or nodeinjections.stopalternate()
+    data[n] = d
+    return d
+end
+
+setmetatableindex(alternates,      extender)
+setmetatableindex(alternates.data, reviver)
+
+alternates.handler = nodes.installattributehandler {
+    name        = "alternate",
+    namespace   = alternates,
+    initializer = states.initialize,
+    finalizer   = states.finalize,
+    processor   = states.simple,
+}
+
+local function register(specification)
+    local text = specification.text or "unknown"
+    local n = registered[text]
+    if not n then
+        n = #values + 1
+        values[n] = text
+        registered[text] = n
+    end
+    return n
+end
+
+local enabled = false
+
+local function enable()
+    if not enabled then
+        enableaction("shipouts","attributes.alternates.handler")
+        enabled = true
+    end
+end
+
+alternates.register = register
+alternates.enable   = enable
+
+-- interface
+
+implement {
+    name      = "setalternate",
+    actions   = function(specification)
+        if not enabled then
+            enable()
+        end
+        texsetattribute(a_alternate,register(specification))
+    end,
+    arguments = {
+        {
+            { "text", "string" },
+        }
+    }
+}
+
+implement {
+    name      = "resetalternate",
+    actions   = function()
+        if enabled then
+            texsetattribute(a_alternate)
+        end
+    end
+}
diff --git a/tex/context/base/mkxl/attr-alt.mkxl b/tex/context/base/mkxl/attr-alt.mkxl
new file mode 100644
index 000000000..3881d929e
--- /dev/null
+++ b/tex/context/base/mkxl/attr-alt.mkxl
@@ -0,0 +1,55 @@
+%D \module
+%D   [       file=attr-alt,
+%D        version=2007.06.06,
+%D          title=\CONTEXT\ Attribute Macros,
+%D       subtitle=Alternates,
+%D         author=Hans Hagen,
+%D           date=\currentdate,
+%D      copyright={PRAGMA ADE \& \CONTEXT\ Development Team}]
+%C
+%C This module is part of the \CONTEXT\ macro||package and is
+%C therefore copyrighted by \PRAGMA. See mreadme.pdf for
+%C details.
+
+\writestatus{loading}{ConTeXt Attribute Macros / Alternates}
+
+\registerctxluafile{attr-alt}{autosuffix}
+
+%D The main reason for providing this is that we need to make sure we have no
+%D dangling end markers when we cross a page. Public viewers don't seem to support
+%D actual text at all and acrobat has some funny selection issues.
+%D
+%D \starttyping
+%D test
+%D     \startalternate[text={A}]
+%D         \dorecurse{10}{A }
+%D         \startalternate[text={B}]
+%D             \dorecurse{10}{B }
+%D         \stopalternate
+%D         \dorecurse{10}{A }
+%D     \stopalternate
+%D test \par
+%D \stoptyping
+%D
+%D \starttyping
+%D test \startalternate[text={e=mc^2}]!$e=mc^2$\stopalternate\par
+%D test \alternate{e=mc^2}{copy:}\nbsp$e=mc^2$\par
+%D \stoptyping
+
+\unprotect
+
+\permanent\protected\def\startalternate[#1]% maybe better/also: [text={...}]
+  {\begingroup
+   \getdummyparameters[\c!text=,#1]%
+   \clf_setalternate text {\dummyparameter\c!text}\relax}
+
+\permanent\protected\def\stopalternate
+  {\endgroup}
+
+\permanent\protected\def\alternate#1%
+  {\groupedcommand{\clf_setalternate text {#1}\relax}{}}
+
+\permanent\protected\def\setalternate  #1{\clf_setalternate text {#1}\relax}
+\permanent\protected\def\resetalternate  {\clf_resetalternate}
+
+\protect \endinput
diff --git a/tex/context/base/mkxl/attr-eff.mkxl b/tex/context/base/mkxl/attr-eff.mkxl
index 04a0c55ce..42aadf9a2 100644
--- a/tex/context/base/mkxl/attr-eff.mkxl
+++ b/tex/context/base/mkxl/attr-eff.mkxl
@@ -30,8 +30,8 @@
 \appendtoks
     \edef\p_method{\effectparameter\c!method}%
     \ifx\p_method\v!command
-        \setuxvalue{\e!start\currenteffect}{\starteffect[#1]}%
-        \setuxvalue{\e!stop \currenteffect}{\stopeffect}%
+        \frozen\protected\xdefcsname\e!start\currenteffect\endcsname{\starteffect[#1]}%
+        \frozen\protected\xdefcsname\e!stop \currenteffect\endcsname{\stopeffect}%
     \fi
 \to \everydefineeffect
 
diff --git a/tex/context/base/mkxl/attr-ini.mkxl b/tex/context/base/mkxl/attr-ini.mkxl
index de22cd6e2..8cef1ec56 100644
--- a/tex/context/base/mkxl/attr-ini.mkxl
+++ b/tex/context/base/mkxl/attr-ini.mkxl
@@ -130,6 +130,7 @@
 \definesystemattribute [ruled]               [public]
 \definesystemattribute [shifted]             [public]
 \definesystemattribute [checkedbreak]        [public]
+\definesystemattribute [alternate]           [public]
 \definesystemattribute [vboxtohboxseparator] [public]
 
 \permanent\protected\let\showattributes\clf_showattributes % maybe at lua end
diff --git a/tex/context/base/mkxl/back-trf.mkxl b/tex/context/base/mkxl/back-ext.mkxl
index fcf69ade4..bba33335d 100644
--- a/tex/context/base/mkxl/back-trf.mkxl
+++ b/tex/context/base/mkxl/back-ext.mkxl
@@ -1,8 +1,8 @@
 %D \module
-%D   [       file=back-trf,
-%D        version=2019.02.08, % 2009.04.15,
+%D   [       file=back-ext,
+%D        version=2019.02.08, % and later, merged file
 %D          title=\CONTEXT\ Backend Macros,
-%D       subtitle=Transformations,
+%D       subtitle=Output,
 %D         author=Hans Hagen,
 %D           date=\currentdate,
 %D      copyright={PRAGMA ADE \& \CONTEXT\ Development Team}]
@@ -11,9 +11,15 @@
 %C therefore copyrighted by \PRAGMA. See mreadme.pdf for
 %C details.
 
+% \registerctxluafile{back-ext}{autosuffix}
+
 \unprotect
 
-\registerctxluafile{back-trf}{autosuffix}
+% \let\normalopenout \openout
+% \let\normalwrite   \write
+% \let\normalcloseout\closeout
+% \let\normallatelua \latelua
+% \let\normalspecial \special
 
 % rotation
 
diff --git a/tex/context/base/mkxl/back-ini.lmt b/tex/context/base/mkxl/back-ini.lmt
index ee40c384d..922705742 100644
--- a/tex/context/base/mkxl/back-ini.lmt
+++ b/tex/context/base/mkxl/back-ini.lmt
@@ -95,17 +95,6 @@ statistics.register("used backend", function()
     end
 end)
 
-local comment = { "comment", "" }
-
-tables.vfspecials = allocate {
-    red        = comment,
-    green      = comment,
-    blue       = comment,
-    black      = comment,
-    startslant = comment,
-    stopslant  = comment,
-}
-
 -- can best be here
 
 interfaces.implement {
@@ -131,25 +120,6 @@ end)
 
 backends.included = included
 
--- Also here:
-
-local paper_width  = 0
-local paper_height = 0
-
-function codeinjections.setpagedimensions(paperwidth,paperheight)
-    if paperwidth then
-        paper_width = paperwidth
-    end
-    if paperheight then
-        paper_height = paperheight
-    end
-    return paper_width, paper_height
-end
-
-function codeinjections.getpagedimensions()
-    return paper_width, paper_height
-end
-
 -- could also be codeinjections
 
 function backends.getcallbackstate()
diff --git a/tex/context/base/mkxl/back-out.lmt b/tex/context/base/mkxl/back-out.lmt
deleted file mode 100644
index fbcb220dc..000000000
--- a/tex/context/base/mkxl/back-out.lmt
+++ /dev/null
@@ -1,255 +0,0 @@
-if not modules then modules = { } end modules ['back-out'] = {
-    version   = 1.001,
-    comment   = "companion to back-ini.mkiv",
-    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
-    copyright = "PRAGMA ADE / ConTeXt Development Team",
-    license   = "see context related readme files"
-}
-
-local type = type
-local loadstring = loadstring
-
-local context             = context
-
--- tokens.scanners.....
-
-local get                 = token.get_index
-local scanners            = tokens.scanners
-local scaninteger         = scanners.integer
-local scanstring          = scanners.string
-local scankeyword         = scanners.keyword
-local scantokenlist       = scanners.tokenlist
-
-local serialize           = token.serialize
-
-local logwriter           = logs.writer
-local openfile            = io.open
-local flushio             = io.flush
-
-local nuts                = nodes.nuts
-local tonode              = nuts.tonode
-local copynode            = nuts.copy
-local nodepool            = nuts.pool
-
-local getdata             = nuts.getdata
-
-local whatsit_code        = nodes.nodecodes.whatsit
-
-local whatsitcodes        = nodes.whatsitcodes
-
-local literalvalues       = nodes.literalvalues
-local originliteral_code  = literalvalues.origin
-local pageliteral_code    = literalvalues.page
-local directliteral_code  = literalvalues.direct
-local rawliteral_code     = literalvalues.raw
-
-local immediate_code      = tex.flagcodes.immediate
-
-local nodeproperties      = nodes.properties.data
-
-local channels            = { }
-
-local register            = nodepool.register
-local newnut              = nuts.new
-
-local opennode            = register(newnut(whatsit_code,whatsitcodes.open))
-local writenode           = register(newnut(whatsit_code,whatsitcodes.write))
-local closenode           = register(newnut(whatsit_code,whatsitcodes.close))
-local lateluanode         = register(newnut(whatsit_code,whatsitcodes.latelua))
-local literalnode         = register(newnut(whatsit_code,whatsitcodes.literal))
-local savenode            = register(newnut(whatsit_code,whatsitcodes.save))
-local restorenode         = register(newnut(whatsit_code,whatsitcodes.restore))
-local setmatrixnode       = register(newnut(whatsit_code,whatsitcodes.setmatrix))
-
-local open_command, write_command, close_command
-
-backends = backends or { }
-
-local function immediately(prefix)
-    return prefix and (prefix & immediate_code) ~= 0
-end
-
-local function openout(prefix)
-    local channel = scaninteger()
-    scankeyword("=") -- hack
-    local filename = scanstring()
-    if not immediately(prefix) then
-        local n = copynode(opennode)
-        nodeproperties[n] = { channel = channel, filename = filename } -- action = "open"
-        return context(tonode(n))
-    elseif not channels[channel] then
-        local handle = openfile(filename,"wb") or false
-        if handle then
-            channels[channel] = handle
-        else
-            -- error
-        end
-    end
-end
-
-function backends.openout(n)
-    local p = nodeproperties[n]
-    if p then
-        local handle = openfile(p.filename,"wb") or false
-        if handle then
-            channels[p.channel] = handle
-        else
-            -- error
-        end
-    end
-end
-
-local function write(prefix)
-    local channel = scaninteger()
-    if not immediately(prefix) then
-        local t = scantokenlist()
-        local n = copynode(writenode)
-        nodeproperties[n] = { channel = channel, data = t } -- action = "write"
-        return context(tonode(n))
-    else
-        local content = scanstring()
-        local handle  = channels[channel]
-        if handle then
-            handle:write(content,"\n")
-        else
-           logwriter(content,"\n")
-        end
-    end
-end
-
-function backends.writeout(n)
-    local p = nodeproperties[n]
-    if p then
-        local handle  = channels[p.channel]
-        local content = serialize(p.data)
-        if handle then
-            handle:write(content,"\n")
-        else
-           logwriter(content,"\n")
-        end
-    end
-end
-
-local function closeout(prefix)
-    local channel = scaninteger()
-    if not immediately(prefix) then
-        local n = copynode(closenode)
-        nodeproperties[n] = { channel = channel } -- action = "close"
-        return context(tonode(n))
-    else
-        local handle = channels[channel]
-        if handle then
-            handle:close()
-            channels[channel] = false
-            flushio()
-        else
-            -- error
-        end
-    end
-end
-
-function backends.closeout(n)
-    local p = nodeproperties[n]
-    if p then
-        local channel = p.channel
-        local handle  = channels[channel]
-        if handle then
-            handle:close()
-            channels[channel] = false
-            flushio()
-        else
-            -- error
-        end
-    end
-end
-
-local noflatelua = 0
-
-local function latelua()
-    local node = copynode(lateluanode)
-    local name = "latelua"
-    if scankeyword("name") then
-        name = scanstring()
-    end
-    local data = scantokenlist()
-    nodeproperties[node] = { name = name, data = data }
-    return context(tonode(node))
-end
-
-function backends.latelua(current,pos_h,pos_v) -- todo: pass pos_h and pos_v (more efficient in lmtx)
-    local p = nodeproperties[current]
-    if p then
-        data = p.data
-    else
-        data = getdata(current)
-    end
-    noflatelua = noflatelua + 1
-    local kind = type(data)
-    if kind == "table" then
-        data.action(data.specification or data)
-    elseif kind == "function" then
-        data()
-    else
-        if kind ~= "string" then
-            data = serialize(data)
-        end
-        if #data ~= "" then
-            local code = loadstring(data)
-            if code then
-                code()
-            end
-        end
-    end
-end
-
-function backends.getcallbackstate()
-    return { count = noflatelua }
-end
-
-function nodepool.originliteral(str) local t = copynode(literalnode) nodeproperties[t] = { data = str, mode = originliteral_code } return t end
-function nodepool.pageliteral  (str) local t = copynode(literalnode) nodeproperties[t] = { data = str, mode = pageliteral_code   } return t end
-function nodepool.directliteral(str) local t = copynode(literalnode) nodeproperties[t] = { data = str, mode = directliteral_code } return t end
-function nodepool.rawliteral   (str) local t = copynode(literalnode) nodeproperties[t] = { data = str, mode = rawliteral_code    } return t end
-
-local pdfliterals = {
-    [originliteral_code] = originliteral_code, [literalvalues[originliteral_code]] = originliteral_code,
-    [pageliteral_code]   = pageliteral_code,   [literalvalues[pageliteral_code]]   = pageliteral_code,
-    [directliteral_code] = directliteral_code, [literalvalues[directliteral_code]] = directliteral_code,
-    [rawliteral_code]    = rawliteral_code,    [literalvalues[rawliteral_code]]    = rawliteral_code,
-}
-
-function nodepool.literal(mode,str)
-    local t = copynode(literalnode)
-    if str then
-        nodeproperties[t] = { data = str, mode = pdfliterals[mode] or pageliteral_code }
-    else
-        nodeproperties[t] = { data = mode, mode = pageliteral_code }
-    end
-    return t
-end
-
---- these 3 will move to node-res as they are generic
-
-function nodepool.save()
-    return copynode(savenode)
-end
-
-function nodepool.restore()
-    return copynode(restorenode)
-end
-
-function nodepool.setmatrix(rx,sx,sy,ry,tx,ty)
-    local t = copynode(setmatrixnode)
-    nodeproperties[t] = { matrix = { rx, sx, sy, ry, tx, ty } }
-    return t
-end
-
-interfaces.implement { name = "openout",   actions = openout,    public = true, usage = "value" }
-interfaces.implement { name = "write",     actions = write,      public = true, usage = "value" }
-interfaces.implement { name = "closeout",  actions = closeout,   public = true, usage = "value" }
-interfaces.implement { name = "latelua",   actions = latelua,    public = true, protected = true }
-interfaces.implement { name = "special",   actions = scanstring, public = true, protected = true }
-
-open_command  = get(token.create("openout"))
-write_command = get(token.create("write"))
-close_command = get(token.create("closeout"))
diff --git a/tex/context/base/mkxl/back-out.mkxl b/tex/context/base/mkxl/back-out.mkxl
deleted file mode 100644
index 5cf79b2ea..000000000
--- a/tex/context/base/mkxl/back-out.mkxl
+++ /dev/null
@@ -1,22 +0,0 @@
-%D \module
-%D   [       file=back-out,
-%D        version=2019.02.08,
-%D          title=\CONTEXT\ Backend Macros,
-%D       subtitle=Output,
-%D         author=Hans Hagen,
-%D           date=\currentdate,
-%D      copyright={PRAGMA ADE \& \CONTEXT\ Development Team}]
-%C
-%C This module is part of the \CONTEXT\ macro||package and is
-%C therefore copyrighted by \PRAGMA. See mreadme.pdf for
-%C details.
-
-\registerctxluafile{back-out}{autosuffix}
-
-% \let\normalopenout \openout
-% \let\normalwrite   \write
-% \let\normalcloseout\closeout
-% \let\normallatelua \latelua
-% \let\normalspecial \special
-
-\endinput
diff --git a/tex/context/base/mkxl/back-pdf.mkxl b/tex/context/base/mkxl/back-pdf.mkxl
index 66db06ef1..d59c29bc0 100644
--- a/tex/context/base/mkxl/back-pdf.mkxl
+++ b/tex/context/base/mkxl/back-pdf.mkxl
@@ -20,7 +20,6 @@
 \registerctxluafile{lpdf-ini}{autosuffix,optimize}
 \registerctxluafile{lpdf-lmt}{autosuffix,optimize}
 \registerctxluafile{lpdf-col}{autosuffix}
-\registerctxluafile{lpdf-vfc}{autosuffix}
 \registerctxluafile{lpdf-xmp}{autosuffix}
 \registerctxluafile{lpdf-ano}{autosuffix}
 \registerctxluafile{lpdf-res}{autosuffix}
diff --git a/tex/context/base/mkxl/back-trf.lmt b/tex/context/base/mkxl/back-trf.lmt
deleted file mode 100644
index e3ec0bda3..000000000
--- a/tex/context/base/mkxl/back-trf.lmt
+++ /dev/null
@@ -1,164 +0,0 @@
-if not modules then modules = { } end modules ['back-trf'] = {
-    version   = 1.001,
-    comment   = "companion to back-ini.mkiv",
-    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
-    copyright = "PRAGMA ADE / ConTeXt Development Team",
-    license   = "see context related readme files"
-}
-
-local sind, cosd, abs = math.sind, math.cosd, math.abs
-local insert, remove = table.insert, table.remove
-local unpack = unpack
-
-local context           = context
-
-local formatters        = string.formatters
-
-local scanners          = tokens.scanners
-local scankeyword       = scanners.keyword
-local scaninteger       = scanners.integer
-local scannumber        = scanners.number
-local scanstring        = scanners.string
-
-local implement         = interfaces.implement
-
-local nodepool          = nodes.pool
-local savenode          = nodepool.save
-local restorenode       = nodepool.restore
-local setmatrixnode     = nodepool.setmatrix
-local literalnode       = nodepool.literal -- has to become some nodeinjection
-
-local stack             = { }
-local restore           = true -- false
-
-updaters.register("backend.update",function()
-    savenode      = nodepool.save      -- not needed
-    restorenode   = nodepool.restore   -- not needed
-    setmatrixnode = nodepool.setmatrix -- not needed
-    literalnode   = nodepool.literal   -- has to become some nodeinjection
-end)
-
-local function stopsomething()
-    local top = remove(stack)
-    if top == false then
-        -- not wrapped
-    elseif top == true then
-        context(restorenode())
-    elseif top then
-        context(setmatrixnode(unpack(top))) -- not really needed anymore
-        context(restorenode())
-    else
-        -- nesting error
-    end
-end
-
-local function startrotation()
-    local a = scannumber()
-    if a == 0 then
-        insert(stack,false)
-    else
-        local s, c = sind(a), cosd(a)
-        if abs(s) < 0.000001 then
-            s = 0 -- otherwise funny -0.00000
-        end
-        if abs(c) < 0.000001 then
-            c = 0 -- otherwise funny -0.00000
-        end
-        context(savenode())
-        context(setmatrixnode(c,s,-s,c))
-        insert(stack,restore and { c, -s, s, c } or true)
-    end
-end
-
-implement { name = "startrotation", actions = startrotation }
-implement { name = "stoprotation",  actions = stopsomething }
-
-local function startscaling() -- at the tex end we use sx and sy instead of rx and ry
-    local rx, ry = 1, 1
-    while true do
-        if scankeyword("rx") then
-            rx = scannumber()
-        elseif scankeyword("ry") then
-            ry = scannumber()
-     -- elseif scankeyword("revert") then
-     --     local top = stack[#stack]
-     --     if top then
-     --         rx = top[1]
-     --         ry = top[4]
-     --     else
-     --         rx = 1
-     --         ry = 1
-     --     end
-        else
-            break
-        end
-    end
-    if rx == 1 and ry == 1 then
-        insert(stack,false)
-    else
-        if rx == 0 then
-            rx = 0.0001
-        end
-        if ry == 0 then
-            ry = 0.0001
-        end
-        context(savenode())
-        context(setmatrixnode(rx,0,0,ry))
-        insert(stack,restore and { 1/rx, 0, 0, 1/ry } or true)
-    end
-end
-
-implement { name = "startscaling", actions = startscaling }
-implement { name = "stopscaling",  actions = stopsomething }
-
-local function startmatrix() -- rx sx sy ry  -- tx, ty
-    local rx, sx, sy, ry = 1, 0, 0, 1
-    while true do
-            if scankeyword("rx") then rx = scannumber()
-        elseif scankeyword("ry") then ry = scannumber()
-        elseif scankeyword("sx") then sx = scannumber()
-        elseif scankeyword("sy") then sy = scannumber()
-        else   break end
-    end
-    if rx == 1 and sx == 0 and sy == 0 and ry == 1 then
-        insert(stack,false)
-    else
-        context(savenode())
-        context(setmatrixnode(rx,sx,sy,ry))
-        insert(stack,store and { -rx, -sx, -sy, -ry } or true)
-    end
-end
-
-implement { name = "startmatrix", actions = startmatrix }
-implement { name = "stopmatrix",  actions = stopsomething }
-
-local function startmirroring()
-    context(setmatrixnode(-1,0,0,1))
-end
-
-implement { name = "startmirroring", actions = startmirroring }
-implement { name = "stopmirroring",  actions = startmirroring } -- not: stopsomething
-
--- this could also run on top of pack-rul ... todo
-
--- local function startclipping()
---  -- context(savenode())
---     context(literalnode("origin",formatters["q 0 w %s W n"](scanstring())))
--- end
---
--- local function stopclipping()
---  -- context(restorenode())
---     context(literalnode("Q"))
--- end
-
-local function startclipping()
-    context(savenode())
-    context(literalnode("origin",formatters["0 w %s W n"](scanstring())))
-end
-
-local function stopclipping()
-    context(restorenode())
-end
-
-implement { name = "startclipping", actions = startclipping }
-implement { name = "stopclipping",  actions = stopclipping }
diff --git a/tex/context/base/mkxl/colo-nod.lmt b/tex/context/base/mkxl/colo-nod.lmt
index d65f5978c..67487fee5 100644
--- a/tex/context/base/mkxl/colo-nod.lmt
+++ b/tex/context/base/mkxl/colo-nod.lmt
@@ -12,9 +12,9 @@ local setattrs          = nuts.setattrs
 
 local privateattributes = attributes.private
 
+local a_colormodel      = privateattributes('colormodel')
 local a_color           = privateattributes('color')
 local a_transparency    = privateattributes('transparency')
-local a_colormodel      = privateattributes('colormodel')
 
 local colors            = { }
 nuts.colors             = colors
@@ -26,9 +26,9 @@ function colors.set(n,ma,ca,ta) -- we could also do layers here
                 ma = 1
             end
             if ta then
-                setattrs(n,a_colorspace,ma,a_color,ca,a_transparency,ta)
+                setattrs(n,a_colormodel,ma,a_color,ca,a_transparency,ta)
             else
-                setattrs(n,a_colorspace,ma,a_color,ca)
+                setattrs(n,a_colormodel,ma,a_color,ca)
             end
         end
     elseif ta then
diff --git a/tex/context/base/mkxl/cont-new.mkxl b/tex/context/base/mkxl/cont-new.mkxl
index 31dbd327a..8f1882ce5 100644
--- a/tex/context/base/mkxl/cont-new.mkxl
+++ b/tex/context/base/mkxl/cont-new.mkxl
@@ -13,7 +13,7 @@
 
 % \normalend % uncomment this to get the real base runtime
 
-\newcontextversion{2021.01.11 16:28}
+\newcontextversion{2021.01.17 21:39}
 
 %D This file is loaded at runtime, thereby providing an excellent place for hacks,
 %D patches, extensions and new features. There can be local overloads in cont-loc
diff --git a/tex/context/base/mkxl/context.mkxl b/tex/context/base/mkxl/context.mkxl
index 751712225..54b1bb730 100644
--- a/tex/context/base/mkxl/context.mkxl
+++ b/tex/context/base/mkxl/context.mkxl
@@ -29,7 +29,7 @@
 %D {YYYY.MM.DD HH:MM} format.
 
 \immutable\edef\contextformat {\jobname}
-\immutable\edef\contextversion{2021.01.11 16:28}
+\immutable\edef\contextversion{2021.01.17 21:39}
 
 %overloadmode 1 % check frozen / warning
 %overloadmode 2 % check frozen / error
@@ -159,7 +159,7 @@
 
 \loadmkxlfile{node-ini}
 
-\loadmkxlfile{cldf-bas} % basics / depends on nodes
+% \loadmkxlfile{cldf-bas} % basics / depends on nodes
 
 \loadmkxlfile{node-fin}
 \loadmkxlfile{node-mig}
@@ -169,13 +169,15 @@
 
 \loadmkxlfile{back-ini}
 \loadmkxlfile{back-res}
-\loadmkxlfile{back-trf}
-\loadmkxlfile{back-out}
+\loadmkxlfile{back-ext}
+
+\loadmkxlfile{cldf-bas} % basics / depends on nodes
 
 \loadmkxlfile{attr-col}
 \loadmkxlfile{attr-lay}
 \loadmkxlfile{attr-neg}
 \loadmkxlfile{attr-eff}
+\loadmkxlfile{attr-alt}
 \loadmkxlfile{attr-mkr}
 
 \loadmkxlfile{trac-tex}
diff --git a/tex/context/base/mkxl/driv-shp.lmt b/tex/context/base/mkxl/driv-shp.lmt
index 9747ba82d..cfa61e30e 100644
--- a/tex/context/base/mkxl/driv-shp.lmt
+++ b/tex/context/base/mkxl/driv-shp.lmt
@@ -99,21 +99,7 @@ local gleaders_code           = gluecodes.gleaders
 
 local spaceskip_code          = gluecodes.spaceskip
 
-local saveposwhatsit_code     = whatsitcodes.savepos
-local userdefinedwhatsit_code = whatsitcodes.userdefined
-local openwhatsit_code        = whatsitcodes.open
-local writewhatsit_code       = whatsitcodes.write
-local closewhatsit_code       = whatsitcodes.close
-local lateluawhatsit_code     = whatsitcodes.latelua
-local literalwhatsit_code     = whatsitcodes.literal
-local setmatrixwhatsit_code   = whatsitcodes.setmatrix
-local savewhatsit_code        = whatsitcodes.save
-local restorewhatsit_code     = whatsitcodes.restore
-
-local getpagedimensions  getpagedimensions = function()
-    getpagedimensions = backends.codeinjections.getpagedimensions
-    return getpagedimensions()
-end
+local getpagedimensions       = layouts.getpagedimensions
 
 local drivers   = drivers
 local instances = drivers.instances
@@ -154,11 +140,6 @@ local flushcharacter
 local flushfontchar
 local flushrule
 local flushliteral
-local flushsetmatrix
-local flushsave
-local flushrestore
-local flushspecial
------ flushimage
 
 -- make local
 
@@ -169,307 +150,323 @@ function drivers.getvpos() return round(pos_v) end
 
 -- characters
 
-local flush_character
-
-local stack   = setmetatableindex("table")
-local level   = 0
-local nesting = 0
-local main    = 0
-
--- experiment (smaller page stream but might be fragile)
+local flush_character do
 
-local tospace = false  directives.register("backends.spaces", function(v) tospace = v end)
+    local stack   = setmetatableindex("table")
+    local level   = 0
+    local nesting = 0
+    local main    = 0
 
--- todo: cache streams
+    -- experiment (smaller page stream but might be fragile)
 
-local default = 16384 * number.dimenfactors.bp -- 65536 // 4
+    local tospace = false  directives.register("backends.spaces", function(v) tospace = v end)
 
-local startcolor = function() end
-local stopcolor  = function() end
+    -- todo: cache streams
 
-updaters.register("backend.update",function()
-    startcolor = fonts.vfcommands.startcolor
-    stopcolor  = fonts.vfcommands.stopcolor
-end)
+    local default = 16384 * number.dimenfactors.bp -- 65536 // 4
 
-local function flush_vf_packet(current,pos_h,pos_v,pos_r,font,char,data,factor,vfcommands,sx,sy)
+    local vfinjectors = fonts.helpers.vfinjectors
 
-    if nesting > 100 then
-        return
-    elseif nesting == 0 then
-        main = font
-    end
+    local function flush_vf_packet(current,pos_h,pos_v,pos_r,font,char,data,factor,vfcommands,sx,sy)
 
-    nesting = nesting + 1
+        if nesting > 100 then
+            return
+        elseif nesting == 0 then
+            main = font
+        end
 
-    local saved_h = pos_h
-    local saved_v = pos_v
-    local saved_r = pos_r
-            pos_r = lefttoright_code
+        nesting = nesting + 1
 
-    local data  = fontdata[font]
-    local fnt   = font
-    local fonts = data.fonts
-    local siz   = (data.parameters.factor or 1)/65536
+        local saved_h = pos_h
+        local saved_v = pos_v
+        local saved_r = pos_r
+                pos_r = lefttoright_code
 
--- siz = siz * data.parameters.size / 1000
+        local data  = fontdata[font]
+        local fnt   = font
+        local fonts = data.fonts
+        local siz   = (data.parameters.factor or 1)/65536
 
-    local function flushchar(font,char,fnt,chr,f,e)
-        if fnt then
-            local nest = char ~= chr or font ~= fnt
-            if fnt == 0 then
-                fnt = main
+        local function flushchar(font,char,fnt,chr,f,e)
+            if fnt then
+                local nest = char ~= chr or font ~= fnt
+                if fnt == 0 then
+                    fnt = main
+                end
+                return flush_character(current,fnt,chr,factor,nest,pos_h,pos_v,pos_r,f,e)
+            else
+                return 0
             end
---          return flush_character(false,fnt,chr,factor,nest,pos_h,pos_v,pos_r,f,e)
-            return flush_character(current,fnt,chr,factor,nest,pos_h,pos_v,pos_r,f,e)
-        else
-            return 0
         end
-    end
 
-    -- we assume resolved fonts: id mandate but maybe also size
-
-    for i=1,#vfcommands do
-        local packet  = vfcommands[i]
-        local command = packet[1]
-        if command == "char" then
-            local chr = packet[2]
-            local f   = packet[3]
-            local e   = packet[4]
-            pos_h = pos_h + flushchar(font,char,fnt,chr,f,e)
-        elseif command == "slot" then
-            local index = packet[2]
-            local chr   = packet[3]
-            local f     = packet[4]
-            local e     = packet[5]
-            if index == 0 then
-                pos_h = pos_h + flushchar(font,char,font,chr,f,e)
-            else
-                local okay = fonts and fonts[index]
-                if okay then
-                    local fnt = okay.id
-                    if fnt then
-                        pos_h = pos_h + flushchar(font,char,fnt,chr,f,e)
-                    end
-                else
-                    -- safeguard, we assume the font itself (often index 1)
-                    pos_h = pos_h + flushchar(font,char,font,chr,f,e)
-                end
-            end
-        elseif command == "use" then
-            local index = packet[2]
-            if index then
-                local fnt
+        -- we assume resolved fonts: id mandate but maybe also size
+
+        -- we could map left, right, up, down -> offset
+        -- we could map char, font, slot to -> slot
+
+        for i=1,#vfcommands do
+            local packet  = vfcommands[i]
+            local command = packet[1]
+            if command == "char" then
+                local chr = packet[2]
+                local f   = packet[3]
+                local e   = packet[4]
+                pos_h = pos_h + flushchar(font,char,fnt,chr,f,e)
+            elseif command == "slot" then
+                local index = packet[2]
+                local chr   = packet[3]
+                local f     = packet[4]
+                local e     = packet[5]
                 if index == 0 then
-                    fnt = font
+                    pos_h = pos_h + flushchar(font,char,font,chr,f,e)
                 else
                     local okay = fonts and fonts[index]
                     if okay then
-                        fnt = okay.id
+                        local fnt = okay.id
+                        if fnt then
+                            pos_h = pos_h + flushchar(font,char,fnt,chr,f,e)
+                        end
+                    else
+                        -- safeguard, we assume the font itself (often index 1)
+                        pos_h = pos_h + flushchar(font,char,font,chr,f,e)
                     end
                 end
-                if fnt then
-                    -- not efficient but ok for now as experiment
-                    local d = characters[fnt]
-                    if d then
-                        for i=3,#packet do
-                            local chr = packet[i]
-                            local dat = d[chr]
-                            if dat then
-                                flushfontchar(fnt,chr,dat)
+            elseif command == "use" then
+                local index = packet[2]
+                if index then
+                    local fnt
+                    if index == 0 then
+                        fnt = font
+                    else
+                        local okay = fonts and fonts[index]
+                        if okay then
+                            fnt = okay.id
+                        end
+                    end
+                    if fnt then
+                        -- not efficient but ok for now as experiment
+                        local d = characters[fnt]
+                        if d then
+                            for i=3,#packet do
+                                local chr = packet[i]
+                                local dat = d[chr]
+                                if dat then
+                                    flushfontchar(fnt,chr,dat)
+                                end
                             end
                         end
                     end
                 end
-            end
-        elseif command == "right" then
-            local h = packet[2] -- already scaled
-            if factor ~= 0 and h ~= 0 then
-                h = h + h * factor / 1000 -- expansion
-            end
-            h = h * sx
-            pos_h = pos_h + h
-        elseif command == "down" then
-            local v = packet[2] -- already scaled
-            v = v * sy
-            pos_v = pos_v - v
-        elseif command == "push" then
-            level = level + 1
-            local s = stack[level]
-            s[1] = pos_h
-            s[2] = pos_v
-        elseif command == "pop" then
-            if level > 0 then
-                local s = stack[level]
-                pos_h = s[1]
-                pos_v = s[2]
-                level = level - 1
-            end
-        elseif command == "rule" then
-            local size_v = packet[2]
-            local size_h = packet[3]
-            if size_h > 0 and size_v > 0 then
-                if factor ~= 0 then
-                    size_h = size_h + size_h * factor / 1000
+            elseif command == "right" then
+                local h = packet[2] -- already scaled
+                if h ~= 0 then
+                    if factor ~= 0 then
+                        h = h + h * factor / 1000 -- expansion
+                    end
+                    pos_h = pos_h + h * sx
                 end
-                if size_h > 0 then
-                    size_h = size_h * sx
-                    size_v = size_v * sy
-                    flushsimplerule(pos_h,pos_v,pos_r,size_h,size_v)
-                    pos_h = pos_h + size_h
+            elseif command == "left" then
+                local h = packet[2] -- already scaled
+                if h ~= 0 then
+                    if factor ~= 0 then
+                        h = h + h * factor / 1000 -- expansion
+                    end
+                    pos_h = pos_h - h * sx
                 end
-            end
-        elseif command == "frame" then
-            -- d:width d:height d:depth d:rulethickness b:outline b:advance b:baseline s:color
-            local width = packet[2]
-            if width > 0 then
-                local height = packet[3] or 0
-                local depth  = packet[4] or 0
-                local total  = height + depth
-                if total > 0 then
+            elseif command == "down" then
+                local v = packet[2] -- already scaled
+                if v and v ~= 0 then
+                    pos_v = pos_v - v * sy
+                end
+            elseif command == "up" then
+                local v = packet[2] -- already scaled
+                if v and v ~= 0 then
+                    pos_v = pos_v + v * sy
+                end
+            elseif command == "offset" then
+                local h = packet[2] or 0
+                local v = packet[3] or 0
+                if h ~= 0 then
                     if factor ~= 0 then
-                        width = width + width * factor / 1000
+                        h = h + h * factor / 1000 -- expansion
                     end
-                    if width > 0 then
-                        local line     = packet[5] or default
-                        local outline  = not packet[6]
-                        local advance  = not packet[7]
-                        local baseline = outline and packet[8]
-                        local color    = packet[9]
-                        if color then
-                            startcolor(color)
-                        end
-                        width  = width  * sx
-                        height = height * sy
-                        depth  = depth  * sy
-                        flushspecialrule(pos_h,pos_v,pos_r,width,height,depth,line,outline,baseline)
-                        if color then
-                            stopcolor()
+                    pos_h = pos_h + h * sx
+                end
+                if v and v ~= 0 then
+                    pos_v = pos_v + v * sy
+                end
+            elseif command == "push" then
+                level = level + 1
+                local s = stack[level]
+                s[1] = pos_h
+                s[2] = pos_v
+            elseif command == "pop" then
+                if level > 0 then
+                    local s = stack[level]
+                    pos_h = s[1]
+                    pos_v = s[2]
+                    level = level - 1
+                end
+            elseif command == "rule" then
+                local size_v = packet[2]
+                local size_h = packet[3]
+                if size_h > 0 and size_v > 0 then
+                    if factor ~= 0 then
+                        size_h = size_h + size_h * factor / 1000
+                    end
+                    if size_h > 0 then
+                        size_h = size_h * sx
+                        size_v = size_v * sy
+                        flushsimplerule(pos_h,pos_v,pos_r,size_h,size_v)
+                        pos_h = pos_h + size_h
+                    end
+                end
+            elseif command == "frame" then
+                -- d:width d:height d:depth d:rulethickness b:outline b:advance b:baseline s:color
+                local width = packet[2]
+                if width > 0 then
+                    local height = packet[3] or 0
+                    local depth  = packet[4] or 0
+                    local total  = height + depth
+                    if total > 0 then
+                        if factor ~= 0 then
+                            width = width + width * factor / 1000
                         end
-                        if advance then
-                            pos_h = pos_h + width
+                        if width > 0 then
+                            local line     = packet[5] or default
+                            local outline  = not packet[6]
+                            local advance  = not packet[7]
+                            local baseline = outline and packet[8]
+                            local color    = packet[9] -- no longer needed probably
+                            if color then
+                                vfinjectors.startcolor(pos_h,pos_v,color) -- takes packet or string
+                            end
+                            width  = width  * sx
+                            height = height * sy
+                            depth  = depth  * sy
+                            flushspecialrule(pos_h,pos_v,pos_r,width,height,depth,line,outline,baseline)
+                            if color then
+                                vfinjectors.stopcolor()
+                            end
+                            if advance then
+                                pos_h = pos_h + width
+                            end
                         end
                     end
                 end
+            elseif command == "font" then
+                local index = packet[2]
+                local okay  = fonts and fonts[index]
+                if okay then
+                    fnt = okay.id or fnt -- or maybe just return
+                end
+            elseif command == "lua" then
+                local code = packet[2]
+                local kind = type(code)
+                if kind ~= "function" then
+                    code = loadstring(code)
+                    kind = type(code)
+                end
+                if kind == "function" then
+                    code(font,char,pos_h,pos_v,sx,sy)
+                end
+            elseif command == "node" then -- obsolete
+                local h = packet[2]
+                hlist_out(h,getlist(h))
+            else
+                local injector = vfinjectors[command]
+                if injector then
+                    injector(pos_h,pos_v,packet)
+                end
             end
-        elseif command == "font" then
-            local index = packet[2]
-            local okay  = fonts and fonts[index]
-            if okay then
-                fnt = okay.id or fnt -- or maybe just return
-            end
-        elseif command == "lua" then
-            local code = packet[2]
-            local kind = type(code)
-            if kind ~= "function" then
-                code = loadstring(code)
-                kind = type(code)
-            end
-            if kind == "function" then
-                code(font,char,pos_h,pos_v,sx,sy)
-            end
-        elseif command == "node" then
-            -- us this really useful?
-            local h = packet[2]
-            hlist_out(h,getlist(h))
-        elseif command == "pdf" then
-            -- this will disappear and become a plug
-            flushliteral(false,pos_h,pos_v,packet[2],packet[3])
-     -- elseif command == "image" then
-     --     -- doesn't work because intercepted by engine so we use a different
-     --     -- mechanism (for now)
-     --     local image = packet[2]
-     --     -- to do
-     -- elseif command == "pdfmode" then
-     --     -- doesn't happen
-     -- elseif command == "special" then
-     --     -- not supported
-     -- elseif command == "nop" then
-     --     -- nothing to do|
-     -- elseif command == "scale" then
-     --     -- not supported
+         -- image   : not needed, maybe some day
+         -- pdfmode : not used
+         -- special : makes no sense
+         -- nop     : the official ignore
+         -- scale   : not supported
         end
-    end
 
-    pos_h = saved_h
-    pos_v = saved_v
-    pos_r = saved_r
+        pos_h = saved_h
+        pos_v = saved_v
+        pos_r = saved_r
 
-    nesting = nesting - 1
-end
+        nesting = nesting - 1
+    end
 
-local onetimemessage -- could be defined later (todo: make plug for this)
+    local onetimemessage -- could be defined later (todo: make plug for this)
 
-local getxyscales = nuts.getxyscales
+    local getxyscales = nuts.getxyscales
 
-flush_character = function(current,font,char,factor,vfcommands,pos_h,pos_v,pos_r,f,e)
+    flush_character = function(current,font,char,factor,vfcommands,pos_h,pos_v,pos_r,f,e)
 
-    if font ~= lastfont then
-        lastfont       = font
-        fontcharacters = characters[font]
-        updatefontstate(font)
-    end
+        if font ~= lastfont then
+            lastfont       = font
+            fontcharacters = characters[font]
+            updatefontstate(font)
+        end
 
-    local data = fontcharacters[char]
-    if not data then
-        if char > 0 then
-            if not onetimemessage then
-                onetimemessage = fonts.loggers.onetimemessage
+        local data = fontcharacters[char]
+        if not data then
+            if char > 0 then
+                if not onetimemessage then
+                    onetimemessage = fonts.loggers.onetimemessage
+                end
+                onetimemessage(font,char,"missing")
             end
-            onetimemessage(font,char,"missing")
-        end
-        return 0, 0, 0
-    end
-    if vfcommands then
-        vfcommands = data.commands
-    end
-    local width, height, depth, naturalwidth, sx, sy
-    if current then
-        naturalwidth, height, depth, factor = getwhd(current,true) -- also get corrected width
-        sx, sy = getxyscales(current) -- maybe: getwhdfs
-        if factor == 0 then
-            width = naturalwidth
-        else
-         -- width = (1.0 + factor/1000000.0) * naturalwidth
-            width = naturalwidth + naturalwidth * factor/1000000.0
-         -- width = naturalwidth + naturalwidth * 0.000001 * factor
+            return 0, 0, 0
         end
-    else
-        width  = data.width or 0
-        height = data.height or 0
-        depth  = data.depth or 0
-        naturalwidth = width
-        if not factor then
-            factor = 0
+        if vfcommands then
+            vfcommands = data.commands
         end
-        sx = 1
-        sy = 1
-    end
-    if pos_r == righttoleft_code then
-        pos_h = pos_h - width -- here ?
-    end
-    if vfcommands then
-        flush_vf_packet(current,pos_h,pos_v,pos_r,font,char,data,factor,vfcommands,sx,sy) -- also f ?
-    else
-        -- kind of messy that we do orientation here and offsets elsewhere
-        local orientation = data.orientation
-        if orientation and (orientation == 1 or orientation == 3) then
-            local x = data.xoffset
-            local y = data.yoffset
-            if x then
-                pos_h = pos_h + x
+        local width, height, depth, naturalwidth, sx, sy
+        if current then
+            naturalwidth, height, depth, factor = getwhd(current,true) -- also get corrected width
+            sx, sy = getxyscales(current) -- maybe: getwhdfs
+            if factor == 0 then
+                width = naturalwidth
+            else
+             -- width = (1.0 + factor/1000000.0) * naturalwidth
+                width = naturalwidth + naturalwidth * factor/1000000.0
+             -- width = naturalwidth + naturalwidth * 0.000001 * factor
             end
-            if y then
-                pos_v = pos_v + y
+        else
+            width  = data.width or 0
+            height = data.height or 0
+            depth  = data.depth or 0
+            naturalwidth = width
+            if not factor then
+                factor = 0
             end
-            pushorientation(orientation,pos_h,pos_v)
-            flushcharacter(current,pos_h,pos_v,pos_r,font,char,data,f,e,factor,sx,sy) -- ,naturalwidth,width)
-            poporientation(orientation,pos_h,pos_v)
+            sx = 1
+            sy = 1
+        end
+        if pos_r == righttoleft_code then
+            pos_h = pos_h - width -- here ?
+        end
+        if vfcommands then
+            flush_vf_packet(current,pos_h,pos_v,pos_r,font,char,data,factor,vfcommands,sx,sy) -- also f ?
         else
-            flushcharacter(current,pos_h,pos_v,pos_r,font,char,data,f,e,factor,sx,sy) -- ,naturalwidth,width)
+            -- kind of messy that we do orientation here and offsets elsewhere .. this might change
+            local orientation = data.orientation
+            if orientation and (orientation == 1 or orientation == 3) then
+                local x = data.xoffset
+                local y = data.yoffset
+                if x then
+                    pos_h = pos_h + x
+                end
+                if y then
+                    pos_v = pos_v + y
+                end
+                pushorientation(orientation,pos_h,pos_v)
+                flushcharacter(current,pos_h,pos_v,pos_r,font,char,data,f,e,factor,sx,sy) -- ,naturalwidth,width)
+                poporientation(orientation,pos_h,pos_v)
+            else
+                flushcharacter(current,pos_h,pos_v,pos_r,font,char,data,f,e,factor,sx,sy) -- ,naturalwidth,width)
+            end
         end
+        return width, height, depth
     end
-    return width, height, depth
+
 end
 
 -- end of characters
@@ -536,6 +533,13 @@ local function flushcloseout(current)
     end
 end
 
+local function flushsavepos(current,pos_h,pos_v)
+    jobpositions.lastx = pos_h
+    jobpositions.lasty = pos_v
+end
+
+local flushwhatsit
+
 local hlist_out, vlist_out  do
 
     local function applyanchor(orientation,x,y,width,height,depth,woffset,hoffset,doffset,xoffset,yoffset)
@@ -905,26 +909,7 @@ local hlist_out, vlist_out  do
                     goto synced
                 end
             elseif id == whatsit_code then
-                if subtype == literalwhatsit_code then
-                    flushliteral(current,pos_h,pos_v)
-                elseif subtype == lateluawhatsit_code then
-                    flushlatelua(current,pos_h,pos_v)
-                elseif subtype == setmatrixwhatsit_code then
-                    flushsetmatrix(current,pos_h,pos_v)
-                elseif subtype == savewhatsit_code then
-                    flushsave(current,pos_h,pos_v)
-                elseif subtype == restorewhatsit_code then
-                    flushrestore(current,pos_h,pos_v)
-                elseif subtype == saveposwhatsit_code then
-                    last_position_x = pos_h
-                    last_position_y = pos_v
-                elseif subtype == writewhatsit_code then
-                    flushwriteout(current)
-                elseif subtype == closewhatsit_code then
-                    flushcloseout(current)
-                elseif subtype == openwhatsit_code then
-                    flushopenout(current)
-                end
+                flushwhatsit[subtype](current,pos_h,pos_v)
             elseif id == disc_code then
                 local replace, tail = getreplace(current)
                 -- actually, we no longer have these select discs in the packaged list ... it's about
@@ -1164,26 +1149,7 @@ local hlist_out, vlist_out  do
                 end
                 cur_v = cur_v + total
             elseif id == whatsit_code then
-                if subtype == literalwhatsit_code then
-                    flushliteral(current,pos_h,pos_v)
-                elseif subtype == lateluawhatsit_code then
-                    flushlatelua(current,pos_h,pos_v)
-                elseif subtype == setmatrixwhatsit_code then
-                    flushsetmatrix(current,pos_h,pos_v)
-                elseif subtype == savewhatsit_code then
-                    flushsave(current,pos_h,pos_v)
-                elseif subtype == restorewhatsit_code then
-                    flushrestore(current,pos_h,pos_v)
-                elseif subtype == saveposwhatsit_code then
-                    last_position_x = pos_h
-                    last_position_y = pos_v
-                elseif subtype == writewhatsit_code then
-                    flushwriteout(current)
-                elseif subtype == closewhatsit_code then
-                    flushcloseout(current)
-                elseif subtype == openwhatsit_code then
-                    flushopenout(current)
-                end
+                flushwhatsit[subtype](current,pos_h,pos_v)
             else
                 -- penalty
                 goto synced
@@ -1223,22 +1189,47 @@ function drivers.converters.lmtx(driver,box,smode,objnum,specification)
     initialize        = actions.initialize
     finalize          = actions.finalize
 
-    updatefontstate   = flushers.updatefontstate
-
-    pushorientation   = flushers.pushorientation
-    poporientation    = flushers.poporientation
+    -- we need to do this once ...
+
+    if not updatefontstate then
+
+        updatefontstate   = flushers.updatefontstate
+
+        pushorientation   = flushers.pushorientation
+        poporientation    = flushers.poporientation
+
+        flushcharacter    = flushers.character
+        flushfontchar     = flushers.fontchar
+        flushrule         = flushers.rule
+        flushsimplerule   = flushers.simplerule
+        flushspecialrule  = flushers.specialrule
+        flushliteral      = flushers.literal
+
+        flushwhatsit      = setmetatableindex ( {
+            [whatsitcodes.literal]        = flushliteral,
+            [whatsitcodes.latelua]        = flushlatelua,
+            [whatsitcodes.userdefined]    = function() end,      -- special purpose, handled in callbacks
+            [whatsitcodes.savepos]        = flushsavepos,        -- only used by generic packages
+            [whatsitcodes.save]           = flushers.save,
+            [whatsitcodes.restore]        = flushers.restore,
+            [whatsitcodes.setmatrix]      = flushers.setmatrix,
+            [whatsitcodes.open]           = flushopenout,        -- generic
+            [whatsitcodes.close]          = flushcloseout,       -- generic
+            [whatsitcodes.write]          = flushwriteout,       -- generic
+            [whatsitcodes.startmatrix]    = flushers.startmatrix,
+            [whatsitcodes.stopmatrix]     = flushers.stopmatrix,
+            [whatsitcodes.startscaling]   = flushers.startscaling,
+            [whatsitcodes.stopscaling]    = flushers.stopscaling,
+            [whatsitcodes.startrotation]  = flushers.startrotation,
+            [whatsitcodes.stoprotation]   = flushers.stoprotation,
+            [whatsitcodes.startmirroring] = flushers.startmirroring,
+            [whatsitcodes.stopmirroring]  = flushers.stopmirroring,
+            [whatsitcodes.startclipping]  = flushers.startclipping,
+            [whatsitcodes.stopclipping]   = flushers.stopclipping,
+            [whatsitcodes.setstate]       = flushers.setstate,
+        }, function(t, k) report("weird whatsit %a",k) return function() end end)
 
-    flushcharacter    = flushers.character
-    flushfontchar     = flushers.fontchar
-    flushrule         = flushers.rule
-    flushsimplerule   = flushers.simplerule
-    flushspecialrule  = flushers.specialrule
-    flushspecial      = flushers.special
-    flushliteral      = flushers.literal
-    flushsetmatrix    = flushers.setmatrix
-    flushsave         = flushers.save
-    flushrestore      = flushers.restore
- -- flushimage        = flushers.image
+    end
 
     reset_dir_stack()
     reset_state()
@@ -1279,12 +1270,6 @@ function drivers.converters.lmtx(driver,box,smode,objnum,specification)
 
         local pagewidth, pageheight = getpagedimensions()
 
-     -- local h_offset_par = texget("hoffset")
-     -- local v_offset_par = texget("voffset")
-
-     -- page_h_origin = trueinch
-     -- page_v_origin = trueinch
-
         pos_r = lefttoright_code
 
         if pagewidth > 0 then
@@ -1307,17 +1292,14 @@ function drivers.converters.lmtx(driver,box,smode,objnum,specification)
             page_size_v = total
         end
 
-        local refpoint_h = 0           -- + page_h_origin + h_offset_par
-        local refpoint_v = page_size_v -- - page_v_origin - v_offset_par
+        local refpoint_h = 0
+        local refpoint_v = page_size_v
 
         pos_h = refpoint_h
         pos_v = refpoint_v - height
-        -- synced
 
     else
 
-     -- page_h_origin = 0
-     -- page_v_origin = 0
         page_size_h   = width
         page_size_v   = total
         pos_r         = getdirection(box)
diff --git a/tex/context/base/mkxl/font-chk.lmt b/tex/context/base/mkxl/font-chk.lmt
index 7141be2c7..8e73d1b3c 100644
--- a/tex/context/base/mkxl/font-chk.lmt
+++ b/tex/context/base/mkxl/font-chk.lmt
@@ -64,7 +64,6 @@ local implement            = interfaces.implement
 
 local glyph_code           = nodes.nodecodes.glyph
 
-local new_special          = nodes.pool.special -- todo: literal
 local hpack_node           = node.hpack
 
 local nuts                 = nodes.nuts
diff --git a/tex/context/base/mkxl/font-con.lmt b/tex/context/base/mkxl/font-con.lmt
index 88e17290a..60e3f0233 100644
--- a/tex/context/base/mkxl/font-con.lmt
+++ b/tex/context/base/mkxl/font-con.lmt
@@ -51,6 +51,8 @@ constructors.designsizes    = designsizes
 local loadedfonts           = allocate()
 constructors.loadedfonts    = loadedfonts
 
+----- scalecommands         = fonts.helpers.scalecommands
+
 --[[ldx--
 <p>We need to normalize the scale factor (in scaled points). This has to
 do with the fact that <l n='tex'/> uses a negative multiple of 1000 as
@@ -260,6 +262,8 @@ function constructors.scale(tfmdata,specification)
     end
     target.specification = specification
     --
+    local scalecommands  = fonts.helpers.scalecommands -- defined later
+    --
     local scaledpoints   = specification.size
     local relativeid     = specification.relativeid
     --
@@ -774,37 +778,7 @@ function constructors.scale(tfmdata,specification)
         end
         local vc = character.commands
         if vc then
-            -- we assume non scaled commands here
-            -- tricky .. we need to scale pseudo math glyphs too
-            -- which is why we deal with rules too
-            local ok = false
-            for i=1,#vc do
-                local key = vc[i][1]
-                if key == "right" or key == "down" or key == "rule" then
-                    ok = true
-                    break
-                end
-            end
-            if ok then
-                local tt = { }
-                for i=1,#vc do
-                    local ivc = vc[i]
-                    local key = ivc[1]
-                    if key == "right" then
-                        tt[i] = { key, ivc[2]*hdelta }
-                    elseif key == "down" then
-                        tt[i] = { key, ivc[2]*vdelta }
-                    elseif key == "rule" then
-                        tt[i] = { key, ivc[2]*vdelta, ivc[3]*hdelta }
-                    else -- not comment
-                        tt[i] = ivc -- shared since in cache and untouched
-                    end
-                end
-                chr.commands = tt
-            else
-                chr.commands = vc
-            end
-         -- chr.index = nil
+            chr.commands = scalecommands(vc,hdelta,vdelta)
         end
         targetcharacters[unicode] = chr
     end
diff --git a/tex/context/base/mkxl/font-fbk.lmt b/tex/context/base/mkxl/font-fbk.lmt
index 651bca331..47d284c84 100644
--- a/tex/context/base/mkxl/font-fbk.lmt
+++ b/tex/context/base/mkxl/font-fbk.lmt
@@ -63,13 +63,12 @@ local function composecharacters(tfmdata)
         local deltaxheight = scale * (Xdesc.boundingbox[4] - xdesc.boundingbox[4])
         local extraxheight = fraction * deltaxheight -- maybe use compose value
         local italicfactor = parameters.italicfactor or 0
-        local vfspecials   = backends.tables.vfspecials --brr
         local red, green, blue, black
         if trace_visualize then
-            red   = vfspecials.startcolor("red")
-            green = vfspecials.startcolor("green")
-            blue  = vfspecials.startcolor("blue")
-            black = vfspecials.stopcolor
+            red   = { "startcolor", "red" }
+            green = { "startcolor", "green" }
+            blue  = { "startcolor", "blue" }
+            black = { "stopcolor" }
         end
         local compose = fonts.goodies.getcompositions(tfmdata)
         if compose and trace_visualize then
diff --git a/tex/context/base/mkxl/font-imp-math.lmt b/tex/context/base/mkxl/font-imp-math.lmt
index 079c867e2..277190f24 100644
--- a/tex/context/base/mkxl/font-imp-math.lmt
+++ b/tex/context/base/mkxl/font-imp-math.lmt
@@ -70,6 +70,35 @@ registerotffeature {
 
 -- A quick and dirty and low level implementation but okay for testing:
 
+function fonts.helpers.mathscriptslots(tfmdata,textcode)
+    local rawdata           = tfmdata.shared.rawdata
+    local rawresources      = rawdata and rawdata.resources
+    local rawfeatures       = rawresources and rawresources.features
+    local basesubstitutions = rawfeatures and rawfeatures.gsub
+    local sequences         = basesubstitutions and tfmdata.resources.sequences
+    if sequences then
+        local characters = tfmdata.characters
+        if characters[textcode] then
+            for s=1,#sequences do
+                local sequence  = sequences[s]
+                local sfeatures = sequence.features
+                if sfeatures and sfeatures.ssty then
+                    local steps = sequence.steps
+                    for i=1,#steps do
+                        local coverage = steps[i].coverage
+                        if coverage then
+                            local okay = coverage[textcode]
+                            if okay then
+                                return okay
+                            end
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+
 local function manipulate(tfmdata,key,value)
     if texconditionals["c_font_compact"] then
         local rawdata           = tfmdata.shared.rawdata
@@ -81,7 +110,7 @@ local function manipulate(tfmdata,key,value)
         if sequences then
             local characters = tfmdata.characters
             for s=1,#sequences do
-                local sequence = sequences[s]
+                local sequence  = sequences[s]
                 local sfeatures = sequence.features
                 if sfeatures and sfeatures.ssty then
                     local steps = sequence.steps
diff --git a/tex/context/base/mkxl/font-imp-tracing.lmt b/tex/context/base/mkxl/font-imp-tracing.lmt
new file mode 100644
index 000000000..59603c9dd
--- /dev/null
+++ b/tex/context/base/mkxl/font-imp-tracing.lmt
@@ -0,0 +1,286 @@
+if not modules then modules = { } end modules ['font-imp-tracing'] = {
+    version   = 1.001,
+    comment   = "companion to font-ini.mkiv and hand-ini.mkiv",
+    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
+    copyright = "PRAGMA ADE / ConTeXt Development Team",
+    license   = "see context related readme files"
+}
+
+local abs = math.abs
+
+local next, type = next, type
+local concat = table.concat
+local formatters = string.formatters
+
+local fonts              = fonts
+
+local handlers           = fonts.handlers
+local registerotffeature = handlers.otf.features.register
+local registerafmfeature = handlers.afm.features.register
+
+local settings_to_array  = utilities.parsers.settings_to_array
+local setmetatableindex  = table.setmetatableindex
+
+local helpers            = fonts.helpers
+local appendcommandtable = helpers.appendcommandtable
+local prependcommands    = helpers.prependcommands
+local charcommand        = helpers.commands.char
+
+local variables          = interfaces.variables
+
+local v_background       = variables.background
+local v_frame            = variables.frame
+local v_empty            = variables.empty
+local v_none             = variables.none
+
+local function initialize(tfmdata,key,value)
+    if value then
+        local vfspecials  = fonts.helpers.vfspecials
+        local vfcommands  = fonts.helpers.commands
+        local backgrounds = vfspecials.backgrounds
+        local outlines    = vfspecials.outlines
+        local characters  = tfmdata.characters
+        local rulecache   = backgrounds
+        local showchar    = true
+        local color       = "palegray"
+        if type(value) == "string" then
+            value = settings_to_array(value)
+            for i=1,#value do
+                local v = value[i]
+                if v == v_frame then
+                    rulecache = outlines
+                elseif v == v_background then
+                    rulecache = backgrounds
+                elseif v == v_empty then
+                    showchar = false
+                elseif v == v_none then
+                    color = nil
+                else
+                    color = v
+                end
+            end
+        end
+        local gray  = color and { "startcolor", color } or nil
+        local black = gray  and { "stopcolor" }         or nil
+        for unicode, character in next, characters do
+            local width  = character.width  or 0
+            local height = character.height or 0
+            local depth  = character.depth  or 0
+            local rule   = rulecache[height][depth][width]
+            if showchar then
+                local commands = character.commands
+                if commands then
+                    if gray then
+                        character.commands = prependcommands (
+                            commands, gray, rule, black
+                        )
+                    else
+                        character.commands = prependcommands (
+                            commands, rule
+                        )
+                    end
+                else
+                    local char = charcommand[unicode]
+                    if gray then
+                        character.commands = {
+                            gray, rule, black, char
+                        }
+                     else
+                        character.commands = {
+                            rule, char
+                        }
+                    end
+                end
+            else
+                if gray then
+                    character.commands = {
+                        gray, rule, black
+                    }
+                else
+                    character.commands = {
+                        rule
+                    }
+                end
+            end
+        end
+    end
+end
+
+local specification = {
+    name        = "boundingbox",
+    description = "show boundingbox",
+    manipulators = {
+        base = initialize,
+        node = initialize,
+    }
+}
+
+registerotffeature(specification)
+registerafmfeature(specification)
+
+local function initialize(tfmdata,key,value)
+    if value then
+        local rawdata       = tfmdata.shared.rawdata
+        local rawresources  = rawdata and rawdata.resources
+        local mathconstants = rawresources.mathconstants
+        if mathconstants then
+            local vfspecials  = fonts.helpers.vfspecials
+            local vfcommands  = fonts.helpers.commands
+            local backgrounds = vfspecials.backgrounds
+            local outlines    = vfspecials.outlines
+            local characters  = tfmdata.characters
+            local rulecache   = backgrounds
+            local push        = vfcommands.push
+            local pop         = vfcommands.pop
+            local black       = { "stopcolor" }
+            local itcolor     = { "startcolor", "trace:0" } -- s / dd (transparent)
+            local brcolor     = { "startcolor", "trace:1" } -- r / dr
+            local trcolor     = { "startcolor", "trace:2" } -- g / dg
+            local blcolor     = { "startcolor", "trace:3" } -- b / db
+            local tlcolor     = { "startcolor", "trace:4" } -- y / dy
+            for unicode, character in next, characters do
+                local mathkern = character.mathkern
+                local italic   = character.vert_italic or character.italic
+                if mathkern or (italic and italic ~= 0) then
+                    local width  = character.width  or 0
+                    local height = character.height or 0
+                    local depth  = character.depth  or 0
+                    local list   = { }
+                    local count  = 0
+                    if italic and italic ~= 0 then
+                        count = count + 1 list[count] = itcolor
+                        count = count + 1 list[count] = push
+                        count = count + 1 list[count] = { "offset", width + (italic < 0 and -italic or 0), 0 }
+                        count = count + 1 list[count] = rulecache[height][depth][abs(-italic)]
+                        count = count + 1 list[count] = pop
+                        count = count + 1 list[count] = black
+                    end
+                    if mathkern then
+                        local br = mathkern.bottom_right
+                        local tr = mathkern.top_right
+                        local bl = mathkern.bottom_left
+                        local tl = mathkern.top_left
+                        if br then
+                            local done = false
+                            for i=1,#br do
+                                local l = br[i]
+                                local h = l.height or 0
+                                local k = l.kern or 0
+                                if k ~= 0 then
+                                    if h == 0 then
+                                        h = height + depth -- todo max
+                                    end
+                                    if not done then
+                                        count = count + 1 list[count] = brcolor
+                                        done  = true
+                                    end
+                                    count = count + 1 list[count] = push
+                                    count = count + 1 list[count] = { "offset", width + (k < 0 and k or 0), - depth }
+                                    count = count + 1 list[count] = rulecache[h][0][abs(k)]
+                                    count = count + 1 list[count] = pop
+                                end
+                            end
+                            if done then
+                                count = count + 1 list[count] = black
+                            end
+                        end
+                        if tr then
+                            local done = false
+                            for i=1,#tr do
+                                local l = tr[i]
+                                local h = l.height or 0
+                                local k = l.kern or 0
+                                if k ~= 0 then
+                                    if h == 0 then
+                                        h = height + depth -- todo max
+                                    end
+                                    if not done then
+                                        count = count + 1 list[count] = trcolor
+                                        done  = true
+                                    end
+                                    count = count + 1 list[count] = push
+                                    count = count + 1 list[count] = { "offset", width + (k < 0 and k or 0), height - h }
+                                    count = count + 1 list[count] = rulecache[h][0][abs(k)]
+                                    count = count + 1 list[count] = pop
+                                end
+                            end
+                            if done then
+                                count = count + 1 list[count] = black
+                            end
+                        end
+                        if bl then
+                            local done = false
+                            for i=1,#bl do
+                                local l = bl[i]
+                                local h = l.height or 0
+                                local k = l.kern or 0
+                                if k ~= 0 then
+                                    if h == 0 then
+                                        h = height + depth -- todo max
+                                    end
+                                    if not done then
+                                        count = count + 1 list[count] = blcolor
+                                        done  = true
+                                    end
+                                    count = count + 1 list[count] = push
+                                    count = count + 1 list[count] = { "offset", (k < 0 and k or 0), -depth }
+                                    count = count + 1 list[count] = rulecache[h][0][abs(k)]
+                                    count = count + 1 list[count] = pop
+                                end
+                            end
+                            if done then
+                                count = count + 1 list[count] = black
+                            end
+                        end
+                        if tl then
+                            local done = false
+                            for i=1,#tl do
+                                local l = tl[i]
+                                local h = l.height or 0
+                                local k = l.kern or 0
+                                if k ~= 0 then
+                                    if h == 0 then
+                                        h = height + depth -- todo max
+                                    end
+                                    if not done then
+                                        count = count + 1 list[count] = tlcolor
+                                        done  = true
+                                    end
+                                    count = count + 1 list[count] = push
+                                    count = count + 1 list[count] = { "offset", (k < 0 and k or 0), height - h }
+                                    count = count + 1 list[count] = rulecache[h][0][abs(k)]
+                                    count = count + 1 list[count] = pop
+                                end
+                            end
+                            if done then
+                                count = count + 1 list[count] = black
+                            end
+                        end
+                    end
+                    if count > 0 then
+                        local commands = character.commands
+                        if commands then
+                            character.commands = appendcommandtable(commands,list)
+                        else
+                            list[#list+1] = charcommand[unicode]
+                            character.commands = list
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+
+local specification = {
+    name         = "staircase",
+    description  = "show staircase kerns",
+--  position     = 1,
+    manipulators = {
+        base = initialize,
+        node = initialize,
+    }
+}
+
+registerotffeature(specification)
+registerafmfeature(specification)
diff --git a/tex/context/base/mkxl/font-lib.mklx b/tex/context/base/mkxl/font-lib.mklx
index 00bddc2c3..e90973d75 100644
--- a/tex/context/base/mkxl/font-lib.mklx
+++ b/tex/context/base/mkxl/font-lib.mklx
@@ -17,7 +17,7 @@
 
 \registerctxluafile{font-ini}{autosuffix}
 \registerctxluafile{font-log}{}
-\registerctxluafile{font-con}{autosuffix}
+\registerctxluafile{font-con}{autosuffix} % kind of early
 %registerctxluafile{font-cft}{}
 \registerctxluafile{font-enc}{}
 \registerctxluafile{font-fmp}{autosuffix}
@@ -88,7 +88,7 @@
 \registerctxluafile{good-ini}{}
 \registerctxluafile{good-gen}{}
 \registerctxluafile{good-ctx}{}
-\registerctxluafile{good-mth}{}
+\registerctxluafile{good-mth}{autosuffix}
 
 \registerctxluafile{font-def}{autosuffix}
 \registerctxluafile{font-ctx}{autosuffix} % after def as it overloads
@@ -116,7 +116,7 @@
     % not yet, lmtx feature
 }
 
-\registerctxluafile{font-imp-tracing}{} % comes last!
+\registerctxluafile{font-imp-tracing}{autosuffix} % comes last!
 
 \registerctxluafile{font-fbk}{autosuffix}
 
diff --git a/tex/context/base/mkxl/font-ogr.lmt b/tex/context/base/mkxl/font-ogr.lmt
index df6449ded..a3f8acb3c 100644
--- a/tex/context/base/mkxl/font-ogr.lmt
+++ b/tex/context/base/mkxl/font-ogr.lmt
@@ -242,6 +242,8 @@ do -- this will move to its own module
         return false
     end
 
+    -- list of tonumber keywords
+
     local function initializemps(tfmdata,kind,value)
         if value then
             local specification = settings_to_hash_strict(value)
@@ -256,9 +258,20 @@ do -- this will move to its own module
                 local categories = settings_to_array(category)
                 local usedshapes = nil
                 local index      = 0
-                local spread     = tonumber(specification.spread or 0)
+                local spread     = tonumber(specification.spread or 0) -- hm
                 local hascolor   = hascolorspec(specification)
-                specification.spread = spread -- now a number
+
+                specification.spread = spread -- now a number, maybe also for slant, weight etc
+
+                local preroll = specification.preroll
+                if preroll then
+                    metapost.simple(instance,"begingroup;",true,true)
+                    metapost.setparameterset("mpsfont",specification)
+                    metapost.simple("simplefun",preroll)
+                    metapost.setparameterset("mpsfont")
+                    metapost.simple(instance,"endgroup;",true,true)
+                end
+
                 for i=1,#categories do
                     local category  = categories[i]
                     local mpsshapes = shapes[category]
@@ -291,25 +304,39 @@ do -- this will move to its own module
                         }
                         -- todo: deal with extensibles and more properties
                         for unicode, shape in sortedhash(mpsshapes.glyphs) do
-                         -- local oldc = characters[unicode]
-                         -- if oldc then
-                                index = index + 1 -- todo: somehow we end up with 2 as first entry after 0
-                                local wd = shape.width  or defaultwidth
-                                local ht = shape.height or defaultheight
-                                local dp = shape.depth  or defaultdepth
-                                local newc = {
-                                    index   = index, -- into usedshapes
-                                    width   = scale * (wd + spread),
-                                    height  = scale * ht,
-                                    depth   = scale * dp,
-                                    unicode = unicode,
-                                }
-                                --
-                                characters  [unicode] = newc
-                                descriptions[unicode] = newc
-                                --
-                                usedshapes[unicode] = shape.code or defaultcode
-                         -- end
+                            index = index + 1 -- todo: somehow we end up with 2 as first entry after 0
+                            local wd = shape.width  or defaultwidth
+                            local ht = shape.height or defaultheight
+                            local dp = shape.depth  or defaultdepth
+                            local uc = shape.tounicode
+                            if uc then
+                                uc = round(uc) -- brrr can be 123.0
+                            end
+                            local newc = {
+                                index   = index, -- into usedshapes
+                                width   = scale * (wd + spread),
+                                height  = scale * ht,
+                                depth   = scale * dp,
+                                unicode = uc or unicode,
+                            }
+                            --
+                            characters  [unicode] = newc
+                            descriptions[unicode] = newc
+                            usedshapes  [unicode] = shape.code or defaultcode
+                            --
+                            -- This is a way to get/use randomized shapes (see punk example).
+                            --
+                            if uc and uc ~= unicode then
+                                local c = characters[uc]
+                                if c then
+                                    local v = c.variants
+                                    if v then
+                                        v[#v + 1] = unicode
+                                    else
+                                        c.variants = { unicode }
+                                    end
+                                end
+                            end
                         end
                     end
                 end
diff --git a/tex/context/base/mkxl/font-pre.mkxl b/tex/context/base/mkxl/font-pre.mkxl
index fafe20a60..884a6c913 100644
--- a/tex/context/base/mkxl/font-pre.mkxl
+++ b/tex/context/base/mkxl/font-pre.mkxl
@@ -405,7 +405,9 @@
    mathalternates=yes,
    mathitalics=yes, % we pass them
    mathdimensions=all,
-compactmath=yes,
+ % mathkerns=yes,
+ % staircase=yes,
+   compactmath=yes,
  % mathgaps=yes,
    language=dflt,
    script=math]
diff --git a/tex/context/base/mkxl/font-vfc.lmt b/tex/context/base/mkxl/font-vfc.lmt
index e39eca683..9330bdea0 100644
--- a/tex/context/base/mkxl/font-vfc.lmt
+++ b/tex/context/base/mkxl/font-vfc.lmt
@@ -71,13 +71,111 @@ function helpers.appendcommandtable(commands,t)
 end
 
 helpers.commands = utilities.storage.allocate {
-    char  = setmetatableindex(function(t,k) local v = { "slot",   0, k } t[k] = v return v end),
-    right = setmetatableindex(function(t,k) local v = { "right",  k    } t[k] = v return v end),
-    left  = setmetatableindex(function(t,k) local v = { "right", -k    } t[k] = v return v end), -- todo: left
-    down  = setmetatableindex(function(t,k) local v = { "down",   k    } t[k] = v return v end),
-    up    = setmetatableindex(function(t,k) local v = { "down",  -k    } t[k] = v return v end), -- todo: up
+    char  = setmetatableindex(function(t,k) local v = { "slot",  0, k } t[k] = v return v end),
+    right = setmetatableindex(function(t,k) local v = { "right", k    } t[k] = v return v end),
+    left  = setmetatableindex(function(t,k) local v = { "left",  k    } t[k] = v return v end),
+    down  = setmetatableindex(function(t,k) local v = { "down",  k    } t[k] = v return v end),
+    up    = setmetatableindex(function(t,k) local v = { "up",    k    } t[k] = v return v end),
     push  = push,
     pop   = pop,
     dummy = dummy,
 }
 
+helpers.vfinjectors = {
+    -- backend specific: startcolor, stopcolor etc
+}
+
+-- maybe round()
+
+local defaultline = 16384
+
+helpers.vfspecials = {
+
+    backgrounds = setmetatableindex(function(t,h)
+        local v = setmetatableindex(function(t,d)
+            local v = setmetatableindex(function(t,w)
+                local v = { "frame", w, h, d, defaultline, true, true }
+                t[w] = v
+                return v
+            end)
+            t[d] = v
+            return v
+        end)
+        t[h] = v
+        return v
+    end),
+
+    outlines = setmetatableindex(function(t,h)
+        local v = setmetatableindex(function(t,d)
+            local v = setmetatableindex(function(t,w)
+                local v = { "frame", w, h, d, defaultline, false, true }
+                t[w] = v
+                return v
+            end)
+            t[d] = v
+            return v
+        end)
+        t[h] = v
+        return v
+    end),
+
+}
+
+-- In the past we only copied when we had something that got scaled but the problem
+-- is that we then run into issues when we extend a commands in the parent. This
+-- needs checking. When we go to glyph scaling, this can go away.
+--
+-- The alternative is to work with unscaled values and always do scaling at the
+-- TeX end. So, then we need accessors instead of tables and we also need to check
+-- all the context code: where do we access values?
+--
+-- On the other hand, in glyph scale mode we hardly do any scaling so we seldom
+-- call the next one.
+--
+-- What if we use named fields: then we can scale by field name.
+
+local scaled = {
+    right  = true,
+    down   = true,
+    left   = true,
+    right  = true,
+    offset = true,
+    rule   = true,
+    char   = false,
+    font   = false,
+    slot   = false,
+    use    = false,
+    push   = false,
+    pop    = false,
+    lua    = false,
+    -- obsolete
+    node   = false,
+    -- additional ones are never scaled (color etc)
+}
+
+function helpers.scalecommands(list,hdelta,vdelta)
+    local n = #list
+    for i=1,n do
+        local key = list[i][1]
+        if scaled[list[i][1]] then
+            local result = { }
+            for i=1,n do
+                local cmd = list[i]
+                local key = ivc[1]
+                if key == "right" or key == "left" then
+                    result[i] = { key, cmd[2]*hdelta }
+                elseif key == "down" or key == "up" then
+                    result[i] = { key, cmd[2]*vdelta }
+                elseif key == "offset" or key == "rule" then
+                    result[i] = { key, cmd[2]*hdelta, cmd[3]*vdelta }
+             -- elseif key == "frame" then
+             --     result[i] = cmd -- already scaled, for now
+                else
+                    result[i] = cmd -- shared since in cache and untouched
+                end
+            end
+            return result
+        end
+    end
+    return list
+end
diff --git a/tex/context/base/mkxl/good-mth.lmt b/tex/context/base/mkxl/good-mth.lmt
new file mode 100644
index 000000000..87b6787df
--- /dev/null
+++ b/tex/context/base/mkxl/good-mth.lmt
@@ -0,0 +1,464 @@
+if not modules then modules = { } end modules ['good-mth'] = {
+    version   = 1.000,
+    comment   = "companion to font-lib.mkiv",
+    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
+    copyright = "PRAGMA ADE / ConTeXt Development Team",
+    license   = "see context related readme files"
+}
+
+local type, next, tonumber, unpack = type, next, tonumber, unpack
+local ceil = math.ceil
+local match = string.match
+
+local fonts = fonts
+
+local trace_goodies      = false  trackers.register("fonts.goodies", function(v) trace_goodies = v end)
+local report_goodies     = logs.reporter("fonts","goodies")
+
+local registerotffeature = fonts.handlers.otf.features.register
+
+local fontgoodies        = fonts.goodies or { }
+
+local fontcharacters     = fonts.hashes.characters
+
+local trace_defining     = false  trackers.register("math.defining",   function(v) trace_defining   = v end)
+
+local report_math        = logs.reporter("mathematics","initializing")
+
+local nuts               = nodes.nuts
+
+local setlink            = nuts.setlink
+
+local nodepool           = nuts.pool
+
+local new_kern           = nodepool.kern
+local new_glyph          = nodepool.glyph
+local new_hlist          = nodepool.hlist
+local new_vlist          = nodepool.vlist
+
+local insert_node_after  = nuts.insert_after
+
+local helpers            = fonts.helpers
+local upcommand          = helpers.commands.up
+local rightcommand       = helpers.commands.right
+local charcommand        = helpers.commands.char
+local prependcommands    = helpers.prependcommands
+
+-- experiment, we have to load the definitions immediately as they precede
+-- the definition so they need to be initialized in the typescript
+
+local function withscriptcode(tfmdata,unicode,data,action)
+    if type(unicode) == "string" then
+        local p, u = match(unicode,"^(.-):(.-)$")
+        if u then
+            u = tonumber(u)
+            if u then
+                local slots = fonts.helpers.mathscriptslots(tfmdata,u)
+                if slots then
+                    if p == "*" then
+                        action(u,data)
+                        for i=1,#slots do
+                            action(slots[i],data)
+                        end
+                    else
+                        p = tonumber(p)
+                        if p then
+                            action(slots[p],data)
+                        end
+                    end
+                end
+            end
+        end
+    else
+        action(unicode,data)
+    end
+end
+
+local function finalize(tfmdata,feature,value)
+--     if tfmdata.mathparameters then -- funny, cambria text has this
+    local goodies = tfmdata.goodies
+    if goodies then
+        local virtualized = mathematics.virtualized
+        for i=1,#goodies do
+            local goodie = goodies[i]
+            local mathematics = goodie.mathematics
+            local dimensions  = mathematics and mathematics.dimensions
+            if dimensions then
+                if trace_defining then
+                    report_math("overloading dimensions in %a @ %p",tfmdata.properties.fullname,tfmdata.parameters.size)
+                end
+                local characters   = tfmdata.characters
+                local descriptions = tfmdata.descriptions
+                local parameters   = tfmdata.parameters
+                local factor       = parameters.factor
+                local hfactor      = parameters.hfactor
+                local vfactor      = parameters.vfactor
+                --
+                tfmdata.type                   = "virtual"
+                tfmdata.properties.virtualized = true
+                --
+                local function overloadone(unicode,data)
+                    local character = characters[unicode]
+                    if not character then
+                        local c = virtualized[unicode]
+                        if c then
+                            character = characters[c]
+                        end
+                    end
+                    if character then
+                        local width  = data.width
+                        local height = data.height
+                        local depth  = data.depth
+                        if trace_defining and (width or height or depth) then
+                            report_math("overloading dimensions of %C, width %p, height %p, depth %p",
+                                unicode,width or 0,height or 0,depth or 0)
+                        end
+                        if width  then character.width  = width  * hfactor end
+                        if height then character.height = height * vfactor end
+                        if depth  then character.depth  = depth  * vfactor end
+                        --
+                        local xoffset = data.xoffset
+                        local yoffset = data.yoffset
+                        if xoffset == "llx" then
+                            local d = descriptions[unicode]
+                            if d then
+                                xoffset         = - d.boundingbox[1] * hfactor
+                                character.width = character.width + xoffset
+                                xoffset         = rightcommand[xoffset]
+                            else
+                                xoffset = nil
+                            end
+                        elseif xoffset and xoffset ~= 0 then
+                            xoffset = rightcommand[xoffset * hfactor]
+                        else
+                            xoffset = nil
+                        end
+                        if yoffset and yoffset ~= 0 then
+                            yoffset = upcommand[yoffset * vfactor]
+                        else
+                            yoffset = nil
+                        end
+                        if xoffset or yoffset then
+                            local commands = characters.commands
+                            if commands then
+                                prependcommands(commands,yoffset,xoffset)
+                            else
+                                local slot = charcommand[unicode]
+                                if xoffset and yoffset then
+                                    character.commands = { xoffset, yoffset, slot }
+                                elseif xoffset then
+                                    character.commands = { xoffset, slot }
+                                else
+                                    character.commands = { yoffset, slot }
+                                end
+                            end
+                        end
+                    elseif trace_defining then
+                        report_math("no overloading dimensions of %C, not in font",unicode)
+                    end
+                end
+                local function overload(dimensions)
+                    for unicode, data in next, dimensions do
+                        withscriptcode(tfmdata,unicode,data,overloadone)
+                    end
+                end
+                if value == nil then
+                    value = { "default" }
+                end
+                if value == "all" or value == true then
+                    for name, value in next, dimensions do
+                        overload(value)
+                    end
+                else
+                    if type(value) == "string" then
+                        value = utilities.parsers.settings_to_array(value)
+                    end
+                    if type(value) == "table" then
+                        for i=1,#value do
+                            local d = dimensions[value[i]]
+                            if d then
+                                overload(d)
+                            end
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+
+registerotffeature {
+    name         = "mathdimensions",
+    description  = "manipulate math dimensions",
+ -- default      = true,
+    manipulators = {
+        base = finalize,
+        node = finalize,
+    }
+}
+
+local function initialize(goodies)
+    local mathgoodies = goodies.mathematics
+    if mathgoodies then
+        local virtuals = mathgoodies.virtuals
+        local mapfiles = mathgoodies.mapfiles
+        local maplines = mathgoodies.maplines
+        if virtuals then
+            for name, specification in next, virtuals do
+                -- beware, they are all constructed ... we should be more selective
+                mathematics.makefont(name,specification,goodies)
+            end
+        end
+        if mapfiles then
+            for i=1,#mapfiles do
+                fonts.mappings.loadfile(mapfiles[i]) -- todo: backend function
+            end
+        end
+        if maplines then
+            for i=1,#maplines do
+                fonts.mappings.loadline(maplines[i]) -- todo: backend function
+            end
+        end
+    end
+end
+
+fontgoodies.register("mathematics", initialize)
+
+-- local enabled = false   directives.register("fontgoodies.mathkerning",function(v) enabled = v end)
+
+local function initialize(tfmdata)
+--     if enabled and tfmdata.mathparameters then -- funny, cambria text has this
+    if tfmdata.mathparameters then -- funny, cambria text has this
+        local goodies = tfmdata.goodies
+        if goodies then
+            local characters = tfmdata.characters
+            if characters[0x1D44E] then -- 119886
+                -- we have at least an italic a
+                for i=1,#goodies do
+                    local mathgoodies = goodies[i].mathematics
+                    if mathgoodies then
+                        local kerns = mathgoodies.kerns
+                        if kerns then
+                            local function kernone(unicode,data)
+                                local chardata = characters[unicode]
+                                if chardata and (not chardata.mathkerns or data.force) then
+                                    chardata.mathkerns = data
+                                end
+                            end
+                            for unicode, data in next, kerns do
+                                withscriptcode(tfmdata,unicode,data,kernone)
+                            end
+                            return
+                        end
+                    end
+                end
+            else
+                return -- no proper math font anyway
+            end
+        end
+    end
+end
+
+registerotffeature {
+    name         = "mathkerns",
+    description  = "math kerns",
+ -- default      = true,
+    initializers = {
+        base = initialize,
+        node = initialize,
+    }
+}
+
+-- math italics (not really needed)
+--
+-- it would be nice to have a \noitalics\font option
+
+local function initialize(tfmdata)
+    local goodies = tfmdata.goodies
+    if goodies then
+        local shared = tfmdata.shared
+        for i=1,#goodies do
+            local mathgoodies = goodies[i].mathematics
+            if mathgoodies then
+                local mathitalics = mathgoodies.italics
+                if mathitalics then
+                    local properties = tfmdata.properties
+                    if properties.setitalics then
+                        mathitalics = mathitalics[file.nameonly(properties.name)] or mathitalics
+                        if mathitalics then
+                            if trace_goodies then
+                                report_goodies("loading mathitalics for font %a",properties.name)
+                            end
+                            local corrections   = mathitalics.corrections
+                            local defaultfactor = mathitalics.defaultfactor
+                         -- properties.mathitalic_defaultfactor = defaultfactor -- we inherit outer one anyway (name will change)
+                            if corrections then
+                                fontgoodies.registerpostprocessor(tfmdata, function(tfmdata) -- this is another tfmdata (a copy)
+                                    -- better make a helper so that we have less code being defined
+                                    local properties = tfmdata.properties
+                                    local parameters = tfmdata.parameters
+                                    local characters = tfmdata.characters
+                                    properties.mathitalic_defaultfactor = defaultfactor
+                                    properties.mathitalic_defaultvalue  = defaultfactor * parameters.quad
+                                    if trace_goodies then
+                                        report_goodies("assigning mathitalics for font %a",properties.name)
+                                    end
+                                    local quad    = parameters.quad
+                                    local hfactor = parameters.hfactor
+                                    for k, v in next, corrections do
+                                        local c = characters[k]
+                                        if c then
+                                            if v > -1 and v < 1 then
+                                                c.italic = v * quad
+                                            else
+                                                c.italic = v * hfactor
+                                            end
+                                        else
+                                            report_goodies("invalid mathitalics entry %U for font %a",k,properties.name)
+                                        end
+                                    end
+                                end)
+                            end
+                            return -- maybe not as these can accumulate
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+
+registerotffeature {
+    name         = "mathitalics",
+    description  = "additional math italic corrections",
+ -- default      = true,
+    initializers = {
+        base = initialize,
+        node = initialize,
+    }
+}
+
+-- fontgoodies.register("mathitalics", initialize)
+
+local function mathradicalaction(n,h,v,font,mchar,echar)
+    local characters = fontcharacters[font]
+    local mchardata  = characters[mchar]
+    local echardata  = characters[echar]
+    local ewidth     = echardata.width
+    local mwidth     = mchardata.width
+    local delta      = h - ewidth
+    local glyph      = new_glyph(font,echar)
+    local head       = glyph
+    if delta > 0 then
+        local count = ceil(delta/mwidth)
+        local kern  = (delta - count * mwidth) / count
+        for i=1,count do
+            local k = new_kern(kern)
+            local g = new_glyph(font,mchar)
+            setlink(k,head)
+            setlink(g,k)
+            head = g
+        end
+    end
+    local height = mchardata.height
+    local list   = new_hlist(head)
+    local kern   = new_kern(height-v)
+    list = setlink(kern,list)
+    local list = new_vlist(kern)
+    insert_node_after(n,n,list)
+end
+
+local function mathhruleaction(n,h,v,font,bchar,mchar,echar)
+    local characters = fontcharacters[font]
+    local bchardata  = characters[bchar]
+    local mchardata  = characters[mchar]
+    local echardata  = characters[echar]
+    local bwidth     = bchardata.width
+    local mwidth     = mchardata.width
+    local ewidth     = echardata.width
+    local delta      = h - ewidth - bwidth
+    local glyph      = new_glyph(font,echar)
+    local head       = glyph
+    if delta > 0 then
+        local count = ceil(delta/mwidth)
+        local kern  = (delta - count * mwidth) / (count+1)
+        for i=1,count do
+            local k = new_kern(kern)
+            local g = new_glyph(font,mchar)
+            setlink(k,head)
+            setlink(g,k)
+            head = g
+        end
+        local k = new_kern(kern)
+        setlink(k,head)
+        head = k
+    end
+    local g = new_glyph(font,bchar)
+    setlink(g,head)
+    head = g
+    local height = mchardata.height
+    local list   = new_hlist(head)
+    local kern   = new_kern(height-v)
+    list = setlink(kern,list)
+    local list = new_vlist(kern)
+    insert_node_after(n,n,list)
+end
+
+local function initialize(tfmdata)
+    local goodies = tfmdata.goodies
+    if goodies then
+        local resources = tfmdata.resources
+        local ruledata  = { }
+        for i=1,#goodies do
+            local mathematics = goodies[i].mathematics
+            if mathematics then
+                local rules = mathematics.rules
+                if rules then
+                    for tag, name in next, rules do
+                        ruledata[tag] = name
+                    end
+                end
+            end
+        end
+        if next(ruledata) then
+            local characters = tfmdata.characters
+            local unicodes   = resources.unicodes
+            if characters and unicodes then
+                local mathruleactions = resources.mathruleactions
+                if not mathruleactions then
+                    mathruleactions = { }
+                    resources.mathruleactions = mathruleactions
+                end
+                --
+                local mchar = unicodes[ruledata["radical.extender"] or false]
+                local echar = unicodes[ruledata["radical.end"]      or false]
+                if mchar and echar then
+                    mathruleactions.radicalaction = function(n,h,v,font)
+                        mathradicalaction(n,h,v,font,mchar,echar)
+                    end
+                end
+                --
+                local bchar = unicodes[ruledata["hrule.begin"]    or false]
+                local mchar = unicodes[ruledata["hrule.extender"] or false]
+                local echar = unicodes[ruledata["hrule.end"]      or false]
+                if bchar and mchar and echar then
+                    mathruleactions.hruleaction = function(n,h,v,font)
+                        mathhruleaction(n,h,v,font,bchar,mchar,echar)
+                    end
+                end
+                -- not that nice but we need to register it at the tex end
+             -- context.enablemathrules("\\fontclass")
+            end
+        end
+    end
+end
+
+registerotffeature {
+    name         = "mathrules",
+    description  = "check math rules",
+    default      = true,
+    initializers = {
+        base = initialize,
+        node = initialize,
+    }
+}
diff --git a/tex/context/base/mkxl/layo-ini.lmt b/tex/context/base/mkxl/layo-ini.lmt
new file mode 100644
index 000000000..1570075d9
--- /dev/null
+++ b/tex/context/base/mkxl/layo-ini.lmt
@@ -0,0 +1,115 @@
+if not modules then modules = { } end modules ['layo-ini'] = {
+    version   = 1.001,
+    comment   = "companion to layo-ini.mkiv",
+    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
+    copyright = "PRAGMA ADE / ConTeXt Development Team",
+    license   = "see context related readme files"
+}
+
+-- We need to share information between the TeX and Lua end about the typographical
+-- model. This happens here. This code might move.
+
+local texgetcount  = tex.getcount
+local conditionals = tex.conditionals
+
+layouts = {
+    status = { },
+}
+
+local status = layouts.status
+
+function status.leftorrightpageaction(left,right)
+    if left == nil then
+        left, right = false, true
+    end
+    if not conditionals.layoutisdoublesided then
+        return left, right
+    elseif conditionals.layoutissinglesided then
+        return left, right
+    elseif texgetcount("pagenoshift") % 2 == 0 then
+        if texgetcount("realpageno") % 2 == 0 then
+            return right, left
+        else
+            return left, right
+        end
+    else
+        if texgetcount("realpageno") % 2 == 0 then
+            return left, right
+        else
+            return right, left
+        end
+    end
+end
+
+function status.isleftpage(r)
+    if not conditionals.layoutisdoublesided then
+        return false
+    elseif conditionals.layoutissinglesided then
+        return false
+    elseif texgetcount("pagenoshift") % 2 == 0 then
+        return (r or texgetcount("realpageno")) % 2 == 0
+    else
+        return not (r or texgetcount("realpageno")) % 2 == 0
+    end
+end
+
+-- Instead of making these these driver specific we make them generic. We can even consider
+-- to make these registers at the tex end.
+
+local canvas = {
+    pagespec     = "default", -- v_default
+    paperwidth   = 0,
+    paperheight  = 0,
+    topoffset    = 0,
+    leftoffset   = 0,
+    height       = 0,
+    width        = 0,
+    cropoffset   = 0,
+    bleedoffset  = 0,
+    trimoffset   = 0,
+    artoffset    = 0,
+    doublesided  = false,
+    marked       = false,
+    copies       = false,
+}
+
+function layouts.setupcanvas(specification)
+    local paperheight = specification.paperheight or canvas.paperheight
+    local paperwidth  = specification.paperwidth  or canvas.paperwidth
+    local cropoffset  = specification.cropoffset  or 0
+    local trimoffset  = cropoffset  - (specification.trimoffset  or 0)
+    local bleedoffset = trimoffset  - (specification.bleedoffset or 0)
+    local artoffset   = bleedoffset - (specification.artoffset   or 0)
+    --
+    canvas.paperheight = paperheight
+    canvas.paperwidth  = paperwidth
+    canvas.cropoffset  = cropoffset
+    canvas.trimoffset  = trimoffset
+    canvas.bleedoffset = bleedoffset
+    canvas.artoffset   = artoffset
+    --
+    canvas.pagespec    = specification.mode       or pagespec
+    canvas.topoffset   = specification.topoffset  or 0
+    canvas.leftoffset  = specification.leftoffset or 0
+    canvas.height      = specification.height     or paperheight
+    canvas.width       = specification.width      or paperwidth
+    canvas.marked      = specification.print
+    --
+    local copies = specification.copies
+    if type(copies) == "number" and copies < 2 then
+        canvas.copies = false
+    end
+    --
+    local doublesided = specification.doublesided
+    if doublesided ~= nil then
+        canvas.doublesided = doublesided
+    end
+end
+
+function layouts.getpagedimensions()
+    return canvas.paperwidth, canvas.paperheight
+end
+
+function layouts.getcanvas()
+    return canvas
+end
diff --git a/tex/context/base/mkxl/layo-ini.mkxl b/tex/context/base/mkxl/layo-ini.mkxl
index 4979989cd..73b7e978e 100644
--- a/tex/context/base/mkxl/layo-ini.mkxl
+++ b/tex/context/base/mkxl/layo-ini.mkxl
@@ -25,6 +25,6 @@
 \ifdefined\pagenoshift         \else \newcount      \pagenoshift         \fi
 \ifdefined\realpageno          \else \newcount      \realpageno          \fi
 
-\registerctxluafile{layo-ini}{}
+\registerctxluafile{layo-ini}{autosuffix}
 
 \protect \endinput
diff --git a/tex/context/base/mkxl/lpdf-col.lmt b/tex/context/base/mkxl/lpdf-col.lmt
index 778d250c6..a999cb2c7 100644
--- a/tex/context/base/mkxl/lpdf-col.lmt
+++ b/tex/context/base/mkxl/lpdf-col.lmt
@@ -6,8 +6,6 @@ if not modules then modules = { } end modules ['lpdf-col'] = {
     license   = "see context related readme files"
 }
 
--- slants also page ?
-
 local type, next, tostring, tonumber = type, next, tostring, tonumber
 local char, byte, format, gsub, rep, gmatch = string.char, string.byte, string.format, string.gsub, string.rep, string.gmatch
 local settings_to_array, settings_to_numbers = utilities.parsers.settings_to_array, utilities.parsers.settings_to_numbers
@@ -25,7 +23,7 @@ local registrations           = backends.pdf.registrations
 
 local nodepool                = nodes.nuts.pool
 local register                = nodepool.register
-local pageliteral             = nodepool.pageliteral
+local setstate                = nodepool.setstate
 
 local pdfconstant             = lpdf.constant
 local pdfdictionary           = lpdf.dictionary
@@ -131,26 +129,26 @@ lpdf.registerpagefinalizer(addpagegroup,3,"pagegroup")
 -- color injection
 
 function nodeinjections.rgbcolor(r,g,b)
-    return register(pageliteral(f_rgb(r,g,b,r,g,b)))
+    return register(setstate(f_rgb(r,g,b,r,g,b)))
 end
 
 function nodeinjections.cmykcolor(c,m,y,k)
-    return register(pageliteral(f_cmyk(c,m,y,k,c,m,y,k)))
+    return register(setstate(f_cmyk(c,m,y,k,c,m,y,k)))
 end
 
 function nodeinjections.graycolor(s) -- caching 0/1 does not pay off
-    return register(pageliteral(f_gray(s,s)))
+    return register(setstate(f_gray(s,s)))
 end
 
 function nodeinjections.spotcolor(n,f,d,p)
     if type(p) == "string" then
         p = gsub(p,","," ") -- brr misuse of spot
     end
-    return register(pageliteral(f_spot(n,n,p,p)))
+    return register(setstate(f_spot(n,n,p,p)))
 end
 
 function nodeinjections.transparency(n)
-    return register(pageliteral(f_tr_gs(n)))
+    return register(setstate(f_tr_gs(n)))
 end
 
 -- a bit weird but let's keep it here for a while
@@ -169,7 +167,7 @@ function nodeinjections.effect(effect,stretch,rulethickness)
     -- always, no zero test (removed)
     rulethickness = bp * rulethickness
     effect = effects[effect] or effects['normal']
-    return register(pageliteral(f_effect(stretch,rulethickness,effect))) -- watch order
+    return register(setstate(f_effect(stretch,rulethickness,effect))) -- watch order
 end
 
 -- spot- and indexcolors
@@ -727,29 +725,20 @@ function lpdf.finishtransparencycode()
     end
 end
 
--- this will move to lpdf-spe.lua an dwe then can also add a metatable with
--- normal context colors
-
 do
 
-    local pdfcolor        = lpdf.color
-    local pdftransparency = lpdf.transparency
-
-    local f_slant = formatters["q 1 0 %N 1 0 0 cm"]
+    local pdfprint, pdfcolor, pdftransparency
 
-    local slants = setmetatableindex(function(t,k)
-        local v = { "pdf", "origin", f_slant(a) }
-        t[k] = v
-        return k
+    updaters.register("backend.update.lpdf",function()
+        pdfprint        = lpdf.print
+        pdfcolor        = lpdf.color
+        pdftransparency = lpdf.transparency
     end)
 
-    local function startslant(a)
-        return slants[a]
-    end
-
     local c_cache = setmetatableindex(function(t,m)
+        -- We inherit the outer transparency.
         local v = setmetatableindex(function(t,c)
-            local p = { "pdf", "page", "q " .. pdfcolor(m,c) }
+            local p = "q " .. pdfcolor(m,c)
             t[c] = p
             return p
         end)
@@ -757,13 +746,11 @@ do
         return v
     end)
 
-    -- we inherit the outer transparency
-
     local t_cache = setmetatableindex(function(t,transparency)
         local p = pdftransparency(transparency)
         local v = setmetatableindex(function(t,colormodel)
             local v = setmetatableindex(function(t,color)
-                local v = { "pdf", "page", "q " .. pdfcolor(colormodel,color) .. " " .. p }
+                local v = "q " .. pdfcolor(colormodel,color) .. " " .. p
                 t[color] = v
                 return v
             end)
@@ -774,120 +761,33 @@ do
         return v
     end)
 
-    local function startcolor(k)
-        local m, c = colortoattributes(k)
-        local t = transparencytoattribute(k)
-        if t and t ~= unsetvalue then
-            return t_cache[t][m][c]
-        else
-            return c_cache[m][c]
-        end
-    end
-
-    -- A problem is that we need to transfer back and this is kind of
-    -- messy so we force text mode .. i'll do a better job on that but
-    -- will experiment first (both engines). Virtual fonts will change
-    -- anyway.
-
-    local vfspecials = backends.pdf.tables.vfspecials or allocate { }
-    backends.pdf.tables.vfspecials = vfspecials
-
-    vfspecials.startcolor = startcolor
- -- vfspecials.stopcolor  = { "pdf", "text", "Q" } -- fails
-    vfspecials.stopcolor  = { "pdf", "page", "Q" }
-
-    vfspecials.startslant = startslant
-    vfspecials.stopslant  = { "pdf", "page", "Q" } -- fails
-
-end
-
--- new method:
-
-do
-
     updaters.register("backend.update.lpdf",function()
-        pdfprint = lpdf.print
-    end)
-
-    -- Is this still used? It's a font property now.
-
-    local f_slant = formatters["q 1 0 %N 1 0 0 cm"]
-
-    local slants = setmetatableindex(function(t,k)
-        local v = f_slant(a)
-        t[k] = v
-        return k
-    end)
 
-    local function startslant(a)
-        return pdfprint("origin", slants[a])
-    end
+        local vfinjectors = fonts.helpers.vfinjectors
 
-    local function stopslant()
-        pdfprint("text", "Q")
-    end
+        vfinjectors.pdf = function(pos_h,pos_v,packet)
+            pdfprint(packet[2],packet[3])
+        end
 
-    -- We inherit the outer transparency.
-
-    local pdfcolor        = lpdf.color
-    local pdftransparency = lpdf.transparency
-
- -- local c_cache = setmetatableindex(function(t,m)
- --     local v = setmetatableindex(function(t,c)
- --         local p = "q " .. pdfcolor(m,c)
- --         t[c] = p
- --         return p
- --     end)
- --     t[m] = v
- --     return v
- -- end)
- --
- -- local t_cache = setmetatableindex(function(t,transparency)
- --     local p = pdftransparency(transparency)
- --     local v = setmetatableindex(function(t,colormodel)
- --         local v = setmetatableindex(function(t,color)
- --             local v = "q " .. pdfcolor(colormodel,color) .. " " .. p
- --             t[color] = v
- --             return v
- --         end)
- --         t[colormodel] = v
- --         return v
- --     end)
- --     t[transparency] = v
- --     return v
- -- end)
-
- -- local function startcolor(color)
- --     local m, c = colortoattributes(color)
- --     local t = transparencytoattribute(color)
- --     if t then
- --         pdfprint("page", t_cache[t][m][c])
- --     else
- --         pdfprint("page", c_cache[m][c])
- --     end
- -- end
-
-    local function startcolor(color)
-        local m, c = colortoattributes(color)
-        local t = transparencytoattribute(color)
-        if t and t ~= unsetvalue then
-            pdfprint("page", "q " .. pdfcolor(m,c) .. " " .. pdftransparency(t))
-        else
-            pdfprint("page", "q " .. pdfcolor(m,c))
+        vfinjectors.startcolor = function(pos_h,pos_v,packet)
+            local color = type(packet) == "table" and packet[2] or packet
+            if color then
+                local m, c = colortoattributes(color)
+                local t = transparencytoattribute(color)
+                if t and t ~= unsetvalue then
+                    pdfprint("page", t_cache[t][m][c]) -- "q " .. pdfcolor(m,c) .. " " .. pdftransparency(t)
+                else
+                    pdfprint("page", c_cache[m][c])    -- "q " .. pdfcolor(m,c))
+                end
+            else
+                pdfprint("page", "q")
+            end
         end
-    end
 
-    local function stopcolor()
-        pdfprint("text", "Q")
-    end
+        vfinjectors.stopcolor = function()
+            pdfprint("text", "Q")
+        end
 
-    updaters.register("backend.update.lpdf",function()
-        fonts.vfcommands = {
-            startslant = startslant,
-            stopslant  = stopslant,
-            startcolor = startcolor,
-            stopcolor  = stopcolor,
-        }
     end)
 
 end
diff --git a/tex/context/base/mkxl/lpdf-ini.lmt b/tex/context/base/mkxl/lpdf-ini.lmt
index 59e728dfb..ea9466d39 100644
--- a/tex/context/base/mkxl/lpdf-ini.lmt
+++ b/tex/context/base/mkxl/lpdf-ini.lmt
@@ -82,12 +82,11 @@ do
         lpdf.getpos = drivers.getpos
     end)
 
-    local pdfgetmatrix, pdfhasmatrix, pdfprint, pdfgetpos
+    local pdfgetmatrix, pdfhasmatrix, pdfgetpos
 
     updaters.register("backend.update.lpdf",function()
         pdfgetmatrix = lpdf.getmatrix
         pdfhasmatrix = lpdf.hasmatrix
-        pdfprint     = lpdf.print
         pdfgetpos    = lpdf.getpos
     end)
 
@@ -541,21 +540,6 @@ end
 
 local function add_x(t,k,v) rawset(t,k,tostring(v)) end
 
--- local mt_x = { __index = { __lpdftype__ = "stream"     }, __lpdftype = "stream",     __tostring = tostring_x, __call = value_x, __newindex = add_x }
--- local mt_d = { __index = { __lpdftype__ = "dictionary" }, __lpdftype = "dictionary", __tostring = tostring_d, __call = value_d, __add = add_to_d }
--- local mt_a = { __index = { __lpdftype__ = "array"      }, __lpdftype = "array",      __tostring = tostring_a, __call = value_a, __add = add_to_a }
--- local mt_u = { __index = { __lpdftype__ = "unicode"    }, __lpdftype = "unicode",    __tostring = tostring_u, __call = value_u }
--- local mt_s = { __index = { __lpdftype__ = "string"     }, __lpdftype = "string",     __tostring = tostring_s, __call = value_s }
--- local mt_p = { __index = { __lpdftype__ = "docstring"  }, __lpdftype = "docstring",  __tostring = tostring_p, __call = value_p }
--- local mt_n = { __index = { __lpdftype__ = "number"     }, __lpdftype = "number",     __tostring = tostring_n, __call = value_n }
--- local mt_c = { __index = { __lpdftype__ = "constant"   }, __lpdftype = "constant",   __tostring = tostring_c, __call = value_c }
--- local mt_z = { __index = { __lpdftype__ = "null"       }, __lpdftype = "null",       __tostring = tostring_z, __call = value_z }
--- local mt_t = { __index = { __lpdftype__ = "true"       }, __lpdftype = "true",       __tostring = tostring_t, __call = value_t }
--- local mt_f = { __index = { __lpdftype__ = "false"      }, __lpdftype = "false",      __tostring = tostring_f, __call = value_f }
--- local mt_r = { __index = { __lpdftype__ = "reference"  }, __lpdftype = "reference",  __tostring = tostring_r, __call = value_r }
--- local mt_v = { __index = { __lpdftype__ = "verbose"    }, __lpdftype = "verbose",    __tostring = tostring_v, __call = value_v }
--- local mt_l = { __index = { __lpdftype__ = "literal"    }, __lpdftype = "literal",    __tostring = tostring_l, __call = value_l }
-
 local mt_x = { __index = { __lpdftype__ = "stream"     }, __tostring = tostring_x, __call = value_x, __newindex = add_x }
 local mt_d = { __index = { __lpdftype__ = "dictionary" }, __tostring = tostring_d, __call = value_d, __add = add_to_d }
 local mt_a = { __index = { __lpdftype__ = "array"      }, __tostring = tostring_a, __call = value_a, __add = add_to_a }
@@ -1259,6 +1243,17 @@ do
         end
     }
 
+    local setstate  = nodes.nuts.pool.setstate
+
+    function nodeinjections.startalternate(str)
+        return setstate(f_actual_text(tosixteen(str)))
+    end
+
+    function nodeinjections.stopalternate()
+        return setstate("EMC")
+    end
+
+
 end
 
 -- interface
diff --git a/tex/context/base/mkxl/lpdf-lmt.lmt b/tex/context/base/mkxl/lpdf-lmt.lmt
index 44352994a..b57557aee 100644
--- a/tex/context/base/mkxl/lpdf-lmt.lmt
+++ b/tex/context/base/mkxl/lpdf-lmt.lmt
@@ -100,6 +100,10 @@ local report_objects = logs.reporter("backend","objects")
 local trace_objects  = false  trackers.register("backend.objects", function(v) trace_objects = v end)
 local trace_details  = false  trackers.register("backend.details", function(v) trace_details = v end)
 
+-- we collect them:
+
+local flushers = { }
+
 -- used variables
 
 local pdf_h, pdf_v
@@ -185,7 +189,7 @@ local tjfactor       = 100 / 65536
 
 lpdf.usedcharacters = usedcharacters
 
-local function updatefontstate(font)
+function flushers.updatefontstate(font)
     fontcharacters   = characters[font]
     fontdescriptions = descriptions[font]
     fontparameters   = parameters[font]
@@ -400,8 +404,7 @@ local function pdf_goto_fontmode()
 end
 
 -- characters
-
-local flushcharacter  do
+do
 
     local round = math.round
 
@@ -413,52 +416,23 @@ local flushcharacter  do
     local hshift       = false
     local vshift       = false
 
- -- local naturalwidths = setmetatableindex(function(t,font)
- --     local d = descriptions[font]
- --     local c = characters[font]
- --     local f = parameters[font].hfactor
- --     local v = setmetatableindex(function(t,char)
- --         local w
- --         local e = d and d[char]
- --         if e then
- --             w = e.width
- --             if w then
- --                 w =  w * f
- --             end
- --         end
- --         if not w then
- --             e = c[char]
- --             if e then
- --                 w = e.width or 0
- --             end
- --         end
- --         if not w then
- --             w = 0
- --         end
- --         t[char] = w
- --         return w
- --     end)
- --     t[font] = v
- --     return v
- -- end)
-
     local naturalwidths = setmetatableindex(function(t,font)
         local d = descriptions[font]
         local c = characters[font]
-        local f = parameters[font].hfactor
+        local f = parameters[font].hfactor or parameters[font].factor
         local v = setmetatableindex(function(t,char)
             local w
-            local e = c[char]
+            local e = d and d[char]
             if e then
-                w = e.width or 0
+                w = e.width
+                if w then
+                    w =  w * f
+                end
             end
             if not w then
-                e = d and d[char]
+                e = c[char]
                 if e then
-                    w = e.width
-                    if w then
-                        w =  w * f
-                    end
+                    w = e.width or 0
                 end
             end
             if not w then
@@ -592,7 +566,7 @@ local flushcharacter  do
     -- luatex (a precursor to lmtx and also for comparison) but only in lmtx now so ...
     -- time to move on I guess.
 
-    flushcharacter = function(current,pos_h,pos_v,pos_r,font,char,data,f,e,factor,sx,sy) -- ,naturalwidth,width)
+    flushers.character = function(current,pos_h,pos_v,pos_r,font,char,data,f,e,factor,sx,sy) -- ,naturalwidth,width)
         if sx ~= f_x_scale or sy ~= f_y_scale or need_tf or font ~= f_cur or f_pdf ~= f_pdf_cur or fs ~= fs_cur or mode == "page" then
             pdf_goto_textmode()
             setup_fontparameters(font,factor,f,e,sx,sy)
@@ -665,7 +639,7 @@ local flushcharacter  do
 
     end
 
-    flushfontchar = function(font,char,data)
+    flushers.fontchar = function(font,char,data)
         local dummy = usedfonts[font]
         local index = data.index or char
         if not pdfcharacters[index] then
@@ -690,14 +664,12 @@ local flushliteral  do
     local textliteral_code    = literalvalues.text
     local fontliteral_code    = literalvalues.font
 
-    local getdata             = nuts.getdata
-
-    flushliteral = function(current,pos_h,pos_v,mode,str)
-        if mode then
-            if not str then
-                mode, str = originliteral_code, mode
-            elseif mode == "mode" then
-                mode = literalvalues[str]
+    flushliteral = function(current,pos_h,pos_v)
+        local p = nodeproperties[current]
+        if p then
+            local str = p.data
+            if str and str ~= "" then
+                local mode = p.mode
                 if mode == originliteral_code then
                     pdf_goto_pagemode()
                     pdf_set_pos(pos_h,pos_v)
@@ -707,49 +679,22 @@ local flushliteral  do
                     pdf_goto_textmode()
                 elseif mode == fontliteral_code then
                     pdf_goto_fontmode()
-                elseif mode == alwaysliteral_code then
+                elseif mode == alwaysliteral_code then -- aka direct
                     pdf_end_string_nl()
                     need_tm = true
                 elseif mode == rawliteral_code then
                     pdf_end_string_nl()
+                else
+                    report("invalid literal mode %a when flushing %a",mode,str)
+                    return
                 end
-                return
-            else
-                mode = literalvalues[mode]
-            end
-        else
-            local p = nodeproperties[current]
-            if p then
-                str  = p.data
-                mode = p.mode
-            else
-                str, mode = getdata(current)
-            end
-        end
-        if str and str ~= "" then
-            if mode == originliteral_code then
-                pdf_goto_pagemode()
-                pdf_set_pos(pos_h,pos_v)
-            elseif mode == pageliteral_code then
-                pdf_goto_pagemode()
-            elseif mode == textliteral_code then
-                pdf_goto_textmode()
-            elseif mode == fontliteral_code then
-                pdf_goto_fontmode()
-            elseif mode == alwaysliteral_code then
-                pdf_end_string_nl()
-                need_tm = true
-            elseif mode == rawliteral_code then
-                pdf_end_string_nl()
-            else
-                report("check literal")
-                pdf_goto_pagemode()
-                pdf_set_pos(pos_h,pos_v)
+                b = b + 1 ; buffer[b] = str
             end
-            b = b + 1 ; buffer[b] = str
         end
     end
 
+    flushers.literal = flushliteral
+
     function lpdf.print(mode,str)
         -- This only works inside objects, don't change this to flush
         -- in between. It's different from luatex but okay.
@@ -774,8 +719,8 @@ local flushliteral  do
             elseif mode == rawliteral_code then
                 pdf_end_string_nl()
             else
-                pdf_goto_pagemode()
-             -- pdf_set_pos(pdf_h,pdf_v)
+                report("invalid literal mode %a when flushing %a",mode,str)
+                return
             end
             b = b + 1 ; buffer[b] = str
         end
@@ -785,14 +730,14 @@ end
 
 -- grouping & orientation
 
-local flushsave, flushrestore, flushsetmatrix  do
+do
 
     local matrices     = { }
     local positions    = { }
     local nofpositions = 0
     local nofmatrices  = 0
 
-    flushsave = function(current,pos_h,pos_v)
+    local flushsave = function(current,pos_h,pos_v)
         nofpositions = nofpositions + 1
         positions[nofpositions] = { pos_h, pos_v, nofmatrices }
         pdf_goto_pagemode()
@@ -800,7 +745,7 @@ local flushsave, flushrestore, flushsetmatrix  do
         b = b + 1 ; buffer[b] = "q"
     end
 
-    flushrestore = function(current,pos_h,pos_v)
+    local flushrestore = function(current,pos_h,pos_v)
         if nofpositions < 1 then
             return
         end
@@ -822,7 +767,7 @@ local flushsave, flushrestore, flushsetmatrix  do
     local f_matrix_2 = formatters["%.6N 0 0 %.6N 0 0 cm"]
     local f_matrix_4 = formatters["%.6N %.6N %.6N %.6N 0 0 cm"]
 
-    flushsetmatrix = function(current,pos_h,pos_v)
+    local flushsetmatrix = function(current,pos_h,pos_v)
         local p = nodeproperties[current]
         if p then
             local m = p.matrix
@@ -879,6 +824,10 @@ local flushsave, flushrestore, flushsetmatrix  do
         end
     end
 
+    flushers.setmatrix = flushsetmatrix
+    flushers.save      = flushsave
+    flushers.restore   = flushrestore
+
     function lpdf.hasmatrix()
         return nofmatrices > 0
     end
@@ -891,7 +840,7 @@ local flushsave, flushrestore, flushsetmatrix  do
         end
     end
 
-    pushorientation = function(orientation,pos_h,pos_v,pos_r)
+    flushers.pushorientation = function(orientation,pos_h,pos_v,pos_r)
         pdf_goto_pagemode()
         pdf_set_pos(pos_h,pos_v)
         b = b + 1 ; buffer[b] = "q"
@@ -904,12 +853,76 @@ local flushsave, flushrestore, flushsetmatrix  do
         end
     end
 
-    poporientation = function(orientation,pos_h,pos_v,pos_r)
+    flushers.poporientation = function(orientation,pos_h,pos_v,pos_r)
         pdf_goto_pagemode()
         pdf_set_pos(pos_h,pos_v)
         b = b + 1 ; buffer[b] = "Q"
     end
 
+    --
+
+    flushers.startmatrix = function(current,pos_h,pos_v)
+        flushsave(current,pos_h,pos_v)
+        flushsetmatrix(current,pos_h,pos_v)
+    end
+
+    flushers.stopmatrix = function(current,pos_h,pos_v)
+        flushrestore(current,pos_h,pos_v)
+    end
+
+    flushers.startscaling = function(current,pos_h,pos_v)
+        flushsave(current,pos_h,pos_v)
+        flushsetmatrix(current,pos_h,pos_v)
+    end
+
+    flushers.stopscaling = function(current,pos_h,pos_v)
+        flushrestore(current,pos_h,pos_v)
+    end
+
+    flushers.startrotation = function(current,pos_h,pos_v)
+        flushsave(current,pos_h,pos_v)
+        flushsetmatrix(current,pos_h,pos_v)
+    end
+
+    flushers.stoprotation = function(current,pos_h,pos_v)
+        flushrestore(current,pos_h,pos_v)
+    end
+
+    flushers.startmirroring = function(current,pos_h,pos_v)
+        flushsave(current,pos_h,pos_v)
+        flushsetmatrix(current,pos_h,pos_v)
+    end
+
+    flushers.stopmirroring = function(current,pos_h,pos_v)
+        flushrestore(current,pos_h,pos_v)
+    end
+
+    flushers.startclipping = function(current,pos_h,pos_v)
+        flushsave(current,pos_h,pos_v)
+        flushliteral("origin",formatters["0 w %s W n"](properties[current].path))
+    end
+
+    flushers.stopclipping = function(current,pos_h,pos_v)
+        flushrestore(current,pos_h,pos_v)
+    end
+
+end
+
+do
+
+    local nodeproperties = nodes.properties.data
+
+    flushers.setstate = function(current,pos_h,pos_v)
+        local p = nodeproperties[current]
+        if p then
+            local d = p.data
+            if d and d ~= "" then
+                pdf_goto_pagemode()
+                b = b + 1 ; buffer[b] = d
+            end
+        end
+    end
+
 end
 
 -- rules
@@ -917,7 +930,7 @@ end
 local flushedxforms  = { } -- actually box resources but can also be direct
 local localconverter = nil -- will be set
 
-local flushrule, flushsimplerule, flushspecialrule, flushimage, flushgroup  do
+local flushimage  do
 
     local rulecodes         = nodes.rulecodes
     local newrule           = nodes.pool.rule
@@ -1041,7 +1054,7 @@ local flushrule, flushsimplerule, flushspecialrule, flushimage, flushgroup  do
         end
     end
 
---     updaters.register("backend.update.tex",function()
+ -- updaters.register("backend.update.tex",function()
     updaters.register("backend.update.lpdf",function()
         tex.saveboxresource          = saveboxresource
         tex.useboxresource           = useboxresource
@@ -1115,7 +1128,7 @@ local flushrule, flushsimplerule, flushspecialrule, flushimage, flushgroup  do
     local groups      = 0
     local group       = nil
 
-    flushgroup = function(content,bbox)
+    local flushgroup = function(content,bbox)
         if not group then
             group = pdfdictionary {
                 Type = pdfconstant("Group"),
@@ -1136,6 +1149,7 @@ local flushrule, flushsimplerule, flushspecialrule, flushimage, flushgroup  do
         return f_gr(groups)
     end
 
+    flushers.group  = flushgroup
     lpdf.flushgroup = flushgroup -- todo: access via driver in mlib-pps
 
     -- end of experiment
@@ -1287,6 +1301,8 @@ local flushrule, flushsimplerule, flushspecialrule, flushimage, flushgroup  do
         b = b + 1 ; buffer[b] = s_e
     end
 
+    flushers.image = flushimage
+
     -- For the moment we need this hack because the engine checks the 'image'
     -- command in virtual fonts (so we use lua instead).
     --
@@ -1294,7 +1310,7 @@ local flushrule, flushsimplerule, flushspecialrule, flushimage, flushgroup  do
     -- never because the next are like the other engines and compensate for
     -- small sizes which is needed for inaccurate viewers.
 
-    flushrule = function(current,pos_h,pos_v,pos_r,size_h,size_v,subtype)
+    flushers.rule = function(current,pos_h,pos_v,pos_r,size_h,size_v,subtype)
 
         if subtype == emptyrule_code then
             return
@@ -1350,7 +1366,7 @@ local flushrule, flushsimplerule, flushspecialrule, flushimage, flushgroup  do
 
     end
 
-    flushsimplerule = function(pos_h,pos_v,pos_r,size_h,size_v)
+    flushers.simplerule = function(pos_h,pos_v,pos_r,size_h,size_v)
         pdf_goto_pagemode()
 
         b = b + 1 ; buffer[b] = s_b
@@ -1374,7 +1390,7 @@ local flushrule, flushsimplerule, flushspecialrule, flushimage, flushgroup  do
         b = b + 1 ; buffer[b] = s_e
     end
 
-    flushspecialrule = function(pos_h,pos_v,pos_r,width,height,depth,line,outline,baseline)
+    flushers.specialrule = function(pos_h,pos_v,pos_r,width,height,depth,line,outline,baseline)
         pdf_goto_pagemode()
 
         b = b + 1 ; buffer[b] = s_b
@@ -2953,24 +2969,7 @@ do
 
     drivers.install {
         name     = "pdf",
-        flushers = {
-            character       = flushcharacter,
-            fontchar        = flushfontchar,
-            rule            = flushrule,
-            simplerule      = flushsimplerule,
-            specialrule     = flushspecialrule,
-            pushorientation = pushorientation,
-            poporientation  = poporientation,
-            --
-            literal         = flushliteral,
-            setmatrix       = flushsetmatrix,
-            save            = flushsave,
-            restore         = flushrestore,
-            image           = flushimage,
-            group           = flushgroup,
-            --
-            updatefontstate = updatefontstate,
-        },
+        flushers = flushers,
         actions  = {
             prepare         = prepare,
             wrapup          = wrapup,
diff --git a/tex/context/base/mkxl/lpdf-mis.lmt b/tex/context/base/mkxl/lpdf-mis.lmt
index 46accf9a4..afb149d8a 100644
--- a/tex/context/base/mkxl/lpdf-mis.lmt
+++ b/tex/context/base/mkxl/lpdf-mis.lmt
@@ -26,11 +26,14 @@ local nodeinjections       = backends.pdf.nodeinjections
 local codeinjections       = backends.pdf.codeinjections
 local registrations        = backends.pdf.registrations
 
+local getpagedimensions    = layouts.getpagedimensions
+local getcanvas            = layouts.getcanvas
+
 local nuts                 = nodes.nuts
 local copy_node            = nuts.copy
 
 local nodepool             = nuts.pool
-local pageliteral          = nodepool.pageliteral
+local setstate             = nodepool.setstate
 local register             = nodepool.register
 
 local pdfdictionary        = lpdf.dictionary
@@ -86,10 +89,10 @@ local v_righttoleft        = variables.righttoleft
 local v_title              = variables.title
 local v_nomenubar          = variables.nomenubar
 
-local positive             = register(pageliteral("/GSpositive gs"))
-local negative             = register(pageliteral("/GSnegative gs"))
-local overprint            = register(pageliteral("/GSoverprint gs"))
-local knockout             = register(pageliteral("/GSknockout gs"))
+local positive             = register(setstate("/GSpositive gs"))
+local negative             = register(setstate("/GSnegative gs"))
+local overprint            = register(setstate("/GSoverprint gs"))
+local knockout             = register(setstate("/GSknockout gs"))
 
 local omitextraboxes       = false
 
@@ -410,46 +413,12 @@ local pagespecs = {
     },
 }
 
-local pagespec, topoffset, leftoffset, height, width, doublesided = "default", 0, 0, 0, 0, false
-local cropoffset, bleedoffset, trimoffset, artoffset = 0, 0, 0, 0
-local marked = false
-local copies = false
+local function documentspecification()
+    local canvas   = getcanvas()
 
-local getpagedimensions  getpagedimensions = function()
-    getpagedimensions = backends.codeinjections.getpagedimensions
-    return getpagedimensions()
-end
+    -- move this to layo-ini ?
 
-function codeinjections.setupcanvas(specification)
-    local paperheight = specification.paperheight
-    local paperwidth  = specification.paperwidth
-    local paperdouble = specification.doublesided
-    --
-    paperwidth, paperheight = codeinjections.setpagedimensions(paperwidth,paperheight)
-    --
-    pagespec    = specification.mode       or pagespec
-    topoffset   = specification.topoffset  or 0
-    leftoffset  = specification.leftoffset or 0
-    height      = specification.height     or paperheight
-    width       = specification.width      or paperwidth
-    marked      = specification.print
-    --
-    copies      = specification.copies
-    if copies and copies < 2 then
-        copies = false
-    end
-    --
-    cropoffset  = specification.cropoffset  or 0
-    trimoffset  = cropoffset  - (specification.trimoffset  or 0)
-    bleedoffset = trimoffset  - (specification.bleedoffset or 0)
-    artoffset   = bleedoffset - (specification.artoffset   or 0)
-    --
-    if paperdouble ~= nil then
-        doublesided = paperdouble
-    end
-end
-
-local function documentspecification()
+    local pagespec = canvas.pagespec
     if not pagespec or pagespec == "" then
         pagespec = v_default
     end
@@ -460,7 +429,7 @@ local function documentspecification()
     local spec     = defaults or pagespecs[v_default]
     -- successive keys can modify this
     if spec.layout == "auto" then
-        if doublesided then
+        if canvas.doublesided then
             local s = pagespecs[v_doublesided] -- to be checked voor interfaces
             for k, v in next, s do
                 spec[k] = v
@@ -478,6 +447,7 @@ local function documentspecification()
             end
         end
     end
+
     -- maybe interfaces.variables
     local layout    = spec.layout
     local mode      = spec.mode
@@ -495,6 +465,8 @@ local function documentspecification()
         addtocatalog("PageMode",pdfconstant(mode))
     end
     local prints = nil
+    local marked = canvas.marked
+    local copies = canvas.copies
     if marked then
         local pages     = structures.pages
         local marked    = pages.allmarked(marked)
@@ -534,10 +506,15 @@ local function boxvalue(n) -- we could share them
 end
 
 local function pagespecification()
-    local paperwidth, paperheight = codeinjections.getpagedimensions()
+    local canvas      = getcanvas()
+    local paperwidth  = canvas.paperwidth
+    local paperheight = canvas.paperheight
+    local leftoffset  = canvas.leftoffset
+    local topoffset   = canvas.topoffset
+    --
     local llx = leftoffset
-    local lly = paperheight + topoffset - height
-    local urx = width - leftoffset
+    local urx = canvas.width - leftoffset
+    local lly = paperheight + topoffset - canvas.height
     local ury = paperheight - topoffset
     -- boxes can be cached
     local function extrabox(WhatBox,offset,always)
@@ -553,10 +530,10 @@ local function pagespecification()
     if omitextraboxes then
         -- only useful for testing / comparing
     else
-        extrabox("CropBox",cropoffset,true) -- mandate for rendering
-        extrabox("TrimBox",trimoffset,true) -- mandate for pdf/x
-        extrabox("BleedBox",bleedoffset)    -- optional
-     -- extrabox("ArtBox",artoffset)        -- optional .. unclear what this is meant to do
+        extrabox("CropBox",canvas.cropoffset,true) -- mandate for rendering
+        extrabox("TrimBox",canvas.trimoffset,true) -- mandate for pdf/x
+        extrabox("BleedBox",canvas.bleedoffset)    -- optional
+     -- extrabox("ArtBox",canvas.artoffset)        -- optional .. unclear what this is meant to do
     end
 end
 
diff --git a/tex/context/base/mkxl/lpdf-ren.lmt b/tex/context/base/mkxl/lpdf-ren.lmt
index 8aa61e1dc..3794250d9 100644
--- a/tex/context/base/mkxl/lpdf-ren.lmt
+++ b/tex/context/base/mkxl/lpdf-ren.lmt
@@ -60,7 +60,7 @@ local copy_node           = nuts.copy
 
 local nodepool            = nuts.pool
 local register            = nodepool.register
-local pageliteral         = nodepool.pageliteral
+local setstate            = nodepool.setstate
 
 local pdf_ocg             = pdfconstant("OCG")
 local pdf_ocmd            = pdfconstant("OCMD")
@@ -267,7 +267,7 @@ function nodeinjections.startlayer(name)
     local c = cache[name]
     if not c then
         useviewerlayer(name)
-        c = register(pageliteral(f_bdc(escapednames[name])))
+        c = register(setstate(f_bdc(escapednames[name])))
         cache[name] = c
     end
     return copy_node(c)
@@ -275,7 +275,7 @@ end
 
 function nodeinjections.stoplayer()
     if not stop then
-        stop = register(pageliteral(s_emc))
+        stop = register(setstate(s_emc))
     end
     return copy_node(stop)
 end
@@ -292,7 +292,7 @@ function nodeinjections.startstackedlayer(s,t,first,last)
         r[#r+1] = startlayer(values[t[i]])
     end
     r = concat(r," ")
-    return pageliteral(r)
+    return setstate(r)
 end
 
 function nodeinjections.stopstackedlayer(s,t,first,last)
@@ -301,7 +301,7 @@ function nodeinjections.stopstackedlayer(s,t,first,last)
         r[#r+1] = stoplayer()
     end
     r = concat(r," ")
-    return pageliteral(r)
+    return setstate(r)
 end
 
 function nodeinjections.changestackedlayer(s,t1,first1,last1,t2,first2,last2)
@@ -313,7 +313,7 @@ function nodeinjections.changestackedlayer(s,t1,first1,last1,t2,first2,last2)
         r[#r+1] = startlayer(values[t2[i]])
     end
     r = concat(r," ")
-    return pageliteral(r)
+    return setstate(r)
 end
 
 -- transitions
diff --git a/tex/context/base/mkxl/lpdf-rul.lmt b/tex/context/base/mkxl/lpdf-rul.lmt
index ae2142a8e..efcc62073 100644
--- a/tex/context/base/mkxl/lpdf-rul.lmt
+++ b/tex/context/base/mkxl/lpdf-rul.lmt
@@ -33,13 +33,9 @@ local formatters       = string.formatters
 
 -- This is very pdf specific. Maybe move some to lpdf-rul.lua some day.
 
-local pdfprint
+local pdfprint ; pdfprint = function(...) pdfprint = lpdf.print return pdfprint(...) end
 
-pdfprint = function(...) pdfprint = lpdf.print return pdfprint(...) end
-
--- updaters.register("backend.update",function()
---     pdfprint = lpdf.print
--- end)
+-- updaters.register("backend.update",function() pdfprint = lpdf.print end)
 
 do
 
diff --git a/tex/context/base/mkxl/lpdf-tag.lmt b/tex/context/base/mkxl/lpdf-tag.lmt
index 4ea92d951..44a84ea59 100644
--- a/tex/context/base/mkxl/lpdf-tag.lmt
+++ b/tex/context/base/mkxl/lpdf-tag.lmt
@@ -63,7 +63,7 @@ local a_image             = attributes.private('image')
 local nuts                = nodes.nuts
 
 local nodepool            = nuts.pool
-local pageliteral         = nodepool.pageliteral
+local setstate            = nodepool.setstate
 local register            = nodepool.register
 
 local getid               = nuts.getid
@@ -369,7 +369,7 @@ local visualize  = nil
 function nodeinjections.addtags(head)
 
     if not EMCliteral then
-        EMCliteral = register(pageliteral("EMC"))
+        EMCliteral = register(setstate("EMC"))
     end
 
     local last   = nil
@@ -516,9 +516,9 @@ end
                 end
             end
             if prev then
-                literal = pageliteral(makecontent(prev,id,specification))
+                literal = setstate(makecontent(prev,id,specification))
             elseif ignore then
-                literal = pageliteral(makeignore(specification))
+                literal = setstate(makeignore(specification))
             else
                 -- maybe also ignore or maybe better: comment or so
             end
@@ -543,7 +543,7 @@ end
 
         else
 
-            local literal = pageliteral(makeignore(specification))
+            local literal = setstate(makeignore(specification))
 
             inject(start,stop,list,literal)
 
@@ -667,9 +667,9 @@ end
 --         end
 --
 --         if r > 0 then
---             local literal = pageliteral(concat(result,"\n"))
+--             local literal = setstate(concat(result,"\n"))
 --             -- use insert instead:
---             local literal = pageliteral(result)
+--             local literal = setstate(result)
 --             local prev = getprev(start)
 --             if prev then
 --                 setlink(prev,literal)
@@ -691,7 +691,7 @@ end
 --         for i=1,noftop do
 --             result[i] = "EMC"
 --         end
---         local literal = pageliteral(concat(result,"\n"))
+--         local literal = setstate(concat(result,"\n"))
 --         -- use insert instead:
 --         local next = getnext(last)
 --         if next then
diff --git a/tex/context/base/mkxl/lpdf-vfc.lmt b/tex/context/base/mkxl/lpdf-vfc.lmt
deleted file mode 100644
index 6030bb028..000000000
--- a/tex/context/base/mkxl/lpdf-vfc.lmt
+++ /dev/null
@@ -1,42 +0,0 @@
-if not modules then modules = { } end modules ['lpdf-vfc'] = {
-    version   = 1.001,
-    comment   = "companion to lpdf-ini.mkiv",
-    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
-    copyright = "PRAGMA ADE / ConTeXt Development Team",
-    license   = "see context related readme files"
-}
-
-local setmetatableindex = table.setmetatableindex
-
-local defaultline = 16384
-
-local vfspecials = backends.pdf.tables.vfspecials or utilities.storage.allocate { }
-backends.pdf.tables.vfspecials = vfspecials
-
-vfspecials.backgrounds = setmetatableindex(function(t,h)
-    local v = setmetatableindex(function(t,d)
-        local v = setmetatableindex(function(t,w)
-            local v = { "frame", w, h, d, defaultline, true, true }
-            t[w] = v
-            return v
-        end)
-        t[d] = v
-        return v
-    end)
-    t[h] = v
-    return v
-end)
-
-vfspecials.outlines = setmetatableindex(function(t,h)
-    local v = setmetatableindex(function(t,d)
-        local v = setmetatableindex(function(t,w)
-            local v = { "frame", w, h, d, defaultline, false, true }
-            t[w] = v
-            return v
-        end)
-        t[d] = v
-        return v
-    end)
-    t[h] = v
-    return v
-end)
diff --git a/tex/context/base/mkxl/math-act.lmt b/tex/context/base/mkxl/math-act.lmt
new file mode 100644
index 000000000..3076f2ac9
--- /dev/null
+++ b/tex/context/base/mkxl/math-act.lmt
@@ -0,0 +1,480 @@
+if not modules then modules = { } end modules ['math-act'] = {
+    version   = 1.001,
+    comment   = "companion to math-ini.mkiv",
+    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
+    copyright = "PRAGMA ADE / ConTeXt Development Team",
+    license   = "see context related readme files"
+}
+
+-- Here we tweak some font properties (if needed). The commented sections
+-- have been removed (no longer viable) but can be found in the .lua variant.
+
+local type, next = type, next
+local fastcopy, insert, remove = table.fastcopy, table.insert, table.remove
+local formatters = string.formatters
+
+local trace_defining   = false  trackers.register("math.defining",   function(v) trace_defining   = v end)
+local trace_collecting = false  trackers.register("math.collecting", function(v) trace_collecting = v end)
+
+local report_math      = logs.reporter("mathematics","initializing")
+
+local context          = context
+local commands         = commands
+local mathematics      = mathematics
+local texsetdimen      = tex.setdimen
+local abs              = math.abs
+
+local helpers          = fonts.helpers
+local upcommand        = helpers.commands.up
+local rightcommand     = helpers.commands.right
+local charcommand      = helpers.commands.char
+local prependcommands  = helpers.prependcommands
+
+local sequencers       = utilities.sequencers
+local appendgroup      = sequencers.appendgroup
+local appendaction     = sequencers.appendaction
+
+local fontchars        = fonts.hashes.characters
+local fontproperties   = fonts.hashes.properties
+
+local mathfontparameteractions = sequencers.new {
+    name      = "mathparameters",
+    arguments = "target,original",
+}
+
+appendgroup("mathparameters","before") -- user
+appendgroup("mathparameters","system") -- private
+appendgroup("mathparameters","after" ) -- user
+
+function fonts.constructors.assignmathparameters(original,target)
+    local runner = mathfontparameteractions.runner
+    if runner then
+        runner(original,target)
+    end
+end
+
+function mathematics.initializeparameters(target,original)
+    local mathparameters = original.mathparameters
+    if mathparameters and next(mathparameters) then
+        mathparameters = mathematics.dimensions(mathparameters)
+        if not mathparameters.SpaceBeforeScript then
+            mathparameters.SpaceBeforeScript = mathparameters.SpaceAfterScript
+        end
+        target.mathparameters = mathparameters
+    end
+end
+
+sequencers.appendaction("mathparameters","system","mathematics.initializeparameters")
+
+local how = {
+ -- RadicalKernBeforeDegree         = "horizontal",
+ -- RadicalKernAfterDegree          = "horizontal",
+    ScriptPercentScaleDown          = "unscaled",
+    ScriptScriptPercentScaleDown    = "unscaled",
+    RadicalDegreeBottomRaisePercent = "unscaled",
+    NoLimitSupFactor                = "unscaled",
+    NoLimitSubFactor                = "unscaled",
+}
+
+function mathematics.scaleparameters(target,original)
+    if not target.properties.math_is_scaled then
+        local mathparameters = target.mathparameters
+        if mathparameters and next(mathparameters) then
+            local parameters = target.parameters
+            local factor  = parameters.factor
+            local hfactor = parameters.hfactor
+            local vfactor = parameters.vfactor
+            for name, value in next, mathparameters do
+                local h = how[name]
+                if h == "unscaled" then
+                    -- kept
+                elseif h == "horizontal" then
+                    value = value * hfactor
+                elseif h == "vertical"then
+                    value = value * vfactor
+                else
+                    value = value * factor
+                end
+               mathparameters[name] = value
+            end
+        end
+        target.properties.math_is_scaled = true
+    end
+end
+
+-- AccentBaseHeight vs FlattenedAccentBaseHeight
+
+function mathematics.checkaccentbaseheight(target,original)
+    local mathparameters = target.mathparameters
+    if mathparameters and mathparameters.AccentBaseHeight == 0 then
+        mathparameters.AccentBaseHeight = target.parameters.x_height -- needs checking
+    end
+end
+
+function mathematics.checkprivateparameters(target,original)
+    local mathparameters = target.mathparameters
+    if mathparameters then
+        local parameters = target.parameters
+        local properties = target.properties
+        if parameters then
+            local size = parameters.size
+            if size then
+                if not mathparameters.FractionDelimiterSize then
+                    mathparameters.FractionDelimiterSize = 1.01 * size
+                end
+                if not mathparameters.FractionDelimiterDisplayStyleSize then
+                    mathparameters.FractionDelimiterDisplayStyleSize = 2.40 * size
+                end
+            elseif properties then
+                report_math("invalid parameters in font %a",properties.fullname or "?")
+            else
+                report_math("invalid parameters in font")
+            end
+        elseif properties then
+            report_math("no parameters in font %a",properties.fullname or "?")
+        else
+            report_math("no parameters and properties in font")
+        end
+    end
+end
+
+function mathematics.overloadparameters(target,original)
+    local mathparameters = target.mathparameters
+    if mathparameters and next(mathparameters) then
+        local goodies = target.goodies
+        if goodies then
+            for i=1,#goodies do
+                local goodie = goodies[i]
+                local mathematics = goodie.mathematics
+                local parameters  = mathematics and mathematics.parameters
+                if parameters then
+                    if trace_defining then
+                        report_math("overloading math parameters in %a @ %p",target.properties.fullname,target.parameters.size)
+                    end
+                    for name, value in next, parameters do
+                        local tvalue = type(value)
+                        if tvalue == "string" then
+                            report_math("comment for math parameter %a: %s",name,value)
+                        else
+                            local oldvalue = mathparameters[name]
+                            local newvalue = oldvalue
+                            if oldvalue then
+                                if tvalue == "number" then
+                                    newvalue = value
+                                elseif tvalue == "function" then
+                                    newvalue = value(oldvalue,target,original)
+                                elseif not tvalue then
+                                    newvalue = nil
+                                end
+                                if trace_defining and oldvalue ~= newvalue then
+                                    report_math("overloading math parameter %a: %S => %S",name,oldvalue,newvalue)
+                                end
+                            else
+                                report_math("invalid math parameter %a",name)
+                            end
+                            mathparameters[name] = newvalue
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+
+local function applytweaks(when,target,original)
+    local goodies = original.goodies
+    if goodies then
+        for i=1,#goodies do
+            local goodie = goodies[i]
+            local mathematics = goodie.mathematics
+            local tweaks = mathematics and mathematics.tweaks
+            if type(tweaks) == "table" then
+                tweaks = tweaks[when]
+                if type(tweaks) == "table" then
+                    if trace_defining then
+                        report_math("tweaking math of %a @ %p (%s)",target.properties.fullname,target.parameters.size,when)
+                    end
+                    for i=1,#tweaks do
+                        local tweak= tweaks[i]
+                        local tvalue = type(tweak)
+                        if tvalue == "function" then
+                            tweak(target,original)
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+
+function mathematics.tweakbeforecopyingfont(target,original)
+    local mathparameters = target.mathparameters -- why not hasmath
+    if mathparameters then
+        applytweaks("beforecopying",target,original)
+    end
+end
+
+function mathematics.tweakaftercopyingfont(target,original)
+    local mathparameters = target.mathparameters -- why not hasmath
+    if mathparameters then
+        applytweaks("aftercopying",target,original)
+    end
+end
+
+sequencers.appendaction("mathparameters","system","mathematics.scaleparameters")
+sequencers.appendaction("mathparameters","system","mathematics.checkaccentbaseheight")  -- should go in lfg instead
+sequencers.appendaction("mathparameters","system","mathematics.checkprivateparameters") -- after scaling !
+sequencers.appendaction("mathparameters","system","mathematics.overloadparameters")
+
+sequencers.appendaction("beforecopyingcharacters","system","mathematics.tweakbeforecopyingfont")
+sequencers.appendaction("aftercopyingcharacters", "system","mathematics.tweakaftercopyingfont")
+
+local virtualized = mathematics.virtualized
+
+-- no, it's a feature now (see good-mth):
+--
+-- sequencers.appendaction("aftercopyingcharacters", "system","mathematics.overloaddimensions")
+
+-- a couple of predefined tweaks:
+
+local tweaks       = { }
+mathematics.tweaks = tweaks
+
+-- helpers
+
+local setmetatableindex  = table.setmetatableindex
+
+local getfontoffamily    = tex.getfontoffamily
+
+local fontcharacters     = fonts.hashes.characters
+local extensibles        = utilities.storage.allocate()
+fonts.hashes.extensibles = extensibles
+
+local chardata           = characters.data
+local extensibles        = mathematics.extensibles
+
+-- we use numbers at the tex end (otherwise we could stick to chars)
+
+local e_left       = extensibles.left
+local e_right      = extensibles.right
+local e_horizontal = extensibles.horizontal
+local e_mixed      = extensibles.mixed
+local e_unknown    = extensibles.unknown
+
+local unknown      = { e_unknown, false, false }
+
+local function extensiblecode(font,unicode)
+    local characters = fontcharacters[font]
+    local character = characters[unicode]
+    if not character then
+        return unknown
+    end
+    local first = character.next
+    local code = unicode
+    local next = first
+    while next do
+        code = next
+        character = characters[next]
+        next = character.next
+    end
+    local char = chardata[unicode]
+    if not char then
+        return unknown
+    end
+    if character.horiz_variants then
+        if character.vert_variants then
+            return { e_mixed, code, character }
+        else
+            local m = char.mathextensible
+            local e = m and extensibles[m]
+            return e and { e, code, character } or unknown
+        end
+    elseif character.vert_variants then
+        local m = char.mathextensible
+        local e = m and extensibles[m]
+        return e and { e, code, character } or unknown
+    elseif first then
+        -- assume accent (they seldom stretch .. sizes)
+        local m = char.mathextensible or char.mathstretch
+        local e = m and extensibles[m]
+        return e and { e, code, character } or unknown
+    else
+        return unknown
+    end
+end
+
+setmetatableindex(extensibles,function(extensibles,font)
+    local codes = { }
+    setmetatableindex(codes, function(codes,unicode)
+        local status = extensiblecode(font,unicode)
+        codes[unicode] = status
+        return status
+    end)
+    extensibles[font] = codes
+    return codes
+end)
+
+local function extensiblecode(family,unicode)
+    return extensibles[getfontoffamily(family or 0)][unicode][1]
+end
+
+-- left       : [head] ...
+-- right      : ... [head]
+-- horizontal : [head] ... [head]
+--
+-- abs(right["start"] - right["end"]) | right.advance | characters[right.glyph].width
+
+local function horizontalcode(family,unicode)
+    local font    = getfontoffamily(family or 0)
+    local data    = extensibles[font][unicode]
+    local kind    = data[1]
+    local loffset = 0
+    local roffset = 0
+    if kind == e_left then
+        local charlist = data[3].horiz_variants
+        if charlist then
+            local left = charlist[1]
+            loffset = abs((left["start"] or 0) - (left["end"] or 0))
+        end
+    elseif kind == e_right then
+        local charlist = data[3].horiz_variants
+        if charlist then
+            local right = charlist[#charlist]
+            roffset = abs((right["start"] or 0) - (right["end"] or 0))
+        end
+     elseif kind == e_horizontal then
+        local charlist = data[3].horiz_variants
+        if charlist then
+            local left  = charlist[1]
+            local right = charlist[#charlist]
+            loffset = abs((left ["start"] or 0) - (left ["end"] or 0))
+            roffset = abs((right["start"] or 0) - (right["end"] or 0))
+        end
+    end
+    return kind, loffset, roffset
+end
+
+mathematics.extensiblecode = extensiblecode
+mathematics.horizontalcode = horizontalcode
+
+interfaces.implement {
+    name      = "extensiblecode",
+    arguments = { "integer", "integer" },
+    actions   = { extensiblecode, context }
+}
+
+interfaces.implement {
+    name      = "horizontalcode",
+    arguments = { "integer", "integer" },
+    actions   = function(family,unicode)
+        local kind, loffset, roffset = horizontalcode(family,unicode)
+        texsetdimen("scratchleftoffset", loffset)
+        texsetdimen("scratchrightoffset",roffset)
+        context(kind)
+    end
+}
+
+
+local stack = { }
+
+function mathematics.registerfallbackid(n,id,name)
+    if trace_collecting then
+        report_math("resolved fallback font %i, name %a, id %a, used %a",
+            n,name,id,fontproperties[id].fontname)
+    end
+    stack[#stack][n] = id
+end
+
+interfaces.implement { -- will be shared with text
+    name      = "registerfontfallbackid",
+    arguments = { "integer", "integer", "string" },
+    actions   = mathematics.registerfallbackid,
+}
+
+function mathematics.resolvefallbacks(target,specification,fallbacks)
+    local definitions = fonts.collections.definitions[fallbacks]
+    if definitions then
+        local size = specification.size -- target.size
+        local list = { }
+        insert(stack,list)
+        context.pushcatcodes("prt") -- context.unprotect()
+        for i=1,#definitions do
+            local definition = definitions[i]
+            local name       = definition.font
+            local features   = definition.features or ""
+            local size       = size * (definition.rscale or 1)
+            context.font_fallbacks_register_math(i,name,features,size)
+            if trace_collecting then
+                report_math("registering fallback font %i, name %a, size %a, features %a",i,name,size,features)
+            end
+        end
+        context.popcatcodes()
+    end
+end
+
+function mathematics.finishfallbacks(target,specification,fallbacks)
+    local list = remove(stack)
+    if list and #list > 0 then
+        local definitions = fonts.collections.definitions[fallbacks]
+        if definitions and #definitions > 0 then
+            if trace_collecting then
+                report_math("adding fallback characters to font %a",specification.hash)
+            end
+            local definedfont = fonts.definers.internal
+            local copiedglyph = fonts.handlers.vf.math.copy_glyph
+            local fonts       = target.fonts
+            local size        = specification.size -- target.size
+            local characters  = target.characters
+            if not fonts then
+                fonts = { }
+                target.fonts = fonts
+            end
+            if #fonts == 0 then
+                fonts[1] = { id = 0, size = size } -- self, will be resolved later
+            end
+            local done = { }
+            for i=1,#definitions do
+                local definition = definitions[i]
+                local name   = definition.font
+                local start  = definition.start
+                local stop   = definition.stop
+                local gaps   = definition.gaps
+                local check  = definition.check
+                local force  = definition.force
+                local rscale = definition.rscale or 1
+                local offset = definition.offset or start
+                local id     = list[i]
+                if id then
+                    local index  = #fonts + 1
+                    fonts[index] = { id = id, size = size }
+                    local chars  = fontchars[id]
+                    local function remap(unic,unicode,gap)
+                        if check and not chars[unicode] then
+                            return
+                        end
+                        if force or (not done[unic] and not characters[unic]) then
+                            if trace_collecting then
+                                report_math("replacing math character %C by %C using vector %a and font id %a for %a%s%s",
+                                    unic,unicode,fallbacks,id,fontproperties[id].fontname,check and ", checked",gap and ", gap plugged")
+                            end
+                            characters[unic] = copiedglyph(target,characters,chars,unicode,index)
+                            done[unic] = true
+                        end
+                    end
+                    local step = offset - start
+                    for unicode = start, stop do
+                        remap(unicode + step,unicode,false)
+                    end
+                    if gaps then
+                        for unic, unicode in next, gaps do
+                            remap(unic,unicode,true)
+                            remap(unicode,unicode,true)
+                        end
+                    end
+                end
+            end
+        elseif trace_collecting then
+            report_math("no fallback characters added to font %a",specification.hash)
+        end
+    end
+end
diff --git a/tex/context/base/mkxl/math-ali.mkxl b/tex/context/base/mkxl/math-ali.mkxl
index d90f3ab0f..72f857720 100644
--- a/tex/context/base/mkxl/math-ali.mkxl
+++ b/tex/context/base/mkxl/math-ali.mkxl
@@ -285,7 +285,7 @@
    \math_number_right_of_eqalign
    \global\settrue\c_math_eqalign_first
    \crcr
-   \dostoptagged} % finish row
+   \noalign{\dostoptagged}} % finish row
 
 \permanent\protected\def\math_alignment_NC
   {\relax
diff --git a/tex/context/base/mkxl/math-ini.mkxl b/tex/context/base/mkxl/math-ini.mkxl
index 95501be65..01ecd63a2 100644
--- a/tex/context/base/mkxl/math-ini.mkxl
+++ b/tex/context/base/mkxl/math-ini.mkxl
@@ -66,7 +66,7 @@
 
 \registerctxluafile{math-ini}{}
 \registerctxluafile{math-dim}{}
-\registerctxluafile{math-act}{}
+\registerctxluafile{math-act}{autosuffix}
 \registerctxluafile{math-ext}{}
 \registerctxluafile{math-vfu}{autosuffix}
 \registerctxluafile{math-ttv}{}
diff --git a/tex/context/base/mkxl/math-noa.lmt b/tex/context/base/mkxl/math-noa.lmt
index c884e6927..92edbc441 100644
--- a/tex/context/base/mkxl/math-noa.lmt
+++ b/tex/context/base/mkxl/math-noa.lmt
@@ -693,7 +693,8 @@ do
     end
 
     -- We can optimize this if we really think that math is a bottleneck which it never
-    -- really is.
+    -- really is. Beware: the font is the text font in the family, so we only check the
+    -- text font here.
 
     relocate[mathchar_code] = function(pointer)
         local g          = getattr(pointer,a_mathgreek) or 0
@@ -757,7 +758,13 @@ do
             end
         end
         if not characters[char] then
+            local fam = getfam(pointer)
+            local fnt = getfontoffamily(fam,1)
             setchar(pointer,errorchar(font,char))
+            if font ~= fnt then
+                errorchar(fnt,char)
+                errorchar(getfontoffamily(fam,2),char)
+            end
         end
         if trace_analyzing then
             setnodecolor(pointer,"font:medi")
diff --git a/tex/context/base/mkxl/meta-imp-punk.mkxl b/tex/context/base/mkxl/meta-imp-punk.mkxl
new file mode 100644
index 000000000..050023642
--- /dev/null
+++ b/tex/context/base/mkxl/meta-imp-punk.mkxl
@@ -0,0 +1,272 @@
+%D \module
+%D   [       file=meta-imp-punk,
+%D        version=2020.01.16,
+%D          title=\METAPOST\ Graphics,
+%D       subtitle=Punk,
+%D         author=Hans Hagen,
+%D           date=\currentdate,
+%D      copyright={PRAGMA ADE \& \CONTEXT\ Development Team}]
+%C
+%C This module is part of the \CONTEXT\ macro||package and is
+%C therefore copyrighted by \PRAGMA. See mreadme.pdf for
+%C details.
+
+% This file is a merge of the original punk files by Donald Knuth, who
+% added this comment:
+%
+%   Font inspired by Gerard and Marjan Unger's lectures, Feb 1985
+%
+% The regular punk files are part of TeXLive and in metafont format. All
+% errors introduced are ours. We also changed the encoding to unicode. In
+% due time we might add a few more more characters. We still need to
+% improve some of the metrics which involves a bit of trial and error. The
+% font just covers basic latin shapes but in ConTeXt MkIV we add virtual
+% composed shapes. There is a module m-punk.tex that implements this. This
+% derivate is also used in mk.tex (mk.pdf) which is one of our tests for
+% LuaTeX. We published an article on it in the MAPS (NTG magazine).
+%
+% 2008, mkiv variant: Taco Hoekwater & Hans Hagen
+% 2020, lmtx variant: Hans Hagen (playground)
+
+\startMPcalculation{simplefun}
+
+    picture PunkShapes[][];
+
+    numeric PunkId       ; PunkId       := 0 ;
+    numeric PunkBase     ; PunkBase     := 0 ;
+    string  PunkName     ; PunkName     := "punk" ;
+    numeric PunkUsed     ; PunkUsed     := 0 ;
+    numeric PunkSlant    ; PunkSlant    := 0 ;
+    numeric PunkWeight   ; PunkWeight   := 1 ;
+    numeric PunkSqueeze  ; PunkSqueeze  := 1 ;
+    numeric PunkExtend   ; PunkExtend   := 1 ;
+    numeric PunkVariants ; PunkVariants := 0 ;
+
+    numeric PunkRatio ; PunkRatio := 2/3 ;
+    numeric PunkScale ; PunkScale := 20 ;  % when zero we use the knuth values
+    numeric PunkN     ; PunkN     := 0 ;
+
+    def beginpunkchar(expr c, n, hor, ver) =
+        begingroup ;
+        save uc, w, h, d, hdev, vdev ;
+        hdev := hor * dev ; % modify horizontal amounts of deviation
+        vdev := ver * dev ; % modify vertical   amounts of deviation
+        uc := if string c : utfnum(c) else : c fi ;
+        h := if PunkScale > 0 : PunkN else : n fi / PunkSqueeze ;
+        w := n * PunkExtend ;
+        d := 0 ;
+        clearxy ;
+        clearit ;
+    enddef ;
+
+    def endpunkchar =
+        if PunkSlant <> 0 :
+            currentpicture := currentpicture slanted PunkSlant ;
+        fi ;
+        save llx, lly, uly ;
+        llx := xpart llcorner currentpicture ;
+        lly := ypart llcorner currentpicture ;
+        uly := ypart ulcorner currentpicture ;
+
+        currentpicture := currentpicture shifted (- llx + 1, 0);
+        w := bbwidth(currentpicture) + 2 ;
+        h := uly ;
+        d := if lly < 0 : - lly else : 0 fi ;
+
+        PunkUsed := if PunkBase > 0 : PunkBase else : uc fi;
+        PunkShapes[PunkId][PunkUsed] := currentpicture ;
+        lmt_registerglyph [
+            category  = PunkName,
+            unicode   = PunkUsed,
+            tounicode = uc,
+            width     = w,
+            height    = h,
+            depth     = d,
+            code      = "draw PunkShapes[" & decimal PunkId & "][" & decimal PunkUsed & "]",
+        ] ;
+        if PunkBase > 0 :
+            PunkBase := PunkBase + 1 ;
+        fi ;
+        endgroup ;
+    enddef ;
+
+    def initialize_punk_upper =
+        PunkN := PunkScale ;
+        dev   := 1 ;
+    enddef ;
+
+    def initialize_punk_lower =
+        PunkN := PunkScale * PunkRatio ;
+        dev   := .5 ;
+    enddef ;
+
+    def revert_punk_lower =
+        PunkN := PunkScale ;
+        dev   := 1 ;
+    enddef ;
+
+    def beginpunkfont =
+
+        begingroup ;
+
+        save dev;
+
+        save u ; u := 1 ;
+
+        PunkBase  := 0 ;
+
+        pen linepen ; linepen := pencircle scaled (PunkWeight * u) ;
+        pen dotpen  ; dotpen  := linepen scaled 2 slanted -PunkSlant ;
+
+        pickup linepen ;
+
+        save pp ; vardef pp expr z =
+            z + (hdev * normaldeviate, vdev * normaldeviate)
+        enddef ;
+
+        save pd ; def pd expr z =
+            drawdot z withpen dotpen ;
+        enddef ;
+
+        PunkId := PunkId + 1 ;
+
+        lmt_registerglyphs [
+            name     = PunkName, % todo: when we do name = name we get ['"name"'] = name
+            units    = 25,
+            width    = 25,
+            height   = 25,
+            depth    = 0,
+            usecolor = true,
+        ] ;
+
+        def endchar = endpunkchar enddef ;
+
+    enddef ;
+
+    def endpunkfont =
+        endgroup;
+    enddef ;
+
+    % We started out with immediate:
+
+  % def MakePunkFont (expr name, filename, slant, weight, squeeze, extend) =
+  %     begingroup ;
+  %         save PunkName, PunkFileName, PunkSlant, PunkWeight, PunkSqueeze, PunkExend, PunkVariants ;
+  %         string PunkName, PunkFileName ;
+  %         PunkFileName := filename ;
+  %         PunkName     := name ;
+  %         PunkSlant    := slant ;
+  %         PunkWeight   := weight ;
+  %         PunkSqueeze  := squeeze ;
+  %         PunkExtend   := extend ;
+  %         PunkVariants := 0 ;
+  %         beginpunkfont ;
+  %             loadfile(PunkFileName) ;
+  %         endpunkfont ;
+  %     endgroup ;
+  % enddef ;
+  %
+  % MakePunkFont("punk",            "punkfont-characters.mp", 1, 0   ) ;
+  % MakePunkFont("punkbold",        "punkfont-characters.mp", 2, 0   ) ;
+  % MakePunkFont("punkslanted",     "punkfont-characters.mp", 1, 0.15) ;
+  % MakePunkFont("punkboldslanted", "punkfont-characters.mp", 2, 0.15) ;
+
+    % And ended up with delayed:
+
+    def punkpreroll =
+        begingroup ;
+            save PunkName, PunkFileName, PunkSlant, PunkWeight, PunkSqueeze, PunkExtend, PunkVariants ;
+            string PunkName, PunkFileName ;
+            PunkName     := getparameterdefault "mpsfont" "name" "punk" ;
+            PunkFileName := getparameterdefault "mpsfont" "filename" "punkfont-characters.mp" ;
+            PunkSlant    := scantokens(getparameterdefault "mpsfont" "slant" "0") ;
+            PunkWeight   := scantokens(getparameterdefault "mpsfont" "weight" "1") ;
+            PunkSqueeze  := scantokens(getparameterdefault "mpsfont" "squeeze" "1") ;
+            PunkExtend   := scantokens(getparameterdefault "mpsfont" "extend" "1") ;
+            PunkVariants := scantokens(getparameterdefault "mpsfont" "variants" "0");
+            beginpunkfont ;
+                loadfile(PunkFileName) ;
+                if PunkVariants > 0 :
+                    PunkBase := 57344 ; % 0xE000 ; 0xF0000 ;
+                    for i=1 upto PunkVariants :
+                        loadfile(PunkFileName) ;
+                    endfor ;
+                fi ;
+            endpunkfont ;
+        endgroup ;
+    enddef ;
+
+\stopMPcalculation
+
+% Are these names okay? If so it can go into the core.
+
+\permanent\protected\def\enablerandomvariants{\setcharactercasing[randomvariant]}
+\permanent\protected\def\randomvariants      {\groupedcommand\enablerandomvariants\donothing}
+\permanent\protected\def\startrandomvariants {\begingroup\enablerandomvariants}
+\permanent\protected\def\stoprandomvariants  {\endgroup}
+
+\definefontfeature [punk]            [metapost={category=punk,preroll=punkpreroll}]
+\definefontfeature [punkrandom]      [metapost={category=punk,preroll=punkpreroll,variants=10}]
+\definefontfeature [punkbold]        [metapost={category=punk,preroll=punkpreroll,weight=2}]
+\definefontfeature [punkslanted]     [metapost={category=punk,preroll=punkpreroll,slant=.15}]
+\definefontfeature [punkboldslanted] [metapost={category=punk,preroll=punkpreroll,slant=.15,weight=2}]
+\definefontfeature [punkveryslanted] [metapost={category=punk,preroll=punkpreroll,slant=-.15}]
+\definefontfeature [punksqueezed]    [metapost={category=punk,preroll=punkpreroll,squeeze=.5}]
+\definefontfeature [punkextended]    [metapost={category=punk,preroll=punkpreroll,extend=1.3}]
+
+\continueifinputfile{meta-imp-punk.mkxl}
+
+% immediate:
+%
+% \definefontfeature [punk]            [metapost=punk]
+% \definefontfeature [punkbold]        [metapost=punkbold]
+% \definefontfeature [punkslanted]     [metapost=punkslanted]
+% \definefontfeature [punkboldslanted] [metapost=punkboldslanted]
+
+% delayed:
+
+% name=punk
+% filename=punkfont-characters.mp
+
+\setupbodyfont[dejavu]
+
+\definefont[PunkA][Serif*punk]
+\definefont[PunkB][Serif*punkbold]
+\definefont[PunkC][Serif*punkslanted]
+\definefont[PunkD][Serif*punkboldslanted]
+\definefont[PunkE][Serif*punkveryslanted]
+\definefont[PunkF][Serif*punkrandom]
+\definefont[PunkG][Serif*punksqueezed]
+\definefont[PunkH][Serif*punkextended]
+
+\starttext
+
+\startTEXpage[offset=10pt,width=30cm]
+    % \showglyphs
+    {\darkcyan    \PunkA \samplefile{tufte} \par}
+    {\darkmagenta \PunkB \samplefile{tufte} \par}
+    {\darkred     \PunkC \samplefile{tufte} \par}
+    {\darkgreen   \PunkD \samplefile{tufte} \par}
+    {\darkblue    \PunkE \samplefile{tufte} \par}
+    {\darkyellow  \PunkF \enablerandomvariants \samplefile{tufte} \par}
+    {\darkgray    \PunkG \samplefile{tufte} \par}
+    {\darkorange  \PunkH \samplefile{tufte} \par}
+\stopTEXpage
+
+\startTEXpage[offset=10pt,width=2cm]
+    \PunkF \enablerandomvariants
+    \dostepwiserecurse{1}{2000}{1}{\glyphscale#1\relax f }
+\stopTEXpage
+
+% \setupbodyfont[dejavu]
+
+\setupbodyfont[punk] %one first needs to load a bodyfont !
+
+\startTEXpage[offset=10pt,width=20cm]
+    {\darkcyan    \tf \samplefile{zapf} \par}
+    {\darkmagenta \bf \samplefile{zapf} \par}
+    {\darkred     \sl \samplefile{zapf} \par}
+    {\darkgreen   \bs \samplefile{zapf} \par}
+\stopTEXpage
+
+\stoptext
diff --git a/tex/context/base/mkxl/mlib-mpf.lmt b/tex/context/base/mkxl/mlib-mpf.lmt
index 6bd31376c..d66491a16 100644
--- a/tex/context/base/mkxl/mlib-mpf.lmt
+++ b/tex/context/base/mkxl/mlib-mpf.lmt
@@ -86,12 +86,10 @@ do
         else
             runscripts[nofscripts] = name
         end
--- print("set",name,nofscripts,f)
         return nofscripts
     end
 
     function metapost.scriptindex(name)
--- print("get",name,runnames[name] or 0)
         return runnames[name] or 0
     end
 
@@ -945,9 +943,14 @@ do
     registerscript("setcount", function() setcount(scanstring(),scannumeric()) end)
     registerscript("settoks",  function() settoks (scanstring(),scanstring()) end)
 
+    local utfnum = utf.byte
     local utflen = utf.len
     local utfsub = utf.sub
 
+    registerscript("utfnum", function()
+        injectnumeric(utfnum(scanstring()))
+    end)
+
     registerscript("utflen", function()
         injectnumeric(utflen(scanstring()))
     end)
diff --git a/tex/context/base/mkxl/node-ext.lmt b/tex/context/base/mkxl/node-ext.lmt
new file mode 100644
index 000000000..2f909cd3d
--- /dev/null
+++ b/tex/context/base/mkxl/node-ext.lmt
@@ -0,0 +1,650 @@
+if not modules then modules = { } end modules ['back-out'] = {
+    version   = 1.001,
+    comment   = "companion to back-ini.mkiv",
+    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
+    copyright = "PRAGMA ADE / ConTeXt Development Team",
+    license   = "see context related readme files"
+}
+
+local type, unpack, rawset = type, unpack, type
+local loadstring = loadstring
+local sind, cosd, abs = math.sind, math.cosd, math.abs
+local insert, remove = table.insert, table.remove
+
+local context             = context
+local implement           = interfaces.implement
+
+local allocate            = utilities.storage.allocate
+
+local formatters          = string.formatters
+
+local get                 = token.get_index -- getters
+local scanners            = tokens.scanners
+local scaninteger         = scanners.integer
+local scanstring          = scanners.string
+local scankeyword         = scanners.keyword
+local scantokenlist       = scanners.tokenlist
+local scannumber          = scanners.number
+
+local nuts                = nodes.nuts
+local tonode              = nuts.tonode
+local copynut             = nuts.copy
+local nutpool             = nuts.pool
+local nodepool            = nodes.pool
+
+local nodeproperties      = nodes.properties.data
+
+local register            = nutpool.register
+local newnut              = nuts.new
+local tonode              = nodes.tonode
+
+-- Whatsits are a generic node type with very few fields. We use them to implement
+-- whatever we like. Some are good old tex whatsits but many are specific to the
+-- macro package. They are part of the backend.
+
+backends                  = backends or { }
+local backends            = backends
+
+local whatsit_code        = nodes.nodecodes.whatsit
+local whatsitcodes        = allocate { }
+nodes.whatsitcodes        = whatsitcodes
+local lastwhatsit         = 0
+
+nodes.subtypes.whatsit    = whatsitcodes
+
+local function registerwhatsit(name)
+    lastwhatsit = lastwhatsit + 1
+    whatsitcodes[lastwhatsit] = name
+    whatsitcodes[name] = lastwhatsit
+    return lastwhatsit
+end
+
+local function registerwhatsitnode(name)
+    return register(newnut(whatsit_code,registerwhatsit(name)))
+end
+
+-- We only have a subset of literals. In fact, we try to avoid literals.
+
+do
+
+    local literalvalues = allocate { }
+    nodes.literalvalues = literalvalues
+    local lastliteral   = 0
+    local literalnode   = registerwhatsitnode("literal")
+
+    local function registerliteral(name,alias)
+        lastliteral = lastliteral + 1
+        literalvalues[lastliteral] = name
+        literalvalues[name] = lastliteral
+        if alias then
+            literalvalues[alias] = lastliteral
+        end
+        return lastliteral
+    end
+
+    local originliteral_code = registerliteral("origin")
+    local pageliteral_code   = registerliteral("page")
+    local directliteral_code = registerliteral("always","direct")
+    local rawliteral_code    = registerliteral("raw")
+    local textliteral_code   = registerliteral("text") -- not to be used
+    local fontliteral_code   = registerliteral("font") -- not to be used
+
+    function nutpool.originliteral(str) local t = copynut(literalnode) nodeproperties[t] = { data = str, mode = originliteral_code } return t end
+    function nutpool.pageliteral  (str) local t = copynut(literalnode) nodeproperties[t] = { data = str, mode = pageliteral_code   } return t end
+    function nutpool.directliteral(str) local t = copynut(literalnode) nodeproperties[t] = { data = str, mode = directliteral_code } return t end
+    function nutpool.rawliteral   (str) local t = copynut(literalnode) nodeproperties[t] = { data = str, mode = rawliteral_code    } return t end
+
+    local pdfliterals = {
+        [originliteral_code] = originliteral_code, [literalvalues[originliteral_code]] = originliteral_code,
+        [pageliteral_code]   = pageliteral_code,   [literalvalues[pageliteral_code]]   = pageliteral_code,
+        [directliteral_code] = directliteral_code, [literalvalues[directliteral_code]] = directliteral_code,
+        [rawliteral_code]    = rawliteral_code,    [literalvalues[rawliteral_code]]    = rawliteral_code,
+    }
+
+    function nutpool.literal(mode,str)
+        local t = copynut(literalnode)
+        if str then
+            nodeproperties[t] = { data = str, mode = pdfliterals[mode] or pageliteral_code }
+        else
+            nodeproperties[t] = { data = mode, mode = pageliteral_code }
+        end
+        return t
+    end
+
+end
+
+-- The latelua node is just another whatsit and we handle the \LUA\ code with
+-- other \LUA\ code, contrary to \LUATEX\ where it's a native node.
+
+do
+
+    local getdata     = nuts.getdata
+    local serialize   = token.serialize
+
+    local lateluanode = registerwhatsitnode("latelua")
+    local noflatelua  = 0
+
+    function nutpool.latelua(code)
+        local n = copynut(lateluanode)
+        nodeproperties[n] = { data = code }
+        return n
+    end
+
+    function backends.latelua(current,pos_h,pos_v) -- todo: pass pos_h and pos_v (more efficient in lmtx)
+        local p = nodeproperties[current]
+        if p then
+            data = p.data
+        else
+            data = getdata(current)
+        end
+        noflatelua = noflatelua + 1
+        local kind = type(data)
+        if kind == "table" then
+            data.action(data.specification or data)
+        elseif kind == "function" then
+            data()
+        else
+            if kind ~= "string" then
+                data = serialize(data)
+            end
+            if #data ~= "" then
+                local code = loadstring(data)
+                if code then
+                    code()
+                end
+            end
+        end
+    end
+
+    function backends.getcallbackstate()
+        return { count = noflatelua }
+    end
+
+    implement {
+        name      = "latelua",
+        public    = true,
+        protected = true,
+        actions   = function()
+            local node = copynut(lateluanode)
+            local name = "latelua"
+            if scankeyword("name") then
+                name = scanstring()
+            end
+            local data = scantokenlist()
+            nodeproperties[node] = { name = name, data = data }
+            return context(tonode(node))
+        end,
+    }
+
+end
+
+-- This can be anything. Dealing with these nodes is done via properties, as with
+-- the other whatsits.
+
+do
+
+    local usernode = registerwhatsitnode("userdefined")
+
+    local userids  = allocate()
+    local lastid   = 0
+
+    setmetatable(userids, {
+        __index = function(t,k)
+            if type(k) == "string" then
+                lastid = lastid + 1
+                rawset(userids,lastid,k)
+                rawset(userids,k,lastid)
+                return lastid
+            else
+                rawset(userids,k,k)
+                return k
+            end
+        end,
+        __call = function(t,k)
+            return t[k]
+        end
+    } )
+
+    function nutpool.userdefined(id,data)
+        local n = copynut(usernode)
+        nodeproperties[n] = { id = id, data = data }
+        return n
+    end
+
+    nutpool .usernode = nutpool.userdefined
+    nutpool .userids  = userids
+    nodepool.userids  = userids
+
+end
+
+-- This one is only used by generic packages.
+
+do
+
+    local saveposnode = registerwhatsitnode("savepos")
+
+    function nutpool.savepos()
+        return copynut(saveposnode)
+    end
+
+end
+
+do
+
+    local savenode      = registerwhatsitnode("save")
+    local restorenode   = registerwhatsitnode("restore")
+    local setmatrixnode = registerwhatsitnode("setmatrix")
+
+    local stack         = { }
+    local restore       = true -- false
+
+    -- these are old school nodes
+
+    function nutpool.save()
+        return copynut(savenode)
+    end
+
+    function nutpool.restore()
+        return copynut(restorenode)
+    end
+
+    function nutpool.setmatrix(rx,sx,sy,ry,tx,ty)
+        local t = copynut(setmatrixnode)
+        nodeproperties[t] = { matrix = { rx, sx, sy, ry, tx, ty } }
+        return t
+    end
+
+    -- common
+
+    local function stopcommon(n)
+        local top = remove(stack)
+        if top == false then
+            return -- not wrapped
+        elseif top == true then
+            return copynut(n)
+        elseif top then
+            local t = copynut(n)
+            nodeproperties[t] = { matrix = { unpack(top) } }
+            return t
+        else
+            return -- nesting error
+        end
+    end
+
+    -- matrix
+
+    local startmatrixnode = registerwhatsitnode("startmatrix")
+    local stopmatrixnode  = registerwhatsitnode("stopmatrix")
+
+    local function startmatrix(rx, sx, sy, ry)
+        if rx == 1 and sx == 0 and sy == 0 and ry == 1 then
+            insert(stack,false)
+        else
+            local t = copynut(startmatrixnode)
+            nodeproperties[t] = { matrix = { rx, sx, sy, ry } }
+            insert(stack,store and { -rx, -sx, -sy, -ry } or true)
+            return t
+        end
+    end
+
+    local function stopmatrix()
+        return stopcommon(stopmatrixnode)
+    end
+
+    implement {
+        name    = "startmatrix",
+        actions = function()
+            local rx, sx, sy, ry = 1, 0, 0, 1
+            while true do
+                    if scankeyword("rx") then rx = scannumber()
+                elseif scankeyword("ry") then ry = scannumber()
+                elseif scankeyword("sx") then sx = scannumber()
+                elseif scankeyword("sy") then sy = scannumber()
+                else   break end
+            end
+            local t = startmatrix(rx,sx,sy,ry)
+            if t then
+                context(tonode(t))
+            end
+        end,
+    }
+
+    implement {
+        name    = "stopmatrix",
+        actions = function()
+            local t = stopmatrix(n)
+            if t then
+                context(tonode(t))
+            end
+        end,
+    }
+
+    -- scale
+
+    local startscalingnode = registerwhatsitnode("startscaling")
+    local stopscalingnode  = registerwhatsitnode("stopscaling")
+
+    local function startscaling(rx, ry) -- at the tex end we use sx and sy instead of rx and ry
+        if rx == 1 and ry == 1 then
+            insert(stack,false)
+        else
+            if rx == 0 then
+                rx = 0.0001
+            end
+            if ry == 0 then
+                ry = 0.0001
+            end
+            local t = copynut(startscalingnode)
+            nodeproperties[t] = { matrix = { rx, 0, 0, ry } }
+            insert(stack,restore and { 1/rx, 0, 0, 1/ry } or true)
+            return t
+        end
+    end
+
+    local function stopscaling() -- at the tex end we use sx and sy instead of rx and ry
+        return stopcommon(stopscalingnode)
+    end
+
+    implement {
+        name    = "startscaling",
+        actions = function()
+            local rx, ry = 1, 1
+            while true do
+                if scankeyword("rx") then
+                    rx = scannumber()
+                elseif scankeyword("ry") then
+                    ry = scannumber()
+                else
+                    break
+                end
+            end
+            local t = startscaling(rx,ry)
+            if t then
+                context(tonode(t))
+            end
+        end,
+    }
+
+    implement {
+        name    = "stopscaling",
+        actions = function()
+            local t = stopscaling(n)
+            if t then
+                context(tonode(t))
+            end
+        end,
+    }
+
+    -- rotate
+
+    local startrotationnode = registerwhatsitnode("startrotation")
+    local stoprotationnode  = registerwhatsitnode("stoprotation")
+
+    local function startrotation(a)
+        if a == 0 then
+            insert(stack,false)
+        else
+            local s, c = sind(a), cosd(a)
+            if abs(s) < 0.000001 then
+                s = 0 -- otherwise funny -0.00000
+            end
+            if abs(c) < 0.000001 then
+                c = 0 -- otherwise funny -0.00000
+            end
+            local t = copynut(startrotationnode)
+            nodeproperties[t] = { matrix = { c, s, -s, c } }
+            insert(stack,restore and { c, -s, s, c } or true)
+            return t
+        end
+    end
+
+    local function stoprotation()
+        return stopcommon(stoprotationnode)
+    end
+
+    nutpool.startrotation = startrotation
+
+    implement {
+        name    = "startrotation",
+        actions = function()
+            local n = scannumber()
+            local t = startrotation(n)
+            if t then
+                context(tonode(t))
+            end
+        end,
+    }
+
+    implement {
+        name    = "stoprotation",
+        actions = function()
+            local t = stoprotation()
+            if t then
+                context(tonode(t))
+            end
+        end,
+    }
+
+    -- mirror
+
+    local startmirroringnode = registerwhatsitnode("startmirroring")
+    local stopmirroringnode  = registerwhatsitnode("stopmirroring")
+
+    local function startmirroring()
+        local t = copynut(startmirroringnode)
+        nodeproperties[t] = { matrix = { -1, 0, 0, 1 } }
+        return t
+    end
+
+    local function stopmirroring()
+        local t = copynut(stopmirroringnode)
+        nodeproperties[t] = { matrix = { -1, 0, 0, 1 } }
+        return t
+    end
+
+    implement {
+        name    = "startmirroring",
+        actions = function()
+            context(tonode(startmirroring()))
+        end,
+    }
+
+    implement {
+        name    = "stopmirroring",
+        actions = function()
+            context(tonode(stopmirroring()))
+        end,
+    }
+
+    -- clip
+
+    local startclippingnode = registerwhatsitnode("startclipping")
+    local stopclippingnode  = registerwhatsitnode("stopclipping")
+
+    local function startclipping(path)
+        local t = copynut(startclippingnode)
+        nodeproperties[t] = { path = path }
+        return t
+    end
+
+    local function stopclipping()
+        return copynut(stopclippingnode)
+    end
+
+    implement {
+        name    = "startclipping",
+        actions = function()
+            context(tonode(startclipping(scanstring())))
+        end
+    }
+
+    implement {
+        name    = "stopclipping",
+        actions = function()
+            context(tonode(stopclipping()))
+        end,
+    }
+
+end
+
+-- The (delayed and immediate) write operations are emulated in \LUA\ and presented
+-- as primitives at the \TEX\ end.
+
+do
+
+    local logwriter      = logs.writer
+    local openfile       = io.open
+    local flushio        = io.flush
+    local serialize      = token.serialize
+
+    local opennode       = registerwhatsitnode("open")
+    local writenode      = registerwhatsitnode("write")
+    local closenode      = registerwhatsitnode("close")
+    local channels       = { }
+    local immediate_code = tex.flagcodes.immediate
+
+    function backends.openout(n)
+        local p = nodeproperties[n]
+        if p then
+            local handle = openfile(p.filename,"wb") or false
+            if handle then
+                channels[p.channel] = handle
+            else
+                -- error
+            end
+        end
+    end
+
+    function backends.writeout(n)
+        local p = nodeproperties[n]
+        if p then
+            local handle  = channels[p.channel]
+            local content = serialize(p.data)
+            if handle then
+                handle:write(content,"\n")
+            else
+               logwriter(content,"\n")
+            end
+        end
+    end
+
+    function backends.closeout(n)
+        local p = nodeproperties[n]
+        if p then
+            local channel = p.channel
+            local handle  = channels[channel]
+            if handle then
+                handle:close()
+                channels[channel] = false
+                flushio()
+            else
+                -- error
+            end
+        end
+    end
+
+    local function immediately(prefix)
+        return prefix and (prefix & immediate_code) ~= 0
+    end
+
+    implement {
+        name    = "openout",
+        public  = true,
+        usage   = "value",
+        actions = function(prefix)
+            local channel = scaninteger()
+            scankeyword("=") -- hack
+            local filename = scanstring()
+            if not immediately(prefix) then
+                local n = copynut(opennode)
+                nodeproperties[n] = { channel = channel, filename = filename } -- action = "open"
+                return context(tonode(n))
+            elseif not channels[channel] then
+                local handle = openfile(filename,"wb") or false
+                if handle then
+                    channels[channel] = handle
+                else
+                    -- error
+                end
+            end
+        end,
+    }
+
+    implement {
+        name    = "write",
+        public  = true,
+        usage   = "value",
+        actions = function(prefix)
+            local channel = scaninteger()
+            if not immediately(prefix) then
+                local t = scantokenlist()
+                local n = copynut(writenode)
+                nodeproperties[n] = { channel = channel, data = t } -- action = "write"
+                return context(tonode(n))
+            else
+                local content = scanstring()
+                local handle  = channels[channel]
+                if handle then
+                    handle:write(content,"\n")
+                else
+                    logwriter(content,"\n")
+                end
+            end
+        end,
+    }
+
+    implement {
+        name    = "closeout",
+        public  = true,
+        usage   = "value",
+        actions = function(prefix)
+            local channel = scaninteger()
+            if not immediately(prefix) then
+                local n = copynut(closenode)
+                nodeproperties[n] = { channel = channel } -- action = "close"
+                return context(tonode(n))
+            else
+                local handle = channels[channel]
+                if handle then
+                    handle:close()
+                    channels[channel] = false
+                    flushio()
+                else
+                    -- error
+                end
+            end
+        end,
+    }
+
+    -- why ...
+
+    local open_command  = get(token.create("openout"))
+    local write_command = get(token.create("write"))
+    local close_command = get(token.create("closeout"))
+
+end
+
+-- states: these get injected independent of grouping
+
+do
+
+    local setstatenode = registerwhatsitnode("setstate")
+
+    function nutpool.setstate(data)
+        local n = copynut(setstatenode)
+        nodeproperties[n] = { data = data }
+        return n
+    end
+
+end
+
+-- We don't support specials so we make them dummies.
+
+do
+    implement {
+        name      = "special",
+        actions   = scanstring,
+        public    = true,
+        protected = true,
+    }
+end
diff --git a/tex/context/base/mkxl/node-fin.lmt b/tex/context/base/mkxl/node-fin.lmt
index dab90863a..a9180ddb2 100644
--- a/tex/context/base/mkxl/node-fin.lmt
+++ b/tex/context/base/mkxl/node-fin.lmt
@@ -36,6 +36,7 @@ local setlist            = nuts.setlist
 local setleader          = nuts.setleader
 
 local copy_node          = nuts.copy
+local find_tail          = nuts.tail
 local insert_node_before = nuts.insert_before
 local insert_node_after  = nuts.insert_after
 
@@ -165,13 +166,15 @@ function states.finalize(namespace,attribute,head) -- is this one ok?
         if id == hlist_code or id == vlist_code then
             local content = getlist(head)
             if content then
-                local list = insert_node_before(content,content,copy_node(nsnone)) -- two return values
+--                 local list = insert_node_before(content,content,copy_node(nsnone)) -- two return values
+                local list = insert_node_after(content,find_tail(content),copy_node(nsnone)) -- two return values
                 if list ~= content then
                     setlist(head,list)
                 end
             end
         else
-            head = insert_node_before(head,head,copy_node(nsnone))
+--             head = insert_node_before(head,head,copy_node(nsnone))
+            head = insert_node_after(find_tail(head),head,copy_node(nsnone))
         end
         return head, true
     end
@@ -295,6 +298,75 @@ states.process = function(namespace,attribute,head,default)
     return process(attribute,head,default)
 end
 
+local function simple(attribute,head)
+    local check  = false
+    local leader = nil
+    for stack, id, subtype, content in nextcontent, head do
+        if id == glyph_code or id == disc_code then
+            check = true
+        elseif id == glue_code then
+            check  = true
+            leader = content
+        elseif id == hlist_code or id == vlist_code then
+            if getorientation(stack) then
+                local outer = getattr(stack,attribute)
+                if outer then
+                    if current ~= outer then
+                        if current > 0 then
+                            head = insert_node_before(head,stack,copy_node(nsnone))
+                        end
+                        head    = insert_node_before(head,stack,copy_node(nsdata[c]))
+                        current = outer
+                    end
+                elseif current > 0 then
+                    head    = insert_node_before(head,stack,copy_node(nsnone))
+                    current = 0
+                end
+            end
+            local list = simple(attribute,content)
+            if content ~= list then
+                setlist(stack,list)
+            end
+        elseif id == rule_code then
+            check = has_dimensions(stack)
+        end
+        if check then
+            local c = getattr(stack,attribute)
+            if c then
+                if current ~= c then
+                    if current > 0 then
+                        head = insert_node_before(head,stack,copy_node(nsnone))
+                    end
+                    head    = insert_node_before(head,stack,copy_node(nsdata[c]))
+                    current = c
+                end
+                if leader then
+                    local savedcurrent = current
+                    local ci = getid(leader)
+                    if ci == hlist_code or ci == vlist_code then
+                        current = 0
+                    end
+                    local list = simple(attribute,leader)
+                    if leader ~= list then
+                        setleader(stack,list)
+                    end
+                    current = savedcurrent
+                    leader = false
+                end
+            elseif current > 0 then
+                head    = insert_node_before(head,stack,copy_node(nsnone))
+                current = 0
+            end
+            check = false
+        end
+    end
+    return head
+end
+
+states.simple = function(namespace,attribute,head,default)
+    return simple(attribute,head,default)
+end
+
 -- we can force a selector, e.g. document wide color spaces, saves a little
 -- watch out, we need to check both the selector state (like colorspace) and
 -- the main state (like color), otherwise we get into troubles when a selector
diff --git a/tex/context/base/mkxl/node-ini.lmt b/tex/context/base/mkxl/node-ini.lmt
index 0fba0a4d9..4ba4b4000 100644
--- a/tex/context/base/mkxl/node-ini.lmt
+++ b/tex/context/base/mkxl/node-ini.lmt
@@ -65,31 +65,6 @@ local function simplified(t)
     return r
 end
 
-local nodecodes = simplified(node.types())
-
-local whatcodes = allocate {
-    literal     = 0x1, [0x1] = "literal",
-    latelua     = 0x2, [0x2] = "latelua",
-    userdefined = 0x3, [0x3] = "userdefined",
-    savepos     = 0x4, [0x4] = "savepos",
-    save        = 0x5, [0x5] = "save",
-    restore     = 0x6, [0x6] = "restore",
-    setmatrix   = 0x7, [0x7] = "setmatrix",
-    open        = 0x8, [0x8] = "open",
-    close       = 0x9, [0x9] = "close",
-    write       = 0xA, [0xA] = "write",
-}
-
-local usercodes = allocate {
-    [ 97] = "attribute", -- a
-    [100] = "number",    -- d
-    [102] = "float",     -- f
-    [108] = "lua",       -- l
-    [110] = "node",      -- n
-    [115] = "string",    -- s
-    [116] = "token"      -- t
-}
-
 local noadoptions = allocate {
     set      =        0x08,
     unused_1 = 0x00 + 0x08,
@@ -102,15 +77,7 @@ local noadoptions = allocate {
     right    = 0x14 + 0x08,
 }
 
-local literalvalues = allocate {
-    [0] = "origin",
-    [1] = "page",
-    [2] = "always",
-    [3] = "raw",
-    [4] = "text",
-    [5] = "font",
-    [6] = "special",
-}
+local nodecodes = simplified(node.types())
 
 gluecodes     = allocate(swapped(gluecodes,gluecodes))
 dircodes      = allocate(swapped(dircodes,dircodes))
@@ -118,7 +85,6 @@ boundarycodes = allocate(swapped(boundarycodes,boundarycodes))
 noadcodes     = allocate(swapped(noadcodes,noadcodes))
 radicalcodes  = allocate(swapped(radicalcodes,radicalcodes))
 nodecodes     = allocate(swapped(nodecodes,nodecodes))
-whatcodes     = allocate(swapped(whatcodes,whatcodes))
 listcodes     = allocate(swapped(listcodes,listcodes))
 glyphcodes    = allocate(swapped(glyphcodes,glyphcodes))
 kerncodes     = allocate(swapped(kerncodes,kerncodes))
@@ -129,18 +95,15 @@ accentcodes   = allocate(swapped(accentcodes,accentcodes))
 fencecodes    = allocate(swapped(fencecodes,fencecodes))
 parcodes      = allocate(swapped(parcodes,parcodes))
 rulecodes     = allocate(swapped(rulecodes,rulecodes))
-usercodes     = allocate(swapped(usercodes,usercodes))
 noadoptions   = allocate(swapped(noadoptions,noadoptions))
 
 dirvalues     = allocate(swapped(dirvalues,dirvalues))
-literalvalues = allocate(swapped(literalvalues,literalvalues))
 fillvalues    = allocate(swapped(fillvalues,fillvalues))
 
 nodes.gluecodes     = gluecodes
 nodes.dircodes      = dircodes
 nodes.boundarycodes = boundarycodes
 nodes.noadcodes     = noadcodes
-nodes.whatcodes     = whatcodes
 nodes.listcodes     = listcodes
 nodes.glyphcodes    = glyphcodes
 nodes.kerncodes     = kerncodes
@@ -152,13 +115,11 @@ nodes.radicalcodes  = radicalcodes
 nodes.fencecodes    = fencecodes
 nodes.parcodes      = parcodes
 nodes.rulecodes     = rulecodes
-nodes.usercodes     = usercodes
 
 nodes.noadoptions   = noadoptions
 nodes.fillvalues    = fillvalues
 nodes.fillcodes     = fillvalues -- for now
 nodes.dirvalues     = dirvalues
-nodes.literalvalues = literalvalues
 
 nodes.nodecodes     = nodecodes
 
@@ -167,7 +128,6 @@ local subtypes = allocate {
     dir       = dircodes,
     boundary  = boundarycodes,
     noad      = noadcodes,
-    whatsit   = whatcodes,
     glyph     = glyphcodes,
     kern      = kerncodes,
     penalty   = penaltycodes,
@@ -201,11 +161,9 @@ nodes.subtypes = subtypes
 
 nodes.skipcodes            = gluecodes
 nodes.directioncodes       = dircodes
-nodes.whatsitcodes         = whatcodes
 nodes.discretionarycodes   = disccodes
 
 nodes.directionvalues      = dirvalues
-nodes.literalvalues        = literalvalues
 
 glyphcodes.glyph           = glyphcodes.character
 
@@ -218,8 +176,6 @@ listcodes.column           = listcodes.alignment
 kerncodes.kerning          = kerncodes.fontkern
 kerncodes.italiccorrection = kerncodes.italiccorrection or 1 -- new
 
-literalvalues.direct       = literalvalues.always
-
 nodes.noadoptions = {
     set      =        0x08,
     unused_1 = 0x00 + 0x08,
diff --git a/tex/context/base/mkxl/node-ini.mkxl b/tex/context/base/mkxl/node-ini.mkxl
index 4de4e00b4..b3f17e041 100644
--- a/tex/context/base/mkxl/node-ini.mkxl
+++ b/tex/context/base/mkxl/node-ini.mkxl
@@ -22,6 +22,7 @@
 \registerctxluafile{node-met}{autosuffix}
 \registerctxluafile{node-nut}{autosuffix}
 \registerctxluafile{node-res}{autosuffix}
+\registerctxluafile{node-ext}{autosuffix}
 %registerctxluafile{node-ppt}{} % experimental, not used so probably useless
 \registerctxluafile{node-aux}{autosuffix}
 \registerctxluafile{node-gcm}{autosuffix}
@@ -33,11 +34,10 @@
 \registerctxluafile{node-dir}{} % experimental, not yet (and maybe never) used
 \registerctxluafile{node-pro}{autosuffix}
 \registerctxluafile{node-ser}{autosuffix}
-%registerctxluafile{node-ext}{}
 \registerctxluafile{node-acc}{autosuffix} % experimental
 %registerctxluafile{node-prp}{} % makes no sense (yet)
 \registerctxluafile{node-scn}{autosuffix}
-\registerctxluafile{node-syn}{}
+\registerctxluafile{node-syn}{autosuffix}
 \registerctxluafile{node-par}{autosuffix}
 
 %D This might go away (needs checking anyway, very old code):
diff --git a/tex/context/base/mkxl/node-res.lmt b/tex/context/base/mkxl/node-res.lmt
index 7a37b1b9e..fbb1d1fe2 100644
--- a/tex/context/base/mkxl/node-res.lmt
+++ b/tex/context/base/mkxl/node-res.lmt
@@ -6,7 +6,7 @@ if not modules then modules = { } end modules ['node-res'] = {
     license   = "see context related readme files"
 }
 
-local type, next = type, next
+local type, next, rawset = type, next, rawset
 local gmatch, format = string.gmatch, string.format
 
 --[[ldx--
@@ -21,7 +21,6 @@ local report_nodes   = logs.reporter("nodes","housekeeping")
 nodes.pool           = nodes.pool or { }
 local nodepool       = nodes.pool
 
-local whatsitcodes   = nodes.whatsitcodes
 local gluecodes      = nodes.gluecodes
 local kerncodes      = nodes.kerncodes
 local rulecodes      = nodes.rulecodes
@@ -36,7 +35,6 @@ local rule_code      = nodecodes.rule
 local kern_code      = nodecodes.kern
 local glue_code      = nodecodes.glue
 local gluespec_code  = nodecodes.gluespec
-local whatsit_code   = nodecodes.whatsit
 
 local currentfont    = font.current
 local texgetcount    = tex.getcount
@@ -45,25 +43,6 @@ local allocate       = utilities.storage.allocate
 
 local reserved       = { }
 local nofreserved    = 0
-local userids        = allocate()
-local lastid         = 0
-
-setmetatable(userids, {
-    __index = function(t,k)
-        if type(k) == "string" then
-            lastid = lastid + 1
-            rawset(userids,lastid,k)
-            rawset(userids,k,lastid)
-            return lastid
-        else
-            rawset(userids,k,k)
-            return k
-        end
-    end,
-    __call = function(t,k)
-        return t[k]
-    end
-} )
 
 -- nuts overload
 
@@ -149,10 +128,7 @@ local function register_node(n)
     return n
 end
 
-nodepool.userids  = userids
 nodepool.register = register_node
-
-nutpool.userids   = userids
 nutpool.register  = register_node -- could be register_nut
 
 -- so far
@@ -168,11 +144,6 @@ local glyph             = register_nut(new_nut(glyph_code,0))
 
 local textdir           = register_nut(new_nut(nodecodes.dir))
 
-local latelua           = register_nut(new_nut(whatsit_code,whatsitcodes.latelua))
-local savepos           = register_nut(new_nut(whatsit_code,whatsitcodes.savepos))
-
-local user_node         = new_nut(whatsit_code,whatsitcodes.userdefined)
-
 local left_margin_kern  = register_nut(new_nut(kern_code,kerncodes.leftmargincode))
 local right_margin_kern = register_nut(new_nut(kern_code,kerncodes.rightmargincode))
 
@@ -414,16 +385,6 @@ function nutpool.leader(width,list)
     return n
 end
 
-function nutpool.savepos()
-    return copy_nut(savepos)
-end
-
-function nutpool.latelua(code)
-    local n = copy_nut(latelua)
-    nodeproperties[n] = { data = code }
-    return n
-end
-
 function nutpool.leftmarginkern(glyph,width)
     local n = copy_nut(left_margin_kern)
     if not glyph then
diff --git a/tex/context/base/mkxl/node-syn.lmt b/tex/context/base/mkxl/node-syn.lmt
new file mode 100644
index 000000000..ce5f0d2dd
--- /dev/null
+++ b/tex/context/base/mkxl/node-syn.lmt
@@ -0,0 +1,782 @@
+if not modules then modules = { } end modules ['node-syn'] = {
+    version   = 1.001,
+    comment   = "companion to node-ini.mkiv",
+    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
+    copyright = "PRAGMA ADE / ConTeXt Development Team",
+    license   = "see context related readme files"
+}
+
+-- Because we have these fields in some node that are used by synctex, and because
+-- some users seem to like that feature, I decided to implement a variant that might
+-- work out better for ConTeXt. This is experimental code. I don't use it myself so
+-- it will take a while to mature. There will be some helpers that one can use in
+-- more complex situations like included xml files. Currently (somewhere else) we
+-- take care of valid files, that is: we prohibit access to files in the tree
+-- because we don't want users to mess up styles.
+--
+-- It is unclear how the output gets interpreted but by reverse engineering (and
+-- stripping) the file generated by generic synctex, I got there eventually. For
+-- instance, we only need to be able to go back to a place where text is entered,
+-- but still we need all that redundant box wrapping. Anyway, I was able to get a
+-- minimal output and cross my fingers that the parser used in editors is not
+-- changed in fundamental ways.
+--
+-- I only tested SumatraPDF with SciTE, for which one needs to configure in the
+-- viewer:
+--
+--   InverseSearchCmdLine = c:\data\system\scite\wscite\scite.exe "%f" "-goto:%l" $
+--
+-- In fact, a way more powerful implementation would have been not to add a library
+-- to a viewer, but letthe viewer call an external program:
+--
+--   InverseSearchCmdLine = mtxrun.exe --script synctex --edit --name="%f" --line="%l" $
+--
+-- which would (re)launch the editor in the right spot. That way we can really
+-- tune well to the macro package used and also avoid the fuzzy heuristics of
+-- the library.
+--
+-- Unfortunately syntex always removes the files at the end and not at the start
+-- (this happens in synctexterminate) so we need to work around that by using an
+-- intermediate file. This is no big deal in context (which has a runner) but
+-- definitely not nice.
+--
+-- The visualizer code is only needed for testing so we don't use fancy colors or
+-- provide more detail. After all we're only interested in rendered source text
+-- anyway. We try to play safe which sometimes means that we'd better no go
+-- somewhere than go someplace wrong.
+--
+-- A previous version had a mode for exporting boxes and such but I removed that
+-- as it made no sense. Also, collecting output in a table was not faster than
+-- directly piping to the file, probably because the amount is not that large. We
+-- keep some left-overs commented.
+--
+-- A significate reduction in file size can be realized when reusing the same
+-- values. Actually that triggered the current approach in ConTeXt. In the latest
+-- synctex parser vertical positions can be repeated by an "=" sign but for some
+-- reason only for that field. It's probably trivial to do that for all of "w h d v
+-- h" but it currently not the case so I'll delay that till all are supported. (We
+-- could benefit a lot from such a repetition scheme but not much from a "v" alone
+-- which -alas- indicates that synctex is still mostly a latex targeted story.)
+--
+-- It's kind of hard to fight the parser because it really wants to go to some file
+-- but maybe some day I can figure it out. Some untagged text (in the pdf) somehow
+-- gets seen as part of the last box. Anonymous content is simply not part of the
+-- concept. Using a dummy name doesn't help either as the editor gets a signal to
+-- open that dummy. Even an empty filename doesn't work.
+--
+-- We output really simple and compact code, like:
+--
+-- SyncTeX Version:1
+-- Input:1:e:/tmp/oeps.tex
+-- Input:2:c:/data/develop/context/sources/klein.tex
+-- Output:pdf
+-- Magnification:1000
+-- Unit:1
+-- X Offset:0
+-- Y Offset:0
+-- Content:
+-- !160
+-- {1
+-- h0,0:0,0,0,0,0
+-- v0,0:0,55380990:39158276,55380990,0
+-- h2,1:4661756,9176901:27969941,655360,327680
+-- h2,2:4661756,10125967:26048041,655360,327680
+-- h2,3:30962888,10125967:1668809,655360,327680
+-- h2,3:4661756,11075033:23142527,655360,327680
+-- h2,4:28046650,11075033:4585047,655360,327680
+-- h2,4:4661756,12024099:22913954,655360,327680
+-- h2,5:27908377,12024099:4723320,655360,327680
+-- h2,5:4661756,12973165:22918783,655360,327680
+-- h2,6:27884864,12973165:4746833,655360,327680
+-- h2,6:4661756,13922231:18320732,655360,327680
+-- ]
+-- !533
+-- }1
+-- Input:3:c:/data/develop/context/sources/ward.tex
+-- !57
+-- {2
+-- h0,0:0,0,0,0,0
+-- v0,0:0,55380990:39158276,55380990,0
+-- h3,1:4661756,9176901:18813145,655360,327680
+-- h3,2:23713999,9176901:8917698,655360,327680
+-- h3,2:4661756,10125967:10512978,655360,327680
+-- h3,3:15457206,10125967:17174491,655360,327680
+-- h3,3:4661756,11075033:3571223,655360,327680
+-- h3,4:8459505,11075033:19885281,655360,327680
+-- h3,5:28571312,11075033:4060385,655360,327680
+-- h3,5:4661756,12024099:15344870,655360,327680
+-- ]
+-- !441
+-- }2
+-- !8
+-- Postamble:
+-- Count:22
+-- !23
+-- Post scriptum:
+--
+-- But for some reason, when the pdf file has some extra content (like page numbers)
+-- the main document is consulted. Bah. It would be nice to have a mode for *only*
+-- looking at marked areas. It somehow works not but maybe depends on the parser.
+--
+-- Supporting reuseable objects makes not much sense as these are often graphics or
+-- ornamental. They can not have hyperlinks etc (at least not without some hackery
+-- which I'm not willing to do) so basically they are sort of useless for text.
+--
+-- Some generic (more clever code) has been removed as I don't see things change
+-- that much.
+
+local type, rawset = type, rawset
+local concat = table.concat
+local formatters = string.formatters
+local replacesuffix, suffixonly, nameonly = file.replacesuffix, file.suffix, file.nameonly
+local openfile, renamefile, removefile = io.open, os.rename, os.remove
+
+local report_system = logs.reporter("system")
+
+local tex                = tex
+local texget             = tex.get
+
+local nuts               = nodes.nuts
+
+local getid              = nuts.getid
+local getlist            = nuts.getlist
+local setlist            = nuts.setlist
+local getnext            = nuts.getnext
+local getwhd             = nuts.getwhd
+local getwidth           = nuts.getwidth
+local getsubtype         = nuts.getsubtype
+
+local nodecodes          = nodes.nodecodes
+local kerncodes          = nodes.kerncodes
+
+local glyph_code         = nodecodes.glyph
+local disc_code          = nodecodes.disc
+local glue_code          = nodecodes.glue
+local penalty_code       = nodecodes.penalty
+local kern_code          = nodecodes.kern
+----- rule_code          = nodecodes.rule
+local hlist_code         = nodecodes.hlist
+local vlist_code         = nodecodes.vlist
+local dir_code           = nodecodes.dir
+local fontkern_code      = kerncodes.fontkern
+
+local cancel_code        = nodes.dircodes.cancel
+
+local insert_before      = nuts.insert_before
+local insert_after       = nuts.insert_after
+
+local nodepool           = nuts.pool
+local new_latelua        = nodepool.latelua
+local new_rule           = nodepool.rule
+local new_kern           = nodepool.kern
+
+local getdimensions      = nuts.dimensions
+local getrangedimensions = nuts.rangedimensions
+
+local getsynctexfields   = nuts.getsynctexfields or nuts.get_synctex_fields
+local forcesynctextag    = tex.forcesynctextag   or tex.force_synctex_tag
+local forcesynctexline   = tex.forcesynctexline  or tex.force_synctex_line
+local getsynctexline     = tex.getsynctexline    or tex.get_synctex_line
+local setsynctexmode     = tex.setsynctexmode    or tex.set_synctex_mode
+
+local foundintree        = resolvers.foundintree
+
+local getpagedimensions  = layouts.getpagedimensions
+
+local eol                = "\010"
+
+----- f_glue             = formatters["g%i,%i:%i,%i\010"]
+----- f_glyph            = formatters["x%i,%i:%i,%i\010"]
+----- f_kern             = formatters["k%i,%i:%i,%i:%i\010"]
+----- f_rule             = formatters["r%i,%i:%i,%i:%i,%i,%i\010"]
+----- f_form             = formatters["f%i,%i,%i\010"]
+local z_hlist            = "[0,0:0,0:0,0,0\010"
+local z_vlist            = "(0,0:0,0:0,0,0\010"
+----- z_xform            = "<0,0:0,0,0\010" -- or so
+local s_hlist            = "]\010"
+local s_vlist            = ")\010"
+----- s_xform            = ">\010"
+local f_hlist_1          = formatters["h%i,%i:%i,%i:%i,%i,%i\010"]
+local f_hlist_2          = formatters["h%i,%i:%i,%s:%i,%i,%i\010"]
+local f_vlist_1          = formatters["v%i,%i:%i,%i:%i,%i,%i\010"]
+local f_vlist_2          = formatters["v%i,%i:%i,%s:%i,%i,%i\010"]
+
+local synctex            = luatex.synctex or { }
+luatex.synctex           = synctex
+
+local getpos ; getpos = function() getpos = job.positions.getpos return getpos() end
+
+-- status stuff
+
+local enabled = false
+local paused  = 0
+local used    = false
+local never   = false
+
+-- the file name stuff
+
+local noftags            = 0
+local stnums             = { }
+local nofblocked         = 0
+local blockedfilenames   = { }
+local blockedsuffixes    = {
+    mkii = true,
+    mkiv = true,
+    mkvi = true,
+    mkxl = true,
+    mklx = true,
+    mkix = true,
+    mkxi = true,
+ -- lfg  = true,
+}
+
+local sttags = table.setmetatableindex(function(t,name)
+    if blockedsuffixes[suffixonly(name)] then
+        -- Just so that I don't get the ones on my development tree.
+        nofblocked = nofblocked + 1
+        return 0
+    elseif blockedfilenames[nameonly(name)] then
+        -- So we can block specific files.
+        nofblocked = nofblocked + 1
+        return 0
+    elseif foundintree(name) then
+        -- One shouldn't edit styles etc this way.
+        nofblocked = nofblocked + 1
+        return 0
+    else
+        noftags = noftags + 1
+        t[name] = noftags
+        stnums[noftags] = name
+        return noftags
+    end
+end)
+
+function synctex.blockfilename(name)
+    blockedfilenames[nameonly(name)] = name
+end
+
+function synctex.setfilename(name,line)
+    if paused == 0 and name then
+        forcesynctextag(sttags[name])
+        if line then
+            forcesynctexline(line)
+        end
+    end
+end
+
+function synctex.resetfilename()
+    if paused == 0 then
+        forcesynctextag(0)
+        forcesynctexline(0)
+    end
+end
+
+do
+
+    local nesting = 0
+    local ignored = false
+
+    function synctex.pushline()
+        nesting = nesting + 1
+        if nesting == 1 then
+            local l = getsynctexline()
+            ignored = l and l > 0
+            if not ignored then
+                forcesynctexline(texget("inputlineno"))
+            end
+        end
+    end
+
+    function synctex.popline()
+        if nesting == 1 then
+            if not ignored then
+                forcesynctexline()
+                ignored = false
+            end
+        end
+        nesting = nesting - 1
+    end
+
+end
+
+-- the node stuff
+
+local filehandle = nil
+local nofsheets  = 0
+local nofobjects = 0
+local last       = 0
+local filesdone  = 0
+local tmpfile    = false
+local logfile    = false
+
+local function writeanchor()
+    local size = filehandle:seek("end")
+    filehandle:write("!",size-last,eol)
+    last = size
+end
+
+local function writefiles()
+    local total = #stnums
+    if filesdone < total then
+        for i=filesdone+1,total do
+            filehandle:write("Input:",i,":",stnums[i],eol)
+        end
+        filesdone = total
+    end
+end
+
+local function makenames()
+    logfile = replacesuffix(tex.jobname,"synctex")
+    tmpfile = replacesuffix(logfile,"syncctx")
+end
+
+local function flushpreamble()
+    makenames()
+    filehandle = openfile(tmpfile,"wb")
+    if filehandle then
+        filehandle:write("SyncTeX Version:1",eol)
+        writefiles()
+        filehandle:write("Output:pdf",eol)
+        filehandle:write("Magnification:1000",eol)
+        filehandle:write("Unit:1",eol)
+        filehandle:write("X Offset:0",eol)
+        filehandle:write("Y Offset:0",eol)
+        filehandle:write("Content:",eol)
+        flushpreamble = function()
+            writefiles()
+            return filehandle
+        end
+    else
+        enabled = false
+    end
+    return filehandle
+end
+
+function synctex.wrapup()
+    if tmpfile then
+        renamefile(tmpfile,logfile)
+        tmpfile = nil
+    end
+end
+
+local function flushpostamble()
+    if not filehandle then
+        return
+    end
+    writeanchor()
+    filehandle:write("Postamble:",eol)
+    filehandle:write("Count:",nofobjects,eol)
+    writeanchor()
+    filehandle:write("Post scriptum:",eol)
+    filehandle:close()
+    enabled = false
+end
+
+local x_hlist  do
+
+    local function doaction_1(t,l,w,h,d)
+        local pagewidth, pageheight = getpagedimensions()
+        local x, y = getpos()
+        filehandle:write(f_hlist_1(t,l,x,pageheight-y,w,h,d))
+        nofobjects = nofobjects + 1
+    end
+
+    local lasty = false
+
+    local function doaction_2(t,l,w,h,d)
+        local pagewidth, pageheight = getpagedimensions()
+        local x, y = getpos()
+        y = pageheight - y
+        filehandle:write(f_hlist_2(t,l,x,y == lasty and "=" or y,w,h,d))
+        lasty = y
+        nofobjects = nofobjects + 1
+    end
+
+    local doaction = doaction_1
+
+    x_hlist = function(head,current,t,l,w,h,d)
+        if filehandle then
+            return insert_before(head,current,new_latelua(function() doaction(t,l,w,h,d) end))
+        else
+            return head
+        end
+    end
+
+    directives.register("system.synctex.compression", function(v)
+        doaction = tonumber(v) == 2 and doaction_2 or doaction_1
+    end)
+
+end
+
+-- color is already handled so no colors
+
+local collect     = nil
+local fulltrace   = false
+local trace       = false
+local height      = 10 * 65536
+local depth       =  5 * 65536
+local traceheight =      32768
+local tracedepth  =      32768
+
+trackers.register("system.synctex.visualize", function(v)
+    trace     = v
+    fulltrace = v == "real"
+end)
+
+local function inject(head,first,last,tag,line)
+    local w, h, d = getdimensions(first,getnext(last))
+    if h < height then
+        h = height
+    end
+    if d < depth then
+        d = depth
+    end
+    if trace then
+        head = insert_before(head,first,new_rule(w,fulltrace and h or traceheight,fulltrace and d or tracedepth))
+        head = insert_before(head,first,new_kern(-w))
+    end
+    head = x_hlist(head,first,tag,line,w,h,d)
+    return head
+end
+
+local function collect_min(head)
+    local current = head
+    while current do
+        local id = getid(current)
+        if id == glyph_code then
+            local first = current
+            local last  = current
+            local tag   = 0
+            local line  = 0
+            while true do
+                if id == glyph_code then
+                    local tc, lc = getsynctexfields(current)
+                    if tc and tc > 0 then
+                        tag  = tc
+                        line = lc
+                    end
+                    last = current
+                elseif id == disc_code or (id == kern_code and getsubtype(current) == fontkern_code) then
+                    last = current
+                else
+                    if tag > 0 then
+                        head = inject(head,first,last,tag,line)
+                    end
+                    break
+                end
+                current = getnext(current)
+                if current then
+                    id = getid(current)
+                else
+                    if tag > 0 then
+                        head = inject(head,first,last,tag,line)
+                    end
+                    return head
+                end
+            end
+        end
+        -- pick up (as id can have changed)
+        if id == hlist_code or id == vlist_code then
+            local list = getlist(current)
+            if list then
+                local l = collect(list)
+                if l ~= list then
+                    setlist(current,l)
+                end
+            end
+        end
+        current = getnext(current)
+    end
+    return head
+end
+
+local function inject(parent,head,first,last,tag,line)
+    local w, h, d = getrangedimensions(parent,first,getnext(last))
+    if h < height then
+        h = height
+    end
+    if d < depth then
+        d = depth
+    end
+    if trace then
+        head = insert_before(head,first,new_rule(w,fulltrace and h or traceheight,fulltrace and d or tracedepth))
+        head = insert_before(head,first,new_kern(-w))
+    end
+    head = x_hlist(head,first,tag,line,w,h,d)
+    return head
+end
+
+local function collect_max(head,parent)
+    local current = head
+    while current do
+        local id = getid(current)
+        if id == glyph_code then
+            local first = current
+            local last  = current
+            local tag   = 0
+            local line  = 0
+            while true do
+                if id == glyph_code then
+                    local tc, lc = getsynctexfields(current)
+                    if tc and tc > 0 then
+                        if tag > 0 and (tag ~= tc or line ~= lc) then
+                            head  = inject(parent,head,first,last,tag,line)
+                            first = current
+                        end
+                        tag  = tc
+                        line = lc
+                        last = current
+                    else
+                        if tag > 0 then
+                            head = inject(parent,head,first,last,tag,line)
+                            tag  = 0
+                        end
+                        first = nil
+                        last  = nil
+                    end
+                elseif id == disc_code then
+                    if not first then
+                        first = current
+                    end
+                    last = current
+                elseif id == kern_code and getsubtype(current) == fontkern_code then
+                    if first then
+                        last = current
+                    end
+                elseif id == glue_code then
+                    if tag > 0 then
+                        local tc, lc = getsynctexfields(current)
+                        if tc and tc > 0 then
+                            if tag ~= tc or line ~= lc then
+                                head = inject(parent,head,first,last,tag,line)
+                                tag  = 0
+                                break
+                            end
+                        else
+                            head = inject(parent,head,first,last,tag,line)
+                            tag  = 0
+                            break
+                        end
+                    else
+                        tag = 0
+                        break
+                    end
+                    id = nil -- so no test later on
+                elseif id == penalty_code then
+                    -- go on (and be nice for math)
+                else
+                    if tag > 0 then
+                        head = inject(parent,head,first,last,tag,line)
+                        tag  = 0
+                    end
+                    break
+                end
+                current = getnext(current)
+                if current then
+                    id = getid(current)
+                else
+                    if tag > 0 then
+                        head = inject(parent,head,first,last,tag,line)
+                    end
+                    return head
+                end
+            end
+        end
+        -- pick up (as id can have changed)
+        if id == hlist_code or id == vlist_code then
+            local list = getlist(current)
+            if list then
+                local l = collect(list,current)
+                if l and l ~= list then
+                    setlist(current,l)
+                end
+            end
+        end
+        current = getnext(current)
+    end
+    return head
+end
+
+collect = collect_max
+
+function synctex.collect(head,where)
+    if enabled and where ~= "object" then
+        return collect(head,head)
+    else
+        return head
+    end
+end
+
+-- also no solution for bad first file resolving in sumatra
+
+function synctex.start()
+    if enabled then
+        nofsheets = nofsheets + 1 -- could be realpageno
+        if flushpreamble() then
+            writeanchor()
+            filehandle:write("{",nofsheets,eol)
+            -- this seems to work:
+            local pagewidth, pageheight = getpagedimensions()
+            filehandle:write(z_hlist)
+            filehandle:write(f_vlist_1(0,0,0,pageheight,pagewidth,pageheight,0))
+        end
+    end
+end
+
+function synctex.stop()
+    if enabled then
+     -- filehandle:write(s_vlist,s_hlist)
+        filehandle:write(s_hlist)
+        writeanchor()
+        filehandle:write("}",nofsheets,eol)
+        nofobjects = nofobjects + 2
+    end
+end
+
+local enablers  = { }
+local disablers = { }
+
+function synctex.registerenabler(f)
+    enablers[#enablers+1] = f
+end
+
+function synctex.registerdisabler(f)
+    disablers[#disablers+1] = f
+end
+
+function synctex.enable()
+    if not never and not enabled then
+        enabled = true
+        setsynctexmode(3) -- we want details
+        if not used then
+            nodes.tasks.enableaction("shipouts","luatex.synctex.collect")
+            report_system("synctex functionality is enabled, expect 5-10 pct runtime overhead!")
+            used = true
+        end
+        for i=1,#enablers do
+            enablers[i](true)
+        end
+    end
+end
+
+function synctex.disable()
+    if enabled then
+        setsynctexmode(0)
+        report_system("synctex functionality is disabled!")
+        enabled = false
+        for i=1,#disablers do
+            disablers[i](false)
+        end
+    end
+end
+
+function synctex.finish()
+    if enabled then
+        flushpostamble()
+    else
+        makenames()
+        removefile(logfile)
+        removefile(tmpfile)
+    end
+end
+
+local filename = nil
+
+function synctex.pause()
+    paused = paused + 1
+    if enabled and paused == 1 then
+        setsynctexmode(0)
+    end
+end
+
+function synctex.resume()
+    if enabled and paused == 1 then
+        setsynctexmode(3)
+    end
+    paused = paused - 1
+end
+
+-- not the best place
+
+luatex.registerstopactions(synctex.finish)
+
+statistics.register("synctex tracing",function()
+    if used then
+        return string.format("%i referenced files, %i files ignored, %i objects flushed, logfile: %s",
+            noftags,nofblocked,nofobjects,logfile)
+    end
+end)
+
+local implement = interfaces.implement
+local variables = interfaces.variables
+
+function synctex.setup(t)
+    if t.state == variables.never then
+        synctex.disable() -- just in case
+        never = true
+        return
+    end
+    if t.method == variables.max then
+        collect = collect_max
+    else
+        collect = collect_min
+    end
+    if t.state == variables.start then
+        synctex.enable()
+    else
+        synctex.disable()
+    end
+end
+
+implement {
+    name      = "synctexblockfilename",
+    arguments = "string",
+    actions   = synctex.blockfilename,
+}
+
+implement {
+    name      = "synctexsetfilename",
+    arguments = "string",
+    actions   = synctex.setfilename,
+}
+
+implement {
+    name      = "synctexresetfilename",
+    actions   = synctex.resetfilename,
+}
+
+implement {
+    name      = "setupsynctex",
+    actions   = synctex.setup,
+    arguments = {
+        {
+            { "state" },
+            { "method" },
+        },
+    },
+}
+
+implement {
+    name    = "synctexpause",
+    actions = synctex.pause,
+}
+
+implement {
+    name    = "synctexresume",
+    actions = synctex.resume,
+}
+
+implement {
+    name    = "synctexpushline",
+    actions = synctex.pushline,
+}
+
+implement {
+    name    = "synctexpopline",
+    actions = synctex.popline,
+}
+
+implement {
+    name    = "synctexdisable",
+    actions = synctex.disable,
+}
diff --git a/tex/context/base/mkxl/node-tra.lmt b/tex/context/base/mkxl/node-tra.lmt
index da3cb1d33..6060522be 100644
--- a/tex/context/base/mkxl/node-tra.lmt
+++ b/tex/context/base/mkxl/node-tra.lmt
@@ -704,7 +704,7 @@ table.setmetatableindex(nodestracerpool,function(t,k,v)
     return v
 end)
 
-function nutstracerpool.rule(w,h,d,c,s) -- so some day we can consider using literals (speedup)
+function nutstracerpool.rule(w,h,d,c,s)
     return setproperties(new_rule(w,h,d),c,s)
 end
 
diff --git a/tex/context/base/mkxl/page-lin.lmt b/tex/context/base/mkxl/page-lin.lmt
index 9ea502899..f50031ab3 100644
--- a/tex/context/base/mkxl/page-lin.lmt
+++ b/tex/context/base/mkxl/page-lin.lmt
@@ -192,7 +192,7 @@ local function resolve(n,m) -- we can now check the 'line' flag (todo)
         if content then
             if id == hlist_code then
                 for current, subtype in nextwhatsit, content do
-                    if subtype == latelua_code then
+                    if subtype == latelua_code then            -- this has to change!
                         local a = getattr(current,a_linereference)
                         if a then
                             cross_references[a] = m
diff --git a/tex/context/base/mkxl/scrn-pag.lmt b/tex/context/base/mkxl/scrn-pag.lmt
new file mode 100644
index 000000000..210a57707
--- /dev/null
+++ b/tex/context/base/mkxl/scrn-pag.lmt
@@ -0,0 +1,56 @@
+if not modules then modules = { } end modules ['scrn-pag'] = {
+    version   = 1.001,
+    comment   = "companion to scrn-pag.mkiv",
+    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
+    copyright = "PRAGMA ADE / ConTeXt Development Team",
+    license   = "see context related readme files"
+}
+
+interactions         = interactions or { }
+interactions.pages   = interactions.pages or { }
+local pages          = interactions.pages
+
+local implement      = interfaces.implement
+
+pages.setupcanvas    = layouts.setupcanvas
+
+local codeinjections = backends.codeinjections
+
+function pages.setpagetransition(specification)
+    codeinjections.setpagetransition(specification)
+end
+
+implement {
+    name      = "setupcanvas",
+    actions   = pages.setupcanvas,
+    arguments = {
+        {
+            { "mode" },
+            { "singlesided", "boolean" },
+            { "doublesided", "boolean" },
+            { "leftoffset", "dimen" },
+            { "topoffset", "dimen" },
+            { "width", "dimen" },
+            { "height", "dimen" },
+            { "paperwidth", "dimen" },
+            { "paperheight", "dimen" },
+            { "cropoffset", "dimen" },
+            { "bleedoffset", "dimen" },
+            { "artoffset", "dimen" },
+            { "trimoffset", "dimen" },
+            { "copies", "integer" },
+            { "print", "string" }, -- , tohash
+        }
+    }
+}
+
+implement {
+    name      = "setpagetransition",
+    actions   = pages.setpagetransition,
+    arguments = {
+        {
+            { "n" },
+            { "delay", "integer" },
+        }
+    }
+}
diff --git a/tex/context/base/mkxl/scrn-pag.mklx b/tex/context/base/mkxl/scrn-pag.mklx
index 80e16f63d..67e24178e 100644
--- a/tex/context/base/mkxl/scrn-pag.mklx
+++ b/tex/context/base/mkxl/scrn-pag.mklx
@@ -15,7 +15,7 @@
 
 \writestatus{loading}{ConTeXt Screen Macros / Pages}
 
-\registerctxluafile{scrn-pag}{}
+\registerctxluafile{scrn-pag}{autosuffix}
 
 \unprotect
 
diff --git a/tex/context/base/mkxl/spac-hor.mkxl b/tex/context/base/mkxl/spac-hor.mkxl
index 426580c7d..13d1f9021 100644
--- a/tex/context/base/mkxl/spac-hor.mkxl
+++ b/tex/context/base/mkxl/spac-hor.mkxl
@@ -677,6 +677,29 @@
 \newskip       \s_spac_narrower_right_last
 \newconditional\s_spac_narrower_last_swap
 
+% \def\spac_narrower_start_apply#1%
+%   {\narrowerparameter\c!before
+%    \global\s_spac_narrower_left  \zeropoint
+%    \global\s_spac_narrower_right \zeropoint
+%    \global\s_spac_narrower_middle\zeropoint
+%    \edef\askednarrower{#1}%
+%    \ifx\askednarrower\v!reverse
+%      \ifconditional\s_spac_narrower_last_swap
+%        \leftskip \s_spac_narrower_right_last
+%        \rightskip\s_spac_narrower_left_last
+%        \setfalse\s_spac_narrower_last_swap
+%      \else
+%        \leftskip \s_spac_narrower_left_last
+%        \rightskip\s_spac_narrower_right_last
+%        \settrue\s_spac_narrower_last_swap
+%      \fi
+%    \else
+%      \normalexpanded{\processcommalistwithparameters[\askednarrower]}\spac_narrower_initialize
+%      \advance\leftskip \dimexpr\s_spac_narrower_left +\s_spac_narrower_middle\relax
+%      \advance\rightskip\dimexpr\s_spac_narrower_right+\s_spac_narrower_middle\relax
+%    \fi
+%    \seteffectivehsize}
+
 \def\spac_narrower_start_apply#1%
   {\narrowerparameter\c!before
    \global\s_spac_narrower_left  \zeropoint
@@ -685,18 +708,18 @@
    \edef\askednarrower{#1}%
    \ifx\askednarrower\v!reverse
      \ifconditional\s_spac_narrower_last_swap
-       \leftskip \s_spac_narrower_right_last
-       \rightskip\s_spac_narrower_left_last
+       \frozen\leftskip \s_spac_narrower_right_last
+       \frozen\rightskip\s_spac_narrower_left_last
        \setfalse\s_spac_narrower_last_swap
      \else
-       \leftskip \s_spac_narrower_left_last
-       \rightskip\s_spac_narrower_right_last
+       \frozen\leftskip \s_spac_narrower_left_last
+       \frozen\rightskip\s_spac_narrower_right_last
        \settrue\s_spac_narrower_last_swap
      \fi
    \else
      \normalexpanded{\processcommalistwithparameters[\askednarrower]}\spac_narrower_initialize
-     \advance\leftskip \dimexpr\s_spac_narrower_left +\s_spac_narrower_middle\relax
-     \advance\rightskip\dimexpr\s_spac_narrower_right+\s_spac_narrower_middle\relax
+     \frozen\advance\leftskip \dimexpr\s_spac_narrower_left +\s_spac_narrower_middle\relax
+     \frozen\advance\rightskip\dimexpr\s_spac_narrower_right+\s_spac_narrower_middle\relax
    \fi
    \seteffectivehsize}
 
diff --git a/tex/context/base/mkxl/strc-reg.mkxl b/tex/context/base/mkxl/strc-reg.mkxl
index af98ca481..dcfdd0946 100644
--- a/tex/context/base/mkxl/strc-reg.mkxl
+++ b/tex/context/base/mkxl/strc-reg.mkxl
@@ -40,6 +40,20 @@
 %  \index[pageclass::]   {textclass::entry}
 %  \index[pageclass::key]{textclass::entry}
 
+% nice example:
+%
+% \setupregister[index]
+%     [n=1,
+%      pageleft=\hfilll,
+%      pageright=\frozen\parfillleftskip 0pt plus 1fill\frozen\parfillrightskip 0pt\par]
+%
+% \starttext
+%
+% {\showmakeup \placeindex \page}
+%
+% % \dorecurse{10}{\dontleavehmode \index{AAA}\page}
+% \dorecurse{100}{\dontleavehmode\index{AAA}\page}
+
 % tzt variant with n entries, parameters and userdata (altnum)
 
 \installcorenamespace{register}
diff --git a/tex/context/base/mkxl/trac-vis.lmt b/tex/context/base/mkxl/trac-vis.lmt
index 8c04a0372..6e9bd8e8c 100644
--- a/tex/context/base/mkxl/trac-vis.lmt
+++ b/tex/context/base/mkxl/trac-vis.lmt
@@ -595,17 +595,28 @@ local whatsit do
     local w_cache      = caches["whatsit"]
 
     local tags         = {
-        open        = "OPN",
-        write       = "WRI",
-        close       = "CLS",
-        special     = "SPE",
-        latelua     = "LUA",
-        savepos     = "POS",
-        userdefined = "USR",
-        literal     = "LIT",
-        setmatrix   = "MAT",
-        save        = "SAV",
-        restore     = "RES",
+        [whatsitcodes.open]           = "OPN",
+        [whatsitcodes.write]          = "WRI",
+        [whatsitcodes.close]          = "CLS",
+     -- [whatsitcodes.special]        = "SPE",
+        [whatsitcodes.latelua]        = "LUA",
+        [whatsitcodes.savepos]        = "POS",
+        [whatsitcodes.userdefined]    = "USR",
+        [whatsitcodes.literal]        = "LIT",
+        [whatsitcodes.setmatrix]      = "MAT",
+        [whatsitcodes.save]           = "SAV",
+        [whatsitcodes.restore]        = "RES",
+        [whatsitcodes.startscaling]   = "+SCA",
+        [whatsitcodes.stopscaling]    = "-SCA",
+        [whatsitcodes.startrotation]  = "+ROT",
+        [whatsitcodes.stoprotation]   = "-ROT",
+        [whatsitcodes.startmirroring] = "+MIR",
+        [whatsitcodes.stopmirroring]  = "-MIR",
+        [whatsitcodes.startclipping]  = "+CLP",
+        [whatsitcodes.stopclipping]   = "-CLP",
+        [whatsitcodes.startmatrix]    = "+MAT",
+        [whatsitcodes.stopmatrix]     = "-MAT",
+        [whatsitcodes.setstate]       = "SET",   -- can't happen because these are added after visualizing
     }
 
     whatsit = function(head,current)
@@ -614,7 +625,7 @@ local whatsit do
         if info then
             -- print("hit whatsit")
         else
-            info = sometext(formatters["W:%s"](what),usedfont,nil,c_white)
+            info = sometext(formatters["W:%s"](tags[what] or what),usedfont,nil,c_white)
             setattr(info,a_layer,l_whatsit)
             w_cache[what] = info
         end
@@ -880,20 +891,13 @@ local ruledglyph do
             setboth(current)
             local linewidth = emwidth/(2*fraction)
             local x_offset, y_offset, l_margin, r_margin, raise = getoffsets(current)
-            wd = wd - l_margin - r_margin
-            local info = (dp == 0 and outlinerule and outlinerule(wd,ht,dp,linewidth)) or userrule {
+            local info = setlink((dp == 0 and outlinerule and outlinerule(wd,ht,dp,linewidth)) or userrule {
                 width  = wd,
                 height = ht,
                 depth  = dp,
                 line   = linewidth,
                 type   = "box",
-            }
-            if l_margin == 0 then
-                info = setlink(info,new_kern(-wd))
-            else
-                info = setlink(new_kern(-l_margin),info,new_kern(-wd+l_margin))
-            end
-            --
+            },new_kern(-wd))
             local c, f = isglyph(current)
             local char = chardata[f][c]
             if char and type(char.unicode) == "table" then -- hackery test
@@ -1409,7 +1413,7 @@ do
                     trace_marginkern    = band(a,0x100000) ~= 0
                     trace_mathlistkern  = band(a,0x200000) ~= 0
                     trace_dir           = band(a,0x400000) ~= 0
-                    trace_whatsit       = band(a,0x800000) ~= 0
+                    trace_par           = band(a,0x800000) ~= 0
                 end
             elseif a == unsetvalue then
                 goto list
diff --git a/tex/context/base/mkxl/typo-cap.lmt b/tex/context/base/mkxl/typo-cap.lmt
index dbf6950c8..67acb2535 100644
--- a/tex/context/base/mkxl/typo-cap.lmt
+++ b/tex/context/base/mkxl/typo-cap.lmt
@@ -11,7 +11,7 @@ if not modules then modules = { } end modules ['typo-cap'] = {
 
 local next, type, tonumber = next, type, tonumber
 local format, insert = string.format, table.insert
-local div, getrandom = math.div, utilities.randomizer.get
+local div, getrandom, random = math.div, utilities.randomizer.get, math.random
 
 local trace_casing = false  trackers.register("typesetters.casing", function(v) trace_casing = v end)
 
@@ -435,3 +435,24 @@ interfaces.implement {
     actions   = cases.set,
     arguments = { "argument" }
 }
+
+-- An example of a special plug, see type-imp-punk for usage.
+
+cases.register("randomvariant", function(start)
+    local char, fnt = isglyph(start)
+    local data = fontchar[fnt][char]
+    if data then
+        local variants = data.variants
+        if variants then
+            local n = #variants
+            local i = getrandom("variant",1,n+1)
+            if i > n then
+                -- we keep the original
+            else
+                setchar(start,variants[i])
+            end
+            return start, true
+        end
+    end
+    return start, false
+end)
diff --git a/tex/context/fonts/mkiv/bonum-math.lfg b/tex/context/fonts/mkiv/bonum-math.lfg
index 8dfa63405..51ca2d7f1 100644
--- a/tex/context/fonts/mkiv/bonum-math.lfg
+++ b/tex/context/fonts/mkiv/bonum-math.lfg
@@ -1,5 +1,8 @@
-local kern_200 = { bottomright = { { kern = -200 } } }
-local kern_100 = { bottomright = { { kern = -100 } } }
+local kern_V   = { bottomright = { { kern = -200 } } }
+local kern_W   = { bottomright = { { kern = -100 } } }
+local offset_f = { xoffset = "llx" }
+
+-- Beware of updates in ssty slots!
 
 return {
     name = "bonum-math",
@@ -10,12 +13,21 @@ return {
     mathematics = {
         dimensions = {
             default = {
-                [0x1D453] = { xoffset = "llx" },-- �
+             -- [0x1D453]     = offset_f, -- �
+             -- ["1:0x1D453"] = offset_f, -- needed for compact
+             -- ["2:0x1D453"] = offset_f, -- needed for compact
+                ["*:0x1D453"] = offset_f, -- �
             },
         },
         kerns = {
-            [0x1D449] = kern_200, -- �
-            [0x1D44A] = kern_100, -- �
+         -- [0x1D449]     = kern_V, -- �
+         -- ["1:0x1D449"] = kern_V, -- needed for compact
+         -- ["2:0x1D449"] = kern_V, -- needed for compact
+         -- [0x1D44A]     = kern_W, -- �
+         -- ["1:0x1D44A"] = kern_W, -- needed for compact
+         -- ["2:0x1D44A"] = kern_W, -- needed for compact
+            ["*:0x1D449"] = kern_V, -- �
+            ["*:0x1D44A"] = kern_W, -- �
         },
         alternates = {
             dotless = { feature = 'dtls', value = 1, comment = "Mathematical Dotless Forms" },
diff --git a/tex/context/fonts/mkiv/dejavu-math.lfg b/tex/context/fonts/mkiv/dejavu-math.lfg
index d28c69060..608b396f8 100644
--- a/tex/context/fonts/mkiv/dejavu-math.lfg
+++ b/tex/context/fonts/mkiv/dejavu-math.lfg
@@ -1,4 +1,7 @@
-local kern_250 = { bottomright = { { kern = -250 } } }
+local kern_V = { bottomright = { { kern = -250 } } }
+local kern_W = kern_W
+
+-- Beware of updates in ssty slots!
 
 return {
     name = "dejavu-math",
@@ -8,8 +11,14 @@ return {
     copyright = "ConTeXt development team",
     mathematics = {
         kerns = {
-            [0x1D449] = kern_250, --
-            [0x1D44A] = kern_250, -- �
+         -- [0x1D449]     = kern_V, -- �
+         -- ["1:0x1D449"] = kern_V, -- needed for compact
+         -- ["2:0x1D449"] = kern_V, -- needed for compact
+         -- [0x1D44A]     = kern_W, -- �
+         -- ["1:0x1D44A"] = kern_W, -- needed for compact
+         -- ["2:0x1D44A"] = kern_W, -- needed for compact
+            ["*:0x1D449"] = kern_V, -- �
+            ["*:0x1D44A"] = kern_W, -- �
         },
         alternates = {
             dotless = { feature = 'dtls', value = 1, comment = "Mathematical Dotless Forms" },
diff --git a/tex/context/fonts/mkiv/minion-math.lfg b/tex/context/fonts/mkiv/minion-math.lfg
index a4f539ec7..863836c1c 100644
--- a/tex/context/fonts/mkiv/minion-math.lfg
+++ b/tex/context/fonts/mkiv/minion-math.lfg
@@ -1,6 +1,5 @@
-local kern_100 = { bottomright = { { kern = -100 } } }
-local kern_150 = { bottomright = { { kern = -150 } } }
-local kern_200 = { bottomright = { { kern = -200 } } }
+local kern_W = { bottomright = { { kern = -150 } } }
+local kern_V = { bottomright = { { kern = -200 } } }
 
 return {
     name = "minion-math",
@@ -23,8 +22,9 @@ return {
     },
     mathematics = {
         kerns = {
-            [0x1D449] = kern_200, -- �
-            [0x1D44A] = kern_150, -- �
+            [0x1D449] = kern_V, -- �
+            [0x1D44A] = kern_W, -- �
+            -- todo: ssty 1/2
         },
     },
 }
diff --git a/tex/context/fonts/mkiv/pagella-math.lfg b/tex/context/fonts/mkiv/pagella-math.lfg
index c85ff3f6b..d4ae14162 100644
--- a/tex/context/fonts/mkiv/pagella-math.lfg
+++ b/tex/context/fonts/mkiv/pagella-math.lfg
@@ -1,7 +1,8 @@
-local kern_200 = { bottomright = { { kern = -200 } } }
-local kern_100 = { bottomright = { { kern = -100 } } }
+local kern_V   = { bottomright = { { kern = -200 } } }
+local kern_W   = { bottomright = { { kern = -100 } } }
+local offset_f = { xoffset = "llx" }
 
--- Beware of updates !
+-- Beware of updates in ssty slots!
 
 return {
     name = "pagella-math",
@@ -12,13 +13,22 @@ return {
     mathematics = {
         dimensions = {
             default = {
-             -- [0x1D453] = { xoffset = 162, width = 278 + 162 },-- �
-                [0x1D453] = { xoffset = "llx" },-- �
+             -- [0x1D453]     = { xoffset = 162, width = 278 + 162 },-- �
+             -- [0x1D453]     = offset_f, -- �
+             -- ["1:0x1D453"] = offset_f, -- needed for compact
+             -- ["2:0x1D453"] = offset_f, -- needed for compact
+                ["*:0x1D453"] = offset_f, -- �
             },
         },
         kerns = {
-            [0x1D449] = kern_200, -- �
-            [0x1D44A] = kern_100, -- �
+         -- [0x1D449]     = kern_V, -- �
+         -- ["1:0x1D449"] = kern_V, -- needed for compact
+         -- ["2:0x1D449"] = kern_V, -- needed for compact
+         -- [0x1D44A]     = kern_W, -- �
+         -- ["1:0x1D44A"] = kern_W, -- needed for compact
+         -- ["2:0x1D44A"] = kern_W, -- needed for compact
+            ["*:0x1D449"] = kern_V, -- �
+            ["*:0x1D44A"] = kern_W, -- �
         },
         alternates = {
             dotless = { feature = 'dtls', value = 1, comment = "Mathematical Dotless Forms" },
diff --git a/tex/context/fonts/mkiv/schola-math.lfg b/tex/context/fonts/mkiv/schola-math.lfg
index 9787c18a9..b60bc6d99 100644
--- a/tex/context/fonts/mkiv/schola-math.lfg
+++ b/tex/context/fonts/mkiv/schola-math.lfg
@@ -1,5 +1,7 @@
-local kern_200_050 = { bottomright = { { kern = -200 } }, topright = { { kern = 50 } } }
-local kern_100_050 = { bottomright = { { kern = -100 } }, topright = { { kern = 50 } } }
+local kern_V = { bottomright = { { kern = -200 } }, topright = { { kern = 50 } } }
+local kern_W = { bottomright = { { kern = -100 } }, topright = { { kern = 50 } } }
+
+-- Beware of updates in ssty slots!
 
 return {
     name = "schola-math",
@@ -9,8 +11,14 @@ return {
     copyright = "ConTeXt development team",
     mathematics = {
         kerns = {
-            [0x1D449] = kern_200_050, --
-            [0x1D44A] = kern_100_050, -- �
+         -- [0x1D449]     = kern_V, -- �
+         -- ["1:0x1D449"] = kern_V, -- needed for compact
+         -- ["2:0x1D449"] = kern_V, -- needed for compact
+         -- [0x1D44A]     = kern_W, -- �
+         -- ["1:0x1D44A"] = kern_W, -- needed for compact
+         -- ["2:0x1D44A"] = kern_W, -- needed for compact
+            ["*:0x1D449"] = kern_V, -- �
+            ["*:0x1D44A"] = kern_W, -- �
         },
         alternates = {
             dotless = { feature = 'dtls', value = 1, comment = "Mathematical Dotless Forms" },
diff --git a/tex/context/fonts/mkiv/termes-math.lfg b/tex/context/fonts/mkiv/termes-math.lfg
index 1501fd536..3cf8685eb 100644
--- a/tex/context/fonts/mkiv/termes-math.lfg
+++ b/tex/context/fonts/mkiv/termes-math.lfg
@@ -1,5 +1,8 @@
-local kern_200 = { bottomright = { { kern = -200 } } }
-local kern_100 = { bottomright = { { kern = -100 } } }
+local kern_V   = { bottomright = { { kern = -200 } } }
+local kern_W   = { bottomright = { { kern = -100 } } }
+local offset_f = { xoffset = "llx" }
+
+-- Beware of updates in ssty slots!
 
 return {
     name = "termes-math",
@@ -10,12 +13,21 @@ return {
     mathematics = {
         dimensions = {
             default = {
-                [0x1D453] = { xoffset = "llx" },-- �
+             -- [0x1D453]     = offset_f, -- �
+             -- ["1:0x1D453"] = offset_f, -- needed for compact
+             -- ["2:0x1D453"] = offset_f, -- needed for compact
+                ["*:0x1D453"] = offset_f, -- �
             },
         },
         kerns = {
-            [0x1D449] = kern_200, -- �
-            [0x1D44A] = kern_100, -- �
+         -- [0x1D449]     = kern_V, -- �
+         -- ["1:0x1D449"] = kern_V, -- needed for compact
+         -- ["2:0x1D449"] = kern_V, -- needed for compact
+         -- [0x1D44A]     = kern_W, -- �
+         -- ["1:0x1D44A"] = kern_W, -- needed for compact
+         -- ["2:0x1D44A"] = kern_W, -- needed for compact
+            ["*:0x1D449"] = kern_V, -- �
+            ["*:0x1D44A"] = kern_W, -- �
         },
         alternates = {
             dotless = { feature = 'dtls', value = 1, comment = "Mathematical Dotless Forms" },
diff --git a/tex/context/fonts/mkiv/type-imp-punk.mkxl b/tex/context/fonts/mkiv/type-imp-punk.mkxl
new file mode 100644
index 000000000..aa01a1d4e
--- /dev/null
+++ b/tex/context/fonts/mkiv/type-imp-punk.mkxl
@@ -0,0 +1,54 @@
+%D \module
+%D   [       file=type-imp-punk,
+%D        version=2020.01.17,
+%D          title=\CONTEXT\ Typescript Macros,
+%D       subtitle=Punk Again,
+%D         author=Hans Hagen,
+%D           date=\currentdate,
+%D      copyright={PRAGMA ADE \& \CONTEXT\ Development Team}]
+%C
+%C This module is part of the \CONTEXT\ macro||package and is
+%C therefore copyrighted by \PRAGMA. See mreadme.pdf for
+%C details.
+
+%D Yet another look at punk.
+
+\ifdefined\enablerandomvariants\else
+    \useMPlibrary[punk]
+\fi
+
+\doifelse {\truefontname{Serif}} {unknown} {
+    \writestatus{fonts}{you need to load a base bodyfont first}
+    \endinput
+} {
+    % we're ok
+}
+
+\starttypescriptcollection[punk]
+
+    \definefontfeature [punk]            [metapost={category=punk,preroll=punkpreroll}]
+    \definefontfeature [punkrandom]      [metapost={category=punk,preroll=punkpreroll,variants=5}]
+    \definefontfeature [punkbold]        [metapost={category=punk,preroll=punkpreroll,weight=2}]
+    \definefontfeature [punkslanted]     [metapost={category=punk,preroll=punkpreroll,slant=.15}]
+    \definefontfeature [punkboldslanted] [metapost={category=punk,preroll=punkpreroll,slant=.15,weight=2}]
+    \definefontfeature [punkveryslanted] [metapost={category=punk,preroll=punkpreroll,slant=-.15}]
+    \definefontfeature [punksqueezed]    [metapost={category=punk,preroll=punkpreroll,squeeze=.5}]
+    \definefontfeature [punkextended]    [metapost={category=punk,preroll=punkpreroll,extend=1.3}]
+
+    \definefontsynonym [punkbase]        [\truefontname{Serif}]
+
+    \starttypescript [\s!serif] [punk]
+        \definefontsynonym [\s!Serif]           [punkbase] [\s!features=punk]
+        \definefontsynonym [\s!SerifSlanted]    [punkbase] [\s!features=punkslanted]
+        \definefontsynonym [\s!SerifBold]       [punkbase] [\s!features=punkbold]
+        \definefontsynonym [\s!SerifBoldSlanted][punkbase] [\s!features=punkboldslanted]
+        \definefontsynonym [\s!SerifItalic]     [\s!SerifSlanted]
+        \definefontsynonym [\s!SerifBoldItalic] [\s!SerifBoldSlanted]
+    \stoptypescript
+
+    \starttypescript [punk]
+        \definetypeface [punk] [\s!rm] [\s!serif] [punk] [\s!default]
+    \stoptypescript
+
+\stoptypescriptcollection
+
diff --git a/tex/context/fonts/mkiv/type-imp-texgyre.mkiv b/tex/context/fonts/mkiv/type-imp-texgyre.mkiv
index d10fe505f..72d3b3588 100644
--- a/tex/context/fonts/mkiv/type-imp-texgyre.mkiv
+++ b/tex/context/fonts/mkiv/type-imp-texgyre.mkiv
@@ -247,8 +247,8 @@
         \starttypescript [\s!math][times,termes][\s!all]
           % \loadfontgoodies[texgyre]
           % \definefontsynonym[\s!MathRoman][file:texgyre-termes-math-regular.otf][\s!features={\s!math\mathsizesuffix,mathextra},\s!goodies=texgyre]
-            \definefontsynonym[\s!MathRoman]    [file:texgyretermes-math.otf][\s!features={\s!math\mathsizesuffix,oldmath,mathextra},\s!goodies=termes-math]
-            \definefontsynonym[\s!MathRomanBold][file:texgyretermes-math.otf][\s!features={\s!math\mathsizesuffix,oldmath,termes-math-bold,mathextra},\s!goodies=termes-math]
+            \definefontsynonym[\s!MathRoman]    [file:texgyretermes-math.otf][\s!features={\s!math\mathsizesuffix,mathextra},\s!goodies=termes-math]
+            \definefontsynonym[\s!MathRomanBold][file:texgyretermes-math.otf][\s!features={\s!math\mathsizesuffix,termes-math-bold,mathextra},\s!goodies=termes-math]
         \stoptypescript
 
     \stoptypescriptcollection
@@ -276,8 +276,8 @@
         \starttypescript [\s!math][palatino,pagella][\s!all]
           % \loadfontgoodies[texgyre]
           % \definefontsynonym[\s!MathRoman][file:texgyre-pagella-math-regular.otf][\s!features={\s!math\mathsizesuffix,mathextra},\s!goodies=texgyre]
-            \definefontsynonym[\s!MathRoman]    [file:texgyrepagella-math.otf][\s!features={\s!math\mathsizesuffix,oldmath,mathextra},\s!goodies=pagella-math]
-            \definefontsynonym[\s!MathRomanBold][file:texgyrepagella-math.otf][\s!features={\s!math\mathsizesuffix,oldmath,pagella-math-bold,mathextra},\s!goodies=pagella-math]
+            \definefontsynonym[\s!MathRoman]    [file:texgyrepagella-math.otf][\s!features={\s!math\mathsizesuffix,mathextra},\s!goodies=pagella-math]
+            \definefontsynonym[\s!MathRomanBold][file:texgyrepagella-math.otf][\s!features={\s!math\mathsizesuffix,pagella-math-bold,mathextra},\s!goodies=pagella-math]
         \stoptypescript
 
     \stoptypescriptcollection
@@ -289,8 +289,8 @@
     \starttypescript [\s!math][bookman,bonum][\s!all]
       % \loadfontgoodies[texgyre]
       % \definefontsynonym[\s!MathRoman][file:texgyre-bonum-math-regular.otf][\s!features={\s!math\mathsizesuffix,mathextra},\s!goodies=texgyre]
-        \definefontsynonym[\s!MathRoman]    [file:texgyrebonum-math.otf][\s!features={\s!math\mathsizesuffix,oldmath,mathextra},\s!goodies=bonum-math]
-        \definefontsynonym[\s!MathRomanBold][file:texgyrebonum-math.otf][\s!features={\s!math\mathsizesuffix,oldmath,bonum-math-bold,mathextra},\s!goodies=bonum-math]
+        \definefontsynonym[\s!MathRoman]    [file:texgyrebonum-math.otf][\s!features={\s!math\mathsizesuffix,mathextra},\s!goodies=bonum-math]
+        \definefontsynonym[\s!MathRomanBold][file:texgyrebonum-math.otf][\s!features={\s!math\mathsizesuffix,bonum-math-bold,mathextra},\s!goodies=bonum-math]
     \stoptypescript
 
 \stoptypescriptcollection
@@ -300,8 +300,8 @@
     \starttypescript [\s!math][schoolbook,schola][\s!all]
       % \loadfontgoodies[texgyre]
       % \definefontsynonym[\s!MathRoman][file:texgyre-schola-math-regular.otf][\s!features={\s!math\mathsizesuffix,mathextra},\s!goodies=texgyre]
-        \definefontsynonym[\s!MathRoman]    [file:texgyreschola-math.otf][\s!features={\s!math\mathsizesuffix,oldmath,mathextra},\s!goodies=schola-math]
-        \definefontsynonym[\s!MathRomanBold][file:texgyreschola-math.otf][\s!features={\s!math\mathsizesuffix,oldmath,schola-math-bold,mathextra},\s!goodies=schola-math]
+        \definefontsynonym[\s!MathRoman]    [file:texgyreschola-math.otf][\s!features={\s!math\mathsizesuffix,mathextra},\s!goodies=schola-math]
+        \definefontsynonym[\s!MathRomanBold][file:texgyreschola-math.otf][\s!features={\s!math\mathsizesuffix,schola-math-bold,mathextra},\s!goodies=schola-math]
     \stoptypescript
 
 \stoptypescriptcollection
diff --git a/tex/context/fonts/mkiv/xits-math.lfg b/tex/context/fonts/mkiv/xits-math.lfg
index b37ab1277..88d3a8d45 100644
--- a/tex/context/fonts/mkiv/xits-math.lfg
+++ b/tex/context/fonts/mkiv/xits-math.lfg
@@ -14,6 +14,7 @@ local italics = {
      -- [0x1D44E] = 0.99,    -- a (fraction of quad)
      -- [0x1D44F] = 100,     -- b (font points)
         [0x1D453] = -0.0375, -- f
+        -- todo: ssty 1/2
     }
 }
 
diff --git a/tex/context/modules/mkiv/m-punk.mkiv b/tex/context/modules/mkiv/m-punk.mkiv
index 47f1a0177..9eb7411ba 100644
--- a/tex/context/modules/mkiv/m-punk.mkiv
+++ b/tex/context/modules/mkiv/m-punk.mkiv
@@ -17,6 +17,11 @@
 %D https://www.youtube.com/watch?v=g5c2Htj8Vtw
 %D \stoptyping
 
+\ifcase\contextlmtxmode\else
+    \writestatus{punk}{use metapost library punk instead}
+    \endinput
+\fi
+
 \startluacode
 local concat   = table.concat
 local round    = math.round
diff --git a/tex/generic/context/luatex/luatex-fonts-merged.lua b/tex/generic/context/luatex/luatex-fonts-merged.lua
index c1300a71b..552559e96 100644
--- a/tex/generic/context/luatex/luatex-fonts-merged.lua
+++ b/tex/generic/context/luatex/luatex-fonts-merged.lua
@@ -1,6 +1,6 @@
 -- merged file : c:/data/develop/context/sources/luatex-fonts-merged.lua
 -- parent file : c:/data/develop/context/sources/luatex-fonts.lua
--- merge date  : 2021-01-11 16:28
+-- merge date  : 2021-01-17 21:39
 
 do -- begin closure to overcome local limits and interference