diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/check/BasicRascalConfig.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/check/BasicRascalConfig.rsc
index b40457b4752..8c24cd390c4 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/check/BasicRascalConfig.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/check/BasicRascalConfig.rsc
@@ -177,10 +177,10 @@ bool isValidRascalTplVersion(str version)
 
 str getCurrentRascalTplVersion() = currentRascalTplVersion;
 
-str currentRascalTplVersion = "2.0.0";
+str currentRascalTplVersion = "3.0.0";
 
 data TModel (
-    str rascalTplVersion = "2.0.0"
+    str rascalTplVersion = "3.0.0"
 );
 
 // Define alias for TypePalConfig
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/check/CollectDataDeclaration.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/check/CollectDataDeclaration.rsc
index e260fa90d25..15e75acc00a 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/check/CollectDataDeclaration.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/check/CollectDataDeclaration.rsc
@@ -69,7 +69,7 @@ void dataDeclaration(Tags tags, Declaration current, list[Variant] variants, Col
     dt = isEmpty(typeParameters) ? defType(aadt(adtName, [], dataSyntax()))
                                  : defType(typeParameters, AType(Solver s) { return aadt(adtName, [ s.getType(tp)[closed=true] | tp <- typeParameters], dataSyntax()); });
     
-    dt.md5 = md5Hash("<adtName><dataCounter>");
+    dt.md5 = normalizedMD5Hash(adtName, dataCounter);
     dataCounter += 1;
     if(!isEmpty(commonKeywordParameterList)) dt.commonKeywordFields = commonKeywordParameterList;
     c.define(adtName, dataId(), current, dt);
@@ -141,7 +141,7 @@ void collect(current:(Variant) `<Name name> ( <{TypeArg ","}* arguments> <Keywor
                 declaredFieldNames += fieldName;
                 fieldType = ta.\type;
                 dt = defType([fieldType], makeFieldType(fieldName, fieldType));
-                dt.md5 = md5Hash("<currentModuleName><adtName><name><unparseNoLayout(current)>");
+                dt.md5 = normalizedMD5Hash(currentModuleName, adtName, name, current);
                 c.define(fieldName, fieldId(), ta.name, dt);
             }
         }
@@ -152,21 +152,20 @@ void collect(current:(Variant) `<Name name> ( <{TypeArg ","}* arguments> <Keywor
             declaredFieldNames += fieldName;
             kwfType = kwf.\type;
             dt = defType([kwfType], makeKeywordFieldType(fieldName, kwf));
-            dt.md5 = md5Hash("<currentModuleName><adtName><dataCounter><name><consArity><kwfType><fieldName>");
+            dt.md5 = normalizedMD5Hash(currentModuleName, adtName, dataCounter, name, consArity, kwfType, fieldName);
             c.define(fieldName, keywordFieldId(), kwf.name, dt);  
         }
     
         scope = c.getScope();
         c.enterScope(current);
             args = "<for(arg <- arguments){><arg is named ? "<arg.\type> <arg.name>" : "<arg>"> <}>";
-            md5Contrib = "<currentModuleName><adtName><dataCounter><name>( <args>)";
             c.defineInScope(adtParentScope, prettyPrintName(name), constructorId(), name, defType(adt + formals + kwFormals + commonKwFormals,
                 AType(Solver s){
                     adtType = s.getType(adt);
                     kwFormalTypes = [kwField(s.getType(kwf.\type)[alabel=prettyPrintName(kwf.name)], prettyPrintName(kwf.name), currentModuleName, kwf.expression) | kwf <- kwFormals /*+ commonKwFormals*/];
                     formalTypes = [f is named ? s.getType(f)[alabel=prettyPrintName(f.name)] : s.getType(f) | f <- formals];
                     return acons(adtType, formalTypes, kwFormalTypes)[alabel=asUnqualifiedName(prettyPrintName(name))];
-                })[md5 = md5Hash(md5Contrib)]);
+                })[md5 = normalizedMD5Hash(currentModuleName, adtName, dataCounter, name, args)]);
             c.fact(current, name);
             beginUseTypeParameters(c, closed=false);
                  // The standard rules would declare arguments and kwFormals as variableId();
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/check/CollectDeclaration.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/check/CollectDeclaration.rsc
index da9e32c7837..d71b84ca302 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/check/CollectDeclaration.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/check/CollectDeclaration.rsc
@@ -169,7 +169,7 @@ void collect(current: (Declaration) `<Tags tags> <Visibility visibility> <Type v
             c.enterLubScope(var);
             dt = defType([varType], makeGetSyntaxType(varType));
             dt.vis = getVis(current.visibility, privateVis());
-            dt.md5 = md5Hash("<md5Contrib4Tags(tags)><visibility><varType><var.name>");
+            dt.md5 = normalizedMD5Hash(md5Contrib4Tags(tags), visibility, varType, var.name);
             if(!isEmpty(tagsMap)) dt.tags = tagsMap;
             vname = prettyPrintName(var.name);
             if(isWildCard(vname)){
@@ -217,7 +217,7 @@ void collect(current: (Declaration) `<Tags tags> <Visibility visibility> anno <T
 
     dt = defType([annoType, onType], AType(Solver s) { return aanno(pname, s.getType(onType), s.getType(annoType)); });
     dt.vis = getVis(current.visibility, publicVis());
-    dt.md5 = md5Hash("<md5Contrib4Tags(tags)><visibility><annoType><onType><name>");
+    dt.md5 = normalizedMD5Hash(md5Contrib4Tags(tags), visibility, annoType, onType, name);
     if(!isEmpty(tagsMap)) dt.tags = tagsMap;
     // if(isWildCard(pname)){
     //     c.report(error(name, "Annotation names starting with `_` are deprecated; only allowed to suppress warning on unused variables"));
@@ -236,7 +236,7 @@ void collect(current: (KeywordFormal) `<Type kwType> <Name name> = <Expression e
     } catch TypeUnavailable(): {
          dt = defType([kwType], makeFieldType(kwformalName, kwType));
     }
-    dt.md5 = md5Hash(unparseNoLayout(current));
+    dt.md5 = normalizedMD5Hash(current);
     c.define(kwformalName, keywordFormalId(), current, dt);
     c.calculate("keyword formal", current, [kwType, expression],
         AType(Solver s){
@@ -277,7 +277,7 @@ void collect(current: (FunctionDeclaration) `<FunctionDeclaration decl>`, Collec
     for(FunctionDeclaration outerFun <- fstk){
         allSignatures += md5Contrib4signature(outerFun.signature);
     }
-    md5Contrib = "<md5Contrib4Tags(decl.tags)><decl.visibility><allSignatures>";
+    md5Contrib = [md5Contrib4Tags(decl.tags), decl.visibility, allSignatures];
     if(size(fstk) > 1){
         localFunctionCounter += 1;
         md5Contrib += "-<localFunctionCounter>";
@@ -419,7 +419,7 @@ void collect(current: (FunctionDeclaration) `<FunctionDeclaration decl>`, Collec
 
         endUseBoundedTypeParameters(c);
 
-        dt.md5 = md5Hash(md5Contrib);
+        dt.md5 = normalizedMD5Hash(md5Contrib);
         c.defineInScope(parentScope, prettyPrintName(fname), functionId(), current, dt);
     c.leaveScope(decl);
     c.pop(currentFunction);
@@ -719,7 +719,7 @@ void collect (current: (Declaration) `<Tags tags> <Visibility visibility> alias
     //     c.report(warning(name, "Alias names starting with `_` are deprecated; only allowed to suppress warning on unused variables"));
     // }
 
-    c.define(aliasName, aliasId(), current, defType([base], AType(Solver s) { return s.getType(base); })[md5 = md5Hash("<md5Contrib4Tags(tags)><visibility><name><base>")]);
+    c.define(aliasName, aliasId(), current, defType([base], AType(Solver s) { return s.getType(base); })[md5 = normalizedMD5Hash(md5Contrib4Tags(tags), visibility, name, base)]);
     c.enterScope(current);
         collect(tags, base, c);
     c.leaveScope(current);
@@ -754,7 +754,7 @@ void collect (current: (Declaration) `<Tags tags> <Visibility visibility> alias
         }
 
         return aalias(aliasName, params, s.getType(base));
-    })[md5 = md5Hash("<md5Contrib4Tags(tags)><visibility><name><parameters><base>")]);
+    })[md5 = normalizedMD5Hash(md5Contrib4Tags(tags), visibility, name, parameters, base)]);
 
     collect(tags, c);
 
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/check/CollectSyntaxDeclaration.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/check/CollectSyntaxDeclaration.rsc
index 6a474472b4e..eeeff2b1d47 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/check/CollectSyntaxDeclaration.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/check/CollectSyntaxDeclaration.rsc
@@ -78,7 +78,7 @@ void declareSyntax(SyntaxDefinition current, SyntaxRole syntaxRole, IdRole idRol
 
         dt = defType(/*current is language && current.\start is present ? \start(nonterminalType) : */nonterminalType);
         dt.vis = vis;
-        dt.md5 = md5Hash("<current is language ? "<current.\start>" : ""><adtName><syndefCounter><unparseNoLayout(defined)>");
+        dt.md5 = normalizedMD5Hash(current is language ? "<current.\start>" : "", adtName, syndefCounter, defined);
         syndefCounter += 1;
 
         // Define the syntax symbol itself and all labelled alternatives as constructors
@@ -199,7 +199,7 @@ void collect(current: (Prod) `<ProdModifier* modifiers> <Name name> : <Sym* syms
                     //def = \start(sdef) := def ? sdef : unset(def, "alabel");
                     return acons(def, fields, [], alabel=unescape("<name>"));
                  } else throw "Unexpected type of production: <ptype>";
-            })[md5=md5Hash("<adt><unparseNoLayout(current)>")]);
+            })[md5=normalizedMD5Hash(adt, current)]);
         beginUseTypeParameters(c,closed=true);
             c.push(currentAlternative, <adt, "<name>", syms>);
                 collect(symbols, c);
@@ -271,7 +271,7 @@ void collect(current: (Prod) `<Prod lhs> | <Prod rhs>`,  Collector c){
         c.pop(inAlternative);
         if(isEmpty(c.getStack(inAlternative))){
             nalternatives += 1;
-              c.define("alternative-<nalternatives>", nonterminalId(), current, defType(current)[md5=md5Hash(unparseNoLayout(current))]);
+              c.define("alternative-<nalternatives>", nonterminalId(), current, defType(current)[md5=normalizedMD5Hash(current)]);
         }
     } else {
         throw "collect alt: currentAdt not found";
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/check/CollectType.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/check/CollectType.rsc
index 3bbdd3d0af9..06fe3f669a4 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/check/CollectType.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/check/CollectType.rsc
@@ -510,8 +510,6 @@ void collect(current:(Sym) `<Nonterminal n>`, Collector c){
     //c.fact(current, n);
 }
 
-str md5ContribSym(Nonterminal n) = "<n>";
-
 void collect(current:(Sym) `& <Nonterminal n>`, Collector c){
     pname = prettyPrintName("<n>");
 
@@ -536,9 +534,6 @@ void collect(current:(Sym) `& <Nonterminal n>`, Collector c){
     c.fact(current, aparameter(prettyPrintName("<n>"),treeType,closed=true));
 }
 
-str md5ContribSym((Sym) `& <Nonterminal n>`)
-    = "R<n>";
-
 void collect(current:(Sym) `<Nonterminal n>[ <{Sym ","}+ parameters> ]`, Collector c){
     params = [p | p <- parameters];
     c.use(n, syntaxRoles);
@@ -556,9 +551,6 @@ void collect(current:(Sym) `<Nonterminal n>[ <{Sym ","}+ parameters> ]`, Collect
     endDefineOrReuseTypeParameters(c);
 }
 
-str md5ContribSym((Sym) `<Nonterminal n>[ <{Sym ","}+ parameters> ]`)
-    = "<n><for(p <- parameters){><md5ContribSym(p)><}>";
-
 void collect(current:(Sym) `start [ <Nonterminal n> ]`, Collector c){
     c.use(n, syntaxRoles);
     c.calculate("start <n>", current, [n],
@@ -570,16 +562,11 @@ void collect(current:(Sym) `start [ <Nonterminal n> ]`, Collector c){
     collect(n, c);
 }
 
-str unparseNoLayout(Tree t){
-    s = "<t>";
-    return "<for(int i <- [0..size(s)]){><s[i] in {" ", "\t", "\n"} ? "" : s[i]><}>";
-}
-
 void collect(current:(Sym) `<Sym symbol> <NonterminalLabel n>`, Collector c){
     un = unescape("<n>");
-    md5Contrib = "";
+    md5Contrib = [];
     if(!isEmpty(c.getStack(currentAlternative)) && <SyntaxDefinition adt, str cname, syms> := c.top(currentAlternative)){
-        md5Contrib += "<adt.defined><cname><unparseNoLayout(syms)>";
+        md5Contrib += [adt.defined, cname, syms];
     } else {
         throw "Cannot compute md5 for <current>";
     }
@@ -589,15 +576,12 @@ void collect(current:(Sym) `<Sym symbol> <NonterminalLabel n>`, Collector c){
         AType(Solver s){
             res = s.getType(symbol)[alabel=un];
           return res;
-        })[md5=md5Hash("<md5Contrib><unparseNoLayout(current)>")]);
+        })[md5=normalizedMD5Hash([*md5Contrib, current])]);
 
     c.fact(current, n);
     collect(symbol, c);
 }
 
-str md5ContribSym((Sym) `<Sym symbol> <NonterminalLabel n>`)
-    = "<md5ContribSym(symbol)><unescape("<n>")>";
-
 // ---- literals
 
 void collect(current:(Sym) `<Class cc>`, Collector c){
@@ -644,9 +628,6 @@ void collect(current:(Sym) `<Sym symbol>+`, Collector c){
     collect(symbol, c);
 }
 
-str md5ContribSym((Sym) `<Sym symbol>+`)
-    = "<md5ContribSym(symbol)>PLUS";
-
 void collect(current:(Sym) `<Sym symbol>*`, Collector c) {
     if(isIterSym(symbol)) c.report(warning(current, "Nested iteration"));
     isLexical = isLexicalContext(c);
@@ -658,9 +639,6 @@ void collect(current:(Sym) `<Sym symbol>*`, Collector c) {
     collect(symbol, c);
 }
 
-str md5ContribSym((Sym) `<Sym symbol>*`)
-    = "<md5ContribSym(symbol)>STAR";
-
 void collect(current:(Sym) `{ <Sym symbol> <Sym sep> }+`, Collector c){
     if(isIterSym(symbol)) c.report(warning(current, "Nested iteration"));
     isLexical = isLexicalContext(c);
@@ -675,11 +653,6 @@ void collect(current:(Sym) `{ <Sym symbol> <Sym sep> }+`, Collector c){
     collect(symbol, sep, c);
 }
 
-str md5ContribSym((Sym) `{ <Sym symbol> <Sym sep> }+`){
-    res = "LC<md5ContribSym(symbol)><md5ContribSym(sep)>RCPLUS";
-    return res;
-}
-
 void collect(current:(Sym) `{ <Sym symbol> <Sym sep> }*`, Collector c){
     if(isIterSym(symbol)) c.report(warning(current, "Nested iteration"));
     isLexical = isLexicalContext(c);
@@ -694,11 +667,6 @@ void collect(current:(Sym) `{ <Sym symbol> <Sym sep> }*`, Collector c){
     collect(symbol, sep, c);
 }
 
-str md5ContribSym((Sym) `{ <Sym symbol> <Sym sep> }*`){
-    res = "LC<md5ContribSym(symbol)><md5ContribSym(sep)>RCSTAR";
-    return res;
-}
-
 void validateSeparators(Tree current, list[AType] separators, Solver s){
     if(all(sep <- separators, isLayoutAType(sep)))
         s.report(warning(current, "At least one element of separators should be non-layout")); // TODO make error
@@ -716,18 +684,12 @@ void collect(current:(Sym) `<Sym symbol>?`, Collector c){
     collect(symbol, c);
 }
 
-str md5ContribSym((Sym) `<Sym symbol>?`)
-    = "<md5ContribSym(symbol)>QUEST";
-
 void collect(current:(Sym) `( <Sym first> | <{Sym "|"}+ alternatives> )`, Collector c){
     alts = first + [alt | alt <- alternatives];
     c.calculate("alternative", current, alts, AType(Solver s) { return AType::alt({s.getType(alt) | alt <- alts}); });
     collect(alts, c);
 }
 
-str md5ContribSym((Sym) `( <Sym first> | <{Sym "|"}+ alternatives> )`)
-    = "L<md5ContribSym(first)><for(a <- alternatives){><md5ContribSym(a)><}>R";
-
 void collect(current:(Sym) `( <Sym first> <Sym+ sequence> )`, Collector c){
     seqs = first + [seq | seq <- sequence];
     c.calculate("sequence", current, seqs,
@@ -739,16 +701,10 @@ void collect(current:(Sym) `( <Sym first> <Sym+ sequence> )`, Collector c){
     collect(seqs, c);
 }
 
-str md5ContribSym((Sym) `( <Sym first> <Sym+ sequence> )`)
-    = "L<md5ContribSym(first)><for(s <- sequence){><md5ContribSym(s)><}>R";
-
 void collect(current:(Sym) `()`, Collector c){
     c.fact(current, AType::aempty());
 }
 
-str md5ContribSym((Sym) `()`)
-    = "LR";
-
 // ---- conditionals
 
 void collect(current:(Sym) `<Sym symbol> @ <IntegerLiteral column>`, Collector c){
@@ -756,25 +712,16 @@ void collect(current:(Sym) `<Sym symbol> @ <IntegerLiteral column>`, Collector c
     collect(symbol, c);
 }
 
-str md5ContribSym((Sym) `<Sym symbol> @ <IntegerLiteral column>`)
-    = "<md5ContribSym(symbol)>COL<column>";
-
 void collect(current:(Sym) `<Sym symbol> $`, Collector c){
     c.calculate("end-of-line", current, [symbol], AType(Solver s) { return AType::conditional(s.getType(symbol), {ACondition::\a-end-of-line() }); });
     collect(symbol, c);
 }
 
-str md5ContribSym((Sym) `<Sym symbol> $`)
-    = "<md5ContribSym(symbol)>END";
-
 void collect(current:(Sym) `^ <Sym symbol>`, Collector c){
     c.calculate("begin-of-line", current, [symbol], AType(Solver s) { return AType::conditional(s.getType(symbol), {ACondition::\a-begin-of-line() }); });
     collect(symbol, c);
 }
 
-str md5ContribSym((Sym) `^ <Sym symbol>`)
-    = "BEGIN<md5ContribSym(symbol)>";
-
 void collect(current:(Sym) `<Sym symbol> ! <NonterminalLabel n>`, Collector c){
     // TODO: c.use(n, {productionId()});
     un = unescape("<n>");
@@ -785,9 +732,6 @@ void collect(current:(Sym) `<Sym symbol> ! <NonterminalLabel n>`, Collector c){
     collect(symbol, c);
 }
 
-str md5ContribSym((Sym) `<Sym symbol> ! <NonterminalLabel n>`)
-    = "<md5ContribSym(symbol)>EXCEPT<unescape("<n>")>";
-
 bool isTerminal((Sym) `<Sym symbol> @ <IntegerLiteral _>`) = isTerminal(symbol);
 bool isTerminal((Sym) `<Sym symbol> $`) = isTerminal(symbol);
 bool isTerminal((Sym) `^ <Sym symbol>`) = isTerminal(symbol);
@@ -805,9 +749,6 @@ void collect(current:(Sym) `<Sym symbol>  \>\> <Sym match>`, Collector c){
    collect(symbol, match, c);
 }
 
-str md5ContribSym((Sym) `<Sym symbol>  \>\> <Sym match>`)
-    = "<md5ContribSym(symbol)>FOLLOW<md5ContribSym(match)>";
-
 void collect(current:(Sym) `<Sym symbol>  !\>\> <Sym match>`, Collector c){
    c.calculate("notFollow", current, [symbol, match],
         AType(Solver s) {
@@ -818,9 +759,6 @@ void collect(current:(Sym) `<Sym symbol>  !\>\> <Sym match>`, Collector c){
    collect(symbol, match, c);
 }
 
-str md5ContribSym((Sym) `<Sym symbol>  !\>\> <Sym match>`)
-    = "<md5ContribSym(symbol)>NOTFOLLOW<md5ContribSym(match)>";
-
 void collect(current:(Sym) `<Sym match>  \<\< <Sym symbol>`, Collector c){
    c.calculate("precede", current, [match, symbol],
         AType(Solver s) {
@@ -830,9 +768,6 @@ void collect(current:(Sym) `<Sym match>  \<\< <Sym symbol>`, Collector c){
    collect(match, symbol, c);
 }
 
-str md5ContribSym((Sym) `<Sym match>  \<\< <Sym symbol>`)
-    = "<md5ContribSym(match)>PRECEDE<md5ContribSym(symbol)>";
-
 void collect(current:(Sym) `<Sym match>  !\<\< <Sym symbol>`, Collector c){
    c.calculate("notPrecede", current, [match, symbol],
         AType(Solver s) {
@@ -842,9 +777,6 @@ void collect(current:(Sym) `<Sym match>  !\<\< <Sym symbol>`, Collector c){
    collect(match, symbol, c);
 }
 
-str md5ContribSym((Sym) `<Sym match>  !\<\< <Sym symbol>`)
-    = "<md5ContribSym(match)>NOTPRECEDE<md5ContribSym(symbol)>";
-
 void collect(current:(Sym) `<Sym symbol> \\ <Sym match>`, Collector c){
    c.calculate("exclude", current, [symbol, match],
         AType(Solver s) {
@@ -857,9 +789,6 @@ void collect(current:(Sym) `<Sym symbol> \\ <Sym match>`, Collector c){
    collect(symbol, match, c);
 }
 
-str md5ContribSym((Sym) `<Sym symbol> \\ <Sym match>`)
-    = "<md5ContribSym(symbol)>NOTEQUAL<md5ContribSym(match)>";
-
 void collect(Sym current, Collector c){
     throw "collect Sym, missed case <current>";
 }
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/check/RascalConfig.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/check/RascalConfig.rsc
index 6e1f3894d83..ae44b42f764 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/check/RascalConfig.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/check/RascalConfig.rsc
@@ -553,6 +553,13 @@ loc rascalCreateLogicalLoc(Define def, str modelName, PathConfig pcfg){
      return def.defined;
 }
 
+private str MD5_CONTRIB_SEPARATOR = "@";
+private map[str, str] MD5_ESCAPES = (MD5_CONTRIB_SEPARATOR: "\\<MD5_CONTRIB_SEPARATOR>");
+
+@synopsis{Hash a variable number of contributing values (MD5).}
+str normalizedMD5Hash(value contribs...)
+    = md5Hash(removeWhitespace(intercalate(MD5_CONTRIB_SEPARATOR, [escape("<c>", MD5_ESCAPES) | c <- contribs])));
+
 @memo{expireAfter(minutes=5),maximumSize(1000)}
 rel[str shortName, str longName] getRascalModuleNames(PathConfig pcfg){
     longNames = {};
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/check/tests/BinaryDependencyTests.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/check/tests/BinaryDependencyTests.rsc
index 67188c0e718..a3c962a6810 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/check/tests/BinaryDependencyTests.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/check/tests/BinaryDependencyTests.rsc
@@ -207,6 +207,7 @@ TModel check(str mname, RascalCompilerConfig cfg){
 
 // ---  Tests for source libraries --------------------------------------------
 
+@ignore{Loads TModel with version 2.0.0 while it is 3.0.0 since a22dcd4416. TODO Make this test more robust.}
 test bool importSimpleSourceModuleWithRascalAsLib(){
     libName = "test-lib";
     lib =
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/check/tests/ChangeAndHashTests.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/check/tests/ChangeAndHashTests.rsc
index 4122d1b3ba0..b40dc9ed3e0 100644
--- a/src/org/rascalmpl/compiler/lang/rascalcore/check/tests/ChangeAndHashTests.rsc
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/check/tests/ChangeAndHashTests.rsc
@@ -311,6 +311,12 @@ test bool consFieldLayoutChanged1()
 test bool consFieldLayoutChanged2()
     = expectEqual("data D = d(int n);", "data D = d  (int n);");
 
+test bool consDifferentNewlineCount()
+    = expectEqual("data A = a(list[A] children\n\n);", "data A = a(list[A] children\n\n\n);");
+
+test bool consDifferentNewlineChars()
+    = expectEqual("data A = a(list[A] children\n);", "data A = a(list[A] children\r\n);");
+
 
 // Keyword fields n and m generate separate locs, therefore we filter on constructors
 test bool consKwFieldChanged()
@@ -542,4 +548,30 @@ test bool synUnequalChanged2()
 
 test bool synUnequalLayoutChanged()
     = expectEqualGrammar("syntax A = \"a\"; syntax B = \"b\"; syntax C = \"c\"; syntax D = A \\ \"b\";",
-                  "syntax A = \"a\"; syntax B = \"b\"; syntax C = \"c\"; syntax D =   A   \\   \"b\" ;");
\ No newline at end of file
+                  "syntax A = \"a\"; syntax B = \"b\"; syntax C = \"c\"; syntax D =   A   \\   \"b\" ;");
+
+// Hash function properties
+
+test bool normalizedHashLayout(str S1, str S2)
+    = normalizedMD5Hash("<S1> <S2>") == normalizedMD5Hash("<S1><S2>");
+
+test bool normalizedHashParts1(str S1, str S2)
+    = normalizedMD5Hash("<S1><S2>") != normalizedMD5Hash(S1, S2);
+
+test bool normalizedHashParts2(str S1, str S2)
+    = normalizedMD5Hash(S1, "", S2) != normalizedMD5Hash(S1, S2);
+
+test bool normalizedHashParts3(str S1, str S2)
+    = normalizedMD5Hash("<S1>|<S2>") != normalizedMD5Hash(S1, S2);
+
+test bool normalizedHashAnyValues(value V1, value V2)
+    = str _ := normalizedMD5Hash(V1, V2);
+
+test bool normalizedHashIdentity1(str S1)
+    = normalizedMD5Hash(S1) == normalizedMD5Hash(S1);
+
+test bool normalizedHashIdentity2(str S1, str S2)
+    = normalizedMD5Hash(S1) == normalizedMD5Hash(S2)
+    ? removeWhitespace(S1) == removeWhitespace(S2)
+    : S1 != S2
+    ;
diff --git a/src/org/rascalmpl/compiler/lang/rascalcore/compile/Examples/CompareTPLs.rsc b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Examples/CompareTPLs.rsc
new file mode 100644
index 00000000000..0834402d40f
--- /dev/null
+++ b/src/org/rascalmpl/compiler/lang/rascalcore/compile/Examples/CompareTPLs.rsc
@@ -0,0 +1,146 @@
+@license{
+Copyright (c) 2018-2025, NWO-I CWI, Swat.engineering and Paul Klint
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+}
+
+module lang::rascalcore::compile::Examples::CompareTPLs
+
+import IO;
+import List;
+import Location;
+import Set;
+import ValueIO;
+import util::FileSystem;
+import util::Monitor;
+
+import analysis::typepal::TModel;
+import lang::rascalcore::check::LogicalLocations;
+
+str JOB = "Comparing TPLs";
+
+void main() {
+    compareTPLs();
+}
+
+@synopsis{Compare locations in two TPLs two verify only expected (OS-specific newline offset) differences.}
+rel[loc, loc, loc] compareTPLs() = job(JOB, rel[loc, loc, loc](void(str, int) step) {
+    /*
+        Preconditions
+        1. Make sure the right Rascal release JAR is present in the Maven repository.
+        2. Compile the same Rascal release locally and copy the JARs to the local target folder.
+    */
+    loc localTarget = |home:///swat/projects/Rascal/rascal/targetBackup/relocatedClasses|;
+    loc remoteTarget = |mvn://org.rascalmpl--rascal--0.41.3-RC8|;
+
+    rel[loc, loc, loc] differentLocations = {};
+    step("Finding local TPLs", 1);
+    allTPLs = sort(find(localTarget, "tpl"), byPathLength);
+    jobTodo(JOB, work=size(allTPLs));
+
+    for (tpl <- allTPLs) {
+        relTplPath = relativize(localTarget, tpl);
+        step("Comparing <relTplPath>", 1);
+        differentLocations += toSet(compareTPL(relTplPath, localTarget, remoteTarget));
+    }
+
+    step("Computing statistics", 1);
+
+    set[str] filesWithDiffs = {l.parent.path | l <- differentLocations<0>};
+    set[loc] defs = differentLocations<0>;
+
+    println("Number of tested TPLs: <size(allTPLs)>");
+    println("Found <size(defs)> different locations in <size(filesWithDiffs)> files.");;
+
+    print("Kinds of different locations: ");
+    iprintln({l.scheme | l <- differentLocations<0>});
+
+    return differentLocations;
+}, totalWork=2);
+
+bool byPathLength(loc a, loc b) = a.path < b.path;
+
+lrel[loc, loc, loc] compareTPL(loc relTplPath, loc localTargetDir, loc unixTargetDir) {
+    loc localTplPath = resolve(localTargetDir, relTplPath);
+    loc unixTplPath = resolve(unixTargetDir, relTplPath);
+
+    if (!exists(localTplPath)) {
+        throw "Local TPL <localTplPath> does not exist";
+    }
+    if (!exists(unixTplPath)) {
+        throw "Unix TPL <unixTplPath> does not exist";
+    }
+
+    localTpl = readBinaryValueFile(#TModel, localTplPath);
+    unixTpl = readBinaryValueFile(#TModel, unixTplPath);
+    
+    differentDefs = [<ll, ul, localTpl.logical2physical[ll]> | <ll, ul> <- difference(localTpl.defines.defined, unixTpl.defines.defined)];
+    if ([_, *_] := differentDefs) {
+        println("Differences in defs of <relTplPath> (\<Local logical, Unix logical, local physical\>): ");
+        iprintln(differentDefs);
+        println();
+    }
+
+    return differentDefs;
+}
+
+lrel[loc, loc] difference(set[loc] lLocs, set[loc] uLocs) =
+    [<l, u> | <l, u> <- pairs, !isEqualModuloNewlines(l, u)]
+    when lrel[loc, loc] pairs := zip2(sort(lLocs, lessThan), sort(uLocs, lessThan));
+
+bool isEqualModuloNewlines(loc localLoc, loc unixLoc) = isRascalLogicalLoc(localLoc)
+    ? isEqualLogicalModuloNewlines(localLoc, unixLoc)
+    : isEqualPhysicalModuloNewlines(localLoc, unixLoc);
+
+bool isEqualLogicalModuloNewlines(loc localLoc, loc unixLoc) = localLoc == unixLoc;
+
+bool isEqualPhysicalModuloNewlines(loc localLoc, loc unixLoc) {
+    if (localLoc.uri != unixLoc.uri) {
+        throw "URIs not equal: <localLoc> vs. <unixLoc>";
+    }
+
+    if (!localLoc.begin?) {
+        // Cannot say anything sensible about newlines without line information
+        return true;
+    }
+
+    if (localLoc.begin.line == localLoc.end.line) {
+        // Single line
+        return localLoc.length == unixLoc.length
+            && localLoc.begin == unixLoc.begin
+            && localLoc.end == unixLoc.end;
+    }
+
+    // Multi line
+    return localLoc.begin == unixLoc.begin
+        && localLoc.end == unixLoc.end;
+}
+
+bool lessThan(loc a, loc b) = a.offset? && a.uri == b.uri
+    ? a.offset < b.offset
+    : a.uri < b.uri;
+
+bool lessThan(tuple[&A, &B] a, tuple[&A, &B] b) = a<0> != b<0>
+    ? lessThan(a<0>, b<0>)
+    : lessThan(a<1>, b<1>);
diff --git a/src/org/rascalmpl/library/Prelude.java b/src/org/rascalmpl/library/Prelude.java
index b85fbe8bef0..f325e3c7946 100644
--- a/src/org/rascalmpl/library/Prelude.java
+++ b/src/org/rascalmpl/library/Prelude.java
@@ -3486,6 +3486,32 @@ private boolean match(IString subject, int i, IString pattern){
 		return true;
 	}
 	
+	private boolean isUnicodeWhitespace(Integer cp) {
+		return Character.isSpaceChar(cp)
+			// Check for characters not included in 'space chars', but considered white space
+			|| cp == 0x0009 // \t
+			|| cp == 0x000A // \n
+			|| cp == 0x000B // VT
+			|| cp == 0x000C // FF
+			|| cp == 0x000D // \r
+			|| cp == 0x0085;// NEL
+	}
+
+	public IString removeWhitespace(IString str) {
+		StringBuilder b = new StringBuilder(str.length());
+		var iter = str.iterator();
+
+		while (iter.hasNext()) {
+			var codepoint = iter.next();
+			// Character.isWhitespace does not cover the complete range of Unicode whitespace
+			if (!isUnicodeWhitespace(codepoint)) {
+				b.appendCodePoint(codepoint);
+			}
+		}
+
+		return values.string(b.toString());
+	}
+
 	public IValue replaceAll(IString str, IString find, IString replacement){
 		int fLength = find.length();
 		if(fLength == 0){
diff --git a/src/org/rascalmpl/library/String.rsc b/src/org/rascalmpl/library/String.rsc
index 83940314813..589af7d77be 100644
--- a/src/org/rascalmpl/library/String.rsc
+++ b/src/org/rascalmpl/library/String.rsc
@@ -254,6 +254,21 @@ public str left(str s, int n, str pad)
 }
 
 
+@synopsis{Remove all whitespace from a string.}
+@description{
+Return a copy of `subject` in which all occurrences of Unicode whitespace characters have been removed.
+}
+@examples{
+```rascal-shell
+import String;
+removeWhitespace("\rabra\ncada bra\t");
+removeWhitespace("Uni\u1680code")
+```
+}
+@javaClass{org.rascalmpl.library.Prelude}
+public java str removeWhitespace(str subject);
+
+
 @synopsis{Replace all occurrences of a string in another string.}
 @description{
 Return a copy of `subject` in which all occurrences of `find` (if any) have been replaced by `replacement`.
diff --git a/src/org/rascalmpl/library/lang/rascal/tests/basic/Strings2.rsc b/src/org/rascalmpl/library/lang/rascal/tests/basic/Strings2.rsc
index d504ac9c568..211928345b7 100644
--- a/src/org/rascalmpl/library/lang/rascal/tests/basic/Strings2.rsc
+++ b/src/org/rascalmpl/library/lang/rascal/tests/basic/Strings2.rsc
@@ -14,3 +14,21 @@ test bool tstWrap(str S1 , str S2) {
   n = max(size(S1), size(S2)) + 2;
   return trim(S) == trim(replaceAll(wrap(S, n), getLineSeparator(), " "));
 }
+
+private set[str] UNICODE_WS = {
+  "\u0009", "\u000A", "\u000B", "\u000C", "\u000D",
+  "\u0020",
+  "\u0085",
+  "\u00A0",
+  "\u1680",
+  "\u2000", "\u2001", "\u2002", "\u2003", "\u2004", "\u2005", "\u2006", "\u2007", "\u2008", "\u2009", "\u200A",
+  "\u2028", "\u2029",
+  "\u202F",
+  "\u205F",
+  "\u3000"
+};
+
+test bool tstRemoveWhitespace1(str S1)
+  = removeWhitespace(S1) == "<for(int i <- [0..size(S1)]){><S1[i] in UNICODE_WS ? "" : S1[i]><}>";
+test bool tstRemoveWhitespace2(str S1)
+  = size(removeWhitespace(S1)) <= size(S1);