diff --git a/changelog.md b/changelog.md
index fbda7058288..0257c28dba4 100644
--- a/changelog.md
+++ b/changelog.md
@@ -5,13 +5,68 @@
 
 
 
+- `std/sharedstrings` module is removed.
+- Constants `colors.colPaleVioletRed` and `colors.colMediumPurple` changed to match the CSS color standard.
+
+- `addr` is now available for all addressable locations, `unsafeAddr` is deprecated and
+becomes an alias for `addr`.
+
 ## Standard library additions and changes
 
+- `macros.parseExpr` and `macros.parseStmt` now accept an optional
+  filename argument for more informative errors.
+- Module `colors` expanded with missing colors from the CSS color standard.
+- Fixed `lists.SinglyLinkedList` being broken after removing the last node ([#19353](https://github.com/nim-lang/Nim/pull/19353)).
+
+- `std/smtp` sends `ehlo` first. If the mail server does not understand, it sends `helo` as a fallback.
+
+- Added `IsoWeekRange`, a range type to represent the number of weeks in an ISO week-based year.
+- Added `IsoYear`, a distinct int type to prevent bugs from confusing the week-based year and the regular year.
+- Added `initDateTime` in `times` to create a datetime from a weekday, and ISO 8601 week number and week-based year.
+- Added `getIsoWeekAndYear` in `times` to get an ISO week number along with the corresponding ISO week-based year from a datetime.
+- Added `getIsoWeeksInYear` in `times` to return the number of weeks in an ISO week-based year.
+
+- Added `std/oserrors` for OS error reporting. Added `std/envvars` for environment variables handling.
+- Removed deprecated `oids.oidToString`.
+
+
+- Changed mimedb to use an `OrderedTable` instead of `OrderedTableRef`, to use it in a const.
+
+- Removed deprecated `math.c_frexp`.
 
 
 ## Language changes
 
 
+  ```nim
+  import macros
+
+  macro multiply(amount: static int, s: untyped): untyped =
+    let name = $s[0].basename
+    result = newNimNode(nnkTypeSection)
+    for i in 1 .. amount:
+      result.add(newTree(nnkTypeDef, ident(name & $i), s[1], s[2]))
+
+  type
+    Foo = object
+    Bar {.multiply: 3.} = object
+      x, y, z: int
+    Baz = object
+
+  # becomes
+
+  type
+    Foo = object
+    Bar1 = object
+      x, y, z: int
+    Bar2 = object
+      x, y, z: int
+    Bar3 = object
+      x, y, z: int
+    Baz = object
+  ```
+- [Case statement macros](manual.html#macros-case-statement-macros) are no longer experimental,
+  meaning you no longer need to enable the experimental switch `caseStmtMacros` to use them. 
 
 ## Compiler changes
 
@@ -23,3 +78,9 @@
 
 
 
+- Nim now supports Nimble version 0.14 which added support for lock-files. This is done by
+  a simple configuration change setting that you can do yourself too. In `$nim/config/nim.cfg`
+  replace `pkgs` by `pkgs2`.
+
+- There is a new switch `--nimMainPrefix:prefix` to influence the `NimMain` that the
+  compiler produces. This is particularly useful for generating static libraries.
diff --git a/changelogs/changelog_1_4_0.md b/changelogs/changelog_1_4_0.md
index 091048ad196..77f66ffdeba 100644
--- a/changelogs/changelog_1_4_0.md
+++ b/changelogs/changelog_1_4_0.md
@@ -282,7 +282,7 @@
 - Removed the deprecated `asyncdispatch.newAsyncNativeSocket`.
 - Removed the deprecated `dom.releaseEvents` and `dom.captureEvents`.
 
-- Removed `sharedlists.initSharedList`, was deprecated and produces undefined behaviour.
+- Removed `sharedlist.initSharedList`, was deprecated and produces undefined behaviour.
 
 - There is a new experimental feature called "strictFuncs" which makes the definition of
   `.noSideEffect` stricter. [See here](manual_experimental.html#stricts-funcs)
diff --git a/compiler/ast/ast_types.nim b/compiler/ast/ast_types.nim
index 95c27dac4b6..0b953ecedd1 100644
--- a/compiler/ast/ast_types.nim
+++ b/compiler/ast/ast_types.nim
@@ -688,7 +688,7 @@ type
     mSwap, mIsNil, mArrToSeq,
     mNewString, mNewStringOfCap, mParseBiggestFloat,
     mMove, mWasMoved, mDestroy, mTrace,
-    mDefault, mUnown, mFinished, mIsolate, mAccessEnv, mReset,
+    mDefault, mUnown, mFinished, mIsolate, mAccessEnv, mAccessTypeField, mReset,
     mArray, mOpenArray, mRange, mSet, mSeq, mVarargs,
     mRef, mPtr, mVar, mDistinct, mVoid, mTuple,
     mOrdinal, mIterableType,
diff --git a/compiler/ast/parser.nim b/compiler/ast/parser.nim
index 044aa287d59..cbb50683b87 100644
--- a/compiler/ast/parser.nim
+++ b/compiler/ast/parser.nim
@@ -605,10 +605,10 @@ proc parsePar(p: var Parser): PNode =
   #|         | 'finally' | 'except' | 'for' | 'block' | 'const' | 'let'
   #|         | 'when' | 'var' | 'mixin'
   #| par = '(' optInd
-  #|           ( &parKeyw (ifExpr \ complexOrSimpleStmt) ^+ ';'
-  #|           | ';' (ifExpr \ complexOrSimpleStmt) ^+ ';'
+  #|           ( &parKeyw (ifExpr / complexOrSimpleStmt) ^+ ';'
+  #|           | ';' (ifExpr / complexOrSimpleStmt) ^+ ';'
   #|           | pragmaStmt
-  #|           | simpleExpr ( ('=' expr (';' (ifExpr \ complexOrSimpleStmt) ^+ ';' )? )
+  #|           | simpleExpr ( ('=' expr (';' (ifExpr / complexOrSimpleStmt) ^+ ';' )? )
   #|                        | (':' expr (',' exprColonEqExpr     ^+ ',' )? ) ) )
   #|           optPar ')'
   #
@@ -1136,11 +1136,14 @@ proc optPragmas(p: var Parser): PNode =
 
 proc parseDoBlock(p: var Parser; info: TLineInfo): PNode =
   #| doBlock = 'do' paramListArrow pragma? colcom stmt
-  let params = parseParamList(p, retColon=false)
+  var params = parseParamList(p, retColon=false)
   let pragmas = optPragmas(p)
   colcom(p, result)
   result = parseStmt(p)
-  if params.kind != nkEmpty:
+  if params.kind != nkEmpty or pragmas.kind != nkEmpty:
+    if params.kind == nkEmpty:
+      params = newNodeP(nkFormalParams, p)
+      params.add(p.emptyNode) # return type
     result = newProcNode(nkDo, info,
       body = result, params = params, name = p.emptyNode, pattern = p.emptyNode,
       genericParams = p.emptyNode, pragmas = pragmas, exceptions = p.emptyNode)
@@ -1407,7 +1410,10 @@ proc postExprBlocks(p: var Parser, x: PNode): PNode =
       if stmtList[0].kind == nkStmtList: stmtList = stmtList[0]
 
       stmtList.flags.incl nfBlockArg
-      if openingParams.kind != nkEmpty:
+      if openingParams.kind != nkEmpty or openingPragmas.kind != nkEmpty:
+        if openingParams.kind == nkEmpty:
+          openingParams = newNodeP(nkFormalParams, p)
+          openingParams.add(p.emptyNode) # return type
         result.add newProcNode(nkDo, stmtList.info, body = stmtList,
                                params = openingParams,
                                name = p.emptyNode, pattern = p.emptyNode,
@@ -1910,7 +1916,7 @@ proc parseEnum(p: var Parser): PNode =
 
     var symPragma = a
     var pragma: PNode
-    if p.tok.tokType == tkCurlyDotLe:
+    if (p.tok.indent < 0 or p.tok.indent >= p.currInd) and p.tok.tokType == tkCurlyDotLe:
       pragma = optPragmas(p)
       symPragma = newNodeP(nkPragmaExpr, p)
       symPragma.add(a)
diff --git a/compiler/ast/types.nim b/compiler/ast/types.nim
index ef6a6b94d49..80fa3a7ddc7 100644
--- a/compiler/ast/types.nim
+++ b/compiler/ast/types.nim
@@ -1381,3 +1381,6 @@ proc isCharArrayPtr*(t: PType; allowPointerToChar: bool): bool =
       result = allowPointerToChar
     else:
       discard
+
+proc lacksMTypeField*(typ: PType): bool {.inline.} =
+  (typ.sym != nil and sfPure in typ.sym.flags) or tfFinal in typ.flags
diff --git a/compiler/ast/wordrecg.nim b/compiler/ast/wordrecg.nim
index 32b3272fdad..c663240a4a2 100644
--- a/compiler/ast/wordrecg.nim
+++ b/compiler/ast/wordrecg.nim
@@ -40,7 +40,7 @@ type
     wImmediate = "immediate", wConstructor = "constructor", wDestructor = "destructor",
     wDelegator = "delegator", wOverride = "override", wImportCpp = "importcpp",
     wCppNonPod = "cppNonPod",
-    wImportObjC = "importobjc", wImportCompilerProc = "importcompilerproc",
+    wImportObjC = "importobjc", wImportCompilerProc = "importCompilerProc",
     wImportc = "importc", wImportJs = "importjs", wExportc = "exportc", wExportCpp = "exportcpp",
     wExportNims = "exportnims",
     wIncompleteStruct = "incompleteStruct", # deprecated
diff --git a/compiler/backend/ccgcalls.nim b/compiler/backend/ccgcalls.nim
index 0eebc33a840..e56bb16d111 100644
--- a/compiler/backend/ccgcalls.nim
+++ b/compiler/backend/ccgcalls.nim
@@ -215,7 +215,7 @@ proc openArrayLoc(p: BProc, formalType: PType, n: PNode): Rope =
   else:
     var a: TLoc
     initLocExpr(p, if n.kind == nkHiddenStdConv: n[1] else: n, a)
-    case skipTypes(a.t, abstractVar).kind
+    case skipTypes(a.t, abstractVar+{tyStatic}).kind
     of tyOpenArray, tyVarargs:
       if reifiedOpenArray(n):
         if a.t.kind in {tyVar, tyLent}:
@@ -377,8 +377,8 @@ proc genParams(p: BProc, ri: PNode, typ: PType): Rope =
         if not needTmp[i - 1]:
           needTmp[i - 1] = potentialAlias(n, potentialWrites)
       getPotentialWrites(ri[i], false, potentialWrites)
-    if ri[i].kind == nkHiddenAddr:
-      # Optimization: don't use a temp, if we would only take the adress anyway
+    if ri[i].kind in {nkHiddenAddr, nkAddr}:
+      # Optimization: don't use a temp, if we would only take the address anyway
       needTmp[i - 1] = false
 
   for i in 1..<ri.len:
diff --git a/compiler/backend/ccgexprs.nim b/compiler/backend/ccgexprs.nim
index 27296f7f07d..5fe6c5a0fd7 100644
--- a/compiler/backend/ccgexprs.nim
+++ b/compiler/backend/ccgexprs.nim
@@ -1753,6 +1753,13 @@ proc genGetTypeInfoV2(p: BProc, e: PNode, d: var TLoc) =
     # use the dynamic type stored at offset 0:
     putIntoDest(p, d, e, rdMType(p, a, nilCheck))
 
+proc genAccessTypeField(p: BProc; e: PNode; d: var TLoc) =
+  var a: TLoc
+  initLocExpr(p, e[1], a)
+  var nilCheck = Rope(nil)
+  # use the dynamic type stored at offset 0:
+  putIntoDest(p, d, e, rdMType(p, a, nilCheck))
+
 template genDollar(p: BProc, n: PNode, d: var TLoc, frmt: string) =
   var a: TLoc
   initLocExpr(p, n[1], a)
@@ -2463,6 +2470,7 @@ proc genMagicExpr(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
   of mMove: genMove(p, e, d)
   of mDestroy: genDestroy(p, e)
   of mAccessEnv: unaryExpr(p, e, d, "$1.ClE_0")
+  of mAccessTypeField: genAccessTypeField(p, e, d)
   of mSlice: genSlice(p, e, d)
   of mTrace: discard "no code to generate"
   else:
diff --git a/compiler/backend/ccgstmts.nim b/compiler/backend/ccgstmts.nim
index b3c8ea69eb3..67cf6dfa6be 100644
--- a/compiler/backend/ccgstmts.nim
+++ b/compiler/backend/ccgstmts.nim
@@ -1363,8 +1363,19 @@ proc genTrySetjmp(p: BProc, t: PNode, d: var TLoc) =
       linefmt(p, cpsStmts, "$1.status = setjmp($1.context);$n", [safePoint])
     elif isDefined(p.config, "nimSigSetjmp"):
       linefmt(p, cpsStmts, "$1.status = sigsetjmp($1.context, 0);$n", [safePoint])
+    elif isDefined(p.config, "nimBuiltinSetjmp"):
+      linefmt(p, cpsStmts, "$1.status = __builtin_setjmp($1.context);$n", [safePoint])
     elif isDefined(p.config, "nimRawSetjmp"):
-      linefmt(p, cpsStmts, "$1.status = _setjmp($1.context);$n", [safePoint])
+      if isDefined(p.config, "mswindows"):
+        # The Windows `_setjmp()` takes two arguments, with the second being an
+        # undocumented buffer used by the SEH mechanism for stack unwinding.
+        # Mingw-w64 has been trying to get it right for years, but it's still
+        # prone to stack corruption during unwinding, so we disable that by setting
+        # it to NULL.
+        # More details: https://github.com/status-im/nimbus-eth2/issues/3121
+        linefmt(p, cpsStmts, "$1.status = _setjmp($1.context, 0);$n", [safePoint])
+      else:
+        linefmt(p, cpsStmts, "$1.status = _setjmp($1.context);$n", [safePoint])
     else:
       linefmt(p, cpsStmts, "$1.status = setjmp($1.context);$n", [safePoint])
     lineCg(p, cpsStmts, "if ($1.status == 0) {$n", [safePoint])
diff --git a/compiler/backend/ccgtypes.nim b/compiler/backend/ccgtypes.nim
index 4b4b813de86..586c2efa867 100644
--- a/compiler/backend/ccgtypes.nim
+++ b/compiler/backend/ccgtypes.nim
@@ -39,7 +39,7 @@ proc mangleName(m: BModule; s: PSym): Rope =
   result = s.loc.r
   if result == nil:
     result = s.name.s.mangle.rope
-    result.add "_"
+    result.add "__"
     result.add m.g.graph.ifaces[s.itemId.module].uniqueName
     result.add "_"
     result.add rope s.itemId.item
@@ -582,7 +582,7 @@ proc getRecordDesc(m: BModule, typ: PType, name: Rope,
 
   if typ.kind == tyObject:
     if typ[0] == nil:
-      if (typ.sym != nil and sfPure in typ.sym.flags) or tfFinal in typ.flags:
+      if lacksMTypeField(typ):
         appcg(m, result, " {$n", [])
       else:
         if optTinyRtti in m.config.globalOptions:
diff --git a/compiler/backend/cgen.nim b/compiler/backend/cgen.nim
index 80010dd240f..6e4d40d495d 100644
--- a/compiler/backend/cgen.nim
+++ b/compiler/backend/cgen.nim
@@ -412,7 +412,8 @@ proc genObjectInit(p: BProc, section: TCProcSection, t: PType, a: var TLoc,
     else:
       linefmt(p, section, "$1.m_type = $2;$n", [r, genTypeInfoV1(p.module, t, a.lode.info)])
   of frEmbedded:
-    if optTinyRtti in p.config.globalOptions:
+    # inheritance in C++ does not allow struct initialization: bug #18410
+    if not p.module.compileToCpp and optTinyRtti in p.config.globalOptions:
       var tmp: TLoc
       if mode == constructRefObj:
         let objType = t.skipTypes(abstractInst+{tyRef})
diff --git a/compiler/backend/extccomp.nim b/compiler/backend/extccomp.nim
index d16e5e9863c..fe1781fabb4 100644
--- a/compiler/backend/extccomp.nim
+++ b/compiler/backend/extccomp.nim
@@ -701,8 +701,10 @@ proc externalFileChanged(conf: ConfigRef; cfile: Cfile): bool =
       close(f)
 
 proc addExternalFileToCompile*(conf: ConfigRef; c: var Cfile) =
+  # we want to generate the hash file unconditionally
+  let extFileChanged = externalFileChanged(conf, c)
   if optForceFullMake notin conf.globalOptions and fileExists(c.obj) and
-      not externalFileChanged(conf, c):
+      not extFileChanged:
     c.flags.incl CfileFlag.Cached
   else:
     # make sure Nim keeps recompiling the external file on reruns
diff --git a/compiler/backend/jsgen.nim b/compiler/backend/jsgen.nim
index f5671af66cf..28f126819ad 100644
--- a/compiler/backend/jsgen.nim
+++ b/compiler/backend/jsgen.nim
@@ -219,7 +219,7 @@ const
 proc mapType(typ: PType): TJSTypeKind =
   let t = skipTypes(typ, abstractInst)
   case t.kind
-  of tyVar, tyRef, tyPtr, tyLent:
+  of tyVar, tyRef, tyPtr:
     if skipTypes(t.lastSon, abstractInst).kind in MappedToObject:
       result = etyObject
     else:
@@ -227,7 +227,8 @@ proc mapType(typ: PType): TJSTypeKind =
   of tyPointer:
     # treat a tyPointer like a typed pointer to an array of bytes
     result = etyBaseIndex
-  of tyRange, tyDistinct, tyOrdinal, tyProxy:
+  of tyRange, tyDistinct, tyOrdinal, tyProxy, tyLent:
+    # tyLent is no-op as JS has pass-by-reference semantics
     result = mapType(t[0])
   of tyInt..tyInt64, tyUInt..tyUInt64, tyEnum, tyChar: result = etyInt
   of tyBool: result = etyBool
@@ -1102,14 +1103,14 @@ proc genAsgnAux(p: PProc, x, y: PNode, noCopyNeeded: bool) =
     xtyp = etySeq
   case xtyp
   of etySeq:
-    if (needsNoCopy(p, y) and needsNoCopy(p, x)) or noCopyNeeded:
+    if x.typ.kind in {tyVar, tyLent} or (needsNoCopy(p, y) and needsNoCopy(p, x)) or noCopyNeeded:
       lineF(p, "$1 = $2;$n", [a.rdLoc, b.rdLoc])
     else:
       useMagic(p, "nimCopy")
       lineF(p, "$1 = nimCopy(null, $2, $3);$n",
                [a.rdLoc, b.res, genTypeInfo(p, y.typ)])
   of etyObject:
-    if x.typ.kind in {tyVar} or (needsNoCopy(p, y) and needsNoCopy(p, x)) or noCopyNeeded:
+    if x.typ.kind in {tyVar, tyLent} or (needsNoCopy(p, y) and needsNoCopy(p, x)) or noCopyNeeded:
       lineF(p, "$1 = $2;$n", [a.rdLoc, b.rdLoc])
     else:
       useMagic(p, "nimCopy")
@@ -1134,10 +1135,18 @@ proc genAsgnAux(p: PProc, x, y: PNode, noCopyNeeded: bool) =
         lineF(p, "$# = [$#, $#];$n", [a.res, b.address, b.res])
         lineF(p, "$1 = $2;$n", [a.address, b.res])
         lineF(p, "$1 = $2;$n", [a.rdLoc, b.rdLoc])
+      elif a.typ == etyBaseIndex:
+        # array indexing may not map to var type
+        if b.address != nil:
+          lineF(p, "$1 = $2; $3 = $4;$n", [a.address, b.address, a.res, b.res])
+        else:
+          lineF(p, "$1 = $2;$n", [a.address, b.res])
       else:
         internalError(p.config, x.info, $("genAsgn", b.typ, a.typ))
-    else:
+    elif b.address != nil:
       lineF(p, "$1 = $2; $3 = $4;$n", [a.address, b.address, a.res, b.res])
+    else:
+      lineF(p, "$1 = $2;$n", [a.address, b.res])
   else:
     lineF(p, "$1 = $2;$n", [a.rdLoc, b.rdLoc])
 
@@ -1502,13 +1511,17 @@ proc genSym(p: PProc, n: PNode, r: var TCompRes) =
   else:
     if s.loc.r == nil:
       internalError(p.config, n.info, "symbol has no generated name: " & s.name.s)
-    r.res = s.loc.r
+    if mapType(p, s.typ) == etyBaseIndex:
+      r.address = s.loc.r
+      r.res = s.loc.r & "_Idx"
+    else:
+      r.res = s.loc.r
   r.kind = resVal
 
 proc genDeref(p: PProc, n: PNode, r: var TCompRes) =
   let it = n[0]
   let t = mapType(p, it.typ)
-  if t == etyObject:
+  if t == etyObject or it.typ.kind == tyLent:
     gen(p, it, r)
   else:
     var a: TCompRes
@@ -1753,7 +1766,7 @@ proc createVar(p: PProc, typ: PType, indirect: bool): Rope =
       result = putToSeq("0", indirect)
   of tyFloat..tyFloat128:
     result = putToSeq("0.0", indirect)
-  of tyRange, tyGenericInst, tyAlias, tySink, tyOwned:
+  of tyRange, tyGenericInst, tyAlias, tySink, tyOwned, tyLent:
     result = createVar(p, lastSon(typ), indirect)
   of tySet:
     result = putToSeq("{}", indirect)
@@ -1795,7 +1808,7 @@ proc createVar(p: PProc, typ: PType, indirect: bool): Rope =
     createObjInitList(p, t, initIntSet(), initList)
     result = ("({$1})") % [initList]
     if indirect: result = "[$1]" % [result]
-  of tyVar, tyPtr, tyLent, tyRef, tyPointer:
+  of tyVar, tyPtr, tyRef, tyPointer:
     if mapType(p, t) == etyBaseIndex:
       result = putToSeq("[null, 0]", indirect)
     else:
@@ -2446,16 +2459,17 @@ proc genProc(oldProc: PProc, prc: PSym): Rope =
   if prc.typ[0] != nil and sfPure notin prc.flags:
     resultSym = prc.ast[resultPos].sym
     let mname = mangleName(p.module, resultSym)
-    if not isIndirect(resultSym) and
+    let returnAddress = not isIndirect(resultSym) and
       resultSym.typ.kind in {tyVar, tyPtr, tyLent, tyRef, tyOwned} and
-        mapType(p, resultSym.typ) == etyBaseIndex:
+        mapType(p, resultSym.typ) == etyBaseIndex
+    if returnAddress:
       resultAsgn = p.indentLine(("var $# = null;$n") % [mname])
       resultAsgn.add p.indentLine("var $#_Idx = 0;$n" % [mname])
     else:
       let resVar = createVar(p, resultSym.typ, isIndirect(resultSym))
       resultAsgn = p.indentLine(("var $# = $#;$n") % [mname, resVar])
     gen(p, prc.ast[resultPos], a)
-    if mapType(p, resultSym.typ) == etyBaseIndex:
+    if returnAddress:
       returnStmt = "return [$#, $#];$n" % [a.address, a.res]
     else:
       returnStmt = "return $#;$n" % [a.res]
@@ -2631,8 +2645,15 @@ proc gen(p: PProc, n: PNode, r: var TCompRes) =
   of nkObjConstr: genObjConstr(p, n, r)
   of nkHiddenStdConv, nkHiddenSubConv, nkConv: genConv(p, n, r)
   of nkAddr, nkHiddenAddr:
-    genAddr(p, n, r)
-  of nkDerefExpr, nkHiddenDeref: genDeref(p, n, r)
+    if n.typ.kind in {tyLent}:
+      gen(p, n[0], r)
+    else:
+      genAddr(p, n, r)
+  of nkDerefExpr, nkHiddenDeref:
+    if n.typ.kind in {tyLent}:
+      gen(p, n[0], r)
+    else:
+      genDeref(p, n, r)
   of nkBracketExpr: genArrayAccess(p, n, r)
   of nkDotExpr: genFieldAccess(p, n, r)
   of nkCheckedFieldExpr: genCheckedFieldOp(p, n, nil, r)
diff --git a/compiler/front/in_options.nim b/compiler/front/in_options.nim
index 9e1ab05ea44..721d6c695a8 100644
--- a/compiler/front/in_options.nim
+++ b/compiler/front/in_options.nim
@@ -193,7 +193,7 @@ type
     dynamicBindSym,
     forLoopMacros, ## not experimental anymore; remains here for backwards
                    ## compatibility
-    caseStmtMacros,
+    caseStmtMacros,## ditto
     codeReordering,
     compiletimeFFI,
       ## This requires building nim with `-d:nimHasLibFFI`
diff --git a/compiler/front/options.nim b/compiler/front/options.nim
index 803ca532d5c..e3943241008 100644
--- a/compiler/front/options.nim
+++ b/compiler/front/options.nim
@@ -25,7 +25,7 @@ const
   useEffectSystem* = true
   useWriteTracking* = false
   hasFFI* = defined(nimHasLibFFI)
-  copyrightYear* = "2021"
+  copyrightYear* = "2022"
 
   nimEnableCovariance* = defined(nimEnableCovariance)
 
diff --git a/compiler/modules/importer.nim b/compiler/modules/importer.nim
index dd7d34c4fa3..f7db7064455 100644
--- a/compiler/modules/importer.nim
+++ b/compiler/modules/importer.nim
@@ -214,11 +214,13 @@ template addUnnamedIt(c: PContext, fromMod: PSym; filter: untyped) {.dirty.} =
   for it in mitems c.graph.ifaces[fromMod.position].converters:
     if filter:
       loadPackedSym(c.graph, it)
-      addConverter(c, it)
+      if sfExported in it.sym.flags:
+        addConverter(c, it)
   for it in mitems c.graph.ifaces[fromMod.position].patterns:
     if filter:
       loadPackedSym(c.graph, it)
-      addPattern(c, it)
+      if sfExported in it.sym.flags:
+        addPattern(c, it)
   for it in mitems c.graph.ifaces[fromMod.position].pureEnums:
     if filter:
       loadPackedSym(c.graph, it)
diff --git a/compiler/sem/isolation_check.nim b/compiler/sem/isolation_check.nim
index 18542e90a23..f1a7d34c422 100644
--- a/compiler/sem/isolation_check.nim
+++ b/compiler/sem/isolation_check.nim
@@ -78,7 +78,7 @@ proc isValueOnlyType(t: PType): bool =
 
 proc canAlias*(arg, ret: PType): bool =
   if isValueOnlyType(arg):
-    # can alias only with unsafeAddr(arg.x) and we don't care if it is not safe
+    # can alias only with addr(arg.x) and we don't care if it is not safe
     result = false
   else:
     var marker = initIntSet()
diff --git a/compiler/sem/liftdestructors.nim b/compiler/sem/liftdestructors.nim
index 769b04e8fc7..f1d287ffc67 100644
--- a/compiler/sem/liftdestructors.nim
+++ b/compiler/sem/liftdestructors.nim
@@ -975,6 +975,12 @@ proc symPrototype(g: ModuleGraph; typ: PType; owner: PSym; kind: TTypeAttachedOp
   incl result.flags, sfFromGeneric
   incl result.flags, sfGeneratedOp
 
+proc genTypeFieldCopy(c: var TLiftCtx; t: PType; body, x, y: PNode) =
+  let xx = genBuiltin(c, mAccessTypeField, "accessTypeField", x)
+  let yy = genBuiltin(c, mAccessTypeField, "accessTypeField", y)
+  xx.typ = getSysType(c.g, c.info, tyPointer)
+  yy.typ = xx.typ
+  body.add newAsgnStmt(xx, yy)
 
 proc produceSym(g: ModuleGraph; c: PContext; typ: PType; kind: TTypeAttachedOp;
               info: TLineInfo; idgen: IdGenerator): PSym =
@@ -1014,6 +1020,10 @@ proc produceSym(g: ModuleGraph; c: PContext; typ: PType; kind: TTypeAttachedOp;
       fillStrOp(a, typ, result.ast[bodyPos], d, src)
     else:
       fillBody(a, typ, result.ast[bodyPos], d, src)
+      if tk == tyObject and a.kind in {attachedAsgn, attachedSink, attachedDeepCopy} and not lacksMTypeField(typ):
+        # bug #19205: Do not forget to also copy the hidden type field:
+        genTypeFieldCopy(a, typ, result.ast[bodyPos], d, src)
+
   if not a.canRaise: incl result.flags, sfNeverRaises
   completePartialOp(g, idgen.module, typ, kind, result)
 
diff --git a/compiler/sem/optimizer.nim b/compiler/sem/optimizer.nim
index ff6bcb81364..130b6fb75d6 100644
--- a/compiler/sem/optimizer.nim
+++ b/compiler/sem/optimizer.nim
@@ -127,11 +127,11 @@ proc analyse(c: var Con; b: var BasicBlock; n: PNode) =
         for i in 0 ..< n.len:
           analyse(c, b, n[i])
       else:
-        #[ Test tmatrix.test3:
+        #[ Test destructor/tmatrix.test3:
         Prevent this from being elided. We should probably
         find a better solution...
 
-            `=sink`(b, - (
+            `=sink`(b, -
               let blitTmp = b;
               wasMoved(b);
               blitTmp + a)
diff --git a/compiler/sem/parampatterns.nim b/compiler/sem/parampatterns.nim
index 7b9ef8181af..3b1f2bae2ac 100644
--- a/compiler/sem/parampatterns.nim
+++ b/compiler/sem/parampatterns.nim
@@ -169,8 +169,11 @@ proc checkForSideEffects*(n: PNode): TSideEffectAnalysis =
       let s = op.sym
       if sfSideEffect in s.flags:
         return seSideEffect
-      # assume no side effect:
-      result = seNoSideEffect
+      elif tfNoSideEffect in op.typ.flags:
+        result = seNoSideEffect
+      else:
+        # assume side effect:
+        result = seSideEffect
     elif tfNoSideEffect in op.typ.flags:
       # indirect call without side effects:
       result = seNoSideEffect
diff --git a/compiler/sem/semfold.nim b/compiler/sem/semfold.nim
index 0010c9bdd39..655d6ac0ca5 100644
--- a/compiler/sem/semfold.nim
+++ b/compiler/sem/semfold.nim
@@ -321,13 +321,7 @@ proc evalOp(m: TMagic, n, a, b, c: PNode; idgen: IdGenerator; g: ModuleGraph): P
     else: result = newStrNodeT("true", n, g)
   of mFloatToStr: result = newStrNodeT($getFloat(a), n, g)
   of mCStrToStr, mCharToStr:
-    if a.kind == nkBracket:
-      var s = ""
-      for b in a.sons:
-        s.add b.getStrOrChar
-      result = newStrNodeT(s, n, g)
-    else:
-      result = newStrNodeT(getStrOrChar(a), n, g)
+    result = newStrNodeT(getStrOrChar(a), n, g)
   of mStrToStr: result = newStrNodeT(getStrOrChar(a), n, g)
   of mEnumToStr: result = newStrNodeT(ordinalValToString(a, g), n, g)
   of mArrToSeq:
diff --git a/compiler/sem/semmagic.nim b/compiler/sem/semmagic.nim
index ca8d3adaf43..0864ccc463e 100644
--- a/compiler/sem/semmagic.nim
+++ b/compiler/sem/semmagic.nim
@@ -16,12 +16,12 @@ proc semAddrArg(c: PContext; n: PNode; isUnsafeAddr = false): PNode =
   let x = semExprWithType(c, n)
   if x.kind == nkSym:
     x.sym.flags.incl(sfAddrTaken)
-  if isAssignable(c, x, isUnsafeAddr) notin {arLValue, arLocalLValue}:
+  if isAssignable(c, x, true) notin {arLValue, arLocalLValue}:
     # Do not suggest the use of unsafeAddr if this expression already is a
     # unsafeAddr
     localReport(c.config, n.info) do:
       reportSem(rsemExprHasNoAddress).withIt do:
-        it.isUnsafeAddr = isUnsafeAddr
+        it.isUnsafeAddr = true
 
   result = x
 
diff --git a/compiler/sem/semobjconstr.nim b/compiler/sem/semobjconstr.nim
index bc732479dea..9f8e3aeea01 100644
--- a/compiler/sem/semobjconstr.nim
+++ b/compiler/sem/semobjconstr.nim
@@ -449,12 +449,12 @@ proc defaultConstructionError(c: PContext, t: PType, info: TLineInfo) =
   if objType.kind == tyObject:
     var constrCtx = initConstrContext(objType, newNodeI(nkObjConstr, info))
     let initResult = semConstructTypeAux(c, constrCtx, {})
-    assert constrCtx.missingFields.len > 0
-    localReport(
-      c.config, info,
-      reportSymbols(
-        rsemObjectRequiresFieldInitNoDefault,
-        constrCtx.missingFields, typ = t))
+    if constrCtx.missingFields.len > 0:
+      localReport(
+        c.config, info,
+        reportSymbols(
+          rsemObjectRequiresFieldInitNoDefault,
+          constrCtx.missingFields, typ = t))
 
   elif objType.kind == tyDistinct:
     localReport(c.config, info, reportTyp(
diff --git a/compiler/sem/semstmts.nim b/compiler/sem/semstmts.nim
index 928d5a71dd6..9d7982d5acd 100644
--- a/compiler/sem/semstmts.nim
+++ b/compiler/sem/semstmts.nim
@@ -1009,10 +1009,9 @@ proc semCase(c: PContext, n: PNode; flags: TExprFlags): PNode =
   else:
     popCaseContext(c)
     closeScope(c)
-    if caseStmtMacros in c.features:
-      result = handleCaseStmtMacro(c, n, flags)
-      if result != nil:
-        return result
+    result = handleCaseStmtMacro(c, n, flags)
+    if result != nil:
+      return result
     result[0] = c.config.newError(n[0], reportSem rsemSelectorMustBeOfCertainTypes)
     return
   for i in 1..<n.len:
diff --git a/compiler/sem/semtempl.nim b/compiler/sem/semtempl.nim
index 2b440540be7..7c5d0095a14 100644
--- a/compiler/sem/semtempl.nim
+++ b/compiler/sem/semtempl.nim
@@ -281,7 +281,8 @@ proc semTemplSymbol(c: PContext, n: PNode, s: PSym; isField: bool): PNode =
     # Issue #12832
     when defined(nimsuggest):
       suggestSym(c.graph, n.info, s, c.graph.usageSym, false)
-    if {optStyleHint, optStyleError} * c.config.globalOptions != {}:
+    # field access (dot expr) will be handled by builtinFieldAccess
+    if not isField and {optStyleHint, optStyleError} * c.config.globalOptions != {}:
       styleCheckUse(c.config, n.info, s)
 
 proc semRoutineInTemplName(c: var TemplCtx, n: PNode): PNode =
diff --git a/compiler/sem/sigmatch.nim b/compiler/sem/sigmatch.nim
index c19bc11b7f3..66fbabe6958 100644
--- a/compiler/sem/sigmatch.nim
+++ b/compiler/sem/sigmatch.nim
@@ -1686,7 +1686,8 @@ typeRel can be used to establish various relationships between types:
             var aa = a
             while aa.kind in {tyTypeDesc, tyGenericParam} and aa.len > 0:
               aa = lastSon(aa)
-            if aa.kind == tyGenericParam:
+            if aa.kind in {tyGenericParam} + tyTypeClasses:
+              # If the constraint is a genericParam or typeClass this isGeneric
               return isGeneric
             result = typeRel(c, f.base, aa, flags)
             if result > isGeneric: result = isGeneric
diff --git a/compiler/sem/typeallowed.nim b/compiler/sem/typeallowed.nim
index 60c1e11422d..a2f35e0b6f3 100644
--- a/compiler/sem/typeallowed.nim
+++ b/compiler/sem/typeallowed.nim
@@ -60,6 +60,8 @@ proc typeAllowedAux(marker: var IntSet, typ: PType, kind: TSymKind,
   of tyVar, tyLent:
     if kind in {skProc, skFunc, skConst} and (views notin c.features):
       result = t
+    elif taIsOpenArray in flags:
+      result = t
     elif t.kind == tyLent and ((kind != skResult and views notin c.features) or
                               kind == skParam): # lent can't be used as parameters.
       result = t
@@ -234,7 +236,7 @@ proc classifyViewTypeAux(marker: var IntSet, t: PType): ViewTypeKind =
   case t.kind
   of tyVar:
     result = mutableView
-  of tyLent, tyOpenArray:
+  of tyLent, tyOpenArray, tyVarargs:
     result = immutableView
   of tyGenericInst, tyDistinct, tyAlias, tyInferred, tySink, tyOwned,
      tyUncheckedArray, tySequence, tyArray, tyRef, tyStatic:
diff --git a/compiler/sem/varpartitions.nim b/compiler/sem/varpartitions.nim
index 6c7d0f3c727..acd6d334149 100644
--- a/compiler/sem/varpartitions.nim
+++ b/compiler/sem/varpartitions.nim
@@ -497,7 +497,7 @@ proc destMightOwn(c: var Partitions; dest: var VarIndex; n: PNode) =
         # calls do construct, what we construct must be destroyed,
         # so dest cannot be a cursor:
         dest.flags.incl ownsData
-      elif n.typ.kind in {tyLent, tyVar}:
+      elif n.typ.kind in {tyLent, tyVar} and n.len > 1:
         # we know the result is derived from the first argument:
         var roots: seq[(PSym, int)]
         allRoots(n[1], roots, RootEscapes)
diff --git a/compiler/utils/bitsets.nim b/compiler/utils/bitsets.nim
index 2e8aa1db6e4..e0d94409eb8 100644
--- a/compiler/utils/bitsets.nim
+++ b/compiler/utils/bitsets.nim
@@ -23,53 +23,40 @@ const
 template modElemSize(arg: untyped): untyped = arg and 7
 template divElemSize(arg: untyped): untyped = arg shr 3
 
-proc bitSetInit*(b: var TBitSet, length: int)
-proc bitSetUnion*(x: var TBitSet, y: TBitSet)
-proc bitSetDiff*(x: var TBitSet, y: TBitSet)
-proc bitSetSymDiff*(x: var TBitSet, y: TBitSet)
-proc bitSetIntersect*(x: var TBitSet, y: TBitSet)
-proc bitSetIncl*(x: var TBitSet, elem: BiggestInt)
-proc bitSetExcl*(x: var TBitSet, elem: BiggestInt)
-proc bitSetIn*(x: TBitSet, e: BiggestInt): bool
-proc bitSetEquals*(x, y: TBitSet): bool
-proc bitSetContains*(x, y: TBitSet): bool
-proc bitSetCard*(x: TBitSet): BiggestInt
-# implementation
-
-proc bitSetIn(x: TBitSet, e: BiggestInt): bool =
+proc bitSetIn*(x: TBitSet, e: BiggestInt): bool =
   result = (x[int(e.divElemSize)] and (One shl e.modElemSize)) != Zero
 
-proc bitSetIncl(x: var TBitSet, elem: BiggestInt) =
+proc bitSetIncl*(x: var TBitSet, elem: BiggestInt) =
   assert(elem >= 0)
   x[int(elem.divElemSize)] = x[int(elem.divElemSize)] or
       (One shl elem.modElemSize)
 
-proc bitSetExcl(x: var TBitSet, elem: BiggestInt) =
+proc bitSetExcl*(x: var TBitSet, elem: BiggestInt) =
   x[int(elem.divElemSize)] = x[int(elem.divElemSize)] and
       not(One shl elem.modElemSize)
 
-proc bitSetInit(b: var TBitSet, length: int) =
+proc bitSetInit*(b: var TBitSet, length: int) =
   newSeq(b, length)
 
-proc bitSetUnion(x: var TBitSet, y: TBitSet) =
+proc bitSetUnion*(x: var TBitSet, y: TBitSet) =
   for i in 0..high(x): x[i] = x[i] or y[i]
 
-proc bitSetDiff(x: var TBitSet, y: TBitSet) =
+proc bitSetDiff*(x: var TBitSet, y: TBitSet) =
   for i in 0..high(x): x[i] = x[i] and not y[i]
 
-proc bitSetSymDiff(x: var TBitSet, y: TBitSet) =
+proc bitSetSymDiff*(x: var TBitSet, y: TBitSet) =
   for i in 0..high(x): x[i] = x[i] xor y[i]
 
-proc bitSetIntersect(x: var TBitSet, y: TBitSet) =
+proc bitSetIntersect*(x: var TBitSet, y: TBitSet) =
   for i in 0..high(x): x[i] = x[i] and y[i]
 
-proc bitSetEquals(x, y: TBitSet): bool =
+proc bitSetEquals*(x, y: TBitSet): bool =
   for i in 0..high(x):
     if x[i] != y[i]:
       return false
   result = true
 
-proc bitSetContains(x, y: TBitSet): bool =
+proc bitSetContains*(x, y: TBitSet): bool =
   for i in 0..high(x):
     if (x[i] and not y[i]) != Zero:
       return false
@@ -96,6 +83,6 @@ const populationCount: array[uint8, uint8] = block:
 
     arr
 
-proc bitSetCard(x: TBitSet): BiggestInt =
+proc bitSetCard*(x: TBitSet): BiggestInt =
   for it in x:
     result.inc int(populationCount[it])
diff --git a/compiler/utils/platform.nim b/compiler/utils/platform.nim
index 1bc00b62923..107003cb636 100644
--- a/compiler/utils/platform.nim
+++ b/compiler/utils/platform.nim
@@ -197,7 +197,8 @@ type
     cpuNone, cpuI386, cpuM68k, cpuAlpha, cpuPowerpc, cpuPowerpc64,
     cpuPowerpc64el, cpuSparc, cpuVm, cpuHppa, cpuIa64, cpuAmd64, cpuMips,
     cpuMipsel, cpuArm, cpuArm64, cpuJS, cpuNimVM, cpuAVR, cpuMSP430,
-    cpuSparc64, cpuMips64, cpuMips64el, cpuRiscV32, cpuRiscV64, cpuEsp, cpuWasm32
+    cpuSparc64, cpuMips64, cpuMips64el, cpuRiscV32, cpuRiscV64, cpuEsp, cpuWasm32,
+    cpuE2k, cpuLoongArch64
 
 type
   TInfoCPU* = tuple[name: string, intSize: int, endian: Endianness,
@@ -232,7 +233,9 @@ const
     (name: "riscv32", intSize: 32, endian: littleEndian, floatSize: 64, bit: 32),
     (name: "riscv64", intSize: 64, endian: littleEndian, floatSize: 64, bit: 64),
     (name: "esp", intSize: 32, endian: littleEndian, floatSize: 64, bit: 32),
-    (name: "wasm32", intSize: 32, endian: littleEndian, floatSize: 64, bit: 32)]
+    (name: "wasm32", intSize: 32, endian: littleEndian, floatSize: 64, bit: 32),
+    (name: "e2k", intSize: 64, endian: littleEndian, floatSize: 64, bit: 64),
+    (name: "loongarch64", intSize: 64, endian: littleEndian, floatSize: 64, bit: 64)]
 
 type
   Target* = object
diff --git a/compiler/vm/vm.nim b/compiler/vm/vm.nim
index 6359fafaa79..3aa20205e83 100644
--- a/compiler/vm/vm.nim
+++ b/compiler/vm/vm.nim
@@ -142,9 +142,9 @@ proc reportException(c: PCtx; tos: PStackFrame, raised: PNode) =
 when not defined(nimComputedGoto):
   {.pragma: computedGoto.}
 
-proc ensureKind(n: var TFullReg, kind: TRegisterKind) =
-  if n.kind != kind:
-    n = TFullReg(kind: kind)
+proc ensureKind(n: var TFullReg, k: TRegisterKind) {.inline.} =
+  if n.kind != k:
+    n = TFullReg(kind: k)
 
 template ensureKind(k: untyped) {.dirty.} =
   ensureKind(regs[ra], k)
@@ -569,6 +569,11 @@ template maybeHandlePtr(node2: PNode, reg: TFullReg, isAssign2: bool): bool =
 when not defined(nimHasSinkInference):
   {.pragma: nosinks.}
 
+template takeAddress(reg, source) =
+  reg.nodeAddr = addr source
+  when defined(gcDestructors):
+    GC_ref source
+
 proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
   var pc = start
   var tos = tos
@@ -760,7 +765,7 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
       let idx = regs[rc].intVal.int
       let src = if regs[rb].kind == rkNode: regs[rb].node else: regs[rb].nodeAddr[]
       if src.kind notin {nkEmpty..nkTripleStrLit} and idx <% src.len:
-        regs[ra].nodeAddr = addr src.sons[idx]
+        takeAddress regs[ra], src.sons[idx]
       else:
         stackTrace(c, tos, pc, reportVmIdx(idx, src.safeLen-1))
     of opcLdStrIdx:
@@ -832,11 +837,11 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
       of nkObjConstr:
         let n = src.sons[rc + 1]
         if n.kind == nkExprColonExpr:
-          regs[ra].nodeAddr = addr n.sons[1]
+          takeAddress regs[ra], n.sons[1]
         else:
-          regs[ra].nodeAddr = addr src.sons[rc + 1]
+          takeAddress regs[ra], src.sons[rc + 1]
       else:
-        regs[ra].nodeAddr = addr src.sons[rc]
+        takeAddress regs[ra], src.sons[rc]
     of opcWrObj:
       # a.b = c
       decodeBC(rkNode)
@@ -864,7 +869,7 @@ proc rawExecute(c: PCtx, start: int, tos: PStackFrame): TFullReg =
       decodeB(rkNodeAddr)
       case regs[rb].kind
       of rkNode:
-        regs[ra].nodeAddr = addr(regs[rb].node)
+        takeAddress regs[ra], regs[rb].node
       of rkNodeAddr: # bug #14339
         regs[ra].nodeAddr = regs[rb].nodeAddr
       else:
diff --git a/config/config.nims b/config/config.nims
index 893d6960fa1..88c344642a7 100644
--- a/config/config.nims
+++ b/config/config.nims
@@ -3,6 +3,11 @@
 cppDefine "errno"
 cppDefine "unix"
 
+# mangle the macro names in nimbase.h
+cppDefine "NAN_INFINITY"
+cppDefine "INF"
+cppDefine "NAN"
+
 when defined(nimStrictMode):
   # xxx add more flags here, and use `-d:nimStrictMode` in more contexts in CI.
 
diff --git a/config/nim.cfg b/config/nim.cfg
index 3b964d124e2..7fe279f5631 100644
--- a/config/nim.cfg
+++ b/config/nim.cfg
@@ -2,6 +2,7 @@
 # (c) 2017 Andreas Rumpf
 
 # Feel free to edit the default values as you need.
+# See https://nim-lang.org/docs/nimc.html
 
 # You may set environment variables with
 # @putenv "key" "val"
@@ -17,11 +18,21 @@ hint[LineTooLong]=off
 #hint[XDeclaredButNotUsed]=off
 
 # Examples of how to setup a cross-compiler:
+# Nim can target architectures and OSes different than the local host
+# Syntax: <arch>.<os>.gcc.exe = "<compiler executable>"
+#         <arch>.<os>.gcc.linkerexe = "<linker executable>"
 
-# Cross-compiling for Raspberry Pi.
-# (This compiler is available in gcc-arm-linux-gnueabihf package on Ubuntu)
+# ARM e.g. Raspberry Pi 2: gcc-arm-linux-gnueabihf package on Debian/Ubuntu
 arm.linux.gcc.exe = "arm-linux-gnueabihf-gcc"
 arm.linux.gcc.linkerexe = "arm-linux-gnueabihf-gcc"
+# ARM64/aarch64 e.g. Raspberry Pi 3: gcc-aarch64-linux-gnu package on Debian/Ubuntu
+arm64.linux.gcc.exe = "aarch64-linux-gnu-gcc"
+arm64.linux.gcc.linkerexe = "aarch64-linux-gnu-gcc"
+# RISC-V: gcc-riscv64-linux-gnu package on Debian/Ubuntu
+riscv32.linux.gcc.exe = "riscv64-linux-gnu-gcc"
+riscv32.linux.gcc.linkerexe = "riscv64-linux-gnu-gcc"
+riscv64.linux.gcc.exe = "riscv64-linux-gnu-gcc"
+riscv64.linux.gcc.linkerexe = "arm-linux-gnueabihf-gcc"
 
 # For OpenWRT, you will also need to adjust PATH to point to your toolchain.
 mips.linux.gcc.exe = "mips-openwrt-linux-gcc"
@@ -44,10 +55,12 @@ path="$lib/core"
 path="$lib/pure"
 
 @if not windows:
+  nimblepath="/opt/nimble/pkgs2/"
   nimblepath="/opt/nimble/pkgs/"
 @else:
   # TODO:
 @end
+nimblepath="$home/.nimble/pkgs2/"
 nimblepath="$home/.nimble/pkgs/"
 
 # Syncronize with compiler/commands.specialDefine
@@ -154,9 +167,6 @@ nimblepath="$home/.nimble/pkgs/"
 # Configuration for the GNU C/C++ compiler:
 @if windows:
   #gcc.path = r"$nim\dist\mingw\bin"
-  @if gcc or tcc:
-    tlsEmulation:on
-  @end
 @end
 
 gcc.maxerrorsimpl = "-fmax-errors=3"
diff --git a/config/nimdoc.tex.cfg b/config/nimdoc.tex.cfg
index 4aff9b379f9..1826d1f56d9 100644
--- a/config/nimdoc.tex.cfg
+++ b/config/nimdoc.tex.cfg
@@ -55,6 +55,11 @@ doc.file = """
 %
 % Compile it by:   xelatex    (up to 3 times to get labels generated)
 %                  -------
+% For example:
+%   xelatex file.tex
+%   xelatex file.tex
+%   makeindex file
+%   xelatex file.tex
 %
 \documentclass[a4paper,11pt]{article}
 \usepackage[a4paper,xetex,left=3cm,right=3cm,top=1.5cm,bottom=2cm]{geometry}
@@ -97,7 +102,9 @@ doc.file = """
 \usepackage{parskip}  % paragraphs delimited by vertical space, no indent
 \usepackage{graphicx}
 
-\newcommand{\nimindexterm}[2]{#2\label{#1}}
+\usepackage{makeidx}
+\newcommand{\nimindexterm}[2]{#2\index{#2}\label{#1}}
+\makeindex
 
 \usepackage{dingbat} % for \carriagereturn, etc
 \usepackage{fvextra}  % for code blocks (works better than original fancyvrb)
@@ -241,5 +248,8 @@ doc.file = """
 \maketitle
 
 $content
+
+\printindex
+
 \end{document}
 """
diff --git a/copying.txt b/copying.txt
index a498a952534..60b6a02170a 100644
--- a/copying.txt
+++ b/copying.txt
@@ -1,7 +1,7 @@
 =====================================================
 Nim -- a Compiler for Nim. https://nim-lang.org/
 
-Copyright (C) 2006-2021 Andreas Rumpf. All rights reserved.
+Copyright (C) 2006-2022 Andreas Rumpf. All rights reserved.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/doc/backends.rst b/doc/backends.rst
index ea50853c6d7..9b080db350d 100644
--- a/doc/backends.rst
+++ b/doc/backends.rst
@@ -52,7 +52,7 @@ The commands to compile to either C, C++ or Objective-C are:
 The most significant difference between these commands is that if you look
 into the ``nimcache`` directory you will find ``.c``, ``.cpp`` or ``.m``
 files, other than that all of them will produce a native binary for your
-project.  This allows you to take the generated code and place it directly
+project. This allows you to take the generated code and place it directly
 into a project using any of these languages. Here are some typical command-
 line invocations:
 
@@ -123,7 +123,7 @@ Nim code can interface with the backend through the `Foreign function
 interface <manual.html#foreign-function-interface>`_ mainly through the
 `importc pragma <manual.html#foreign-function-interface-importc-pragma>`_.
 The `importc` pragma is the *generic* way of making backend symbols available
-in Nim and is available in all the target backends (JavaScript too).  The C++
+in Nim and is available in all the target backends (JavaScript too). The C++
 or Objective-C backends have their respective `ImportCpp
 <manual.html#implementation-specific-pragmas-importcpp-pragma>`_ and
 `ImportObjC <manual.html#implementation-specific-pragmas-importobjc-pragma>`_
@@ -246,11 +246,6 @@ Also, C code requires you to specify a forward declaration for functions or
 the compiler will assume certain types for the return value and parameters
 which will likely make your program crash at runtime.
 
-The Nim compiler can generate a C interface header through the `--header`:option:
-command-line switch. The generated header will contain all the exported
-symbols and the `NimMain` proc which you need to call before any other
-Nim code.
-
 
 Nim invocation example from C
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -269,9 +264,10 @@ Create a ``maths.c`` file with the following content:
 
 .. code-block:: c
 
-  #include "fib.h"
   #include <stdio.h>
 
+  extern int fib(int a);
+
   int main(void)
   {
     NimMain();
@@ -286,13 +282,12 @@ program:
 
 .. code:: cmd
 
-  nim c --noMain --noLinking --header:fib.h fib.nim
+  nim c --noMain --noLinking fib.nim
   gcc -o m -I$HOME/.cache/nim/fib_d -Ipath/to/nim/lib $HOME/.cache/nim/fib_d/*.c maths.c
 
 The first command runs the Nim compiler with three special options to avoid
-generating a `main()`:c: function in the generated files, avoid linking the
-object files into a final binary, and explicitly generate a header file for C
-integration. All the generated files are placed into the ``nimcache``
+generating a `main()`:c: function in the generated files and to avoid linking the
+object files into a final binary. All the generated files are placed into the ``nimcache``
 directory. That's why the next command compiles the ``maths.c`` source plus
 all the ``.c`` files from ``nimcache``. In addition to this path, you also
 have to tell the C compiler where to find Nim's ``nimbase.h`` header file.
@@ -302,12 +297,12 @@ also ask the Nim compiler to generate a statically linked library:
 
 .. code:: cmd
 
-  nim c --app:staticLib --noMain --header fib.nim
+  nim c --app:staticLib --noMain fib.nim
   gcc -o m -Inimcache -Ipath/to/nim/lib libfib.nim.a maths.c
 
 The Nim compiler will handle linking the source files generated in the
 ``nimcache`` directory into the ``libfib.nim.a`` static library, which you can
-then link into your C program.  Note that these commands are generic and will
+then link into your C program. Note that these commands are generic and will
 vary for each system. For instance, on Linux systems you will likely need to
 use `-ldl`:option: too to link in required dlopen functionality.
 
diff --git a/doc/basicopt.txt b/doc/basicopt.txt
index a2db1c92ec9..390fc6fd23d 100644
--- a/doc/basicopt.txt
+++ b/doc/basicopt.txt
@@ -27,11 +27,11 @@ Options:
   -a, --assertions:on|off   turn assertions on|off
   --opt:none|speed|size     optimize not at all or for speed|size
                             Note: use -d:release for a release build!
-  --debugger:native         Use native debugger (gdb)
+  --debugger:native         use native debugger (gdb)
   --app:console|gui|lib|staticlib
                             generate a console app|GUI app|DLL|static library
   -r, --run                 run the compiled program with given arguments
-  --eval:cmd                evaluates nim code directly; e.g.: `nim --eval:"echo 1"`
+  --eval:cmd                evaluate nim code directly; e.g.: `nim --eval:"echo 1"`
                             defaults to `e` (nimscript) but customizable:
                             `nim r --eval:'for a in stdin.lines: echo a'`
   --fullhelp                show all command line switches
diff --git a/doc/destructors.rst b/doc/destructors.rst
index 195dc8f9758..83a50230b91 100644
--- a/doc/destructors.rst
+++ b/doc/destructors.rst
@@ -101,7 +101,7 @@ The memory management for Nim's standard `string` and `seq` types as
 well as other standard collections is performed via so-called
 "Lifetime-tracking hooks", which are particular `type bound operators <manual.html#procedures-type-bound-operators>`_.
 
-There are 3 different hooks for each (generic or concrete) object type `T` (`T` can also be a
+There are 4 different hooks for each (generic or concrete) object type `T` (`T` can also be a
 `distinct` type) that are called implicitly by the compiler.
 
 (Note: The word "hook" here does not imply any kind of dynamic binding
@@ -555,14 +555,14 @@ for expressions of type `lent T` or of type `var T`.
     echo t[0] # accessor does not copy the element!
 
 
-The .cursor annotation
-======================
+The cursor pragma
+=================
 
 Under the `--gc:arc|orc`:option: modes Nim's `ref` type is implemented
 via the same runtime "hooks" and thus via reference counting.
 This means that cyclic structures cannot be freed
 immediately (`--gc:orc`:option: ships with a cycle collector).
-With the `.cursor` annotation one can break up cycles declaratively:
+With the `cursor` pragma one can break up cycles declaratively:
 
 .. code-block:: nim
 
@@ -575,7 +575,7 @@ But please notice that this is not C++'s weak_ptr, it means the right field is n
 involved in the reference counting, it is a raw pointer without runtime checks.
 
 Automatic reference counting also has the disadvantage that it introduces overhead
-when iterating over linked structures. The `.cursor` annotation can also be used
+when iterating over linked structures. The `cursor` pragma can also be used
 to avoid this overhead:
 
 .. code-block:: nim
@@ -586,10 +586,10 @@ to avoid this overhead:
     it = it.next
 
 
-In fact, `.cursor` more generally prevents object construction/destruction pairs
+In fact, `cursor` more generally prevents object construction/destruction pairs
 and so can also be useful in other contexts. The alternative solution would be to
 use raw pointers (`ptr`) instead which is more cumbersome and also more dangerous
-for Nim's evolution: Later on, the compiler can try to prove `.cursor` annotations
+for Nim's evolution: Later on, the compiler can try to prove `cursor` pragmas
 to be safe, but for `ptr` the compiler has to remain silent about possible
 problems.
 
@@ -597,7 +597,7 @@ problems.
 Cursor inference / copy elision
 ===============================
 
-The current implementation also performs `.cursor` inference. Cursor inference is
+The current implementation also performs `cursor` inference. Cursor inference is
 a form of copy elision.
 
 To see how and when we can do that, think about this question: In `dest = src` when
@@ -612,7 +612,7 @@ indirections:
 .. code-block:: nim
 
   proc main(tab: Table[string, string]) =
-    let v = tab["key"] # inferred as .cursor because 'tab' is not mutated.
+    let v = tab["key"] # inferred as cursor because 'tab' is not mutated.
     # no copy into 'v', no destruction of 'v'.
     use(v)
     useItAgain(v)
@@ -653,7 +653,7 @@ The ability to override a hook leads to a phase ordering problem:
     discard
 
 
-The solution is to define `proc `=destroy`[T](f: var Foo[T])` before
+The solution is to define ``proc `=destroy`[T](f: var Foo[T])`` before
 it is used. The compiler generates implicit
 hooks for all types in *strategic places* so that an explicitly provided
 hook that comes too "late" can be detected reliably. These *strategic places*
diff --git a/doc/grammar.txt b/doc/grammar.txt
index 8f86dd98c28..bf6d381deaf 100644
--- a/doc/grammar.txt
+++ b/doc/grammar.txt
@@ -37,10 +37,10 @@ parKeyw = 'discard' | 'include' | 'if' | 'while' | 'case' | 'try'
         | 'finally' | 'except' | 'for' | 'block' | 'const' | 'let'
         | 'when' | 'var' | 'mixin'
 par = '(' optInd
-          ( &parKeyw (ifExpr \ complexOrSimpleStmt) ^+ ';'
-          | ';' (ifExpr \ complexOrSimpleStmt) ^+ ';'
+          ( &parKeyw (ifExpr / complexOrSimpleStmt) ^+ ';'
+          | ';' (ifExpr / complexOrSimpleStmt) ^+ ';'
           | pragmaStmt
-          | simpleExpr ( ('=' expr (';' (ifExpr \ complexOrSimpleStmt) ^+ ';' )? )
+          | simpleExpr ( ('=' expr (';' (ifExpr / complexOrSimpleStmt) ^+ ';' )? )
                        | (':' expr (',' exprColonEqExpr     ^+ ',' )? ) ) )
           optPar ')'
 literal = | INT_LIT | INT8_LIT | INT16_LIT | INT32_LIT | INT64_LIT
diff --git a/doc/intern.rst b/doc/intern.rst
index 9cb0c0dfdaf..71c404fde8c 100644
--- a/doc/intern.rst
+++ b/doc/intern.rst
@@ -210,7 +210,7 @@ current commit:
 
 You can also bisect using custom options to build the compiler, for example if
 you don't need a debug version of the compiler (which runs slower), you can replace
-`./koch.py temp`:cmd: by explicit compilation command, see `Rebuilding the compiler`_.
+`./koch.py temp`:cmd: by explicit compilation command, see `Bootstrapping the compiler`_.
 
 Runtimes
 ========
diff --git a/doc/lib.rst b/doc/lib.rst
index db7d0548667..1ae68389157 100644
--- a/doc/lib.rst
+++ b/doc/lib.rst
@@ -134,12 +134,6 @@ Collections
 * `sets <sets.html>`_
   Nim hash set support.
 
-* `sharedlist <sharedlist.html>`_
-  Nim shared linked list support. Contains a shared singly-linked list.
-
-* `sharedtables <sharedtables.html>`_
-  Nim shared hash table support. Contains shared tables.
-
 * `tables <tables.html>`_
   Nim hash table support. Contains tables, ordered tables, and count tables.
 
@@ -452,7 +446,7 @@ Hashing
   from the MongoDB interface and it thus binary compatible with a MongoDB OID.
 
 * `sha1 <sha1.html>`_
-  This module implements a sha1 encoder and decoder.
+  This module implements the SHA-1 checksum algorithm.
 
 
 Miscellaneous
diff --git a/doc/manual.rst b/doc/manual.rst
index 208bf515d6c..e1d993f6cd4 100644
--- a/doc/manual.rst
+++ b/doc/manual.rst
@@ -497,10 +497,10 @@ backtick token and the character literal. This special case ensures that a decla
 like ``proc `'customLiteral`(s: string)`` is valid. ``proc `'customLiteral`(s: string)``
 is the same as ``proc `'\''customLiteral`(s: string)``.
 
-See also `Custom Numeric Literals <#custom-numeric-literals>`_.
+See also `custom numeric literals <#custom-numeric-literals>`_.
 
 
-Numeric Literals
+Numeric literals
 ----------------
 
 Numeric literals have the form::
@@ -625,7 +625,7 @@ Hence: 0b10000000'u8 == 0x80'u8 == 128, but, 0b10000000'i8 == 0x80'i8 == -1
 instead of causing an overflow error.
 
 
-Custom Numeric Literals
+Custom numeric literals
 ~~~~~~~~~~~~~~~~~~~~~~~
 
 If the suffix is not predefined, then the suffix is assumed to be a call
@@ -700,26 +700,6 @@ contain a dot: `{..}` are the three tokens `{`:tok:, `..`:tok:, `}`:tok:
 and not the two tokens `{.`:tok:, `.}`:tok:.
 
 
-Unicode Operators
------------------
-
-Under the `--experimental:unicodeOperators` switch these Unicode operators are
-also parsed as operators::
-
-  ∙ ∘ × ★ ⊗ ⊘ ⊙ ⊛ ⊠ ⊡ ∩ ∧ ⊓   # same priority as * (multiplication)
-  ± ⊕ ⊖ ⊞ ⊟ ∪ ∨ ⊔             # same priority as + (addition)
-
-
-If enabled, Unicode operators can be combined with non-Unicode operator
-symbols. The usual precedence extensions then apply, for example, `⊠=` is an
-assignment like operator just like `*=` is.
-
-No Unicode normalization step is performed.
-
-**Note**: Due to parser limitations one **cannot** enable this feature via a
-pragma `{.experimental: "unicodeOperators".}` reliably.
-
-
 Syntax
 ======
 
@@ -1323,46 +1303,6 @@ as `MyEnum.value`:
 
 To implement bit fields with enums see `Bit fields <#set-type-bit-fields>`_
 
-Overloadable enum field names
------------------------------
-
-To be enabled via `{.experimental: "overloadableEnums".}`.
-
-Enum field names are overloadable much like routines. When an overloaded
-enum field is used, it produces a closed sym choice construct, here
-written as `(E|E)`.
-During overload resolution the right `E` is picked, if possible.
-For (array/object...) constructors the right `E` is picked, comparable to
-how `[byte(1), 2, 3]` works, one needs to use `[T.E, E2, E3]`. Ambiguous
-enum fields produce a static error:
-
-.. code-block:: nim
-    :test: "nim c $1"
-
-  {.experimental: "overloadableEnums".}
-
-  type
-    E1 = enum
-      value1,
-      value2
-    E2 = enum
-      value1,
-      value2 = 4
-
-  const
-    Lookuptable = [
-      E1.value1: "1",
-      value2: "2"
-    ]
-
-  proc p(e: E1) =
-    # disambiguation in 'case' statements:
-    case e
-    of value1: echo "A"
-    of value2: echo "B"
-
-  p value2
-
 
 String type
 -----------
@@ -1684,11 +1624,6 @@ must match the order of the tuple's definition. Different tuple-types are
 *equivalent* if they specify the same fields of the same type in the same
 order. The *names* of the fields also have to be the same.
 
-The assignment operator for tuples copies each component.
-The default assignment operator for objects copies each component. Overloading
-of the assignment operator is described `here
-<manual_experimental.html#type-bound-operations>`_.
-
 .. code-block:: nim
 
   type
@@ -1765,6 +1700,10 @@ introduce new object roots apart from `system.RootObj`.
     Student = ref object of Person # Error: inheritance only works with non-final objects
       id: int
 
+The assignment operator for tuples and objects copies each component.
+The methods to override this copying behavior are described `here
+<manual.html#procedures-type-bound-operations>`_.
+
 
 Object construction
 -------------------
@@ -1899,7 +1838,7 @@ A small example:
 cast uncheckedAssign
 --------------------
 
-Some restrictions for case objects can be disabled via a `{.cast(unsafeAssign).}` section:
+Some restrictions for case objects can be disabled via a `{.cast(uncheckedAssign).}` section:
 
 .. code-block:: nim
     :test: "nim c $1"
@@ -2685,6 +2624,7 @@ Varargs matching
 
 See `Varargs <#types-varargs>`_.
 
+
 iterable
 --------
 
@@ -2725,6 +2665,24 @@ available. Let `p` be an overloaded symbol. These contexts are:
 
 As usual, ambiguous matches produce a compile-time error.
 
+Named argument overloading
+--------------------------
+
+Routines with the same type signature can be called individually if
+a parameter has different names between them.
+
+.. code-block:: Nim
+  proc foo(x: int) =
+    echo "Using x: ", x
+  proc foo(y: int) =
+    echo "Using y: ", y
+
+  foo(x = 2) # Using x: 2
+  foo(y = 2) # Using y: 2
+
+Not supplying the parameter name in such cases results in an
+ambiguity error.
+
 
 Statements and expressions
 ==========================
@@ -2860,7 +2818,7 @@ The implicit initialization can be avoided for optimization reasons with the
 
 .. code-block:: nim
   var
-    a {.noInit.}: array[0..1023, char]
+    a {.noinit.}: array[0..1023, char]
 
 If a proc is annotated with the `noinit` pragma, this refers to its implicit
 `result` variable:
@@ -2975,6 +2933,20 @@ Even some code that has side effects is permitted in a static block:
   static:
     echo "echo at compile time"
 
+`static` can also be used like a routine.
+
+.. code-block:: nim
+
+  proc getNum(a: int): int = a
+
+  # Below calls "echo getNum(123)" at compile time.
+  static:
+    echo getNum(123)
+
+  # Below call evaluates the "getNum(123)" at compile time, but its
+  # result gets used at run time.
+  echo static(getNum(123))
+
 There are limitations on what Nim code can be executed at compile time;
 see `Restrictions on Compile-Time Execution
 <#restrictions-on-compileminustime-execution>`_ for details.
@@ -3186,7 +3158,7 @@ Return statement
 Example:
 
 .. code-block:: nim
-  return 40+2
+  return 40 + 2
 
 The `return` statement ends the execution of the current procedure.
 It is only allowed in procedures. If there is an `expr`, this is syntactic
@@ -3530,8 +3502,9 @@ location is `T`, the `addr` operator result is of the type `ptr T`. An
 address is always an untraced reference. Taking the address of an object that
 resides on the stack is **unsafe**, as the pointer may live longer than the
 object on the stack and can thus reference a non-existing object. One can get
-the address of variables, but one can't use it on variables declared through
-`let` statements:
+the address of variables. For easier interoperability with other compiled languages
+such as C, retrieving the address of a `let` variable, a parameter,
+or a `for` loop variable can be accomplished too:
 
 .. code-block:: nim
 
@@ -3543,24 +3516,18 @@ the address of variables, but one can't use it on variables declared through
   # --> ref 0x7fff6b71b670 --> 0x10bb81050"Hello"
   echo cast[ptr string](t3)[]
   # --> Hello
-  # The following line doesn't compile:
+  # The following line also works
   echo repr(addr(t1))
-  # Error: expression has no address
-
 
 The unsafeAddr operator
 -----------------------
 
-For easier interoperability with other compiled languages such as C, retrieving
-the address of a `let` variable, a parameter, or a `for` loop variable can
-be accomplished by using the `unsafeAddr` operation:
+The `unsafeAddr` operator is a deprecated alias for the `addr` operator:
 
 .. code-block:: nim
-
   let myArray = [1, 2, 3]
   foreignProcThatTakesAnAddr(unsafeAddr myArray)
 
-
 Procedures
 ==========
 
@@ -3589,9 +3556,17 @@ does not provide a value for the argument. The value will be reevaluated
 every time the function is called.
 
 .. code-block:: nim
-  # b is optional with 47 as its default value
+  # b is optional with 47 as its default value.
   proc foo(a: int, b: int = 47): int
 
+Just as the comma propagates the types from right to left until the
+first parameter or until a semicolon is hit, it also propagates the
+default value starting from the parameter declared with it.
+
+.. code-block:: nim
+  # Both a and b are optional with 47 as their default values.
+  proc foo(a, b: int = 47): int
+
 Parameters can be declared mutable and so allow the proc to modify those
 arguments, by using the type modifier `var`.
 
@@ -3814,8 +3789,8 @@ behavior inside loop bodies. See `closureScope
 <system.html#closureScope.t,untyped>`_ and `capture
 <sugar.html#capture.m,varargs[typed],untyped>`_ for details on how to change this behavior.
 
-Anonymous Procs
----------------
+Anonymous procedures
+--------------------
 
 Unnamed procedures can be used as lambda expressions to pass into other
 procedures:
@@ -3823,8 +3798,8 @@ procedures:
 .. code-block:: nim
   var cities = @["Frankfurt", "Tokyo", "New York", "Kyiv"]
 
-  cities.sort(proc (x,y: string): int =
-      cmp(x.len, y.len))
+  cities.sort(proc (x, y: string): int =
+    cmp(x.len, y.len))
 
 
 Procs as expressions can appear both as nested procs and inside top-level
@@ -3832,6 +3807,42 @@ executable code. The  `sugar <sugar.html>`_ module contains the `=>` macro
 which enables a more succinct syntax for anonymous procedures resembling
 lambdas as they are in languages like JavaScript, C#, etc.
 
+Do notation
+-----------
+
+As a special convenience notation that keeps most elements of a
+regular proc expression, the `do` keyword can be used to pass
+anonymous procedures to routines:
+
+.. code-block:: nim
+  var cities = @["Frankfurt", "Tokyo", "New York", "Kyiv"]
+
+  sort(cities) do (x, y: string) -> int:
+    cmp(x.len, y.len)
+
+  # Less parentheses using the method plus command syntax:
+  cities = cities.map do (x: string) -> string:
+    "City of " & x
+
+`do` is written after the parentheses enclosing the regular proc params.
+The proc expression represented by the `do` block is appended to the routine
+call as the last argument. In calls using the command syntax, the `do` block
+will bind to the immediately preceding expression rather than the command call.
+
+`do` with a parameter list or pragma list corresponds to an anonymous `proc`,
+however `do` without parameters or pragmas is treated as a normal statement
+list. This allows macros to receive both indented statement lists as an
+argument in inline calls, as well as a direct mirror of Nim's routine syntax.
+
+.. code-block:: nim
+  # Passing a statement list to an inline macro:
+  macroResults.add quote do:
+    if not `ex`:
+      echo `info`, ": Check failed: ", `expString`
+  
+  # Processing a routine definition in a macro:
+  rpc(router, "add") do (a, b: int) -> int:
+    result = a + b
 
 Func
 ----
@@ -3886,6 +3897,18 @@ the operator is in scope (including if it is private).
 Type bound operators are:
 `=destroy`, `=copy`, `=sink`, `=trace`, `=deepcopy`.
 
+These operations can be *overridden* instead of *overloaded*. This means that
+the implementation is automatically lifted to structured types. For instance,
+if the type `T` has an overridden assignment operator `=`, this operator is
+also used for assignments of the type `seq[T]`.
+
+Since these operations are bound to a type, they have to be bound to a
+nominal type for reasons of simplicity of implementation; this means an
+overridden `deepCopy` for `ref T` is really bound to `T` and not to `ref T`.
+This also means that one cannot override `deepCopy` for both `ptr T` and
+`ref T` at the same time, instead a distinct or object helper type has to be
+used for one pointer type.
+
 For more details on some of those procs, see
 `Lifetime-tracking hooks <destructors.html#lifetimeminustracking-hooks>`_.
 
@@ -5111,7 +5134,7 @@ code:
         deletedKeys: seq[bool]
 
 
-Type Classes
+Type classes
 ------------
 
 A type class is a special pseudo-type that can be used to match against
@@ -5841,7 +5864,15 @@ twice:
 While macros enable advanced compile-time code transformations, they
 cannot change Nim's syntax.
 
-Debug Example
+**Style note:** For code readability, it is best to use the least powerful
+programming construct that remains expressive. So the "check list" is:
+
+(1) Use an ordinary proc/iterator, if possible.
+(2) Else: Use a generic proc/iterator, if possible.
+(3) Else: Use a template, if possible.
+(4) Else: Use a macro.
+
+Debug example
 -------------
 
 The following example implements a powerful `debug` command that accepts a
@@ -5899,7 +5930,7 @@ constructor expression. This is why `debug` iterates over all of `args`'s
 children.
 
 
-BindSym
+bindSym
 -------
 
 The above `debug` macro relies on the fact that `write`, `writeLine` and
@@ -5948,43 +5979,38 @@ However, the symbols `write`, `writeLine` and `stdout` are already bound
 and are not looked up again. As the example shows, `bindSym` does work with
 overloaded symbols implicitly.
 
-Case-Of Macro
--------------
+Note that the symbol names passed to `bindSym` have to be constant. The
+experimental feature `dynamicBindSym` (`experimental manual
+<manual_experimental.html#dynamic-arguments-for-bindsym>`_)
+allows this value to be computed dynamically.
 
-In Nim, it is possible to have a macro with the syntax of a *case-of*
-expression just with the difference that all *of-branches* are passed to
-and processed by the macro implementation. It is then up the macro
-implementation to transform the *of-branches* into a valid Nim
-statement. The following example should show how this feature could be
-used for a lexical analyzer.
-
-.. code-block:: nim
-  import std/macros
-
-  macro case_token(args: varargs[untyped]): untyped =
-    echo args.treeRepr
-    # creates a lexical analyzer from regular expressions
-    # ... (implementation is an exercise for the reader ;-)
-    discard
+Post-statement blocks
+---------------------
 
-  case_token: # this colon tells the parser it is a macro statement
-  of r"[A-Za-z_]+[A-Za-z_0-9]*":
-    return tkIdentifier
-  of r"0-9+":
-    return tkInteger
-  of r"[\+\-\*\?]+":
-    return tkOperator
+Macros can receive `of`, `elif`, `else`, `except`, `finally` and `do`
+blocks (including their different forms such as `do` with routine parameters)
+as arguments if called in statement form.
+
+.. code-block:: nim
+  macro performWithUndo(task, undo: untyped) = ...
+
+  performWithUndo do:
+    # multiple-line block of code
+    # to perform the task
+  do:
+    # code to undo it
+  
+  let num = 12
+  # a single colon may be used if there is no initial block
+  match (num mod 3, num mod 5):
+  of (0, 0):
+    echo "FizzBuzz"
+  of (0, _):
+    echo "Fizz"
+  of (_, 0):
+    echo "Buzz"
   else:
-    return tkUnknown
-
-
-**Style note**: For code readability, it is best to use the least powerful
-programming construct that still suffices. So the "check list" is:
-
-(1) Use an ordinary proc/iterator, if possible.
-(2) Else: Use a generic proc/iterator, if possible.
-(3) Else: Use a template, if possible.
-(4) Else: Use a macro.
+    echo num
 
 
 For loop macro
@@ -6050,6 +6076,48 @@ Another example:
     echo a, " ", b
 
 
+Case statement macros
+---------------------
+
+Macros named `` `case` `` can provide implementations of `case` statements
+for certain types. The following is an example of such an implementation
+for tuples, leveraging the existing equality operator for tuples
+(as provided in `system.==`):
+
+.. code-block:: nim
+    :test: "nim c $1"
+  import std/macros
+
+  macro `case`(n: tuple): untyped =
+    result = newTree(nnkIfStmt)
+    let selector = n[0]
+    for i in 1 ..< n.len:
+      let it = n[i]
+      case it.kind
+      of nnkElse, nnkElifBranch, nnkElifExpr, nnkElseExpr:
+        result.add it
+      of nnkOfBranch:
+        for j in 0..it.len-2:
+          let cond = newCall("==", selector, it[j])
+          result.add newTree(nnkElifBranch, cond, it[^1])
+      else:
+        error "custom 'case' for tuple cannot handle this node", it
+
+  case ("foo", 78)
+  of ("foo", 78): echo "yes"
+  of ("bar", 88): echo "no"
+  else: discard
+
+`case` macros are subject to overload resolution. The type of the
+`case` statement's selector expression is matched against the type
+of the first argument of the `case` macro. Then the complete `case`
+statement is passed in place of the argument and the macro is evaluated.
+
+In other words, the macro needs to transform the full `case` statement
+but only the statement's selector expression is used to determine which
+macro to call.
+
+
 Special Types
 =============
 
@@ -6568,7 +6636,7 @@ but accessed at runtime:
   doAssert nameToProc[2][1]() == "baz"
 
 
-noReturn pragma
+noreturn pragma
 ---------------
 The `noreturn` pragma is used to mark a proc that never returns.
 
@@ -6699,11 +6767,11 @@ statement, as seen in stack backtraces:
     if not cond:
       # change run-time line information of the 'raise' statement:
       {.line: instantiationInfo().}:
-        raise newException(EAssertionFailed, msg)
+        raise newException(AssertionDefect, msg)
 
 If the `line` pragma is used with a parameter, the parameter needs be a
 `tuple[filename: string, line: int]`. If it is used without a parameter,
-`system.InstantiationInfo()` is used.
+`system.instantiationInfo()` is used.
 
 
 linearScanEnd pragma
@@ -6937,7 +7005,8 @@ experimental pragma
 The `experimental` pragma enables experimental language features. Depending
 on the concrete feature, this means that the feature is either considered
 too unstable for an otherwise stable release or that the future of the feature
-is uncertain (it may be removed at any time).
+is uncertain (it may be removed at any time). See the
+`experimental manual <manual_experimental.html>`_ for more details.
 
 Example:
 
@@ -7038,6 +7107,21 @@ alignment requirement of the type are ignored.
 This pragma has no effect on the JS backend.
 
 
+Noalias pragma
+==============
+
+Since version 1.4 of the Nim compiler, there is a `.noalias` annotation for variables
+and parameters. It is mapped directly to C/C++'s `restrict`:c: keyword and means that
+the underlying pointer is pointing to a unique location in memory, no other aliases to
+this location exist. It is *unchecked* that this alias restriction is followed. If the
+restriction is violated, the backend optimizer is free to miscompile the code.
+This is an **unsafe** language feature.
+
+Ideally in later versions of the language, the restriction will be enforced at
+compile time. (This is also why the name `noalias` was choosen instead of a more
+verbose name like `unsafeAssumeNoAlias`.)
+
+
 Volatile pragma
 ---------------
 The `volatile` pragma is for variables only. It declares the variable as
@@ -7619,7 +7703,7 @@ Example:
     {.pragma: rtl, importc, dynlib: "client.dll", cdecl.}
 
   proc p*(a, b: int): int {.rtl.} =
-    result = a+b
+    result = a + b
 
 In the example, a new pragma named `rtl` is introduced that either imports
 a symbol from a dynamic library or exports the symbol for dynamic library
@@ -8009,3 +8093,137 @@ Threads and exceptions
 The interaction between threads and exceptions is simple: A *handled* exception
 in one thread cannot affect any other thread. However, an *unhandled* exception
 in one thread terminates the whole *process*.
+
+
+Guards and locks
+================
+
+Nim provides common low level concurrency mechanisms like locks, atomic
+intrinsics or condition variables.
+
+Nim significantly improves on the safety of these features via additional
+pragmas:
+
+1) A `guard`:idx: annotation is introduced to prevent data races.
+2) Every access of a guarded memory location needs to happen in an
+   appropriate `locks`:idx: statement.
+
+
+Guards and locks sections
+-------------------------
+
+Protecting global variables
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Object fields and global variables can be annotated via a `guard` pragma:
+
+.. code-block:: nim
+
+  var glock: TLock
+  var gdata {.guard: glock.}: int
+
+The compiler then ensures that every access of `gdata` is within a `locks`
+section:
+
+.. code-block:: nim
+
+  proc invalid =
+    # invalid: unguarded access:
+    echo gdata
+
+  proc valid =
+    # valid access:
+    {.locks: [glock].}:
+      echo gdata
+
+Top level accesses to `gdata` are always allowed so that it can be initialized
+conveniently. It is *assumed* (but not enforced) that every top level statement
+is executed before any concurrent action happens.
+
+The `locks` section deliberately looks ugly because it has no runtime
+semantics and should not be used directly! It should only be used in templates
+that also implement some form of locking at runtime:
+
+.. code-block:: nim
+
+  template lock(a: TLock; body: untyped) =
+    pthread_mutex_lock(a)
+    {.locks: [a].}:
+      try:
+        body
+      finally:
+        pthread_mutex_unlock(a)
+
+
+The guard does not need to be of any particular type. It is flexible enough to
+model low level lockfree mechanisms:
+
+.. code-block:: nim
+
+  var dummyLock {.compileTime.}: int
+  var atomicCounter {.guard: dummyLock.}: int
+
+  template atomicRead(x): untyped =
+    {.locks: [dummyLock].}:
+      memoryReadBarrier()
+      x
+
+  echo atomicRead(atomicCounter)
+
+
+The `locks` pragma takes a list of lock expressions `locks: [a, b, ...]`
+in order to support *multi lock* statements. Why these are essential is
+explained in the `lock levels <#guards-and-locks-lock-levels>`_ section.
+
+
+Protecting general locations
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The `guard` annotation can also be used to protect fields within an object.
+The guard then needs to be another field within the same object or a
+global variable.
+
+Since objects can reside on the heap or on the stack, this greatly enhances
+the expressivity of the language:
+
+.. code-block:: nim
+
+  type
+    ProtectedCounter = object
+      v {.guard: L.}: int
+      L: TLock
+
+  proc incCounters(counters: var openArray[ProtectedCounter]) =
+    for i in 0..counters.high:
+      lock counters[i].L:
+        inc counters[i].v
+
+The access to field `x.v` is allowed since its guard `x.L`  is active.
+After template expansion, this amounts to:
+
+.. code-block:: nim
+
+  proc incCounters(counters: var openArray[ProtectedCounter]) =
+    for i in 0..counters.high:
+      pthread_mutex_lock(counters[i].L)
+      {.locks: [counters[i].L].}:
+        try:
+          inc counters[i].v
+        finally:
+          pthread_mutex_unlock(counters[i].L)
+
+There is an analysis that checks that `counters[i].L` is the lock that
+corresponds to the protected location `counters[i].v`. This analysis is called
+`path analysis`:idx: because it deals with paths to locations
+like `obj.field[i].fieldB[j]`.
+
+The path analysis is **currently unsound**, but that doesn't make it useless.
+Two paths are considered equivalent if they are syntactically the same.
+
+This means the following compiles (for now) even though it really should not:
+
+.. code-block:: nim
+
+  {.locks: [a[i].L].}:
+    inc i
+    access a[i].v
diff --git a/doc/manual_experimental.rst b/doc/manual_experimental.rst
index 458512292f3..407924a132e 100644
--- a/doc/manual_experimental.rst
+++ b/doc/manual_experimental.rst
@@ -19,47 +19,8 @@ Some of these are not covered by the `.experimental` pragma or
 one may want to use Nim libraries using these features without using them
 oneself.
 
-**Note**: Unless otherwise indicated, these features are not to be removed,
-but refined and overhauled.
-
-
-Package level objects
-=====================
-
-Every Nim module resides in a (nimble) package. An object type can be attached
-to the package it resides in. If that is done, the type can be referenced from
-other modules as an `incomplete`:idx: object type. This feature allows to
-break up recursive type dependencies across module boundaries. Incomplete
-object types are always passed `byref` and can only be used in pointer like
-contexts (`var/ref/ptr IncompleteObject`) in general since the compiler does
-not yet know the size of the object. To complete an incomplete object
-the `package` pragma has to be used. `package` implies `byref`.
-
-As long as a type `T` is incomplete, neither `sizeof(T)` nor runtime
-type information for `T` is available.
-
-
-Example:
-
-.. code-block:: nim
-
-  # module A (in an arbitrary package)
-  type
-    Pack.SomeObject = object ## declare as incomplete object of package 'Pack'
-    Triple = object
-      a, b, c: ref SomeObject ## pointers to incomplete objects are allowed
-
-  ## Incomplete objects can be used as parameters:
-  proc myproc(x: SomeObject) = discard
-
-
-.. code-block:: nim
-
-  # module B (in package "Pack")
-  type
-    SomeObject* {.package.} = object ## Use 'package' to complete the object
-      s, t: string
-      x, y: int
+.. note:: Unless otherwise indicated, these features are not to be removed,
+  but refined and overhauled.
 
 
 Void type
@@ -105,23 +66,117 @@ The `void` type is only valid for parameters and return types; other symbols
 cannot have the type `void`.
 
 
-Automatic dereferencing
-=======================
+Unicode Operators
+=================
 
-Automatic dereferencing is performed for the first argument of a routine call.
-This feature has to be enabled via `{.experimental: "implicitDeref".}`:
+Under the `--experimental:unicodeOperators`:option: switch,
+these Unicode operators are also parsed as operators::
+
+  ∙ ∘ × ★ ⊗ ⊘ ⊙ ⊛ ⊠ ⊡ ∩ ∧ ⊓   # same priority as * (multiplication)
+  ± ⊕ ⊖ ⊞ ⊟ ∪ ∨ ⊔             # same priority as + (addition)
+
+
+If enabled, Unicode operators can be combined with non-Unicode operator
+symbols. The usual precedence extensions then apply, for example, `⊠=` is an
+assignment like operator just like `*=` is.
+
+No Unicode normalization step is performed.
+
+.. note:: Due to parser limitations one **cannot** enable this feature via a
+  pragma `{.experimental: "unicodeOperators".}` reliably.
+
+
+Overloadable enum value names
+=============================
+
+Enabled via `{.experimental: "overloadableEnums".}`.
+
+Enum value names are overloadable, much like routines. If both of the enums
+`T` and `U` have a member named `foo`, then the identifier `foo` corresponds
+to a choice between `T.foo` and `U.foo`. During overload resolution,
+the correct type of `foo` is decided from the context. If the type of `foo` is
+ambiguous, a static error will be produced.
 
 .. code-block:: nim
+    :test: "nim c $1"
 
-  {.experimental: "implicitDeref".}
+  {.experimental: "overloadableEnums".}
 
-  proc depth(x: NodeObj): int = ...
+  type
+    E1 = enum
+      value1,
+      value2
+    E2 = enum
+      value1,
+      value2 = 4
 
-  var
-    n: Node
-  new(n)
-  echo n.depth
-  # no need to write n[].depth either
+  const
+    Lookuptable = [
+      E1.value1: "1",
+      # no need to qualify value2, known to be E1.value2
+      value2: "2"
+    ]
+
+  proc p(e: E1) =
+    # disambiguation in 'case' statements:
+    case e
+    of value1: echo "A"
+    of value2: echo "B"
+
+  p value2
+
+
+Package level objects
+=====================
+
+Every Nim module resides in a (nimble) package. An object type can be attached
+to the package it resides in. If that is done, the type can be referenced from
+other modules as an `incomplete`:idx: object type. This feature allows to
+break up recursive type dependencies across module boundaries. Incomplete
+object types are always passed `byref` and can only be used in pointer like
+contexts (`var/ref/ptr IncompleteObject`) in general, since the compiler does
+not yet know the size of the object. To complete an incomplete object,
+the `package` pragma has to be used. `package` implies `byref`.
+
+As long as a type `T` is incomplete, no runtime type information for `T` is
+available.
+
+
+Example:
+
+.. code-block:: nim
+
+  # module A (in an arbitrary package)
+  type
+    Pack.SomeObject = object # declare as incomplete object of package 'Pack'
+    Triple = object
+      a, b, c: ref SomeObject # pointers to incomplete objects are allowed
+
+  # Incomplete objects can be used as parameters:
+  proc myproc(x: SomeObject) = discard
+
+
+.. code-block:: nim
+
+  # module B (in package "Pack")
+  type
+    SomeObject* {.package.} = object # Use 'package' to complete the object
+      s, t: string
+      x, y: int
+
+This feature will likely be superseded in the future by support for
+recursive module dependencies.
+
+
+Importing private symbols
+=========================
+
+In some situations, it may be useful to import all symbols (public or private)
+from a module. The syntax `import foo {.all.}` can be used to import all
+symbols from the module `foo`. Note that importing private symbols is
+generally not recommended.
+
+See also the experimental `importutils <importutils.html>`_ module.
 
 
 Code reordering
@@ -230,65 +285,30 @@ scope. Therefore, the following will *fail to compile:*
 
   a()
 
-
-Named argument overloading
-==========================
-
-Routines with the same type signature can be called differently if a parameter
-has different names. This does not need an `experimental` switch, but is an
-unstable feature.
-
-.. code-block:: Nim
-
-  proc foo(x: int) =
-    echo "Using x: ", x
-  proc foo(y: int) =
-    echo "Using y: ", y
-
-  foo(x = 2)
-  # Using x: 2
-  foo(y = 2)
-  # Using y: 2
+This feature will likely be replaced with a better solution to remove
+the need for forward declarations.
 
 
-Do notation
-===========
+Automatic dereferencing
+=======================
 
-As a special more convenient notation, proc expressions involved in procedure
-calls can use the `do` keyword:
+Automatic dereferencing is performed for the first argument of a routine call.
+This feature has to be enabled via `{.experimental: "implicitDeref".}`:
 
 .. code-block:: nim
 
-  sort(cities) do (x,y: string) -> int:
-    cmp(x.len, y.len)
-
-  # Less parenthesis using the method plus command syntax:
-  cities = cities.map do (x:string) -> string:
-    "City of " & x
-
-  # In macros, the do notation is often used for quasi-quoting
-  macroResults.add quote do:
-    if not `ex`:
-      echo `info`, ": Check failed: ", `expString`
-
-`do` is written after the parentheses enclosing the regular proc params.
-The proc expression represented by the do block is appended to them.
-In calls using the command syntax, the do block will bind to the immediately
-preceding expression, transforming it in a call.
-
-`do` with parentheses is an anonymous `proc`; however a `do` without
-parentheses is just a block of code. The `do` notation can be used to
-pass multiple blocks to a macro:
+  {.experimental: "implicitDeref".}
 
-.. code-block:: nim
+  type
+    NodeObj = object
+      # ...
+    Node = ref NodeObj
 
-  macro performWithUndo(task, undo: untyped) = ...
+  proc depth(x: NodeObj): int = ...
 
-  performWithUndo do:
-    # multiple-line block of code
-    # to perform the task
-  do:
-    # code to undo it
+  let n = Node()
+  echo n.depth
+  # no need to write n[].depth
 
 
 Special Operators
@@ -297,8 +317,8 @@ Special Operators
 dot operators
 -------------
 
-**Note**: Dot operators are still experimental and so need to be enabled
-via `{.experimental: "dotOperators".}`.
+.. note:: Dot operators are still experimental and so need to be enabled
+  via `{.experimental: "dotOperators".}`.
 
 Nim offers a special family of dot operators that can be used to
 intercept and rewrite proc call and field access attempts, referring
@@ -418,1296 +438,1115 @@ here.
 .. include:: manual_experimental_strictnotnil.rst
 
 
-Concepts
-========
+Aliasing restrictions in parameter passing
+==========================================
 
-Concepts, also known as "user-defined type classes", are used to specify an
-arbitrary set of requirements that the matched type must satisfy.
+.. note:: The aliasing restrictions are currently not enforced by the
+  implementation and need to be fleshed out further.
 
-Concepts are written in the following form:
+"Aliasing" here means that the underlying storage locations overlap in memory
+at runtime. An "output parameter" is a parameter of type `var T`,
+an input parameter is any parameter that is not of type `var`.
 
-.. code-block:: nim
+1. Two output parameters should never be aliased.
+2. An input and an output parameter should not be aliased.
+3. An output parameter should never be aliased with a global or thread local
+   variable referenced by the called proc.
+4. An input parameter should not be aliased with a global or thread local
+   variable updated by the called proc.
 
-  type
-    Comparable = concept x, y
-      (x < y) is bool
+One problem with rules 3 and 4 is that they affect specific global or thread
+local variables, but Nim's effect tracking only tracks "uses no global variable"
+via `.noSideEffect`. The rules 3 and 4 can also be approximated by a different rule:
 
-    Stack[T] = concept s, var v
-      s.pop() is T
-      v.push(T)
+5. A global or thread local variable (or a location derived from such a location)
+   can only passed to a parameter of a `.noSideEffect` proc.
 
-      s.len is Ordinal
 
-      for value in s:
-        value is T
+Strict funcs
+============
 
-The concept is a match if:
+Since version 1.4, a stricter definition of "side effect" is available.
+In addition to the existing rule that a side effect is calling a function
+with side effects, the following rule is also enforced:
 
-a) all of the expressions within the body can be compiled for the tested type
-b) all statically evaluable boolean expressions in the body must be true
+Any mutation to an object does count as a side effect if that object is reachable
+via a parameter that is not declared as a `var` parameter.
 
-The identifiers following the `concept` keyword represent instances of the
-currently matched type. You can apply any of the standard type modifiers such
-as `var`, `ref`, `ptr` and `static` to denote a more specific type of
-instance. You can also apply the `type` modifier to create a named instance of
-the type itself:
+For example:
 
 .. code-block:: nim
 
-  type
-    MyConcept = concept x, var v, ref r, ptr p, static s, type T
-      ...
-
-Within the concept body, types can appear in positions where ordinary values
-and parameters are expected. This provides a more convenient way to check for
-the presence of callable symbols with specific signatures:
-
-.. code-block:: nim
+  {.experimental: "strictFuncs".}
 
   type
-    OutputStream = concept var s
-      s.write(string)
+    Node = ref object
+      le, ri: Node
+      data: string
 
-In order to check for symbols accepting `type` params, you must prefix
-the type with the explicit `type` modifier. The named instance of the
-type, following the `concept` keyword is also considered to have the
-explicit modifier and will be matched only as a type.
+  func len(n: Node): int =
+    # valid: len does not have side effects
+    var it = n
+    while it != nil:
+      inc result
+      it = it.ri
 
-.. code-block:: nim
+  func mut(n: Node) =
+    let m = n # is the statement that connected the mutation to the parameter
+    m.data = "yeah" # the mutation is here
+    # Error: 'mut' can have side effects
+    # an object reachable from 'n' is potentially mutated
 
-  type
-    # Let's imagine a user-defined casting framework with operators
-    # such as `val.to(string)` and `val.to(JSonValue)`. We can test
-    # for these with the following concept:
-    MyCastables = concept x
-      x.to(type string)
-      x.to(type JSonValue)
 
-    # Let's define a couple of concepts, known from Algebra:
-    AdditiveMonoid* = concept x, y, type T
-      x + y is T
-      T.zero is T # require a proc such as `int.zero` or 'Position.zero'
+The algorithm behind this analysis is described in
+the `view types section <#view-types-algorithm>`_.
 
-    AdditiveGroup* = concept x, y, type T
-      x is AdditiveMonoid
-      -x is T
-      x - y is T
 
-Please note that the `is` operator allows one to easily verify the precise
-type signatures of the required operations, but since type inference and
-default parameters are still applied in the concept body, it's also possible
-to describe usage protocols that do not reveal implementation details.
+View types
+==========
 
-Much like generics, concepts are instantiated exactly once for each tested type
-and any static code included within the body is executed only once.
+.. tip::  `--experimental:views`:option: is more effective
+  with `--experimental:strictFuncs`:option:.
 
+A view type is a type that is or contains one of the following types:
 
-Concept diagnostics
--------------------
+- `lent T` (view into `T`)
+- `openArray[T]` (pair of (pointer to array of `T`, size))
 
-By default, the compiler will report the matching errors in concepts only when
-no other overload can be selected and a normal compilation error is produced.
-When you need to understand why the compiler is not matching a particular
-concept and, as a result, a wrong overload is selected, you can apply the
-`explain` pragma to either the concept body or a particular call-site.
+For example:
 
 .. code-block:: nim
 
   type
-    MyConcept {.explain.} = concept ...
+    View1 = openArray[byte]
+    View2 = lent string
+    View3 = Table[openArray[char], int]
 
-  overloadedProc(x, y, z) {.explain.}
 
-This will provide Hints in the compiler output either every time the concept is
-not matched or only on the particular call-site.
+Exceptions to this rule are types constructed via `ptr` or `proc`.
+For example, the following types are **not** view types:
 
+.. code-block:: nim
 
-Generic concepts and type binding rules
----------------------------------------
+  type
+    NotView1 = proc (x: openArray[int])
+    NotView2 = ptr openArray[char]
+    NotView3 = ptr array[4, lent int]
 
-The concept types can be parametric just like the regular generic types:
 
-.. code-block:: nim
+The mutability aspect of a view type is not part of the type but part
+of the locations it's derived from. More on this later.
 
-  ### matrixalgo.nim
+A *view* is a symbol (a let, var, const, etc.) that has a view type.
 
-  import std/typetraits
+Since version 1.4, Nim allows view types to be used as local variables.
+This feature needs to be enabled via `{.experimental: "views".}`.
 
-  type
-    AnyMatrix*[R, C: static int; T] = concept m, var mvar, type M
-      M.ValueType is T
-      M.Rows == R
-      M.Cols == C
+A local variable of a view type *borrows* from the locations and
+it is statically enforced that the view does not outlive the location
+it was borrowed from.
 
-      m[int, int] is T
-      mvar[int, int] = T
+For example:
 
-      type TransposedType = stripGenericParams(M)[C, R, T]
+.. code-block:: nim
 
-    AnySquareMatrix*[N: static int, T] = AnyMatrix[N, N, T]
+  {.experimental: "views".}
 
-    AnyTransform3D* = AnyMatrix[4, 4, float]
+  proc take(a: openArray[int]) =
+    echo a.len
 
-  proc transposed*(m: AnyMatrix): m.TransposedType =
-    for r in 0 ..< m.R:
-      for c in 0 ..< m.C:
-        result[r, c] = m[c, r]
+  proc main(s: seq[int]) =
+    var x: openArray[int] = s # 'x' is a view into 's'
+    # it is checked that 'x' does not outlive 's' and
+    # that 's' is not mutated.
+    for i in 0 .. high(x):
+      echo x[i]
+    take(x)
 
-  proc determinant*(m: AnySquareMatrix): int =
-    ...
+    take(x.toOpenArray(0, 1)) # slicing remains possible
+    let y = x  # create a view from a view
+    take y
+    # it is checked that 'y' does not outlive 'x' and
+    # that 'x' is not mutated as long as 'y' lives.
 
-  proc setPerspectiveProjection*(m: AnyTransform3D) =
-    ...
 
-  --------------
-  ### matrix.nim
+  main(@[11, 22, 33])
 
-  type
-    Matrix*[M, N: static int; T] = object
-      data: array[M*N, T]
 
-  proc `[]`*(M: Matrix; m, n: int): M.T =
-    M.data[m * M.N + n]
+A local variable of a view type can borrow from a location
+derived from a parameter, another local variable, a global `const` or `let`
+symbol or a thread-local `var` or `let`.
 
-  proc `[]=`*(M: var Matrix; m, n: int; v: M.T) =
-    M.data[m * M.N + n] = v
+Let `p` the proc that is analysed for the correctness of the borrow operation.
 
-  # Adapt the Matrix type to the concept's requirements
-  template Rows*(M: typedesc[Matrix]): int = M.M
-  template Cols*(M: typedesc[Matrix]): int = M.N
-  template ValueType*(M: typedesc[Matrix]): typedesc = M.T
+Let `source` be one of:
 
-  -------------
-  ### usage.nim
+- A formal parameter of `p`. Note that this does not cover parameters of
+  inner procs.
+- The `result` symbol of `p`.
+- A local `var` or `let` or `const` of `p`. Note that this does
+  not cover locals of inner procs.
+- A thread-local `var` or `let`.
+- A global `let` or `const`.
+- A constant array/seq/object/tuple constructor.
 
-  import matrix, matrixalgo
 
-  var
-    m: Matrix[3, 3, int]
-    projectionMatrix: Matrix[4, 4, float]
+Path expressions
+----------------
 
-  echo m.transposed.determinant
-  setPerspectiveProjection projectionMatrix
+A location derived from `source` is then defined as a path expression that
+has `source` as the owner. A path expression `e` is defined recursively:
 
-When the concept type is matched against a concrete type, the unbound type
-parameters are inferred from the body of the concept in a way that closely
-resembles the way generic parameters of callable symbols are inferred on
-call sites.
+- `source` itself is a path expression.
+- Container access like `e[i]` is a path expression.
+- Tuple access `e[0]` is a path expression.
+- Object field access `e.field` is a path expression.
+- `system.toOpenArray(e, ...)` is a path expression.
+- Pointer dereference `e[]` is a path expression.
+- An address `addr e` is a path expression.
+- A type conversion `T(e)` is a path expression.
+- A cast expression `cast[T](e)` is a path expression.
+- `f(e, ...)` is a path expression if `f`'s return type is a view type.
+  Because the view can only have been borrowed from `e`, we then know
+  that the owner of `f(e, ...)` is `e`.
 
-Unbound types can appear both as params to calls such as `s.push(T)` and
-on the right-hand side of the `is` operator in cases such as `x.pop is T`
-and `x.data is seq[T]`.
 
-Unbound static params will be inferred from expressions involving the `==`
-operator and also when types dependent on them are being matched:
+If a view type is used as a return type, the location must borrow from a location
+that is derived from the first parameter that is passed to the proc.
+See `the manual <https://nim-lang.org/docs/manual.html#procedures-var-return-type>`_
+for details about how this is done for `var T`.
 
-.. code-block:: nim
+A mutable view can borrow from a mutable location, an immutable view can borrow
+from both a mutable or an immutable location.
 
-  type
-    MatrixReducer[M, N: static int; T] = concept x
-      x.reduce(SquareMatrix[N, T]) is array[M, int]
+If a view borrows from a mutable location, the view can be used to update the
+location. Otherwise it cannot be used for mutations.
 
-The Nim compiler includes a simple linear equation solver, allowing it to
-infer static params in some situations where integer arithmetic is involved.
+The *duration* of a borrow is the span of commands beginning from the assignment
+to the view and ending with the last usage of the view.
 
-Just like in regular type classes, Nim discriminates between `bind once`
-and `bind many` types when matching the concept. You can add the `distinct`
-modifier to any of the otherwise inferable types to get a type that will be
-matched without permanently inferring it. This may be useful when you need
-to match several procs accepting the same wide class of types:
+For the duration of the borrow operation, no mutations to the borrowed locations
+may be performed except via the view that borrowed from the
+location. The borrowed location is said to be *sealed* during the borrow.
 
 .. code-block:: nim
 
-  type
-    Enumerable[T] = concept e
-      for v in e:
-        v is T
+  {.experimental: "views".}
 
   type
-    MyConcept = concept o
-      # this could be inferred to a type such as Enumerable[int]
-      o.foo is distinct Enumerable
+    Obj = object
+      field: string
 
-      # this could be inferred to a different type such as Enumerable[float]
-      o.bar is distinct Enumerable
+  proc dangerous(s: var seq[Obj]) =
+    let v: lent Obj = s[0] # seal 's'
+    s.setLen 0  # prevented at compile-time because 's' is sealed.
+    echo v.field
 
-      # it's also possible to give an alias name to a `bind many` type class
-      type Enum = distinct Enumerable
-      o.baz is Enum
 
-On the other hand, using `bind once` types allows you to test for equivalent
-types used in multiple signatures, without actually requiring any concrete
-types, thus allowing you to encode implementation-defined types:
+The scope of the view does not matter:
 
 .. code-block:: nim
 
-  type
-    MyConcept = concept x
-      type T1 = auto
-      x.foo(T1)
-      x.bar(T1) # both procs must accept the same type
+  proc valid(s: var seq[Obj]) =
+    let v: lent Obj = s[0]  # begin of borrow
+    echo v.field            # end of borrow
+    s.setLen 0  # valid because 'v' isn't used afterwards
 
-      type T2 = seq[SomeNumber]
-      x.alpha(T2)
-      x.omega(T2) # both procs must accept the same type
-                  # and it must be a numeric sequence
 
-As seen in the previous examples, you can refer to generic concepts such as
-`Enumerable[T]` just by their short name. Much like the regular generic types,
-the concept will be automatically instantiated with the bind once auto type
-in the place of each missing generic param.
+The analysis requires as much precision about mutations as is reasonably obtainable,
+so it is more effective with the experimental `strict funcs <#strict-funcs>`_
+feature. In other words `--experimental:views`:option: works better
+with `--experimental:strictFuncs`:option:.
 
-Please note that generic concepts such as `Enumerable[T]` can be matched
-against concrete types such as `string`. Nim doesn't require the concept
-type to have the same number of parameters as the type being matched.
-If you wish to express a requirement towards the generic parameters of
-the matched type, you can use a type mapping operator such as `genericHead`
-or `stripGenericParams` within the body of the concept to obtain the
-uninstantiated version of the type, which you can then try to instantiate
-in any required way. For example, here is how one might define the classic
-`Functor` concept from Haskell and then demonstrate that Nim's `Option[T]`
-type is an instance of it:
+The analysis is currently control flow insensitive:
 
 .. code-block:: nim
-    :test: "nim c $1"
 
-  import std/[sugar, typetraits]
+  proc invalid(s: var seq[Obj]) =
+    let v: lent Obj = s[0]
+    if false:
+      s.setLen 0
+    echo v.field
 
-  type
-    Functor[A] = concept f
-      type MatchedGenericType = genericHead(typeof(f))
-        # `f` will be a value of a type such as `Option[T]`
-        # `MatchedGenericType` will become the `Option` type
+In this example, the compiler assumes that `s.setLen 0` invalidates the
+borrow operation of `v` even though a human being can easily see that it
+will never do that at runtime.
 
-      f.val is A
-        # The Functor should provide a way to obtain
-        # a value stored inside it
 
-      type T = auto
-      map(f, A -> T) is MatchedGenericType[T]
-        # And it should provide a way to map one instance of
-        # the Functor to a instance of a different type, given
-        # a suitable `map` operation for the enclosed values
+Start of a borrow
+-----------------
 
-  import std/options
-  echo Option[int] is Functor # prints true
+A borrow starts with one of the following:
 
+- The assignment of a non-view-type to a view-type.
+- The assignment of a location that is derived from a local parameter
+  to a view-type.
 
-Concept derived values
-----------------------
 
-All top level constants or types appearing within the concept body are
-accessible through the dot operator in procs where the concept was successfully
-matched to a concrete type:
+End of a borrow
+---------------
 
-.. code-block:: nim
+A borrow operation ends with the last usage of the view variable.
 
-  type
-    DateTime = concept t1, t2, type T
-      const Min = T.MinDate
-      T.Now is T
 
-      t1 < t2 is bool
+Reborrows
+---------
 
-      type TimeSpan = typeof(t1 - t2)
-      TimeSpan * int is TimeSpan
-      TimeSpan + TimeSpan is TimeSpan
+A view `v` can borrow from multiple different locations. However, the borrow
+is always the full span of `v`'s lifetime and every location that is borrowed
+from is sealed during `v`'s lifetime.
 
-      t1 + TimeSpan is T
 
-  proc eventsJitter(events: Enumerable[DateTime]): float =
-    var
-      # this variable will have the inferred TimeSpan type for
-      # the concrete Date-like value the proc was called with:
-      averageInterval: DateTime.TimeSpan
+Algorithm
+---------
 
-      deviation: float
-    ...
+The following section is an outline of the algorithm that the current implementation
+uses. The algorithm performs two traversals over the AST of the procedure or global
+section of code that uses a view variable. No fixpoint iterations are performed, the
+complexity of the analysis is O(N) where N is the number of nodes of the AST.
 
+The first pass over the AST computes the lifetime of each local variable based on
+a notion of an "abstract time", in the implementation it's a simple integer that is
+incremented for every visited node.
 
-Concept refinement
-------------------
+In the second pass, information about the underlying object "graphs" is computed.
+Let `v` be a parameter or a local variable. Let `G(v)` be the graph
+that `v` belongs to. A graph is defined by the set of variables that belong
+to the graph. Initially for all `v`: `G(v) = {v}`. Every variable can only
+be part of a single graph.
 
-When the matched type within a concept is directly tested against a different
-concept, we say that the outer concept is a refinement of the inner concept and
-thus it is more-specific. When both concepts are matched in a call during
-overload resolution, Nim will assign a higher precedence to the most specific
-one. As an alternative way of defining concept refinements, you can use the
-object inheritance syntax involving the `of` keyword:
+Assignments like `a = b` "connect" two variables, both variables end up in the
+same graph `{a, b} = G(a) = G(b)`. Unfortunately, the pattern to look for is
+much more complex than that and can involve multiple assignment targets
+and sources::
 
-.. code-block:: nim
+  f(x, y) = g(a, b)
 
-  type
-    Graph = concept g, type G of EquallyComparable, Copyable
-      type
-        VertexType = G.VertexType
-        EdgeType = G.EdgeType
+connects `x` and `y` to `a` and `b`: `G(x) = G(y) = G(a) = G(b) = {x, y, a, b}`.
+A type based alias analysis rules out some of these combinations, for example
+a `string` value cannot possibly be connected to a `seq[int]`.
 
-      VertexType is Copyable
-      EdgeType is Copyable
+A pattern like `v[] = value` or `v.field = value` marks `G(v)` as mutated.
+After the second pass a set of disjoint graphs was computed.
 
-      var
-        v: VertexType
-        e: EdgeType
+For strict functions it is then enforced that there is no graph that is both mutated
+and has an element that is an immutable parameter (that is a parameter that is not
+of type `var T`).
 
-    IncidendeGraph = concept of Graph
-      # symbols such as variables and types from the refined
-      # concept are automatically in scope:
+For borrow checking, a different set of checks is performed. Let `v` be the view
+and `b` the location that is borrowed from.
 
-      g.source(e) is VertexType
-      g.target(e) is VertexType
+- The lifetime of `v` must not exceed `b`'s lifetime. Note: The lifetime of
+  a parameter is the complete proc body.
+- If `v` is used for a mutation, `b` must be a mutable location too.
+- During `v`'s lifetime, `G(b)` can only be modified by `v` (and only if
+  `v` is a mutable view).
+- If `v` is `result` then `b` has to be a location derived from the first
+  formal parameter or from a constant location.
+- A view cannot be used for a read or a write access before it was assigned to.
 
-      g.outgoingEdges(v) is Enumerable[EdgeType]
 
-    BidirectionalGraph = concept g, type G
-      # The following will also turn the concept into a refinement when it
-      # comes to overload resolution, but it doesn't provide the convenient
-      # symbol inheritance
-      g is IncidendeGraph
+Concepts
+========
 
-      g.incomingEdges(G.VertexType) is Enumerable[G.EdgeType]
+Concepts, also known as "user-defined type classes", are used to specify an
+arbitrary set of requirements that the matched type must satisfy.
 
-  proc f(g: IncidendeGraph)
-  proc f(g: BidirectionalGraph) # this one will be preferred if we pass a type
-                                # matching the BidirectionalGraph concept
+Concepts are written in the following form:
 
-..
-  Converter type classes
-  ----------------------
+.. code-block:: nim
 
-  Concepts can also be used to convert a whole range of types to a single type or
-  a small set of simpler types. This is achieved with a `return` statement within
-  the concept body:
+  type
+    Comparable = concept x, y
+      (x < y) is bool
 
-  .. code-block:: nim
+    Stack[T] = concept s, var v
+      s.pop() is T
+      v.push(T)
 
-    type
-      Stringable = concept x
-        $x is string
-        return $x
+      s.len is Ordinal
 
-      StringRefValue[CharType] = object
-        base: ptr CharType
-        len: int
+      for value in s:
+        value is T
 
-      StringRef = concept x
-        # the following would be an overloaded proc for cstring, string, seq and
-        # other user-defined types, returning either a StringRefValue[char] or
-        # StringRefValue[wchar]
-        return makeStringRefValue(x)
+The concept matches if:
 
-    # the varargs param will here be converted to an array of StringRefValues
-    # the proc will have only two instantiations for the two character types
-    proc log(format: static string, varargs[StringRef])
+a) all expressions within the body can be compiled for the tested type
+b) all statically evaluable boolean expressions in the body are true
 
-    # this proc will allow char and wchar values to be mixed in
-    # the same call at the cost of additional instantiations
-    # the varargs param will be converted to a tuple
-    proc log(format: static string, varargs[distinct StringRef])
+The identifiers following the `concept` keyword represent instances of the
+currently matched type. You can apply any of the standard type modifiers such
+as `var`, `ref`, `ptr` and `static` to denote a more specific type of
+instance. You can also apply the `type` modifier to create a named instance of
+the type itself:
 
+.. code-block:: nim
 
-..
-  VTable types
-  ------------
+  type
+    MyConcept = concept x, var v, ref r, ptr p, static s, type T
+      ...
 
-  Concepts allow Nim to define a great number of algorithms, using only
-  static polymorphism and without erasing any type information or sacrificing
-  any execution speed. But when polymorphic collections of objects are required,
-  the user must use one of the provided type erasure techniques - either common
-  base types or VTable types.
+Within the concept body, types can appear in positions where ordinary values
+and parameters are expected. This provides a more convenient way to check for
+the presence of callable symbols with specific signatures:
 
-  VTable types are represented as "fat pointers" storing a reference to an
-  object together with a reference to a table of procs implementing a set of
-  required operations (the so called vtable).
+.. code-block:: nim
 
-  In contrast to other programming languages, the vtable in Nim is stored
-  externally to the object, allowing you to create multiple different vtable
-  views for the same object. Thus, the polymorphism in Nim is unbounded -
-  any type can implement an unlimited number of protocols or interfaces not
-  originally envisioned by the type's author.
+  type
+    OutputStream = concept var s
+      s.write(string)
 
-  Any concept type can be turned into a VTable type by using the `vtref`
-  or the `vtptr` compiler magics. Under the hood, these magics generate
-  a converter type class, which converts the regular instances of the matching
-  types to the corresponding VTable type.
+In order to check for symbols accepting `type` params, you must prefix
+the type with the explicit `type` modifier. The named instance of the
+type, following the `concept` keyword is also considered to have the
+explicit modifier and will be matched only as a type.
 
-  .. code-block:: nim
+.. code-block:: nim
 
-    type
-      IntEnumerable = vtref Enumerable[int]
+  type
+    # Let's imagine a user-defined casting framework with operators
+    # such as `val.to(string)` and `val.to(JSonValue)`. We can test
+    # for these with the following concept:
+    MyCastables = concept x
+      x.to(type string)
+      x.to(type JSonValue)
 
-      MyObject = object
-        enumerables: seq[IntEnumerable]
-        streams: seq[OutputStream.vtref]
+    # Let's define a couple of concepts, known from Algebra:
+    AdditiveMonoid* = concept x, y, type T
+      x + y is T
+      T.zero is T # require a proc such as `int.zero` or 'Position.zero'
 
-    proc addEnumerable(o: var MyObject, e: IntEnumerable) =
-      o.enumerables.add e
+    AdditiveGroup* = concept x, y, type T
+      x is AdditiveMonoid
+      -x is T
+      x - y is T
 
-    proc addStream(o: var MyObject, e: OutputStream.vtref) =
-      o.streams.add e
+Please note that the `is` operator allows one to easily verify the precise
+type signatures of the required operations, but since type inference and
+default parameters are still applied in the concept body, it's also possible
+to describe usage protocols that do not reveal implementation details.
 
-  The procs that will be included in the vtable are derived from the concept
-  body and include all proc calls for which all param types were specified as
-  concrete types. All such calls should include exactly one param of the type
-  matched against the concept (not necessarily in the first position), which
-  will be considered the value bound to the vtable.
+Much like generics, concepts are instantiated exactly once for each tested type
+and any static code included within the body is executed only once.
 
-  Overloads will be created for all captured procs, accepting the vtable type
-  in the position of the captured underlying object.
 
-  Under these rules, it's possible to obtain a vtable type for a concept with
-  unbound type parameters or one instantiated with metatypes (type classes),
-  but it will include a smaller number of captured procs. A completely empty
-  vtable will be reported as an error.
+Concept diagnostics
+-------------------
 
-  The `vtref` magic produces types which can be bound to `ref` types and
-  the `vtptr` magic produced types bound to `ptr` types.
+By default, the compiler will report the matching errors in concepts only when
+no other overload can be selected and a normal compilation error is produced.
+When you need to understand why the compiler is not matching a particular
+concept and, as a result, a wrong overload is selected, you can apply the
+`explain` pragma to either the concept body or a particular call-site.
 
+.. code-block:: nim
 
-Type bound operations
-=====================
+  type
+    MyConcept {.explain.} = concept ...
 
-There are 4 operations that are bound to a type:
+  overloadedProc(x, y, z) {.explain.}
 
-1. Assignment
-2. Moves
-3. Destruction
-4. Deep copying for communication between threads
+This will provide Hints in the compiler output either every time the concept is
+not matched or only on the particular call-site.
 
-These operations can be *overridden* instead of *overloaded*. This means the
-implementation is automatically lifted to structured types. For instance if type
-`T` has an overridden assignment operator `=` this operator is also used
-for assignments of the type `seq[T]`. Since these operations are bound to a
-type they have to be bound to a nominal type for reasons of simplicity of
-implementation: This means an overridden `deepCopy` for `ref T` is really
-bound to `T` and not to `ref T`. This also means that one cannot override
-`deepCopy` for both `ptr T` and `ref T` at the same time; instead a
-helper distinct or object type has to be used for one pointer type.
 
-Assignments, moves and destruction are specified in
-the `destructors <destructors.html>`_ document.
+Generic concepts and type binding rules
+---------------------------------------
 
+The concept types can be parametric just like the regular generic types:
 
-deepCopy
---------
+.. code-block:: nim
 
-`=deepCopy` is a builtin that is invoked whenever data is passed to
-a `spawn`'ed proc to ensure memory safety. The programmer can override its
-behaviour for a specific `ref` or `ptr` type `T`. (Later versions of the
-language may weaken this restriction.)
+  ### matrixalgo.nim
 
-The signature has to be:
+  import std/typetraits
 
-.. code-block:: nim
+  type
+    AnyMatrix*[R, C: static int; T] = concept m, var mvar, type M
+      M.ValueType is T
+      M.Rows == R
+      M.Cols == C
 
-  proc `=deepCopy`(x: T): T
+      m[int, int] is T
+      mvar[int, int] = T
 
-This mechanism will be used by most data structures that support shared memory
-like channels to implement thread safe automatic memory management.
+      type TransposedType = stripGenericParams(M)[C, R, T]
 
-The builtin `deepCopy` can even clone closures and their environments. See
-the documentation of `spawn <#parallel-amp-spawn-spawn-statement>`_ for details.
+    AnySquareMatrix*[N: static int, T] = AnyMatrix[N, N, T]
 
+    AnyTransform3D* = AnyMatrix[4, 4, float]
 
-Case statement macros
-=====================
+  proc transposed*(m: AnyMatrix): m.TransposedType =
+    for r in 0 ..< m.R:
+      for c in 0 ..< m.C:
+        result[r, c] = m[c, r]
 
-Macros named `case` can rewrite `case` statements for certain types in order to
-implement `pattern matching`:idx:. The following example implements a
-simplistic form of pattern matching for tuples, leveraging the existing
-equality operator for tuples (as provided in `system.==`):
+  proc determinant*(m: AnySquareMatrix): int =
+    ...
 
-.. code-block:: nim
-    :test: "nim c $1"
+  proc setPerspectiveProjection*(m: AnyTransform3D) =
+    ...
 
-  {.experimental: "caseStmtMacros".}
+  --------------
+  ### matrix.nim
 
-  import std/macros
+  type
+    Matrix*[M, N: static int; T] = object
+      data: array[M*N, T]
 
-  macro `case`(n: tuple): untyped =
-    result = newTree(nnkIfStmt)
-    let selector = n[0]
-    for i in 1 ..< n.len:
-      let it = n[i]
-      case it.kind
-      of nnkElse, nnkElifBranch, nnkElifExpr, nnkElseExpr:
-        result.add it
-      of nnkOfBranch:
-        for j in 0..it.len-2:
-          let cond = newCall("==", selector, it[j])
-          result.add newTree(nnkElifBranch, cond, it[^1])
-      else:
-        error "custom 'case' for tuple cannot handle this node", it
+  proc `[]`*(M: Matrix; m, n: int): M.T =
+    M.data[m * M.N + n]
+
+  proc `[]=`*(M: var Matrix; m, n: int; v: M.T) =
+    M.data[m * M.N + n] = v
 
-  case ("foo", 78)
-  of ("foo", 78): echo "yes"
-  of ("bar", 88): echo "no"
-  else: discard
+  # Adapt the Matrix type to the concept's requirements
+  template Rows*(M: typedesc[Matrix]): int = M.M
+  template Cols*(M: typedesc[Matrix]): int = M.N
+  template ValueType*(M: typedesc[Matrix]): typedesc = M.T
 
+  -------------
+  ### usage.nim
 
-Currently case statement macros must be enabled explicitly
-via `{.experimental: "caseStmtMacros".}`.
+  import matrix, matrixalgo
 
-`case` macros are subject to overload resolution. The type of the
-`case` statement's selector expression is matched against the type
-of the first argument of the `case` macro. Then the complete `case`
-statement is passed in place of the argument and the macro is evaluated.
+  var
+    m: Matrix[3, 3, int]
+    projectionMatrix: Matrix[4, 4, float]
 
-In other words, the macro needs to transform the full `case` statement
-but only the statement's selector expression is used to determine which
-macro to call.
+  echo m.transposed.determinant
+  setPerspectiveProjection projectionMatrix
 
+When the concept type is matched against a concrete type, the unbound type
+parameters are inferred from the body of the concept in a way that closely
+resembles the way generic parameters of callable symbols are inferred on
+call sites.
 
-Term rewriting macros
-=====================
+Unbound types can appear both as params to calls such as `s.push(T)` and
+on the right-hand side of the `is` operator in cases such as `x.pop is T`
+and `x.data is seq[T]`.
 
-Term rewriting macros are macros or templates that have not only
-a *name* but also a *pattern* that is searched for after the semantic checking
-phase of the compiler: This means they provide an easy way to enhance the
-compilation pipeline with user defined optimizations:
+Unbound static params will be inferred from expressions involving the `==`
+operator and also when types dependent on them are being matched:
 
 .. code-block:: nim
 
-  template optMul{`*`(a, 2)}(a: int): int = a+a
+  type
+    MatrixReducer[M, N: static int; T] = concept x
+      x.reduce(SquareMatrix[N, T]) is array[M, int]
 
-  let x = 3
-  echo x * 2
+The Nim compiler includes a simple linear equation solver, allowing it to
+infer static params in some situations where integer arithmetic is involved.
 
-The compiler now rewrites `x * 2` as `x + x`. The code inside the
-curlies is the pattern to match against. The operators `*`,  `**`,
-`|`, `~` have a special meaning in patterns if they are written in infix
-notation, so to match verbatim against `*` the ordinary function call syntax
-needs to be used.
-
-Term rewriting macro are applied recursively, up to a limit. This means that
-if the result of a term rewriting macro is eligible for another rewriting,
-the compiler will try to perform it, and so on, until no more optimizations
-are applicable. To avoid putting the compiler into an infinite loop, there is
-a hard limit on how many times a single term rewriting macro can be applied.
-Once this limit has been passed, the term rewriting macro will be ignored.
-
-Unfortunately optimizations are hard to get right and even the tiny example
-is **wrong**:
-
-.. code-block:: nim
-
-  template optMul{`*`(a, 2)}(a: int): int = a+a
-
-  proc f(): int =
-    echo "side effect!"
-    result = 55
-
-  echo f() * 2
-
-We cannot duplicate 'a' if it denotes an expression that has a side effect!
-Fortunately Nim supports side effect analysis:
-
-.. code-block:: nim
-
-  template optMul{`*`(a, 2)}(a: int{noSideEffect}): int = a+a
-
-  proc f(): int =
-    echo "side effect!"
-    result = 55
-
-  echo f() * 2 # not optimized ;-)
-
-You can make one overload matching with a constraint and one without, and the
-one with a constraint will have precedence, and so you can handle both cases
-differently.
-
-So what about `2 * a`? We should tell the compiler `*` is commutative. We
-cannot really do that however as the following code only swaps arguments
-blindly:
-
-.. code-block:: nim
-
-  template mulIsCommutative{`*`(a, b)}(a, b: int): int = b*a
-
-What optimizers really need to do is a *canonicalization*:
-
-.. code-block:: nim
-
-  template canonMul{`*`(a, b)}(a: int{lit}, b: int): int = b*a
-
-The `int{lit}` parameter pattern matches against an expression of
-type `int`, but only if it's a literal.
-
-
-
-Parameter constraints
----------------------
-
-The `parameter constraint`:idx: expression can use the operators `|` (or),
-`&` (and) and `~` (not) and the following predicates:
-
-===================      =====================================================
-Predicate                Meaning
-===================      =====================================================
-`atom`                   The matching node has no children.
-`lit`                    The matching node is a literal like `"abc"`, `12`.
-`sym`                    The matching node must be a symbol (a bound
-                         identifier).
-`ident`                  The matching node must be an identifier (an unbound
-                         identifier).
-`call`                   The matching AST must be a call/apply expression.
-`lvalue`                 The matching AST must be an lvalue.
-`sideeffect`             The matching AST must have a side effect.
-`nosideeffect`           The matching AST must have no side effect.
-`param`                  A symbol which is a parameter.
-`genericparam`           A symbol which is a generic parameter.
-`module`                 A symbol which is a module.
-`type`                   A symbol which is a type.
-`var`                    A symbol which is a variable.
-`let`                    A symbol which is a `let` variable.
-`const`                  A symbol which is a constant.
-`result`                 The special `result` variable.
-`proc`                   A symbol which is a proc.
-`method`                 A symbol which is a method.
-`iterator`               A symbol which is an iterator.
-`converter`              A symbol which is a converter.
-`macro`                  A symbol which is a macro.
-`template`               A symbol which is a template.
-`field`                  A symbol which is a field in a tuple or an object.
-`enumfield`              A symbol which is a field in an enumeration.
-`forvar`                 A for loop variable.
-`label`                  A label (used in `block` statements).
-`nk*`                    The matching AST must have the specified kind.
-                         (Example: `nkIfStmt` denotes an `if` statement.)
-`alias`                  States that the marked parameter needs to alias
-                         with *some* other parameter.
-`noalias`                States that *every* other parameter must not alias
-                         with the marked parameter.
-===================      =====================================================
-
-Predicates that share their name with a keyword have to be escaped with
-backticks.
-The `alias` and `noalias` predicates refer not only to the matching AST,
-but also to every other bound parameter; syntactically they need to occur after
-the ordinary AST predicates:
+Just like in regular type classes, Nim discriminates between `bind once`
+and `bind many` types when matching the concept. You can add the `distinct`
+modifier to any of the otherwise inferable types to get a type that will be
+matched without permanently inferring it. This may be useful when you need
+to match several procs accepting the same wide class of types:
 
 .. code-block:: nim
 
-  template ex{a = b + c}(a: int{noalias}, b, c: int) =
-    # this transformation is only valid if 'b' and 'c' do not alias 'a':
-    a = b
-    inc a, c
-
-Another example:
-
-.. code-block:: nim
-
-  proc somefunc(s: string)                 = assert s == "variable"
-  proc somefunc(s: string{nkStrLit})       = assert s == "literal"
-  proc somefunc(s: string{nkRStrLit})      = assert s == r"raw"
-  proc somefunc(s: string{nkTripleStrLit}) = assert s == """triple"""
-  proc somefunc(s: static[string])         = assert s == "constant"
-
-  # Use parameter constraints to provide overloads based on both the input parameter type and form.
-  var variable = "variable"
-  somefunc(variable)
-  const constant = "constant"
-  somefunc(constant)
-  somefunc("literal")
-  somefunc(r"raw")
-  somefunc("""triple""")
-
-
-Pattern operators
------------------
-
-The operators `*`,  `**`, `|`, `~` have a special meaning in patterns
-if they are written in infix notation.
-
-
-The `|` operator
-~~~~~~~~~~~~~~~~~~
+  type
+    Enumerable[T] = concept e
+      for v in e:
+        v is T
 
-The `|` operator if used as infix operator creates an ordered choice:
+  type
+    MyConcept = concept o
+      # this could be inferred to a type such as Enumerable[int]
+      o.foo is distinct Enumerable
 
-.. code-block:: nim
+      # this could be inferred to a different type such as Enumerable[float]
+      o.bar is distinct Enumerable
 
-  template t{0|1}(): untyped = 3
-  let a = 1
-  # outputs 3:
-  echo a
+      # it's also possible to give an alias name to a `bind many` type class
+      type Enum = distinct Enumerable
+      o.baz is Enum
 
-The matching is performed after the compiler performed some optimizations like
-constant folding, so the following does not work:
+On the other hand, using `bind once` types allows you to test for equivalent
+types used in multiple signatures, without actually requiring any concrete
+types, thus allowing you to encode implementation-defined types:
 
 .. code-block:: nim
 
-  template t{0|1}(): untyped = 3
-  # outputs 1:
-  echo 1
-
-The reason is that the compiler already transformed the 1 into "1" for
-the `echo` statement. However, a term rewriting macro should not change the
-semantics anyway. In fact they can be deactivated with the `--patterns:off`:option:
-command line option or temporarily with the `patterns` pragma.
+  type
+    MyConcept = concept x
+      type T1 = auto
+      x.foo(T1)
+      x.bar(T1) # both procs must accept the same type
 
+      type T2 = seq[SomeNumber]
+      x.alpha(T2)
+      x.omega(T2) # both procs must accept the same type
+                  # and it must be a numeric sequence
 
-The `{}` operator
-~~~~~~~~~~~~~~~~~~~
+As seen in the previous examples, you can refer to generic concepts such as
+`Enumerable[T]` just by their short name. Much like the regular generic types,
+the concept will be automatically instantiated with the bind once auto type
+in the place of each missing generic param.
 
-A pattern expression can be bound to a pattern parameter via the `expr{param}`
-notation:
+Please note that generic concepts such as `Enumerable[T]` can be matched
+against concrete types such as `string`. Nim doesn't require the concept
+type to have the same number of parameters as the type being matched.
+If you wish to express a requirement towards the generic parameters of
+the matched type, you can use a type mapping operator such as `genericHead`
+or `stripGenericParams` within the body of the concept to obtain the
+uninstantiated version of the type, which you can then try to instantiate
+in any required way. For example, here is how one might define the classic
+`Functor` concept from Haskell and then demonstrate that Nim's `Option[T]`
+type is an instance of it:
 
 .. code-block:: nim
+    :test: "nim c $1"
 
-  template t{(0|1|2){x}}(x: untyped): untyped = x+1
-  let a = 1
-  # outputs 2:
-  echo a
-
-
-The `~` operator
-~~~~~~~~~~~~~~~~~~
+  import std/[sugar, typetraits]
 
-The `~` operator is the **not** operator in patterns:
+  type
+    Functor[A] = concept f
+      type MatchedGenericType = genericHead(typeof(f))
+        # `f` will be a value of a type such as `Option[T]`
+        # `MatchedGenericType` will become the `Option` type
 
-.. code-block:: nim
+      f.val is A
+        # The Functor should provide a way to obtain
+        # a value stored inside it
 
-  template t{x = (~x){y} and (~x){z}}(x, y, z: bool) =
-    x = y
-    if x: x = z
+      type T = auto
+      map(f, A -> T) is MatchedGenericType[T]
+        # And it should provide a way to map one instance of
+        # the Functor to a instance of a different type, given
+        # a suitable `map` operation for the enclosed values
 
-  var
-    a = false
-    b = true
-    c = false
-  a = b and c
-  echo a
+  import std/options
+  echo Option[int] is Functor # prints true
 
 
-The `*` operator
-~~~~~~~~~~~~~~~~~~
+Concept derived values
+----------------------
 
-The `*` operator can *flatten* a nested binary expression like `a & b & c`
-to `&(a, b, c)`:
+All top level constants or types appearing within the concept body are
+accessible through the dot operator in procs where the concept was successfully
+matched to a concrete type:
 
 .. code-block:: nim
 
-  var
-    calls = 0
-
-  proc `&&`(s: varargs[string]): string =
-    result = s[0]
-    for i in 1..len(s)-1: result.add s[i]
-    inc calls
-
-  template optConc{ `&&` * a }(a: string): untyped = &&a
-
-  let space = " "
-  echo "my" && (space & "awe" && "some " ) && "concat"
+  type
+    DateTime = concept t1, t2, type T
+      const Min = T.MinDate
+      T.Now is T
 
-  # check that it's been optimized properly:
-  doAssert calls == 1
+      t1 < t2 is bool
 
+      type TimeSpan = typeof(t1 - t2)
+      TimeSpan * int is TimeSpan
+      TimeSpan + TimeSpan is TimeSpan
 
-The second operator of `*` must be a parameter; it is used to gather all the
-arguments. The expression `"my" && (space & "awe" && "some " ) && "concat"`
-is passed to `optConc` in `a` as a special list (of kind `nkArgList`)
-which is flattened into a call expression; thus the invocation of `optConc`
-produces:
+      t1 + TimeSpan is T
 
-.. code-block:: nim
+  proc eventsJitter(events: Enumerable[DateTime]): float =
+    var
+      # this variable will have the inferred TimeSpan type for
+      # the concrete Date-like value the proc was called with:
+      averageInterval: DateTime.TimeSpan
 
-   `&&`("my", space & "awe", "some ", "concat")
+      deviation: float
+    ...
 
 
-The `**` operator
-~~~~~~~~~~~~~~~~~~~
+Concept refinement
+------------------
 
-The `**` is much like the `*` operator, except that it gathers not only
-all the arguments, but also the matched operators in reverse polish notation:
+When the matched type within a concept is directly tested against a different
+concept, we say that the outer concept is a refinement of the inner concept and
+thus it is more-specific. When both concepts are matched in a call during
+overload resolution, Nim will assign a higher precedence to the most specific
+one. As an alternative way of defining concept refinements, you can use the
+object inheritance syntax involving the `of` keyword:
 
 .. code-block:: nim
 
-  import std/macros
-
   type
-    Matrix = object
-      dummy: int
-
-  proc `*`(a, b: Matrix): Matrix = discard
-  proc `+`(a, b: Matrix): Matrix = discard
-  proc `-`(a, b: Matrix): Matrix = discard
-  proc `$`(a: Matrix): string = result = $a.dummy
-  proc mat21(): Matrix =
-    result.dummy = 21
-
-  macro optM{ (`+`|`-`|`*`) ** a }(a: Matrix): untyped =
-    echo treeRepr(a)
-    result = newCall(bindSym"mat21")
-
-  var x, y, z: Matrix
-
-  echo x + y * z - x
-
-This passes the expression `x + y * z - x` to the `optM` macro as
-an `nnkArgList` node containing::
+    Graph = concept g, type G of EquallyComparable, Copyable
+      type
+        VertexType = G.VertexType
+        EdgeType = G.EdgeType
 
-  Arglist
-    Sym "x"
-    Sym "y"
-    Sym "z"
-    Sym "*"
-    Sym "+"
-    Sym "x"
-    Sym "-"
+      VertexType is Copyable
+      EdgeType is Copyable
 
-(Which is the reverse polish notation of `x + y * z - x`.)
+      var
+        v: VertexType
+        e: EdgeType
 
+    IncidendeGraph = concept of Graph
+      # symbols such as variables and types from the refined
+      # concept are automatically in scope:
 
-Parameters
-----------
+      g.source(e) is VertexType
+      g.target(e) is VertexType
 
-Parameters in a pattern are type checked in the matching process. If a
-parameter is of the type `varargs` it is treated specially and it can match
-0 or more arguments in the AST to be matched against:
+      g.outgoingEdges(v) is Enumerable[EdgeType]
 
-.. code-block:: nim
+    BidirectionalGraph = concept g, type G
+      # The following will also turn the concept into a refinement when it
+      # comes to overload resolution, but it doesn't provide the convenient
+      # symbol inheritance
+      g is IncidendeGraph
 
-  template optWrite{
-    write(f, x)
-    ((write|writeLine){w})(f, y)
-  }(x, y: varargs[untyped], f: File, w: untyped) =
-    w(f, x, y)
+      g.incomingEdges(G.VertexType) is Enumerable[G.EdgeType]
 
+  proc f(g: IncidendeGraph)
+  proc f(g: BidirectionalGraph) # this one will be preferred if we pass a type
+                                # matching the BidirectionalGraph concept
 
+..
+  Converter type classes
+  ----------------------
 
-Example: Partial evaluation
----------------------------
+  Concepts can also be used to convert a whole range of types to a single type or
+  a small set of simpler types. This is achieved with a `return` statement within
+  the concept body:
 
-The following example shows how some simple partial evaluation can be
-implemented with term rewriting:
+  .. code-block:: nim
 
-.. code-block:: nim
+    type
+      Stringable = concept x
+        $x is string
+        return $x
 
-  proc p(x, y: int; cond: bool): int =
-    result = if cond: x + y else: x - y
+      StringRefValue[CharType] = object
+        base: ptr CharType
+        len: int
 
-  template optP1{p(x, y, true)}(x, y: untyped): untyped = x + y
-  template optP2{p(x, y, false)}(x, y: untyped): untyped = x - y
+      StringRef = concept x
+        # the following would be an overloaded proc for cstring, string, seq and
+        # other user-defined types, returning either a StringRefValue[char] or
+        # StringRefValue[wchar]
+        return makeStringRefValue(x)
 
+    # the varargs param will here be converted to an array of StringRefValues
+    # the proc will have only two instantiations for the two character types
+    proc log(format: static string, varargs[StringRef])
 
-Example: Hoisting
------------------
+    # this proc will allow char and wchar values to be mixed in
+    # the same call at the cost of additional instantiations
+    # the varargs param will be converted to a tuple
+    proc log(format: static string, varargs[distinct StringRef])
 
-The following example shows how some form of hoisting can be implemented:
 
-.. code-block:: nim
+..
+  VTable types
+  ------------
 
-  import std/pegs
+  Concepts allow Nim to define a great number of algorithms, using only
+  static polymorphism and without erasing any type information or sacrificing
+  any execution speed. But when polymorphic collections of objects are required,
+  the user must use one of the provided type erasure techniques - either common
+  base types or VTable types.
 
-  template optPeg{peg(pattern)}(pattern: string{lit}): Peg =
-    var gl {.global, gensym.} = peg(pattern)
-    gl
+  VTable types are represented as "fat pointers" storing a reference to an
+  object together with a reference to a table of procs implementing a set of
+  required operations (the so called vtable).
 
-  for i in 0 .. 3:
-    echo match("(a b c)", peg"'(' @ ')'")
-    echo match("W_HI_Le", peg"\y 'while'")
+  In contrast to other programming languages, the vtable in Nim is stored
+  externally to the object, allowing you to create multiple different vtable
+  views for the same object. Thus, the polymorphism in Nim is unbounded -
+  any type can implement an unlimited number of protocols or interfaces not
+  originally envisioned by the type's author.
 
-The `optPeg` template optimizes the case of a peg constructor with a string
-literal, so that the pattern will only be parsed once at program startup and
-stored in a global `gl` which is then re-used. This optimization is called
-hoisting because it is comparable to classical loop hoisting.
+  Any concept type can be turned into a VTable type by using the `vtref`
+  or the `vtptr` compiler magics. Under the hood, these magics generate
+  a converter type class, which converts the regular instances of the matching
+  types to the corresponding VTable type.
 
+  .. code-block:: nim
 
-AST based overloading
-=====================
+    type
+      IntEnumerable = vtref Enumerable[int]
 
-Parameter constraints can also be used for ordinary routine parameters; these
-constraints affect ordinary overloading resolution then:
+      MyObject = object
+        enumerables: seq[IntEnumerable]
+        streams: seq[OutputStream.vtref]
 
-.. code-block:: nim
+    proc addEnumerable(o: var MyObject, e: IntEnumerable) =
+      o.enumerables.add e
 
-  proc optLit(a: string{lit|`const`}) =
-    echo "string literal"
-  proc optLit(a: string) =
-    echo "no string literal"
+    proc addStream(o: var MyObject, e: OutputStream.vtref) =
+      o.streams.add e
 
-  const
-    constant = "abc"
+  The procs that will be included in the vtable are derived from the concept
+  body and include all proc calls for which all param types were specified as
+  concrete types. All such calls should include exactly one param of the type
+  matched against the concept (not necessarily in the first position), which
+  will be considered the value bound to the vtable.
 
-  var
-    variable = "xyz"
+  Overloads will be created for all captured procs, accepting the vtable type
+  in the position of the captured underlying object.
 
-  optLit("literal")
-  optLit(constant)
-  optLit(variable)
+  Under these rules, it's possible to obtain a vtable type for a concept with
+  unbound type parameters or one instantiated with metatypes (type classes),
+  but it will include a smaller number of captured procs. A completely empty
+  vtable will be reported as an error.
 
-However, the constraints `alias` and `noalias` are not available in
-ordinary routines.
+  The `vtref` magic produces types which can be bound to `ref` types and
+  the `vtptr` magic produced types bound to `ptr` types.
 
 
-Parallel & Spawn
-================
+..
+  deepCopy
+  --------
+  `=deepCopy` is a builtin that is invoked whenever data is passed to
+  a `spawn`'ed proc to ensure memory safety. The programmer can override its
+  behaviour for a specific `ref` or `ptr` type `T`. (Later versions of the
+  language may weaken this restriction.)
 
-Nim has two flavors of parallelism:
-1) `Structured`:idx: parallelism via the `parallel` statement.
-2) `Unstructured`:idx: parallelism via the standalone `spawn` statement.
+  The signature has to be:
 
-Nim has a builtin thread pool that can be used for CPU intensive tasks. For
-IO intensive tasks the `async` and `await` features should be
-used instead. Both parallel and spawn need the `threadpool <threadpool.html>`_
-module to work.
+  .. code-block:: nim
 
-Somewhat confusingly, `spawn` is also used in the `parallel` statement
-with slightly different semantics. `spawn` always takes a call expression of
-the form `f(a, ...)`. Let `T` be `f`'s return type. If `T` is `void`
-then `spawn`'s return type is also `void` otherwise it is `FlowVar[T]`.
+    proc `=deepCopy`(x: T): T
 
-Within a `parallel` section sometimes the `FlowVar[T]` is eliminated
-to `T`. This happens when `T` does not contain any GC'ed memory.
-The compiler can ensure the location in `location = spawn f(...)` is not
-read prematurely within a `parallel` section and so there is no need for
-the overhead of an indirection via `FlowVar[T]` to ensure correctness.
+  This mechanism will be used by most data structures that support shared memory,
+  like channels, to implement thread safe automatic memory management.
 
-**Note**: Currently exceptions are not propagated between `spawn`'ed tasks!
+  The builtin `deepCopy` can even clone closures and their environments. See
+  the documentation of `spawn <#parallel-amp-spawn-spawn-statement>`_ for details.
 
 
-Spawn statement
----------------
+Dynamic arguments for bindSym
+=============================
 
-`spawn`:idx: can be used to pass a task to the thread pool:
+This experimental feature allows the symbol name argument of `macros.bindSym`
+to be computed dynamically.
 
 .. code-block:: nim
+  {.experimental: "dynamicBindSym".}
 
-  import std/threadpool
-
-  proc processLine(line: string) =
-    discard "do some heavy lifting here"
+  import macros
 
-  for x in lines("myinput.txt"):
-    spawn processLine(x)
-  sync()
+  macro callOp(opName, arg1, arg2): untyped =
+    result = newCall(bindSym($opName), arg1, arg2)
 
-For reasons of type safety and implementation simplicity the expression
-that `spawn` takes is restricted:
+  echo callOp("+", 1, 2)
+  echo callOp("-", 5, 4)
 
-* It must be a call expression `f(a, ...)`.
-* `f` must be `gcsafe`.
-* `f` must not have the calling convention `closure`.
-* `f`'s parameters may not be of type `var`.
-  This means one has to use raw `ptr`'s for data passing reminding the
-  programmer to be careful.
-* `ref` parameters are deeply copied which is a subtle semantic change and
-  can cause performance problems but ensures memory safety. This deep copy
-  is performed via `system.deepCopy` and so can be overridden.
-* For *safe* data exchange between `f` and the caller a global `TChannel`
-  needs to be used. However, since spawn can return a result, often no further
-  communication is required.
 
+Term rewriting macros
+=====================
 
-`spawn` executes the passed expression on the thread pool and returns
-a `data flow variable`:idx: `FlowVar[T]` that can be read from. The reading
-with the `^` operator is **blocking**. However, one can use `blockUntilAny` to
-wait on multiple flow variables at the same time:
+Term rewriting macros are macros or templates that have not only
+a *name* but also a *pattern* that is searched for after the semantic checking
+phase of the compiler: This means they provide an easy way to enhance the
+compilation pipeline with user defined optimizations:
 
 .. code-block:: nim
 
-  import std/threadpool, ...
+  template optMul{`*`(a, 2)}(a: int): int = a + a
 
-  # wait until 2 out of 3 servers received the update:
-  proc main =
-    var responses = newSeq[FlowVarBase](3)
-    for i in 0..2:
-      responses[i] = spawn tellServer(Update, "key", "value")
-    var index = blockUntilAny(responses)
-    assert index >= 0
-    responses.del(index)
-    discard blockUntilAny(responses)
+  let x = 3
+  echo x * 2
 
-Data flow variables ensure that no data races
-are possible. Due to technical limitations not every type `T` is possible in
-a data flow variable: `T` has to be of the type `ref`, `string`, `seq`
-or of a type that doesn't contain a type that is garbage collected. This
-restriction is not hard to work-around in practice.
+The compiler now rewrites `x * 2` as `x + x`. The code inside the
+curly brackets is the pattern to match against. The operators `*`,  `**`,
+`|`, `~` have a special meaning in patterns if they are written in infix
+notation, so to match verbatim against `*` the ordinary function call syntax
+needs to be used.
+
+Term rewriting macros are applied recursively, up to a limit. This means that
+if the result of a term rewriting macro is eligible for another rewriting,
+the compiler will try to perform it, and so on, until no more optimizations
+are applicable. To avoid putting the compiler into an infinite loop, there is
+a hard limit on how many times a single term rewriting macro can be applied.
+Once this limit has been passed, the term rewriting macro will be ignored.
 
+Unfortunately optimizations are hard to get right and even this tiny example
+is **wrong**:
 
+.. code-block:: nim
 
-Parallel statement
-------------------
+  template optMul{`*`(a, 2)}(a: int): int = a + a
 
-Example:
+  proc f(): int =
+    echo "side effect!"
+    result = 55
+
+  echo f() * 2
+
+We cannot duplicate 'a' if it denotes an expression that has a side effect!
+Fortunately Nim supports side effect analysis:
 
 .. code-block:: nim
-    :test: "nim c --threads:on $1"
 
-  # Compute PI in an inefficient way
-  import std/[strutils, math, threadpool]
-  {.experimental: "parallel".}
+  template optMul{`*`(a, 2)}(a: int{noSideEffect}): int = a + a
 
-  proc term(k: float): float = 4 * math.pow(-1, k) / (2*k + 1)
+  proc f(): int =
+    echo "side effect!"
+    result = 55
 
-  proc pi(n: int): float =
-    var ch = newSeq[float](n+1)
-    parallel:
-      for k in 0..ch.high:
-        ch[k] = spawn term(float(k))
-    for k in 0..ch.high:
-      result += ch[k]
+  echo f() * 2 # not optimized ;-)
 
-  echo formatFloat(pi(5000))
+You can make one overload matching with a constraint and one without, and the
+one with a constraint will have precedence, and so you can handle both cases
+differently.
 
+So what about `2 * a`? We should tell the compiler `*` is commutative. We
+cannot really do that however as the following code only swaps arguments
+blindly:
 
-The parallel statement is the preferred mechanism to introduce parallelism in a
-Nim program. A subset of the Nim language is valid within a `parallel`
-section. This subset is checked during semantic analysis to be free of data
-races. A sophisticated `disjoint checker`:idx: ensures that no data races are
-possible even though shared memory is extensively supported!
+.. code-block:: nim
 
-The subset is in fact the full language with the following
-restrictions / changes:
+  template mulIsCommutative{`*`(a, b)}(a, b: int): int = b * a
 
-* `spawn` within a `parallel` section has special semantics.
-* Every location of the form `a[i]` and `a[i..j]` and `dest` where
-  `dest` is part of the pattern `dest = spawn f(...)` has to be
-  provably disjoint. This is called the *disjoint check*.
-* Every other complex location `loc` that is used in a spawned
-  proc (`spawn f(loc)`) has to be immutable for the duration of
-  the `parallel` section. This is called the *immutability check*. Currently
-  it is not specified what exactly "complex location" means. We need to make
-  this an optimization!
-* Every array access has to be provably within bounds. This is called
-  the *bounds check*.
-* Slices are optimized so that no copy is performed. This optimization is not
-  yet performed for ordinary slices outside of a `parallel` section.
+What optimizers really need to do is a *canonicalization*:
 
+.. code-block:: nim
 
-Guards and locks
-================
+  template canonMul{`*`(a, b)}(a: int{lit}, b: int): int = b * a
 
-Apart from `spawn` and `parallel` Nim also provides all the common low level
-concurrency mechanisms like locks, atomic intrinsics or condition variables.
+The `int{lit}` parameter pattern matches against an expression of
+type `int`, but only if it's a literal.
 
-Nim significantly improves on the safety of these features via additional
-pragmas:
 
-1) A `guard`:idx: annotation is introduced to prevent data races.
-2) Every access of a guarded memory location needs to happen in an
-   appropriate `locks`:idx: statement.
-3) Locks and routines can be annotated with `lock levels`:idx: to allow
-   potential deadlocks to be detected during semantic analysis.
 
+Parameter constraints
+---------------------
 
-Guards and the locks section
-----------------------------
+The `parameter constraint`:idx: expression can use the operators `|` (or),
+`&` (and) and `~` (not) and the following predicates:
 
-Protecting global variables
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
+===================      =====================================================
+Predicate                Meaning
+===================      =====================================================
+`atom`                   The matching node has no children.
+`lit`                    The matching node is a literal like `"abc"`, `12`.
+`sym`                    The matching node must be a symbol (a bound
+                         identifier).
+`ident`                  The matching node must be an identifier (an unbound
+                         identifier).
+`call`                   The matching AST must be a call/apply expression.
+`lvalue`                 The matching AST must be an lvalue.
+`sideeffect`             The matching AST must have a side effect.
+`nosideeffect`           The matching AST must have no side effect.
+`param`                  A symbol which is a parameter.
+`genericparam`           A symbol which is a generic parameter.
+`module`                 A symbol which is a module.
+`type`                   A symbol which is a type.
+`var`                    A symbol which is a variable.
+`let`                    A symbol which is a `let` variable.
+`const`                  A symbol which is a constant.
+`result`                 The special `result` variable.
+`proc`                   A symbol which is a proc.
+`method`                 A symbol which is a method.
+`iterator`               A symbol which is an iterator.
+`converter`              A symbol which is a converter.
+`macro`                  A symbol which is a macro.
+`template`               A symbol which is a template.
+`field`                  A symbol which is a field in a tuple or an object.
+`enumfield`              A symbol which is a field in an enumeration.
+`forvar`                 A for loop variable.
+`label`                  A label (used in `block` statements).
+`nk*`                    The matching AST must have the specified kind.
+                         (Example: `nkIfStmt` denotes an `if` statement.)
+`alias`                  States that the marked parameter needs to alias
+                         with *some* other parameter.
+`noalias`                States that *every* other parameter must not alias
+                         with the marked parameter.
+===================      =====================================================
 
-Object fields and global variables can be annotated via a `guard` pragma:
+Predicates that share their name with a keyword have to be escaped with
+backticks.
+The `alias` and `noalias` predicates refer not only to the matching AST,
+but also to every other bound parameter; syntactically they need to occur after
+the ordinary AST predicates:
 
 .. code-block:: nim
 
-  var glock: TLock
-  var gdata {.guard: glock.}: int
+  template ex{a = b + c}(a: int{noalias}, b, c: int) =
+    # this transformation is only valid if 'b' and 'c' do not alias 'a':
+    a = b
+    inc a, c
 
-The compiler then ensures that every access of `gdata` is within a `locks`
-section:
+Another example:
 
 .. code-block:: nim
 
-  proc invalid =
-    # invalid: unguarded access:
-    echo gdata
+  proc somefunc(s: string)                 = assert s == "variable"
+  proc somefunc(s: string{nkStrLit})       = assert s == "literal"
+  proc somefunc(s: string{nkRStrLit})      = assert s == r"raw"
+  proc somefunc(s: string{nkTripleStrLit}) = assert s == """triple"""
+  proc somefunc(s: static[string])         = assert s == "constant"
 
-  proc valid =
-    # valid access:
-    {.locks: [glock].}:
-      echo gdata
+  # Use parameter constraints to provide overloads based on both the input parameter type and form.
+  var variable = "variable"
+  somefunc(variable)
+  const constant = "constant"
+  somefunc(constant)
+  somefunc("literal")
+  somefunc(r"raw")
+  somefunc("""triple""")
 
-Top level accesses to `gdata` are always allowed so that it can be initialized
-conveniently. It is *assumed* (but not enforced) that every top level statement
-is executed before any concurrent action happens.
 
-The `locks` section deliberately looks ugly because it has no runtime
-semantics and should not be used directly! It should only be used in templates
-that also implement some form of locking at runtime:
+Pattern operators
+-----------------
 
-.. code-block:: nim
+The operators `*`,  `**`, `|`, `~` have a special meaning in patterns
+if they are written in infix notation.
 
-  template lock(a: TLock; body: untyped) =
-    pthread_mutex_lock(a)
-    {.locks: [a].}:
-      try:
-        body
-      finally:
-        pthread_mutex_unlock(a)
 
+The `|` operator
+~~~~~~~~~~~~~~~~~~
 
-The guard does not need to be of any particular type. It is flexible enough to
-model low level lockfree mechanisms:
+The `|` operator if used as infix operator creates an ordered choice:
 
 .. code-block:: nim
 
-  var dummyLock {.compileTime.}: int
-  var atomicCounter {.guard: dummyLock.}: int
-
-  template atomicRead(x): untyped =
-    {.locks: [dummyLock].}:
-      memoryReadBarrier()
-      x
+  template t{0|1}(): untyped = 3
+  let a = 1
+  # outputs 3:
+  echo a
 
-  echo atomicRead(atomicCounter)
+The matching is performed after the compiler performed some optimizations like
+constant folding, so the following does not work:
 
+.. code-block:: nim
 
-The `locks` pragma takes a list of lock expressions `locks: [a, b, ...]`
-in order to support *multi lock* statements. Why these are essential is
-explained in the `lock levels <#guards-and-locks-lock-levels>`_ section.
+  template t{0|1}(): untyped = 3
+  # outputs 1:
+  echo 1
 
+The reason is that the compiler already transformed the 1 into "1" for
+the `echo` statement. However, a term rewriting macro should not change the
+semantics anyway. In fact, they can be deactivated with the `--patterns:off`:option:
+command line option or temporarily with the `patterns` pragma.
 
-Protecting general locations
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The `guard` annotation can also be used to protect fields within an object.
-The guard then needs to be another field within the same object or a
-global variable.
+The `{}` operator
+~~~~~~~~~~~~~~~~~~~
 
-Since objects can reside on the heap or on the stack this greatly enhances the
-expressivity of the language:
+A pattern expression can be bound to a pattern parameter via the `expr{param}`
+notation:
 
 .. code-block:: nim
 
-  type
-    ProtectedCounter = object
-      v {.guard: L.}: int
-      L: TLock
+  template t{(0|1|2){x}}(x: untyped): untyped = x + 1
+  let a = 1
+  # outputs 2:
+  echo a
 
-  proc incCounters(counters: var openArray[ProtectedCounter]) =
-    for i in 0..counters.high:
-      lock counters[i].L:
-        inc counters[i].v
 
-The access to field `x.v` is allowed since its guard `x.L`  is active.
-After template expansion, this amounts to:
+The `~` operator
+~~~~~~~~~~~~~~~~~~
+
+The `~` operator is the 'not' operator in patterns:
 
 .. code-block:: nim
 
-  proc incCounters(counters: var openArray[ProtectedCounter]) =
-    for i in 0..counters.high:
-      pthread_mutex_lock(counters[i].L)
-      {.locks: [counters[i].L].}:
-        try:
-          inc counters[i].v
-        finally:
-          pthread_mutex_unlock(counters[i].L)
+  template t{x = (~x){y} and (~x){z}}(x, y, z: bool) =
+    x = y
+    if x: x = z
+
+  var
+    a = false
+    b = true
+    c = false
+  a = b and c
+  echo a
 
-There is an analysis that checks that `counters[i].L` is the lock that
-corresponds to the protected location `counters[i].v`. This analysis is called
-`path analysis`:idx: because it deals with paths to locations
-like `obj.field[i].fieldB[j]`.
 
-The path analysis is **currently unsound**, but that doesn't make it useless.
-Two paths are considered equivalent if they are syntactically the same.
+The `*` operator
+~~~~~~~~~~~~~~~~~~
 
-This means the following compiles (for now) even though it really should not:
+The `*` operator can *flatten* a nested binary expression like `a & b & c`
+to `&(a, b, c)`:
 
 .. code-block:: nim
 
-  {.locks: [a[i].L].}:
-    inc i
-    access a[i].v
+  var
+    calls = 0
+
+  proc `&&`(s: varargs[string]): string =
+    result = s[0]
+    for i in 1..len(s)-1: result.add s[i]
+    inc calls
 
+  template optConc{ `&&` * a }(a: string): untyped = &&a
 
+  let space = " "
+  echo "my" && (space & "awe" && "some " ) && "concat"
 
-Lock levels
------------
+  # check that it's been optimized properly:
+  doAssert calls == 1
 
-Lock levels are used to enforce a global locking order in order to detect
-potential deadlocks during semantic analysis. A lock level is an constant
-integer in the range 0..1_000. Lock level 0 means that no lock is acquired at
-all.
 
-If a section of code holds a lock of level `M` than it can also acquire any
-lock of level `N < M`. Another lock of level `M` cannot be acquired. Locks
-of the same level can only be acquired *at the same time* within a
-single `locks` section:
+The second operator of `*` must be a parameter; it is used to gather all the
+arguments. The expression `"my" && (space & "awe" && "some " ) && "concat"`
+is passed to `optConc` in `a` as a special list (of kind `nkArgList`)
+which is flattened into a call expression; thus the invocation of `optConc`
+produces:
 
 .. code-block:: nim
 
-  var a, b: TLock[2]
-  var x: TLock[1]
-  # invalid locking order: TLock[1] cannot be acquired before TLock[2]:
-  {.locks: [x].}:
-    {.locks: [a].}:
-      ...
-  # valid locking order: TLock[2] acquired before TLock[1]:
-  {.locks: [a].}:
-    {.locks: [x].}:
-      ...
-
-  # invalid locking order: TLock[2] acquired before TLock[2]:
-  {.locks: [a].}:
-    {.locks: [b].}:
-      ...
+   `&&`("my", space & "awe", "some ", "concat")
 
-  # valid locking order, locks of the same level acquired at the same time:
-  {.locks: [a, b].}:
-    ...
 
+The `**` operator
+~~~~~~~~~~~~~~~~~~~
 
-Here is how a typical multilock statement can be implemented in Nim. Note how
-the runtime check is required to ensure a global ordering for two locks `a`
-and `b` of the same lock level:
+The `**` is much like the `*` operator, except that it gathers not only
+all the arguments, but also the matched operators in reverse polish notation:
 
 .. code-block:: nim
 
-  template multilock(a, b: ptr TLock; body: untyped) =
-    if cast[ByteAddress](a) < cast[ByteAddress](b):
-      pthread_mutex_lock(a)
-      pthread_mutex_lock(b)
-    else:
-      pthread_mutex_lock(b)
-      pthread_mutex_lock(a)
-    {.locks: [a, b].}:
-      try:
-        body
-      finally:
-        pthread_mutex_unlock(a)
-        pthread_mutex_unlock(b)
+  import std/macros
 
+  type
+    Matrix = object
+      dummy: int
 
-Whole routines can also be annotated with a `locks` pragma that takes a lock
-level. This then means that the routine may acquire locks of up to this level.
-This is essential so that procs can be called within a `locks` section:
+  proc `*`(a, b: Matrix): Matrix = discard
+  proc `+`(a, b: Matrix): Matrix = discard
+  proc `-`(a, b: Matrix): Matrix = discard
+  proc `$`(a: Matrix): string = result = $a.dummy
+  proc mat21(): Matrix =
+    result.dummy = 21
 
-.. code-block:: nim
+  macro optM{ (`+`|`-`|`*`) ** a }(a: Matrix): untyped =
+    echo treeRepr(a)
+    result = newCall(bindSym"mat21")
 
-  proc p() {.locks: 3.} = discard
+  var x, y, z: Matrix
 
-  var a: TLock[4]
-  {.locks: [a].}:
-    # p's locklevel (3) is strictly less than a's (4) so the call is allowed:
-    p()
+  echo x + y * z - x
 
+This passes the expression `x + y * z - x` to the `optM` macro as
+an `nnkArgList` node containing::
 
-As usual `locks` is an inferred effect and there is a subtype
-relation: `proc () {.locks: N.}` is a subtype of `proc () {.locks: M.}`
-iff (M <= N).
+  Arglist
+    Sym "x"
+    Sym "y"
+    Sym "z"
+    Sym "*"
+    Sym "+"
+    Sym "x"
+    Sym "-"
 
-The `locks` pragma can also take the special value `"unknown"`. This
-is useful in the context of dynamic method dispatching. In the following
-example, the compiler can infer a lock level of 0 for the `base` case.
-However, one of the overloaded methods calls a procvar which is
-potentially locking. Thus, the lock level of calling `g.testMethod`
-cannot be inferred statically, leading to compiler warnings. By using
-`{.locks: "unknown".}`, the base method can be marked explicitly as
-having unknown lock level as well:
+(This is the reverse polish notation of `x + y * z - x`.)
 
-.. code-block:: nim
 
-  type SomeBase* = ref object of RootObj
-  type SomeDerived* = ref object of SomeBase
-    memberProc*: proc ()
+Parameters
+----------
 
-  method testMethod(g: SomeBase) {.base, locks: "unknown".} = discard
-  method testMethod(g: SomeDerived) =
-    if g.memberProc != nil:
-      g.memberProc()
+Parameters in a pattern are type checked in the matching process. If a
+parameter is of the type `varargs`, it is treated specially and can match
+0 or more arguments in the AST to be matched against:
+
+.. code-block:: nim
+
+  template optWrite{
+    write(f, x)
+    ((write|writeLine){w})(f, y)
+  }(x, y: varargs[untyped], f: File, w: untyped) =
+    w(f, x, y)
 
 
 noRewrite pragma
@@ -1731,324 +1570,304 @@ e.g. with given example `echo("ab")` will be rewritten just once:
 `noRewrite` pragma can be useful to control term-rewriting macros recursion.
 
 
-Aliasing restrictions in parameter passing
-==========================================
-
-**Note**: The aliasing restrictions are currently not enforced by the
-implementation and need to be fleshed out further.
-
-"Aliasing" here means that the underlying storage locations overlap in memory
-at runtime. An "output parameter" is a parameter of type `var T`,
-an input parameter is any parameter that is not of type `var`.
-
-1. Two output parameters should never be aliased.
-2. An input and an output parameter should not be aliased.
-3. An output parameter should never be aliased with a global or thread local
-   variable referenced by the called proc.
-4. An input parameter should not be aliased with a global or thread local
-   variable updated by the called proc.
-
-One problem with rules 3 and 4 is that they affect specific global or thread
-local variables, but Nim's effect tracking only tracks "uses no global variable"
-via `.noSideEffect`. The rules 3 and 4 can also be approximated by a different rule:
-
-5. A global or thread local variable (or a location derived from such a location)
-   can only passed to a parameter of a `.noSideEffect` proc.
-
-
-Noalias annotation
-==================
-
-Since version 1.4 of the Nim compiler, there is a `.noalias` annotation for variables
-and parameters. It is mapped directly to C/C++'s `restrict`:c: keyword and means that
-the underlying pointer is pointing to a unique location in memory, no other aliases to
-this location exist. It is *unchecked* that this alias restriction is followed, if the
-restriction is violated, the backend optimizer is free to miscompile the code.
-This is an **unsafe** language feature.
-
-Ideally in later versions of the language, the restriction will be enforced at
-compile time. (Which is also why the name `noalias` was choosen instead of a more
-verbose name like `unsafeAssumeNoAlias`.)
-
-
-Strict funcs
-============
-
-Since version 1.4 a stricter definition of "side effect" is available. In addition
-to the existing rule that a side effect is calling a function with side effects
-the following rule is also enforced:
 
-Any mutation to an object does count as a side effect if that object is reachable
-via a parameter that is not declared as a `var` parameter.
+Example: Partial evaluation
+---------------------------
 
-For example:
+The following example shows how some simple partial evaluation can be
+implemented with term rewriting:
 
 .. code-block:: nim
 
-  {.experimental: "strictFuncs".}
-
-  type
-    Node = ref object
-      le, ri: Node
-      data: string
-
-  func len(n: Node): int =
-    # valid: len does not have side effects
-    var it = n
-    while it != nil:
-      inc result
-      it = it.ri
-
-  func mut(n: Node) =
-    let m = n # is the statement that connected the mutation to the parameter
-    m.data = "yeah" # the mutation is here
-    # Error: 'mut' can have side effects
-    # an object reachable from 'n' is potentially mutated
+  proc p(x, y: int; cond: bool): int =
+    result = if cond: x + y else: x - y
 
+  template optP1{p(x, y, true)}(x, y: untyped): untyped = x + y
+  template optP2{p(x, y, false)}(x, y: untyped): untyped = x - y
 
-The algorithm behind this analysis is described in
-the `view types section <#view-types-algorithm>`_.
 
+Example: Hoisting
+-----------------
 
-View types
-==========
+The following example shows how some form of hoisting can be implemented:
 
-**Note**:  `--experimental:views`:option: is more effective
-with `--experimental:strictFuncs`:option:.
+.. code-block:: nim
 
-A view type is a type that is or contains one of the following types:
+  import std/pegs
 
-- `lent T` (view into `T`)
-- `openArray[T]` (pair of (pointer to array of `T`, size))
+  template optPeg{peg(pattern)}(pattern: string{lit}): Peg =
+    var gl {.global, gensym.} = peg(pattern)
+    gl
 
-For example:
+  for i in 0 .. 3:
+    echo match("(a b c)", peg"'(' @ ')'")
+    echo match("W_HI_Le", peg"\y 'while'")
 
-.. code-block:: nim
+The `optPeg` template optimizes the case of a peg constructor with a string
+literal, so that the pattern will only be parsed once at program startup and
+stored in a global `gl` which is then re-used. This optimization is called
+hoisting because it is comparable to classical loop hoisting.
 
-  type
-    View1 = openArray[byte]
-    View2 = lent string
-    View3 = Table[openArray[char], int]
 
+AST based overloading
+=====================
 
-Exceptions to this rule are types constructed via `ptr` or `proc`.
-For example, the following types are **not** view types:
+Parameter constraints can also be used for ordinary routine parameters; these
+constraints then affect ordinary overloading resolution:
 
 .. code-block:: nim
 
-  type
-    NotView1 = proc (x: openArray[int])
-    NotView2 = ptr openArray[char]
-    NotView3 = ptr array[4, lent int]
+  proc optLit(a: string{lit|`const`}) =
+    echo "string literal"
+  proc optLit(a: string) =
+    echo "no string literal"
 
+  const
+    constant = "abc"
 
-The mutability aspect of a view type is not part of the type but part
-of the locations it's derived from. More on this later.
+  var
+    variable = "xyz"
 
-A *view* is a symbol (a let, var, const, etc.) that has a view type.
+  optLit("literal")
+  optLit(constant)
+  optLit(variable)
 
-Since version 1.4 Nim allows view types to be used as local variables.
-This feature needs to be enabled via `{.experimental: "views".}`.
+However, the constraints `alias` and `noalias` are not available in
+ordinary routines.
 
-A local variable of a view type *borrows* from the locations and
-it is statically enforced that the view does not outlive the location
-it was borrowed from.
 
-For example:
+Parallel & Spawn
+================
 
-.. code-block:: nim
+Nim has two flavors of parallelism:
+1) `Structured`:idx: parallelism via the `parallel` statement.
+2) `Unstructured`:idx: parallelism via the standalone `spawn` statement.
 
-  {.experimental: "views".}
+Nim has a builtin thread pool that can be used for CPU intensive tasks. For
+IO intensive tasks the `async` and `await` features should be
+used instead. Both parallel and spawn need the `threadpool <threadpool.html>`_
+module to work.
 
-  proc take(a: openArray[int]) =
-    echo a.len
+Somewhat confusingly, `spawn` is also used in the `parallel` statement
+with slightly different semantics. `spawn` always takes a call expression of
+the form `f(a, ...)`. Let `T` be `f`'s return type. If `T` is `void`,
+then `spawn`'s return type is also `void`, otherwise it is `FlowVar[T]`.
 
-  proc main(s: seq[int]) =
-    var x: openArray[int] = s # 'x' is a view into 's'
-    # it is checked that 'x' does not outlive 's' and
-    # that 's' is not mutated.
-    for i in 0 .. high(x):
-      echo x[i]
-    take(x)
+Within a `parallel` section, the `FlowVar[T]` is sometimes eliminated
+to `T`. This happens when `T` does not contain any GC'ed memory.
+The compiler can ensure the location in `location = spawn f(...)` is not
+read prematurely within a `parallel` section and so there is no need for
+the overhead of an indirection via `FlowVar[T]` to ensure correctness.
 
-    take(x.toOpenArray(0, 1)) # slicing remains possible
-    let y = x  # create a view from a view
-    take y
-    # it is checked that 'y' does not outlive 'x' and
-    # that 'x' is not mutated as long as 'y' lives.
+.. note:: Currently exceptions are not propagated between `spawn`'ed tasks!
 
+This feature is likely to be removed in the future as external packages
+can have better solutions. 
 
-  main(@[11, 22, 33])
 
+Spawn statement
+---------------
 
-A local variable of a view type can borrow from a location
-derived from a parameter, another local variable, a global `const` or `let`
-symbol or a thread-local `var` or `let`.
+The `spawn`:idx: statement can be used to pass a task to the thread pool:
 
-Let `p` the proc that is analysed for the correctness of the borrow operation.
+.. code-block:: nim
 
-Let `source` be one of:
+  import std/threadpool
 
-- A formal parameter of `p`. Note that this does not cover parameters of
-  inner procs.
-- The `result` symbol of `p`.
-- A local `var` or `let` or `const` of `p`. Note that this does
-  not cover locals of inner procs.
-- A thread-local `var` or `let`.
-- A global `let` or `const`.
-- A constant array/seq/object/tuple constructor.
+  proc processLine(line: string) =
+    discard "do some heavy lifting here"
 
+  for x in lines("myinput.txt"):
+    spawn processLine(x)
+  sync()
 
-Path expressions
-----------------
+For reasons of type safety and implementation simplicity the expression
+that `spawn` takes is restricted:
 
-A location derived from `source` is then defined as a path expression that
-has `source` as the owner. A path expression `e` is defined recursively:
+* It must be a call expression `f(a, ...)`.
+* `f` must be `gcsafe`.
+* `f` must not have the calling convention `closure`.
+* `f`'s parameters may not be of type `var`.
+  This means one has to use raw `ptr`'s for data passing reminding the
+  programmer to be careful.
+* `ref` parameters are deeply copied, which is a subtle semantic change and
+  can cause performance problems, but ensures memory safety. This deep copy
+  is performed via `system.deepCopy`, so it can be overridden.
+* For *safe* data exchange between `f` and the caller, a global `Channel`
+  needs to be used. However, since spawn can return a result, often no further
+  communication is required.
 
-- `source` itself is a path expression.
-- Container access like `e[i]` is a path expression.
-- Tuple access `e[0]` is a path expression.
-- Object field access `e.field` is a path expression.
-- `system.toOpenArray(e, ...)` is a path expression.
-- Pointer dereference `e[]` is a path expression.
-- An address `addr e`, `unsafeAddr e` is a path expression.
-- A type conversion `T(e)` is a path expression.
-- A cast expression `cast[T](e)` is a path expression.
-- `f(e, ...)` is a path expression if `f`'s return type is a view type.
-  Because the view can only have been borrowed from `e`, we then know
-  that owner of `f(e, ...)` is `e`.
 
+`spawn` executes the passed expression on the thread pool and returns
+a `data flow variable`:idx: `FlowVar[T]` that can be read from. The reading
+with the `^` operator is **blocking**. However, one can use `blockUntilAny` to
+wait on multiple flow variables at the same time:
 
-If a view type is used as a return type, the location must borrow from a location
-that is derived from the first parameter that is passed to the proc.
-See https://nim-lang.org/docs/manual.html#procedures-var-return-type for
-details about how this is done for `var T`.
+.. code-block:: nim
 
-A mutable view can borrow from a mutable location, an immutable view can borrow
-from both a mutable or an immutable location.
+  import std/threadpool, ...
 
-If a view borrows from a mutable location, the view can be used to update the
-location. Otherwise it cannot be used for mutations.
+  # wait until 2 out of 3 servers received the update:
+  proc main =
+    var responses = newSeq[FlowVarBase](3)
+    for i in 0..2:
+      responses[i] = spawn tellServer(Update, "key", "value")
+    var index = blockUntilAny(responses)
+    assert index >= 0
+    responses.del(index)
+    discard blockUntilAny(responses)
 
-The *duration* of a borrow is the span of commands beginning from the assignment
-to the view and ending with the last usage of the view.
+Data flow variables ensure that no data races are possible. Due to
+technical limitations, not every type `T` can be used in
+a data flow variable: `T` has to be a `ref`, `string`, `seq`
+or of a type that doesn't contain any GC'd type. This
+restriction is not hard to work-around in practice.
 
-For the duration of the borrow operation, no mutations to the borrowed locations
-may be performed except via the view that borrowed from the
-location. The borrowed location is said to be *sealed* during the borrow.
 
-.. code-block:: nim
 
-  {.experimental: "views".}
+Parallel statement
+------------------
 
-  type
-    Obj = object
-      field: string
+Example:
 
-  proc dangerous(s: var seq[Obj]) =
-    let v: lent Obj = s[0] # seal 's'
-    s.setLen 0  # prevented at compile-time because 's' is sealed.
-    echo v.field
+.. code-block:: nim
+    :test: "nim c --threads:on $1"
 
+  # Compute pi in an inefficient way
+  import std/[strutils, math, threadpool]
+  {.experimental: "parallel".}
 
-The scope of the view does not matter:
+  proc term(k: float): float = 4 * math.pow(-1, k) / (2*k + 1)
 
-.. code-block:: nim
+  proc pi(n: int): float =
+    var ch = newSeq[float](n + 1)
+    parallel:
+      for k in 0..ch.high:
+        ch[k] = spawn term(float(k))
+    for k in 0..ch.high:
+      result += ch[k]
 
-  proc valid(s: var seq[Obj]) =
-    let v: lent Obj = s[0]  # begin of borrow
-    echo v.field            # end of borrow
-    s.setLen 0  # valid because 'v' isn't used afterwards
+  echo formatFloat(pi(5000))
 
 
-The analysis requires as much precision about mutations as is reasonably obtainable,
-so it is more effective with the experimental `strict funcs <#strict-funcs>`_
-feature. In other words `--experimental:views`:option: works better
-with `--experimental:strictFuncs`:option:.
+The parallel statement is the preferred mechanism to introduce parallelism in a
+Nim program. Only a subset of the Nim language is valid within a `parallel`
+section. This subset is checked during semantic analysis to be free of data
+races. A sophisticated `disjoint checker`:idx: ensures that no data races are
+possible, even though shared memory is extensively supported!
 
-The analysis is currently control flow insensitive:
+The subset is in fact the full language with the following
+restrictions / changes:
 
-.. code-block:: nim
+* `spawn` within a `parallel` section has special semantics.
+* Every location of the form `a[i]`, `a[i..j]` and `dest` where
+  `dest` is part of the pattern `dest = spawn f(...)` has to be
+  provably disjoint. This is called the *disjoint check*.
+* Every other complex location `loc` that is used in a spawned
+  proc (`spawn f(loc)`) has to be immutable for the duration of
+  the `parallel` section. This is called the *immutability check*. Currently
+  it is not specified what exactly "complex location" means. We need to make
+  this an optimization!
+* Every array access has to be provably within bounds. This is called
+  the *bounds check*.
+* Slices are optimized so that no copy is performed. This optimization is not
+  yet performed for ordinary slices outside of a `parallel` section.
 
-  proc invalid(s: var seq[Obj]) =
-    let v: lent Obj = s[0]
-    if false:
-      s.setLen 0
-    echo v.field
 
-In this example, the compiler assumes that `s.setLen 0` invalidates the
-borrow operation of `v` even though a human being can easily see that it
-will never do that at runtime.
 
+Lock levels
+===========
 
-Start of a borrow
------------------
+Lock levels are used to enforce a global locking order in order to detect
+potential deadlocks during semantic analysis. A lock level is an constant
+integer in the range 0..1_000. Lock level 0 means that no lock is acquired at
+all.
 
-A borrow starts with one of the following:
+If a section of code holds a lock of level `M`, it can also acquire any
+lock of level `N < M`. Another lock of level `M` cannot be acquired. Locks
+of the same level can only be acquired *at the same time* within a
+single `locks` section:
 
-- The assignment of a non-view-type to a view-type.
-- The assignment of a location that is derived from a local parameter
-  to a view-type.
+.. code-block:: nim
+
+  var a, b: TLock[2]
+  var x: TLock[1]
+  # invalid locking order: TLock[1] cannot be acquired before TLock[2]:
+  {.locks: [x].}:
+    {.locks: [a].}:
+      ...
+  # valid locking order: TLock[2] acquired before TLock[1]:
+  {.locks: [a].}:
+    {.locks: [x].}:
+      ...
 
+  # invalid locking order: TLock[2] acquired before TLock[2]:
+  {.locks: [a].}:
+    {.locks: [b].}:
+      ...
 
-End of a borrow
----------------
+  # valid locking order, locks of the same level acquired at the same time:
+  {.locks: [a, b].}:
+    ...
 
-A borrow operation ends with the last usage of the view variable.
 
+Here is how a typical multilock statement can be implemented in Nim. Note how
+the runtime check is required to ensure a global ordering for two locks `a`
+and `b` of the same lock level:
 
-Reborrows
----------
+.. code-block:: nim
 
-A view `v` can borrow from multiple different locations. However, the borrow
-is always the full span of `v`'s lifetime and every location that is borrowed
-from is sealed during `v`'s lifetime.
+  template multilock(a, b: ptr TLock; body: untyped) =
+    if cast[ByteAddress](a) < cast[ByteAddress](b):
+      pthread_mutex_lock(a)
+      pthread_mutex_lock(b)
+    else:
+      pthread_mutex_lock(b)
+      pthread_mutex_lock(a)
+    {.locks: [a, b].}:
+      try:
+        body
+      finally:
+        pthread_mutex_unlock(a)
+        pthread_mutex_unlock(b)
 
 
-Algorithm
----------
+Whole routines can also be annotated with a `locks` pragma that takes a lock
+level. This then means that the routine may acquire locks of up to this level.
+This is essential so that procs can be called within a `locks` section:
 
-The following section is an outline of the algorithm that the current implementation
-uses. The algorithm performs two traversals over the AST of the procedure or global
-section of code that uses a view variable. No fixpoint iterations are performed, the
-complexity of the analysis is O(N) where N is the number of nodes of the AST.
+.. code-block:: nim
 
-The first pass over the AST computes the lifetime of each local variable based on
-a notion of an "abstract time", in the implementation it's a simple integer that is
-incremented for every visited node.
+  proc p() {.locks: 3.} = discard
 
-In the second pass information about the underlying object "graphs" is computed.
-Let `v` be a parameter or a local variable. Let `G(v)` be the graph
-that `v` belongs to. A graph is defined by the set of variables that belong
-to the graph. Initially for all `v`: `G(v) = {v}`. Every variable can only
-be part of a single graph.
+  var a: TLock[4]
+  {.locks: [a].}:
+    # p's locklevel (3) is strictly less than a's (4) so the call is allowed:
+    p()
 
-Assignments like `a = b` "connect" two variables, both variables end up in the
-same graph `{a, b} = G(a) = G(b)`. Unfortunately, the pattern to look for is
-much more complex than that and can involve multiple assignment targets
-and sources::
 
-  f(x, y) = g(a, b)
+As usual, `locks` is an inferred effect and there is a subtype
+relation: `proc () {.locks: N.}` is a subtype of `proc () {.locks: M.}`
+iff (M <= N).
 
-connects `x` and `y` to `a` and `b`: `G(x) = G(y) = G(a) = G(b) = {x, y, a, b}`.
-A type based alias analysis rules out some of these combinations, for example
-a `string` value cannot possibly be connected to a `seq[int]`.
+The `locks` pragma can also take the special value `"unknown"`. This
+is useful in the context of dynamic method dispatching. In the following
+example, the compiler can infer a lock level of 0 for the `base` case.
+However, one of the overloaded methods calls a procvar which is
+potentially locking. Thus, the lock level of calling `g.testMethod`
+cannot be inferred statically, leading to compiler warnings. By using
+`{.locks: "unknown".}`, the base method can be marked explicitly as
+having unknown lock level as well:
 
-A pattern like `v[] = value` or `v.field = value` marks `G(v)` as mutated.
-After the second pass a set of disjoint graphs was computed.
+.. code-block:: nim
 
-For strict functions it is then enforced that there is no graph that is both mutated
-and has an element that is an immutable parameter (that is a parameter that is not
-of type `var T`).
+  type SomeBase* = ref object of RootObj
+  type SomeDerived* = ref object of SomeBase
+    memberProc*: proc ()
 
-For borrow checking a different set of checks is performed. Let `v` be the view
-and `b` the location that is borrowed from.
+  method testMethod(g: SomeBase) {.base, locks: "unknown".} = discard
+  method testMethod(g: SomeDerived) =
+    if g.memberProc != nil:
+      g.memberProc()
 
-- The lifetime of `v` must not exceed `b`'s lifetime. Note: The lifetime of
-  a parameter is the complete proc body.
-- If `v` is used for a mutation, `b` must be a mutable location too.
-- During `v`'s lifetime, `G(b)` can only be modified by `v` (and only if
-  `v` is a mutable view).
-- If `v` is `result` then `b` has to be a location derived from the first
-  formal parameter or from a constant location.
-- A view cannot be used for a read or a write access before it was assigned to.
+This feature may be removed in the future due to its practical difficulties.
diff --git a/doc/nimc.rst b/doc/nimc.rst
index e32624da3ea..0fd559c3fa6 100644
--- a/doc/nimc.rst
+++ b/doc/nimc.rst
@@ -179,6 +179,22 @@ ignored too. `--define:FOO`:option: and `--define:foo`:option: are identical.
 Compile-time symbols starting with the `nim` prefix are reserved for the
 implementation and should not be used elsewhere.
 
+==========================       ============================================
+Name                             Description
+==========================       ============================================
+nimStdSetjmp                     Use the standard `setjmp()/longjmp()` library
+                                 functions for setjmp-based exceptions. This is
+                                 the default on most platforms.
+nimSigSetjmp                     Use `sigsetjmp()/siglongjmp()` for setjmp-based exceptions.
+nimRawSetjmp                     Use `_setjmp()/_longjmp()` on POSIX and `_setjmp()/longjmp()`
+                                 on Windows, for setjmp-based exceptions. It's the default on
+                                 BSDs and BSD-like platforms, where it's significantly faster
+                                 than the standard functions.
+nimBuiltinSetjmp                 Use `__builtin_setjmp()/__builtin_longjmp()` for setjmp-based
+                                 exceptions. This will not work if an exception is being thrown
+                                 and caught inside the same procedure. Useful for benchmarking.
+==========================       ============================================
+
 
 Configuration files
 -------------------
diff --git a/doc/tut1.rst b/doc/tut1.rst
index f35909fba02..8cd860098db 100644
--- a/doc/tut1.rst
+++ b/doc/tut1.rst
@@ -923,7 +923,7 @@ Let's return to the simple counting example:
     echo i
 
 Can a `countup <system.html#countup.i,T,T,Positive>`_ proc be written that
-supports this loop? Lets try:
+supports this loop? Let's try:
 
 .. code-block:: nim
   proc countup(a, b: int): int =
@@ -1062,7 +1062,7 @@ errors.
 
 Lossless `Automatic type conversion`:idx: is performed in expressions where different
 kinds of integer types are used. However, if the type conversion
-would cause loss of information, the ``RangeDefect``:idx: is raised (if the error
+would cause loss of information, the `RangeDefect`:idx: is raised (if the error
 cannot be detected at compile time).
 
 
diff --git a/lib/core/macros.nim b/lib/core/macros.nim
index 806ea7e3134..d2b90c29249 100644
--- a/lib/core/macros.nim
+++ b/lib/core/macros.nim
@@ -465,12 +465,7 @@ proc bindSym*(ident: string | NimNode, rule: BindSymRule = brClosed): NimNode {.
   ## If `rule == brForceOpen` always an `nnkOpenSymChoice` tree is
   ## returned even if the symbol is not ambiguous.
   ##
-  ## Experimental feature:
-  ## use {.experimental: "dynamicBindSym".} to activate it.
-  ## If called from template / regular code, `ident` and `rule` must be
-  ## constant expression / literal value.
-  ## If called from macros / compile time procs / static blocks,
-  ## `ident` and `rule` can be VM computed value.
+  ## See the `manual <manual.html#macros-bindsym>`_ for more details.
 
 proc genSym*(kind: NimSymKind = nskLet; ident = ""): NimNode {.
   magic: "NGenSym", noSideEffect.}
@@ -1376,7 +1371,7 @@ template findChild*(n: NimNode; cond: untyped): NimNode {.dirty.} =
   ##
   ## .. code-block:: nim
   ##   var res = findChild(n, it.kind == nnkPostfix and
-  ##                          it.basename.ident == toNimIdent"foo")
+  ##                          it.basename.ident == ident"foo")
   block:
     var res: NimNode
     for it in n.children:
@@ -1496,6 +1491,22 @@ macro expandMacros*(body: typed): untyped =
   echo body.toStrLit
   result = body
 
+proc extractTypeImpl(n: NimNode): NimNode =
+    ## attempts to extract the type definition of the given symbol
+    case n.kind
+    of nnkSym: # can extract an impl
+      result = n.getImpl.extractTypeImpl()
+    of nnkObjectTy, nnkRefTy, nnkPtrTy: result = n
+    of nnkBracketExpr:
+      if n.typeKind == ntyTypeDesc:
+        result = n[1].extractTypeImpl()
+      else:
+        doAssert n.typeKind == ntyGenericInst
+        result = n[0].getImpl()
+    of nnkTypeDef:
+      result = n[2]
+    else: error("Invalid node to retrieve type implementation of: " & $n.kind)
+
 proc customPragmaNode(n: NimNode): NimNode =
   expectKind(n, {nnkSym, nnkDotExpr, nnkBracketExpr, nnkTypeOfExpr, nnkCheckedFieldExpr})
   let
@@ -1504,7 +1515,10 @@ proc customPragmaNode(n: NimNode): NimNode =
   if typ.kind == nnkBracketExpr and typ.len > 1 and typ[1].kind == nnkProcTy:
     return typ[1][1]
   elif typ.typeKind == ntyTypeDesc:
-    let impl = typ[1].getImpl()
+    let impl = getImpl(
+      if kind(typ[1]) == nnkBracketExpr: typ[1][0]
+      else: typ[1]
+    )
     if impl[0].kind == nnkPragmaExpr:
       return impl[0][1]
     else:
@@ -1526,10 +1540,13 @@ proc customPragmaNode(n: NimNode): NimNode =
   if n.kind in {nnkDotExpr, nnkCheckedFieldExpr}:
     let name = $(if n.kind == nnkCheckedFieldExpr: n[0][1] else: n[1])
     let typInst = getTypeInst(if n.kind == nnkCheckedFieldExpr or n[0].kind == nnkHiddenDeref: n[0][0] else: n[0])
-    var typDef = getImpl(if typInst.kind == nnkVarTy: typInst[0] else: typInst)
+    var typDef = getImpl(
+      if typInst.kind in {nnkVarTy, nnkBracketExpr}: typInst[0]
+      else: typInst
+    )
     while typDef != nil:
       typDef.expectKind(nnkTypeDef)
-      let typ = typDef[2]
+      let typ = typDef[2].extractTypeImpl()
       typ.expectKind({nnkRefTy, nnkPtrTy, nnkObjectTy})
       let isRef = typ.kind in {nnkRefTy, nnkPtrTy}
       if isRef and typ[0].kind in {nnkSym, nnkBracketExpr}: # defines ref type for another object(e.g. X = ref X)
@@ -1718,8 +1735,8 @@ proc extractDocCommentsAndRunnables*(n: NimNode): NimNode =
     case ni.kind
     of nnkCommentStmt:
       result.add ni
-    of nnkCall:
-      if ni[0].kind == nnkIdent and ni[0].strVal == "runnableExamples":
+    of nnkCall, nnkCommand:
+      if ni[0].kind == nnkIdent and ni[0].eqIdent "runnableExamples":
         result.add ni
       else: break
     else: break
diff --git a/lib/deprecated/pure/LockFreeHash.nim b/lib/deprecated/pure/LockFreeHash.nim
index 97e1ef6ad45..69e12226fe0 100644
--- a/lib/deprecated/pure/LockFreeHash.nim
+++ b/lib/deprecated/pure/LockFreeHash.nim
@@ -1,10 +1,12 @@
 #nim c -t:-march=i686 --cpu:amd64 --threads:on -d:release lockfreehash.nim
 
-import math, hashes
-
 #------------------------------------------------------------------------------
 ## Memory Utility Functions
 
+{.deprecated.}
+
+import math, hashes
+
 proc newHeap*[T](): ptr T =
   result = cast[ptr T](alloc0(sizeof(T)))
 
diff --git a/lib/deprecated/pure/events.nim b/lib/deprecated/pure/events.nim
index 218cb45d57c..85fc349c244 100644
--- a/lib/deprecated/pure/events.nim
+++ b/lib/deprecated/pure/events.nim
@@ -36,6 +36,8 @@
 ##    myobj.SomeEvent.addHandler(handleevent)
 ##    ee.emit(myobj.SomeEvent, genericargs)
 
+{.deprecated.}
+
 type
   EventArgs* = object of RootObj ## Base object for event arguments that are passed to callback functions.
   EventHandler* = tuple[name: string, handlers: seq[proc(e: EventArgs) {.closure.}]] ## An eventhandler for an event.
diff --git a/lib/deprecated/pure/ospaths.nim b/lib/deprecated/pure/ospaths.nim
index 6c7fe4fb304..e253a3e5a01 100644
--- a/lib/deprecated/pure/ospaths.nim
+++ b/lib/deprecated/pure/ospaths.nim
@@ -7,8 +7,9 @@
 #    distribution, for details about the copyright.
 #
 
-## This module is deprecated, `import os` instead.
-{.deprecated: "import os.nim instead".}
+## This module is deprecated, `import std/os` instead.
+
+{.deprecated: "use `std/os` instead".}
 
 import os
 export ReadEnvEffect, WriteEnvEffect, ReadDirEffect, WriteDirEffect, OSErrorCode,
diff --git a/lib/deprecated/pure/securehash.nim b/lib/deprecated/pure/securehash.nim
index 2f4530d8893..ea7930f8112 100644
--- a/lib/deprecated/pure/securehash.nim
+++ b/lib/deprecated/pure/securehash.nim
@@ -1,6 +1,5 @@
-
-
 ## This module is a deprecated alias for the `sha1` module.
-{.deprecated.}
+
+{.deprecated: "use `std/sha1` instead".}
 
 include "../std/sha1"
diff --git a/lib/deprecated/pure/sharedstrings.nim b/lib/deprecated/pure/sharedstrings.nim
deleted file mode 100644
index 4d4ae151bc7..00000000000
--- a/lib/deprecated/pure/sharedstrings.nim
+++ /dev/null
@@ -1,152 +0,0 @@
-#
-#
-#            Nim's Runtime Library
-#        (c) Copyright 2015 Andreas Rumpf
-#
-#    See the file "copying.txt", included in this
-#    distribution, for details about the copyright.
-#
-
-## Shared string support for Nim.
-
-type
-  UncheckedCharArray = UncheckedArray[char]
-
-type
-  Buffer = ptr object
-    refcount: int
-    capacity, realLen: int
-    data: UncheckedCharArray
-
-  SharedString* = object ## A string that can be shared. Slicing is O(1).
-    buffer: Buffer
-    first, len: int
-
-proc decRef(b: Buffer) {.inline.} =
-  if atomicDec(b.refcount) <= 0:
-    deallocShared(b)
-
-proc incRef(b: Buffer) {.inline.} =
-  atomicInc(b.refcount)
-
-{.experimental.}
-
-proc `=destroy`*(s: SharedString) =
-  #echo "destroyed"
-  if not s.buffer.isNil:
-    decRef(s.buffer)
-
-when false:
-  proc `=copy`*(dest: var SharedString; src: SharedString) =
-    incRef(src.buffer)
-    if not dest.buffer.isNil:
-      decRef(dest.buffer)
-    dest.buffer = src.buffer
-    dest.first = src.first
-    dest.len = src.len
-
-proc len*(s: SharedString): int = s.len
-
-proc `[]`*(s: SharedString; i: Natural): char =
-  if i < s.len: result = s.buffer.data[i+s.first]
-  else: raise newException(IndexDefect, formatErrorIndexBound(i, s.len-1))
-
-proc `[]=`*(s: var SharedString; i: Natural; value: char) =
-  if i < s.len: s.buffer.data[i+s.first] = value
-  else: raise newException(IndexDefect, formatErrorIndexBound(i, s.len-1))
-
-proc `[]`*(s: SharedString; ab: HSlice[int, int]): SharedString =
-  #incRef(src.buffer)
-  if ab.a < s.len:
-    result.buffer = s.buffer
-    result.first = ab.a
-    result.len = min(s.len, ab.b - ab.a + 1)
-  # else: produce empty string ;-)
-
-proc newBuffer(cap, len: int): Buffer =
-  assert cap >= len
-  result = cast[Buffer](allocShared0(sizeof(int)*3 + cap))
-  result.refcount = 0
-  result.capacity = cap
-  result.realLen = len
-
-proc newSharedString*(len: Natural): SharedString =
-  if len != 0:
-    # optimization: Don't have an underlying buffer when 'len == 0'
-    result.buffer = newBuffer(len, len)
-  result.first = 0
-  result.len = len
-
-proc newSharedString*(s: string): SharedString =
-  let len = s.len
-  if len != 0:
-    # optimization: Don't have an underlying buffer when 'len == 0'
-    result.buffer = newBuffer(len, len)
-    copyMem(addr result.buffer.data[0], cstring(s), s.len)
-  result.first = 0
-  result.len = len
-
-when declared(atomicLoadN):
-  template load(x): untyped = atomicLoadN(addr x, ATOMIC_SEQ_CST)
-else:
-  # XXX Fixme
-  template load(x): untyped = x
-
-proc add*(s: var SharedString; t: cstring; len: Natural) =
-  if len == 0: return
-  let newLen = s.len + len
-  if s.buffer.isNil:
-    s.buffer = newBuffer(len, len)
-    copyMem(addr s.buffer.data[0], t, len)
-    s.len = len
-  elif newLen >= s.buffer.capacity or s.first != 0 or
-      s.len != s.buffer.realLen or load(s.buffer.refcount) > 1:
-    let oldBuf = s.buffer
-    s.buffer = newBuffer(max(s.buffer.capacity * 3 div 2, newLen), newLen)
-    copyMem(addr s.buffer.data[0], addr oldBuf.data[s.first], s.len)
-    copyMem(addr s.buffer.data[s.len], t, len)
-    decRef(oldBuf)
-  else:
-    copyMem(addr s.buffer.data[s.len], t, len)
-    s.buffer.realLen += len
-    s.len += len
-
-proc add*(s: var SharedString; t: string) =
-  s.add(t.cstring, t.len)
-
-proc rawData*(s: var SharedString): pointer =
-  if s.buffer.isNil: result = nil
-  else: result = addr s.buffer.data[s.first]
-
-proc add*(s: var SharedString; t: SharedString) =
-  if t.buffer.isNil: return
-  s.add(cast[cstring](addr s.buffer.data[s.first]), t.len)
-
-proc `$`*(s: SharedString): string =
-  result = newString(s.len)
-  if s.len > 0:
-    copyMem(addr result[0], addr s.buffer.data[s.first], s.len)
-
-proc `==`*(s: SharedString; t: string): bool =
-  if s.buffer.isNil: result = t.len == 0
-  else: result = t.len == s.len and equalMem(addr s.buffer.data[s.first],
-                                             cstring(t), t.len)
-
-proc `==`*(s, t: SharedString): bool =
-  if s.buffer.isNil: result = t.len == 0
-  else: result = t.len == s.len and equalMem(addr s.buffer.data[s.first],
-                                             addr t.buffer.data[t.first], t.len)
-
-iterator items*(s: SharedString): char =
-  let buf = s.buffer.data
-  let x = s.first
-  if buf != nil:
-    for i in 0..<s.len:
-      yield buf[i+x]
-
-import hashes
-
-proc hash*(s: SharedString): THash =
-  var h: THash = 0
-  for x in s: h = h !& x.hash
-  result = !$h
diff --git a/lib/experimental/sexp.nim b/lib/experimental/sexp.nim
index 67d2229055f..23bc4e6367e 100644
--- a/lib/experimental/sexp.nim
+++ b/lib/experimental/sexp.nim
@@ -442,7 +442,7 @@ macro convertSexp*(x: untyped): untyped =
   ## `%` for every element.
   result = toSexp(x)
 
-proc `==`* (a,b: SexpNode): bool =
+proc `==`* (a, b: SexpNode): bool {.noSideEffect.} =
   ## Check two nodes for equality
   if a.isNil:
     if b.isNil: return true
diff --git a/lib/impure/nre.nim b/lib/impure/nre.nim
index f346d84cbb6..03cbf5220eb 100644
--- a/lib/impure/nre.nim
+++ b/lib/impure/nre.nim
@@ -281,7 +281,7 @@ proc matchesCrLf(pattern: Regex): bool =
   let newlineFlags = flags and (pcre.NEWLINE_CRLF or
                                 pcre.NEWLINE_ANY or
                                 pcre.NEWLINE_ANYCRLF)
-  if newLineFlags > 0u32:
+  if newlineFlags > 0u32:
     return true
 
   # get flags from build config
diff --git a/lib/impure/re.nim b/lib/impure/re.nim
index d6922f4f1ea..4eacf0091cf 100644
--- a/lib/impure/re.nim
+++ b/lib/impure/re.nim
@@ -152,6 +152,9 @@ proc findBounds*(buf: cstring, pattern: Regex, matches: var openArray[string],
   ## and the captured
   ## substrings in the array `matches`. If it does not match, nothing
   ## is written into `matches` and `(-1,0)` is returned.
+  ##
+  ## Note: The memory for `matches` needs to be allocated before this function is
+  ## called, otherwise it will just remain empty.
   var
     rtarray = initRtArray[cint]((matches.len+1)*3)
     rawMatches = rtarray.getRawData
@@ -171,6 +174,14 @@ proc findBounds*(s: string, pattern: Regex, matches: var openArray[string],
   ## and the captured substrings in the array `matches`.
   ## If it does not match, nothing
   ## is written into `matches` and `(-1,0)` is returned.
+  ##
+  ## .. note:: The memory for `matches` needs to be allocated before this function is called, otherwise it will just remain empty.
+  runnableExamples:
+    var matches = newSeq[string](1)
+    let (first, last) = findBounds("Hello World", re"(W\w+)", matches)
+    doAssert first == 6
+    doAssert last == 10
+    doAssert matches[0] == "World"
   result = findBounds(cstring(s), pattern, matches,
       min(start, MaxReBufSize), min(s.len, MaxReBufSize))
 
@@ -182,6 +193,8 @@ proc findBounds*(buf: cstring, pattern: Regex,
   ## and the captured substrings in the array `matches`.
   ## If it does not match, nothing is written into `matches` and
   ## `(-1,0)` is returned.
+  ##
+  ## .. note:: The memory for `matches` needs to be allocated before this function is called, otherwise it will just remain empty.
   var
     rtarray = initRtArray[cint]((matches.len+1)*3)
     rawMatches = rtarray.getRawData
@@ -202,6 +215,14 @@ proc findBounds*(s: string, pattern: Regex,
   ## and the captured substrings in the array `matches`.
   ## If it does not match, nothing is written into `matches` and
   ## `(-1,0)` is returned.
+  ##
+  ## .. note:: The memory for `matches` needs to be allocated before this function is called, otherwise it will just remain empty.
+  runnableExamples:
+    var matches = newSeq[tuple[first, last: int]](1)
+    let (first, last) = findBounds("Hello World", re"(\w+)", matches)
+    doAssert first == 0
+    doAssert last == 4
+    doAssert matches[0] == (0, 4)
   result = findBounds(cstring(s), pattern, matches,
       min(start, MaxReBufSize), min(s.len, MaxReBufSize))
 
@@ -255,6 +276,8 @@ proc matchLen*(s: string, pattern: Regex, matches: var openArray[string],
   ## the same as `match`, but it returns the length of the match,
   ## if there is no match, `-1` is returned. Note that a match length
   ## of zero can happen.
+  ##
+  ## .. note:: The memory for `matches` needs to be allocated before this function is called, otherwise it will just remain empty.
   result = matchOrFind(cstring(s), pattern, matches, start.cint, s.len.cint, pcre.ANCHORED)
 
 proc matchLen*(buf: cstring, pattern: Regex, matches: var openArray[string],
@@ -262,6 +285,8 @@ proc matchLen*(buf: cstring, pattern: Regex, matches: var openArray[string],
   ## the same as `match`, but it returns the length of the match,
   ## if there is no match, `-1` is returned. Note that a match length
   ## of zero can happen.
+  ##
+  ## .. note:: The memory for `matches` needs to be allocated before this function is called, otherwise it will just remain empty.
   return matchOrFind(buf, pattern, matches, start.cint, bufSize.cint, pcre.ANCHORED)
 
 proc matchLen*(s: string, pattern: Regex, start = 0): int {.inline.} =
@@ -292,6 +317,7 @@ proc match*(s: string, pattern: Regex, matches: var openArray[string],
   ## match, nothing is written into `matches` and `false` is
   ## returned.
   ##
+  ## .. note:: The memory for `matches` needs to be allocated before this function is called, otherwise it will just remain empty.
   runnableExamples:
     import std/sequtils
     var matches: array[2, string]
@@ -306,6 +332,8 @@ proc match*(buf: cstring, pattern: Regex, matches: var openArray[string],
   ## match, nothing is written into `matches` and `false` is
   ## returned.
   ## `buf` has length `bufSize` (not necessarily `'\0'` terminated).
+  ##
+  ## .. note:: The memory for `matches` needs to be allocated before this function is called, otherwise it will just remain empty.
   result = matchLen(buf, pattern, matches, start, bufSize) != -1
 
 proc find*(buf: cstring, pattern: Regex, matches: var openArray[string],
@@ -314,6 +342,8 @@ proc find*(buf: cstring, pattern: Regex, matches: var openArray[string],
   ## substrings in the array `matches`. If it does not match, nothing
   ## is written into `matches` and `-1` is returned.
   ## `buf` has length `bufSize` (not necessarily `'\0'` terminated).
+  ##
+  ## .. note:: The memory for `matches` needs to be allocated before this function is called, otherwise it will just remain empty.
   var
     rtarray = initRtArray[cint]((matches.len+1)*3)
     rawMatches = rtarray.getRawData
@@ -332,6 +362,8 @@ proc find*(s: string, pattern: Regex, matches: var openArray[string],
   ## returns the starting position of `pattern` in `s` and the captured
   ## substrings in the array `matches`. If it does not match, nothing
   ## is written into `matches` and `-1` is returned.
+  ##
+  ## .. note:: The memory for `matches` needs to be allocated before this function is called, otherwise it will just remain empty.
   result = find(cstring(s), pattern, matches, start, s.len)
 
 proc find*(buf: cstring, pattern: Regex, start = 0, bufSize: int): int =
@@ -433,6 +465,8 @@ proc contains*(s: string, pattern: Regex, start = 0): bool {.inline.} =
 proc contains*(s: string, pattern: Regex, matches: var openArray[string],
               start = 0): bool {.inline.} =
   ## same as `find(s, pattern, matches, start) >= 0`
+  ##
+  ## .. note:: The memory for `matches` needs to be allocated before this function is called, otherwise it will just remain empty.
   return find(s, pattern, matches, start) >= 0
 
 proc startsWith*(s: string, prefix: Regex): bool {.inline.} =
@@ -522,19 +556,22 @@ iterator split*(s: string, sep: Regex; maxsplit = -1): string =
       @["", "this", "is", "an", "example", ""]
   var last = 0
   var splits = maxsplit
-  var x: int
+  var x = -1
+  if len(s) == 0:
+    last = 1
+  if matchLen(s, sep, 0) == 0:
+    x = 0
   while last <= len(s):
     var first = last
     var sepLen = 1
+    if x == 0:
+      inc(last)
     while last < len(s):
       x = matchLen(s, sep, last)
       if x >= 0:
         sepLen = x
         break
       inc(last)
-    if x == 0:
-      if last >= len(s): break
-      inc last
     if splits == 0: last = len(s)
     yield substr(s, first, last-1)
     if splits == 0: break
diff --git a/lib/js/jsffi.nim b/lib/js/jsffi.nim
index 937e3727bad..ac963eb899f 100644
--- a/lib/js/jsffi.nim
+++ b/lib/js/jsffi.nim
@@ -163,28 +163,28 @@ macro jsFromAst*(n: untyped): untyped =
 proc `&`*(a, b: cstring): cstring {.importjs: "(# + #)".}
   ## Concatenation operator for JavaScript strings.
 
-proc `+`  *(x, y: JsObject): JsObject {.importjs: "(# + #)".}
-proc `-`  *(x, y: JsObject): JsObject {.importjs: "(# - #)".}
-proc `*`  *(x, y: JsObject): JsObject {.importjs: "(# * #)".}
-proc `/`  *(x, y: JsObject): JsObject {.importjs: "(# / #)".}
-proc `%`  *(x, y: JsObject): JsObject {.importjs: "(# % #)".}
-proc `+=` *(x, y: JsObject): JsObject {.importjs: "(# += #)", discardable.}
-proc `-=` *(x, y: JsObject): JsObject {.importjs: "(# -= #)", discardable.}
-proc `*=` *(x, y: JsObject): JsObject {.importjs: "(# *= #)", discardable.}
-proc `/=` *(x, y: JsObject): JsObject {.importjs: "(# /= #)", discardable.}
-proc `%=` *(x, y: JsObject): JsObject {.importjs: "(# %= #)", discardable.}
-proc `++` *(x:    JsObject): JsObject {.importjs: "(++#)".}
-proc `--` *(x:    JsObject): JsObject {.importjs: "(--#)".}
-proc `>`  *(x, y: JsObject): JsObject {.importjs: "(# > #)".}
-proc `<`  *(x, y: JsObject): JsObject {.importjs: "(# < #)".}
-proc `>=` *(x, y: JsObject): JsObject {.importjs: "(# >= #)".}
-proc `<=` *(x, y: JsObject): JsObject {.importjs: "(# <= #)".}
-proc `**` *(x, y: JsObject): JsObject {.importjs: "((#) ** #)".}
+proc `+`*(x, y: JsObject): JsObject {.importjs: "(# + #)".}
+proc `-`*(x, y: JsObject): JsObject {.importjs: "(# - #)".}
+proc `*`*(x, y: JsObject): JsObject {.importjs: "(# * #)".}
+proc `/`*(x, y: JsObject): JsObject {.importjs: "(# / #)".}
+proc `%`*(x, y: JsObject): JsObject {.importjs: "(# % #)".}
+proc `+=`*(x, y: JsObject): JsObject {.importjs: "(# += #)", discardable.}
+proc `-=`*(x, y: JsObject): JsObject {.importjs: "(# -= #)", discardable.}
+proc `*=`*(x, y: JsObject): JsObject {.importjs: "(# *= #)", discardable.}
+proc `/=`*(x, y: JsObject): JsObject {.importjs: "(# /= #)", discardable.}
+proc `%=`*(x, y: JsObject): JsObject {.importjs: "(# %= #)", discardable.}
+proc `++`*(x:    JsObject): JsObject {.importjs: "(++#)".}
+proc `--`*(x:    JsObject): JsObject {.importjs: "(--#)".}
+proc `>`*(x, y: JsObject): JsObject {.importjs: "(# > #)".}
+proc `<`*(x, y: JsObject): JsObject {.importjs: "(# < #)".}
+proc `>=`*(x, y: JsObject): JsObject {.importjs: "(# >= #)".}
+proc `<=`*(x, y: JsObject): JsObject {.importjs: "(# <= #)".}
+proc `**`*(x, y: JsObject): JsObject {.importjs: "((#) ** #)".}
   # (#) needed, refs https://github.com/nim-lang/Nim/pull/16409#issuecomment-760550812
 proc `and`*(x, y: JsObject): JsObject {.importjs: "(# && #)".}
-proc `or` *(x, y: JsObject): JsObject {.importjs: "(# || #)".}
+proc `or`*(x, y: JsObject): JsObject {.importjs: "(# || #)".}
 proc `not`*(x:    JsObject): JsObject {.importjs: "(!#)".}
-proc `in` *(x, y: JsObject): JsObject {.importjs: "(# in #)".}
+proc `in`*(x, y: JsObject): JsObject {.importjs: "(# in #)".}
 
 proc `[]`*(obj: JsObject, field: cstring): JsObject {.importjs: getImpl.}
   ## Returns the value of a property of name `field` from a JsObject `obj`.
diff --git a/lib/packages/docutils/rst.nim b/lib/packages/docutils/rst.nim
index 9c4f8cf525a..a3987d5a16b 100644
--- a/lib/packages/docutils/rst.nim
+++ b/lib/packages/docutils/rst.nim
@@ -2505,7 +2505,7 @@ type
   DirFlag = enum
     hasArg, hasOptions, argIsFile, argIsWord
   DirFlags = set[DirFlag]
-  SectionParser = proc (p: var RstParser): PRstNode {.nimcall.}
+  SectionParser = proc (p: var RstParser): PRstNode {.nimcall, gcsafe.}
 
 proc parseDirective(p: var RstParser, k: RstNodeKind, flags: DirFlags): PRstNode =
   ## Parses arguments and options for a directive block.
@@ -2552,7 +2552,7 @@ proc indFollows(p: RstParser): bool =
   result = currentTok(p).kind == tkIndent and currentTok(p).ival > currInd(p)
 
 proc parseBlockContent(p: var RstParser, father: var PRstNode,
-                       contentParser: SectionParser): bool =
+                       contentParser: SectionParser): bool {.gcsafe.} =
   ## parse the final content part of explicit markup blocks (directives,
   ## footnotes, etc). Returns true if succeeded.
   if currentTok(p).kind != tkIndent or indFollows(p):
@@ -2806,7 +2806,7 @@ proc prefix(ftnType: FootnoteType): string =
   of fnAutoSymbol: result = "footnotesym-"
   of fnCitation: result = "citation-"
 
-proc parseFootnote(p: var RstParser): PRstNode =
+proc parseFootnote(p: var RstParser): PRstNode {.gcsafe.} =
   ## Parses footnotes and citations, always returns 2 sons:
   ##
   ## 1) footnote label, always containing rnInner with 1 or more sons
diff --git a/lib/packages/docutils/rstgen.nim b/lib/packages/docutils/rstgen.nim
index 8eac373072c..2e45bda4ce4 100644
--- a/lib/packages/docutils/rstgen.nim
+++ b/lib/packages/docutils/rstgen.nim
@@ -406,7 +406,7 @@ proc renderIndexTerm*(d: PDoc, n: PRstNode, result: var string) =
   var term = ""
   renderAux(d, n, term)
   setIndexTerm(d, changeFileExt(extractFilename(d.filename), HtmlExt), id, term, d.currentSection)
-  dispA(d.target, result, "<span id=\"$1\">$2</span>", "\\nimindexterm{$2}{$1}",
+  dispA(d.target, result, "<span id=\"$1\">$2</span>", "\\nimindexterm{$1}{$2}",
         [id, term])
 
 type
diff --git a/lib/posix/posix.nim b/lib/posix/posix.nim
index 45fe00d5d3c..cc7aa97e493 100644
--- a/lib/posix/posix.nim
+++ b/lib/posix/posix.nim
@@ -153,9 +153,9 @@ proc ntohs*(a1: uint16): uint16 {.importc, header: "<arpa/inet.h>".}
 
 proc inet_addr*(a1: cstring): InAddrT {.importc, header: "<arpa/inet.h>".}
 proc inet_ntoa*(a1: InAddr): cstring {.importc, header: "<arpa/inet.h>".}
-proc inet_ntop*(a1: cint, a2: pointer, a3: cstring, a4: int32): cstring {.
+proc inet_ntop*(a1: cint, a2: pointer | ptr InAddr | ptr In6Addr, a3: cstring, a4: int32): cstring {.
   importc:"(char *)$1", header: "<arpa/inet.h>".}
-proc inet_pton*(a1: cint, a2: cstring, a3: pointer): cint {.
+proc inet_pton*(a1: cint, a2: cstring, a3: pointer | ptr InAddr | ptr In6Addr): cint {.
   importc, header: "<arpa/inet.h>".}
 
 var
@@ -770,6 +770,13 @@ else:
   proc sigtimedwait*(a1: var Sigset, a2: var SigInfo,
                      a3: var Timespec): cint {.importc, header: "<signal.h>".}
 
+when defined(sunos) or defined(solaris):
+  # The following compile time flag is needed on Illumos/Solaris to use the POSIX
+  # `sigwait` implementation. See the documentation here:
+  # https://docs.oracle.com/cd/E19455-01/806-5257/6je9h033k/index.html
+  # https://www.illumos.org/man/2/sigwait
+  {.passc: "-D_POSIX_PTHREAD_SEMANTICS".}
+
 proc sigwait*(a1: var Sigset, a2: var cint): cint {.
   importc, header: "<signal.h>".}
 proc sigwaitinfo*(a1: var Sigset, a2: var SigInfo): cint {.
diff --git a/lib/posix/termios.nim b/lib/posix/termios.nim
index b03ce74f3a1..f755c720dce 100644
--- a/lib/posix/termios.nim
+++ b/lib/posix/termios.nim
@@ -237,8 +237,11 @@ proc tcFlow*(fd: cint; action: cint): cint {.importc: "tcflow",
     header: "<termios.h>".}
 # Get process group ID for session leader for controlling terminal FD.
 
-# Window size ioctl.  Should work on on any Unix that xterm has been ported to.
-var TIOCGWINSZ*{.importc, header: "<sys/ioctl.h>".}: culong
+# Window size ioctl.  Solaris based systems have an uncommen place for this.
+when defined(solaris) or defined(sunos):
+  var TIOCGWINSZ*{.importc, header: "<sys/termios.h>".}: culong
+else:
+  var TIOCGWINSZ*{.importc, header: "<sys/ioctl.h>".}: culong
 
 when defined(nimHasStyleChecks):
   {.push styleChecks: off.}
diff --git a/lib/pure/base64.nim b/lib/pure/base64.nim
index 513ec582695..9b7af88ef11 100644
--- a/lib/pure/base64.nim
+++ b/lib/pure/base64.nim
@@ -56,8 +56,8 @@ runnableExamples:
 ## ========
 ##
 ## * `hashes module<hashes.html>`_ for efficient computations of hash values for diverse Nim types
-## * `md5 module<md5.html>`_ implements the MD5 checksum algorithm
-## * `sha1 module<sha1.html>`_ implements a sha1 encoder and decoder
+## * `md5 module<md5.html>`_ for the MD5 checksum algorithm
+## * `sha1 module<sha1.html>`_ for the SHA-1 checksum algorithm
 
 template cbBase(a, b): untyped = [
   'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
diff --git a/lib/pure/collections/deques.nim b/lib/pure/collections/deques.nim
index 7cc2f91c417..aba51bb9285 100644
--- a/lib/pure/collections/deques.nim
+++ b/lib/pure/collections/deques.nim
@@ -86,20 +86,6 @@ proc initDeque*[T](initialSize: int = defaultInitialSize): Deque[T] =
   ## * `toDeque proc <#toDeque,openArray[T]>`_
   result.initImpl(initialSize)
 
-proc toDeque*[T](x: openArray[T]): Deque[T] {.since: (1, 3).} =
-  ## Creates a new deque that contains the elements of `x` (in the same order).
-  ##
-  ## **See also:**
-  ## * `initDeque proc <#initDeque,int>`_
-  runnableExamples:
-    let a = toDeque([7, 8, 9])
-    assert len(a) == 3
-    assert $a == "[7, 8, 9]"
-
-  result.initImpl(x.len)
-  for item in items(x):
-    result.addLast(item)
-
 proc len*[T](deq: Deque[T]): int {.inline.} =
   ## Returns the number of elements of `deq`.
   result = deq.count
@@ -302,6 +288,20 @@ proc addLast*[T](deq: var Deque[T], item: sink T) =
   deq.data[deq.tail] = item
   deq.tail = (deq.tail + 1) and deq.mask
 
+proc toDeque*[T](x: openArray[T]): Deque[T] {.since: (1, 3).} =
+  ## Creates a new deque that contains the elements of `x` (in the same order).
+  ##
+  ## **See also:**
+  ## * `initDeque proc <#initDeque,int>`_
+  runnableExamples:
+    let a = toDeque([7, 8, 9])
+    assert len(a) == 3
+    assert $a == "[7, 8, 9]"
+
+  result.initImpl(x.len)
+  for item in items(x):
+    result.addLast(item)
+
 proc peekFirst*[T](deq: Deque[T]): lent T {.inline.} =
   ## Returns the first element of `deq`, but does not remove it from the deque.
   ##
diff --git a/lib/pure/collections/lists.nim b/lib/pure/collections/lists.nim
index af53bb68b48..d1de0ea6725 100644
--- a/lib/pure/collections/lists.nim
+++ b/lib/pure/collections/lists.nim
@@ -56,7 +56,6 @@ runnableExamples:
 
 ## # See also
 ## * `deques module <deques.html>`_ for double-ended queues
-## * `sharedlist module <sharedlist.html>`_ for shared singly-linked lists
 
 import std/private/since
 
@@ -531,11 +530,12 @@ proc addMoved*[T](a, b: var SinglyLinkedList[T]) {.since: (1, 5, 1).} =
         ci
     assert s == [0, 1, 0, 1, 0, 1]
 
-  if a.tail != nil:
-    a.tail.next = b.head
-  a.tail = b.tail
-  if a.head == nil:
-    a.head = b.head
+  if b.head != nil:
+    if a.head == nil:
+      a.head = b.head
+    else:
+      a.tail.next = b.head
+    a.tail = b.tail
   if a.addr != b.addr:
     b.head = nil
     b.tail = nil
@@ -675,12 +675,12 @@ proc addMoved*[T](a, b: var DoublyLinkedList[T]) {.since: (1, 5, 1).} =
     assert s == [0, 1, 0, 1, 0, 1]
 
   if b.head != nil:
-    b.head.prev = a.tail
-  if a.tail != nil:
-    a.tail.next = b.head
-  a.tail = b.tail
-  if a.head == nil:
-    a.head = b.head
+    if a.head == nil:
+      a.head = b.head
+    else:
+      b.head.prev = a.tail
+      a.tail.next = b.head
+    a.tail = b.tail
   if a.addr != b.addr:
     b.head = nil
     b.tail = nil
@@ -739,6 +739,8 @@ proc remove*[T](L: var SinglyLinkedList[T], n: SinglyLinkedNode[T]): bool {.disc
     if prev.next == nil:
       return false
     prev.next = n.next
+    if L.tail == n:
+      L.tail = prev # update tail if we removed the last node
   true
 
 proc remove*[T](L: var DoublyLinkedList[T], n: DoublyLinkedNode[T]) =
diff --git a/lib/pure/collections/sharedlist.nim b/lib/pure/collections/sharedlist.nim
index 73e147e055d..e61883220ae 100644
--- a/lib/pure/collections/sharedlist.nim
+++ b/lib/pure/collections/sharedlist.nim
@@ -11,6 +11,8 @@
 ##
 ## Unstable API.
 
+{.deprecated.}
+
 {.push stackTrace: off.}
 
 import
diff --git a/lib/pure/collections/sharedtables.nim b/lib/pure/collections/sharedtables.nim
index 109e9abaa81..367eaf66284 100644
--- a/lib/pure/collections/sharedtables.nim
+++ b/lib/pure/collections/sharedtables.nim
@@ -14,6 +14,8 @@
 ##
 ## Unstable API.
 
+{.deprecated.}
+
 import
   hashes, math, locks
 
diff --git a/lib/pure/collections/tables.nim b/lib/pure/collections/tables.nim
index 963269dbf08..c13ede2121c 100644
--- a/lib/pure/collections/tables.nim
+++ b/lib/pure/collections/tables.nim
@@ -191,7 +191,6 @@ runnableExamples:
 ##
 ## * `json module<json.html>`_ for table-like structure which allows
 ##   heterogeneous members
-## * `sharedtables module<sharedtables.html>`_ for shared hash table support
 ## * `strtabs module<strtabs.html>`_ for efficient hash tables
 ##   mapping from strings to strings
 ## * `hashes module<hashes.html>`_ for helper functions for hashing
diff --git a/lib/pure/colors.nim b/lib/pure/colors.nim
index 4a3f47e925e..8cda2fab8a2 100644
--- a/lib/pure/colors.nim
+++ b/lib/pure/colors.nim
@@ -6,7 +6,8 @@
 #    distribution, for details about the copyright.
 #
 
-## This module implements color handling for Nim.
+## This module implements color handling for Nim,
+## namely color mixing and parsing the CSS color names.
 
 import strutils
 from algorithm import binarySearch
@@ -170,6 +171,7 @@ const
   colDarkGoldenRod* = Color(0xB8860B)
   colDarkGray* = Color(0xA9A9A9)
   colDarkGreen* = Color(0x006400)
+  colDarkGrey* = Color(0xA9A9A9)
   colDarkKhaki* = Color(0xBDB76B)
   colDarkMagenta* = Color(0x8B008B)
   colDarkOliveGreen* = Color(0x556B2F)
@@ -180,11 +182,13 @@ const
   colDarkSeaGreen* = Color(0x8FBC8F)
   colDarkSlateBlue* = Color(0x483D8B)
   colDarkSlateGray* = Color(0x2F4F4F)
+  colDarkSlateGrey* = Color(0x2F4F4F)
   colDarkTurquoise* = Color(0x00CED1)
   colDarkViolet* = Color(0x9400D3)
   colDeepPink* = Color(0xFF1493)
   colDeepSkyBlue* = Color(0x00BFFF)
   colDimGray* = Color(0x696969)
+  colDimGrey* = Color(0x696969)
   colDodgerBlue* = Color(0x1E90FF)
   colFireBrick* = Color(0xB22222)
   colFloralWhite* = Color(0xFFFAF0)
@@ -196,6 +200,7 @@ const
   colGoldenRod* = Color(0xDAA520)
   colGray* = Color(0x808080)
   colGreen* = Color(0x008000)
+  colGrey* = Color(0x808080)
   colGreenYellow* = Color(0xADFF2F)
   colHoneyDew* = Color(0xF0FFF0)
   colHotPink* = Color(0xFF69B4)
@@ -211,13 +216,15 @@ const
   colLightCoral* = Color(0xF08080)
   colLightCyan* = Color(0xE0FFFF)
   colLightGoldenRodYellow* = Color(0xFAFAD2)
-  colLightGrey* = Color(0xD3D3D3)
+  colLightGray* = Color(0xD3D3D3)
   colLightGreen* = Color(0x90EE90)
+  colLightGrey* = Color(0xD3D3D3)
   colLightPink* = Color(0xFFB6C1)
   colLightSalmon* = Color(0xFFA07A)
   colLightSeaGreen* = Color(0x20B2AA)
   colLightSkyBlue* = Color(0x87CEFA)
   colLightSlateGray* = Color(0x778899)
+  colLightSlateGrey* = Color(0x778899)
   colLightSteelBlue* = Color(0xB0C4DE)
   colLightYellow* = Color(0xFFFFE0)
   colLime* = Color(0x00FF00)
@@ -228,7 +235,7 @@ const
   colMediumAquaMarine* = Color(0x66CDAA)
   colMediumBlue* = Color(0x0000CD)
   colMediumOrchid* = Color(0xBA55D3)
-  colMediumPurple* = Color(0x9370D8)
+  colMediumPurple* = Color(0x9370DB)
   colMediumSeaGreen* = Color(0x3CB371)
   colMediumSlateBlue* = Color(0x7B68EE)
   colMediumSpringGreen* = Color(0x00FA9A)
@@ -249,7 +256,7 @@ const
   colPaleGoldenRod* = Color(0xEEE8AA)
   colPaleGreen* = Color(0x98FB98)
   colPaleTurquoise* = Color(0xAFEEEE)
-  colPaleVioletRed* = Color(0xD87093)
+  colPaleVioletRed* = Color(0xDB7093)
   colPapayaWhip* = Color(0xFFEFD5)
   colPeachPuff* = Color(0xFFDAB9)
   colPeru* = Color(0xCD853F)
@@ -257,6 +264,7 @@ const
   colPlum* = Color(0xDDA0DD)
   colPowderBlue* = Color(0xB0E0E6)
   colPurple* = Color(0x800080)
+  colRebeccaPurple* = Color(0x663399)
   colRed* = Color(0xFF0000)
   colRosyBrown* = Color(0xBC8F8F)
   colRoyalBlue* = Color(0x4169E1)
@@ -270,6 +278,7 @@ const
   colSkyBlue* = Color(0x87CEEB)
   colSlateBlue* = Color(0x6A5ACD)
   colSlateGray* = Color(0x708090)
+  colSlateGrey* = Color(0x708090)
   colSnow* = Color(0xFFFAFA)
   colSpringGreen* = Color(0x00FF7F)
   colSteelBlue* = Color(0x4682B4)
@@ -285,147 +294,155 @@ const
   colYellow* = Color(0xFFFF00)
   colYellowGreen* = Color(0x9ACD32)
 
-  colorNames = [
-    ("aliceblue", colAliceBlue),
-    ("antiquewhite", colAntiqueWhite),
-    ("aqua", colAqua),
-    ("aquamarine", colAquamarine),
-    ("azure", colAzure),
-    ("beige", colBeige),
-    ("bisque", colBisque),
-    ("black", colBlack),
-    ("blanchedalmond", colBlanchedAlmond),
-    ("blue", colBlue),
-    ("blueviolet", colBlueViolet),
-    ("brown", colBrown),
-    ("burlywood", colBurlyWood),
-    ("cadetblue", colCadetBlue),
-    ("chartreuse", colChartreuse),
-    ("chocolate", colChocolate),
-    ("coral", colCoral),
-    ("cornflowerblue", colCornflowerBlue),
-    ("cornsilk", colCornsilk),
-    ("crimson", colCrimson),
-    ("cyan", colCyan),
-    ("darkblue", colDarkBlue),
-    ("darkcyan", colDarkCyan),
-    ("darkgoldenrod", colDarkGoldenRod),
-    ("darkgray", colDarkGray),
-    ("darkgreen", colDarkGreen),
-    ("darkkhaki", colDarkKhaki),
-    ("darkmagenta", colDarkMagenta),
-    ("darkolivegreen", colDarkOliveGreen),
-    ("darkorange", colDarkorange),
-    ("darkorchid", colDarkOrchid),
-    ("darkred", colDarkRed),
-    ("darksalmon", colDarkSalmon),
-    ("darkseagreen", colDarkSeaGreen),
-    ("darkslateblue", colDarkSlateBlue),
-    ("darkslategray", colDarkSlateGray),
-    ("darkturquoise", colDarkTurquoise),
-    ("darkviolet", colDarkViolet),
-    ("deeppink", colDeepPink),
-    ("deepskyblue", colDeepSkyBlue),
-    ("dimgray", colDimGray),
-    ("dodgerblue", colDodgerBlue),
-    ("firebrick", colFireBrick),
-    ("floralwhite", colFloralWhite),
-    ("forestgreen", colForestGreen),
-    ("fuchsia", colFuchsia),
-    ("gainsboro", colGainsboro),
-    ("ghostwhite", colGhostWhite),
-    ("gold", colGold),
-    ("goldenrod", colGoldenRod),
-    ("gray", colGray),
-    ("green", colGreen),
-    ("greenyellow", colGreenYellow),
-    ("honeydew", colHoneyDew),
-    ("hotpink", colHotPink),
-    ("indianred", colIndianRed),
-    ("indigo", colIndigo),
-    ("ivory", colIvory),
-    ("khaki", colKhaki),
-    ("lavender", colLavender),
-    ("lavenderblush", colLavenderBlush),
-    ("lawngreen", colLawnGreen),
-    ("lemonchiffon", colLemonChiffon),
-    ("lightblue", colLightBlue),
-    ("lightcoral", colLightCoral),
-    ("lightcyan", colLightCyan),
-    ("lightgoldenrodyellow", colLightGoldenRodYellow),
-    ("lightgrey", colLightGrey),
-    ("lightgreen", colLightGreen),
-    ("lightpink", colLightPink),
-    ("lightsalmon", colLightSalmon),
-    ("lightseagreen", colLightSeaGreen),
-    ("lightskyblue", colLightSkyBlue),
-    ("lightslategray", colLightSlateGray),
-    ("lightsteelblue", colLightSteelBlue),
-    ("lightyellow", colLightYellow),
-    ("lime", colLime),
-    ("limegreen", colLimeGreen),
-    ("linen", colLinen),
-    ("magenta", colMagenta),
-    ("maroon", colMaroon),
-    ("mediumaquamarine", colMediumAquaMarine),
-    ("mediumblue", colMediumBlue),
-    ("mediumorchid", colMediumOrchid),
-    ("mediumpurple", colMediumPurple),
-    ("mediumseagreen", colMediumSeaGreen),
-    ("mediumslateblue", colMediumSlateBlue),
-    ("mediumspringgreen", colMediumSpringGreen),
-    ("mediumturquoise", colMediumTurquoise),
-    ("mediumvioletred", colMediumVioletRed),
-    ("midnightblue", colMidnightBlue),
-    ("mintcream", colMintCream),
-    ("mistyrose", colMistyRose),
-    ("moccasin", colMoccasin),
-    ("navajowhite", colNavajoWhite),
-    ("navy", colNavy),
-    ("oldlace", colOldLace),
-    ("olive", colOlive),
-    ("olivedrab", colOliveDrab),
-    ("orange", colOrange),
-    ("orangered", colOrangeRed),
-    ("orchid", colOrchid),
-    ("palegoldenrod", colPaleGoldenRod),
-    ("palegreen", colPaleGreen),
-    ("paleturquoise", colPaleTurquoise),
-    ("palevioletred", colPaleVioletRed),
-    ("papayawhip", colPapayaWhip),
-    ("peachpuff", colPeachPuff),
-    ("peru", colPeru),
-    ("pink", colPink),
-    ("plum", colPlum),
-    ("powderblue", colPowderBlue),
-    ("purple", colPurple),
-    ("red", colRed),
-    ("rosybrown", colRosyBrown),
-    ("royalblue", colRoyalBlue),
-    ("saddlebrown", colSaddleBrown),
-    ("salmon", colSalmon),
-    ("sandybrown", colSandyBrown),
-    ("seagreen", colSeaGreen),
-    ("seashell", colSeaShell),
-    ("sienna", colSienna),
-    ("silver", colSilver),
-    ("skyblue", colSkyBlue),
-    ("slateblue", colSlateBlue),
-    ("slategray", colSlateGray),
-    ("snow", colSnow),
-    ("springgreen", colSpringGreen),
-    ("steelblue", colSteelBlue),
-    ("tan", colTan),
-    ("teal", colTeal),
-    ("thistle", colThistle),
-    ("tomato", colTomato),
-    ("turquoise", colTurquoise),
-    ("violet", colViolet),
-    ("wheat", colWheat),
-    ("white", colWhite),
-    ("whitesmoke", colWhiteSmoke),
-    ("yellow", colYellow),
-    ("yellowgreen", colYellowGreen)]
+  colorNames = {
+    "aliceblue": colAliceBlue,
+    "antiquewhite": colAntiqueWhite,
+    "aqua": colAqua,
+    "aquamarine": colAquamarine,
+    "azure": colAzure,
+    "beige": colBeige,
+    "bisque": colBisque,
+    "black": colBlack,
+    "blanchedalmond": colBlanchedAlmond,
+    "blue": colBlue,
+    "blueviolet": colBlueViolet,
+    "brown": colBrown,
+    "burlywood": colBurlyWood,
+    "cadetblue": colCadetBlue,
+    "chartreuse": colChartreuse,
+    "chocolate": colChocolate,
+    "coral": colCoral,
+    "cornflowerblue": colCornflowerBlue,
+    "cornsilk": colCornsilk,
+    "crimson": colCrimson,
+    "cyan": colCyan,
+    "darkblue": colDarkBlue,
+    "darkcyan": colDarkCyan,
+    "darkgoldenrod": colDarkGoldenRod,
+    "darkgray": colDarkGray,
+    "darkgreen": colDarkGreen,
+    "darkgrey": colDarkGrey,
+    "darkkhaki": colDarkKhaki,
+    "darkmagenta": colDarkMagenta,
+    "darkolivegreen": colDarkOliveGreen,
+    "darkorange": colDarkorange,
+    "darkorchid": colDarkOrchid,
+    "darkred": colDarkRed,
+    "darksalmon": colDarkSalmon,
+    "darkseagreen": colDarkSeaGreen,
+    "darkslateblue": colDarkSlateBlue,
+    "darkslategray": colDarkSlateGray,
+    "darkslategrey": colDarkSlateGrey,
+    "darkturquoise": colDarkTurquoise,
+    "darkviolet": colDarkViolet,
+    "deeppink": colDeepPink,
+    "deepskyblue": colDeepSkyBlue,
+    "dimgray": colDimGray,
+    "dimgrey": colDimGrey,
+    "dodgerblue": colDodgerBlue,
+    "firebrick": colFireBrick,
+    "floralwhite": colFloralWhite,
+    "forestgreen": colForestGreen,
+    "fuchsia": colFuchsia,
+    "gainsboro": colGainsboro,
+    "ghostwhite": colGhostWhite,
+    "gold": colGold,
+    "goldenrod": colGoldenRod,
+    "gray": colGray,
+    "green": colGreen,
+    "grey": colGrey,
+    "greenyellow": colGreenYellow,
+    "honeydew": colHoneyDew,
+    "hotpink": colHotPink,
+    "indianred": colIndianRed,
+    "indigo": colIndigo,
+    "ivory": colIvory,
+    "khaki": colKhaki,
+    "lavender": colLavender,
+    "lavenderblush": colLavenderBlush,
+    "lawngreen": colLawnGreen,
+    "lemonchiffon": colLemonChiffon,
+    "lightblue": colLightBlue,
+    "lightcoral": colLightCoral,
+    "lightcyan": colLightCyan,
+    "lightgoldenrodyellow": colLightGoldenRodYellow,
+    "lightgray": colLightGray,
+    "lightgreen": colLightGreen,
+    "lightgrey": colLightGrey,
+    "lightpink": colLightPink,
+    "lightsalmon": colLightSalmon,
+    "lightseagreen": colLightSeaGreen,
+    "lightskyblue": colLightSkyBlue,
+    "lightslategray": colLightSlateGray,
+    "lightslategrey": colLightSlateGrey,
+    "lightsteelblue": colLightSteelBlue,
+    "lightyellow": colLightYellow,
+    "lime": colLime,
+    "limegreen": colLimeGreen,
+    "linen": colLinen,
+    "magenta": colMagenta,
+    "maroon": colMaroon,
+    "mediumaquamarine": colMediumAquaMarine,
+    "mediumblue": colMediumBlue,
+    "mediumorchid": colMediumOrchid,
+    "mediumpurple": colMediumPurple,
+    "mediumseagreen": colMediumSeaGreen,
+    "mediumslateblue": colMediumSlateBlue,
+    "mediumspringgreen": colMediumSpringGreen,
+    "mediumturquoise": colMediumTurquoise,
+    "mediumvioletred": colMediumVioletRed,
+    "midnightblue": colMidnightBlue,
+    "mintcream": colMintCream,
+    "mistyrose": colMistyRose,
+    "moccasin": colMoccasin,
+    "navajowhite": colNavajoWhite,
+    "navy": colNavy,
+    "oldlace": colOldLace,
+    "olive": colOlive,
+    "olivedrab": colOliveDrab,
+    "orange": colOrange,
+    "orangered": colOrangeRed,
+    "orchid": colOrchid,
+    "palegoldenrod": colPaleGoldenRod,
+    "palegreen": colPaleGreen,
+    "paleturquoise": colPaleTurquoise,
+    "palevioletred": colPaleVioletRed,
+    "papayawhip": colPapayaWhip,
+    "peachpuff": colPeachPuff,
+    "peru": colPeru,
+    "pink": colPink,
+    "plum": colPlum,
+    "powderblue": colPowderBlue,
+    "purple": colPurple,
+    "rebeccapurple": colRebeccaPurple,
+    "red": colRed,
+    "rosybrown": colRosyBrown,
+    "royalblue": colRoyalBlue,
+    "saddlebrown": colSaddleBrown,
+    "salmon": colSalmon,
+    "sandybrown": colSandyBrown,
+    "seagreen": colSeaGreen,
+    "seashell": colSeaShell,
+    "sienna": colSienna,
+    "silver": colSilver,
+    "skyblue": colSkyBlue,
+    "slateblue": colSlateBlue,
+    "slategray": colSlateGray,
+    "slategrey": colSlateGrey,
+    "snow": colSnow,
+    "springgreen": colSpringGreen,
+    "steelblue": colSteelBlue,
+    "tan": colTan,
+    "teal": colTeal,
+    "thistle": colThistle,
+    "tomato": colTomato,
+    "turquoise": colTurquoise,
+    "violet": colViolet,
+    "wheat": colWheat,
+    "white": colWhite,
+    "whitesmoke": colWhiteSmoke,
+    "yellow": colYellow,
+    "yellowgreen": colYellowGreen}
 
 proc `$`*(c: Color): string =
   ## Converts a color into its textual representation.
diff --git a/lib/pure/concurrency/atomics.nim b/lib/pure/concurrency/atomics.nim
index b252789fb4c..c0a122bf950 100644
--- a/lib/pure/concurrency/atomics.nim
+++ b/lib/pure/concurrency/atomics.nim
@@ -293,19 +293,16 @@ else:
       AtomicInt32 {.importc: "_Atomic NI32".} = int32
       AtomicInt64 {.importc: "_Atomic NI64".} = int64
 
-    template atomicType*(T: typedesc[Trivial]): untyped =
-      # Maps the size of a trivial type to it's internal atomic type
-      when sizeof(T) == 1: AtomicInt8
-      elif sizeof(T) == 2: AtomicInt16
-      elif sizeof(T) == 4: AtomicInt32
-      elif sizeof(T) == 8: AtomicInt64
-
     type
       AtomicFlag* {.importc: "atomic_flag", size: 1.} = object
 
       Atomic*[T] = object
         when T is Trivial:
-          value: T.atomicType
+          # Maps the size of a trivial type to it's internal atomic type
+          when sizeof(T) == 1: value: AtomicInt8
+          elif sizeof(T) == 2: value: AtomicInt16
+          elif sizeof(T) == 4: value: AtomicInt32
+          elif sizeof(T) == 8: value: AtomicInt64
         else:
           nonAtomicValue: T
           guard: AtomicFlag
@@ -364,11 +361,11 @@ else:
       cast[T](atomic_fetch_xor_explicit(addr(location.value), cast[nonAtomicType(T)](value), order))
 
   template withLock[T: not Trivial](location: var Atomic[T]; order: MemoryOrder; body: untyped): untyped =
-    while location.guard.testAndSet(moAcquire): discard
+    while testAndSet(location.guard, moAcquire): discard
     try:
       body
     finally:
-      location.guard.clear(moRelease)
+      clear(location.guard, moRelease)
 
   proc load*[T: not Trivial](location: var Atomic[T]; order: MemoryOrder = moSequentiallyConsistent): T {.inline.} =
     withLock(location, order):
diff --git a/lib/pure/concurrency/cpuinfo.nim b/lib/pure/concurrency/cpuinfo.nim
index ee43b8e11fa..16d32002da1 100644
--- a/lib/pure/concurrency/cpuinfo.nim
+++ b/lib/pure/concurrency/cpuinfo.nim
@@ -18,6 +18,9 @@ include "system/inclrtl"
 when defined(posix) and not (defined(macosx) or defined(bsd)):
   import posix
 
+when defined(windows):
+  import std/private/win_getsysteminfo
+
 when defined(freebsd) or defined(macosx):
   {.emit: "#include <sys/types.h>".}
 
@@ -54,25 +57,10 @@ proc countProcessors*(): int {.rtl, extern: "ncpi$1".} =
   ## Returns the number of the processors/cores the machine has.
   ## Returns 0 if it cannot be detected.
   when defined(windows):
-    type
-      SYSTEM_INFO {.final, pure.} = object
-        u1: int32
-        dwPageSize: int32
-        lpMinimumApplicationAddress: pointer
-        lpMaximumApplicationAddress: pointer
-        dwActiveProcessorMask: ptr int32
-        dwNumberOfProcessors: int32
-        dwProcessorType: int32
-        dwAllocationGranularity: int32
-        wProcessorLevel: int16
-        wProcessorRevision: int16
-
-    proc GetSystemInfo(lpSystemInfo: var SYSTEM_INFO) {.stdcall, dynlib: "kernel32", importc: "GetSystemInfo".}
-
     var
-      si: SYSTEM_INFO
-    GetSystemInfo(si)
-    result = si.dwNumberOfProcessors
+      si: SystemInfo
+    getSystemInfo(addr si)
+    result = int(si.dwNumberOfProcessors)
   elif defined(macosx) or defined(bsd):
     var
       mib: array[0..3, cint]
diff --git a/lib/pure/concurrency/threadpool.nim b/lib/pure/concurrency/threadpool.nim
index f8a5f9ba835..9334b48339c 100644
--- a/lib/pure/concurrency/threadpool.nim
+++ b/lib/pure/concurrency/threadpool.nim
@@ -448,19 +448,21 @@ proc preferSpawn*(): bool =
   ## <#spawnX.t>`_ instead.
   result = gSomeReady.counter > 0
 
-proc spawn*(call: sink typed) {.magic: "Spawn".}
+proc spawn*(call: sink typed) {.magic: "Spawn".} =
   ## Always spawns a new task, so that the `call` is never executed on
   ## the calling thread.
   ##
   ## `call` has to be a proc call `p(...)` where `p` is gcsafe and has a
   ## return type that is either `void` or compatible with `FlowVar[T]`.
+  discard "It uses `nimSpawn3` internally"
 
-proc pinnedSpawn*(id: ThreadId; call: sink typed) {.magic: "Spawn".}
+proc pinnedSpawn*(id: ThreadId; call: sink typed) {.magic: "Spawn".} =
   ## Always spawns a new task on the worker thread with `id`, so that
   ## the `call` is **always** executed on the thread.
   ##
   ## `call` has to be a proc call `p(...)` where `p` is gcsafe and has a
   ## return type that is either `void` or compatible with `FlowVar[T]`.
+  discard "It uses `nimSpawn4` internally"
 
 template spawnX*(call) =
   ## Spawns a new task if a CPU core is ready, otherwise executes the
diff --git a/lib/pure/cookies.nim b/lib/pure/cookies.nim
index 25d701eb447..7bf34f75bf3 100644
--- a/lib/pure/cookies.nim
+++ b/lib/pure/cookies.nim
@@ -50,6 +50,8 @@ proc setCookie*(key, value: string, domain = "", path = "",
                 maxAge = none(int), sameSite = SameSite.Default): string =
   ## Creates a command in the format of
   ## `Set-Cookie: key=value; Domain=...; ...`
+  ##
+  ## .. tip:: Cookies can be vulnerable. Consider setting `secure=true`, `httpOnly=true` and `sameSite=Strict`.
   result = ""
   if not noName: result.add("Set-Cookie: ")
   result.add key & "=" & value
diff --git a/lib/pure/hashes.nim b/lib/pure/hashes.nim
index d9f53467029..47dacec7da0 100644
--- a/lib/pure/hashes.nim
+++ b/lib/pure/hashes.nim
@@ -62,7 +62,7 @@ runnableExamples:
 ## ========
 ## * `md5 module <md5.html>`_ for the MD5 checksum algorithm
 ## * `base64 module <base64.html>`_ for a Base64 encoder and decoder
-## * `std/sha1 module <sha1.html>`_ for a SHA-1 encoder and decoder
+## * `std/sha1 module <sha1.html>`_ for the SHA-1 checksum algorithm
 ## * `tables module <tables.html>`_ for hash tables
 
 import std/private/since
diff --git a/lib/pure/httpclient.nim b/lib/pure/httpclient.nim
index e7a3759b889..099f10f43f2 100644
--- a/lib/pure/httpclient.nim
+++ b/lib/pure/httpclient.nim
@@ -458,7 +458,7 @@ proc generateHeaders(requestUrl: Uri, httpMethod: HttpMethod, headers: HttpHeade
   # Proxy auth header.
   if not proxy.isNil and proxy.auth != "":
     let auth = base64.encode(proxy.auth)
-    add(result, "Proxy-Authorization: basic " & auth & httpNewLine)
+    add(result, "Proxy-Authorization: Basic " & auth & httpNewLine)
 
   for key, val in headers:
     add(result, key & ": " & val & httpNewLine)
@@ -554,7 +554,7 @@ proc reportProgress(client: HttpClient,
                     progress: BiggestInt) =
   client.contentProgress += progress
   client.oneSecondProgress += progress
-  if (getMonoTime() - client.lastProgressReport).inSeconds > 1:
+  if (getMonoTime() - client.lastProgressReport).inSeconds >= 1:
     if not client.onProgressChanged.isNil:
       client.onProgressChanged(client.contentTotal,
                                client.contentProgress,
diff --git a/lib/pure/includes/osenv.nim b/lib/pure/includes/osenv.nim
index 00a82327c03..e248d1bbc61 100644
--- a/lib/pure/includes/osenv.nim
+++ b/lib/pure/includes/osenv.nim
@@ -45,7 +45,7 @@ when not defined(nimscript):
     proc c_getenv(env: cstring): cstring {.
       importc: "getenv", header: "<stdlib.h>".}
     when defined(windows):
-      proc c_putenv_s(envname: cstring, envval: cstring): cint {.importc: "_putenv_s", header: "<stdlib.h>".}
+      proc c_putenv(envstring: cstring): cint {.importc: "_putenv", header: "<stdlib.h>".}
       from std/private/win_setenv import setEnvImpl
     else:
       proc c_setenv(envname: cstring, envval: cstring, overwrite: cint): cint {.importc: "setenv", header: "<stdlib.h>".}
@@ -121,7 +121,8 @@ when not defined(nimscript):
         ]#
         if key.len == 0 or '=' in key:
           raise newException(OSError, "invalid key, got: " & key)
-        if c_putenv_s(key, "") != 0'i32: bail
+        let envToDel = key & "="
+        if c_putenv(cstring envToDel) != 0'i32: bail
       else:
         if c_unsetenv(key) != 0'i32: bail
 
diff --git a/lib/pure/math.nim b/lib/pure/math.nim
index 66f1a2e2ca2..1c47258bc6f 100644
--- a/lib/pure/math.nim
+++ b/lib/pure/math.nim
@@ -69,11 +69,6 @@ when defined(c) or defined(cpp):
 
   proc c_signbit(x: SomeFloat): cint {.importc: "signbit", header: "<math.h>".}
 
-  func c_frexp*(x: cfloat, exponent: var cint): cfloat {.
-      importc: "frexpf", header: "<math.h>", deprecated: "Use `frexp` instead".}
-  func c_frexp*(x: cdouble, exponent: var cint): cdouble {.
-      importc: "frexp", header: "<math.h>", deprecated: "Use `frexp` instead".}
-
   # don't export `c_frexp` in the future and remove `c_frexp2`.
   func c_frexp2(x: cfloat, exponent: var cint): cfloat {.
       importc: "frexpf", header: "<math.h>".}
diff --git a/lib/pure/md5.nim b/lib/pure/md5.nim
index 11c3245484b..ef3d43bb978 100644
--- a/lib/pure/md5.nim
+++ b/lib/pure/md5.nim
@@ -13,8 +13,8 @@
 ##
 ## See also
 ## ========
-## * `base64 module<base64.html>`_ implements a Base64 encoder and decoder
-## * `std/sha1 module <sha1.html>`_ for a SHA-1 encoder and decoder
+## * `base64 module<base64.html>`_ for a Base64 encoder and decoder
+## * `std/sha1 module <sha1.html>`_ for the SHA-1 checksum algorithm
 ## * `hashes module<hashes.html>`_ for efficient computations of hash values
 ##   for diverse Nim types
 
diff --git a/lib/pure/mimetypes.nim b/lib/pure/mimetypes.nim
index 6ae63a0aede..d1566d897df 100644
--- a/lib/pure/mimetypes.nim
+++ b/lib/pure/mimetypes.nim
@@ -31,7 +31,7 @@ from strutils import startsWith, toLowerAscii, strip
 
 type
   MimeDB* = object
-    mimes: OrderedTableRef[string, string]
+    mimes: OrderedTable[string, string]
 
 const mimes* = {
   "123": "application/vnd.lotus-1-2-3",
@@ -1904,7 +1904,7 @@ func newMimetypes*(): MimeDB =
   ## Creates a new Mimetypes database. The database will contain the most
   ## common mimetypes.
   {.cast(noSideEffect).}:
-    result.mimes = mimes.newOrderedTable()
+    result.mimes = mimes.toOrderedTable()
 
 func getMimetype*(mimedb: MimeDB, ext: string, default = "text/plain"): string =
   ## Gets mimetype which corresponds to `ext`. Returns `default` if `ext`
diff --git a/lib/pure/net.nim b/lib/pure/net.nim
index 09cdc8afb6d..a210d580dcc 100644
--- a/lib/pure/net.nim
+++ b/lib/pure/net.nim
@@ -65,6 +65,11 @@ runnableExamples("-r:off"):
   let socket = newSocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)
   socket.sendTo("192.168.0.1", Port(27960), "status\n")
 
+runnableExamples("-r:off"):
+  let socket = newSocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)
+  let ip = parseIpAddress("192.168.0.1")
+  doAssert socket.sendTo(ip, Port(27960), "status\c\l") == 8
+
 ## Creating a server
 ## -----------------
 ##
@@ -673,7 +678,8 @@ when defineSsl:
           # Scan for certs in known locations. For CVerifyPeerUseEnvVars also scan
           # the SSL_CERT_FILE and SSL_CERT_DIR env vars
           var found = false
-          for fn in scanSSLCertificates():
+          let useEnvVars = (if verifyMode == CVerifyPeerUseEnvVars: true else: false)
+          for fn in scanSSLCertificates(useEnvVars = useEnvVars):
             if newCTX.SSL_CTX_load_verify_locations(fn, nil) == VerifySuccess:
               found = true
               break
@@ -1604,11 +1610,12 @@ proc recvLine*(socket: Socket, timeout = -1,
   result = ""
   readLine(socket, result, timeout, flags, maxLength)
 
-proc recvFrom*(socket: Socket, data: var string, length: int,
-               address: var string, port: var Port, flags = 0'i32): int {.
+proc recvFrom*[T: string | IpAddress](socket: Socket, data: var string, length: int,
+               address: var T, port: var Port, flags = 0'i32): int {.
                tags: [ReadIOEffect].} =
   ## Receives data from `socket`. This function should normally be used with
-  ## connection-less sockets (UDP sockets).
+  ## connection-less sockets (UDP sockets). The source address of the data
+  ## packet is stored in the `address` argument as either a string or an IpAddress.
   ##
   ## If an error occurs an OSError exception will be raised. Otherwise the return
   ## value will be the length of data received.
@@ -1617,31 +1624,37 @@ proc recvFrom*(socket: Socket, data: var string, length: int,
   ##   so when `socket` is buffered the non-buffered implementation will be
   ##   used. Therefore if `socket` contains something in its buffer this
   ##   function will make no effort to return it.
-  template adaptRecvFromToDomain(domain: Domain) =
-    var addrLen = sizeof(sockAddress).SockLen
+  template adaptRecvFromToDomain(sockAddress: untyped, domain: Domain) =
+    var addrLen = SockLen(sizeof(sockAddress))
     result = recvfrom(socket.fd, cstring(data), length.cint, flags.cint,
                       cast[ptr SockAddr](addr(sockAddress)), addr(addrLen))
 
     if result != -1:
       data.setLen(result)
-      address = getAddrString(cast[ptr SockAddr](addr(sockAddress)))
-      when domain == AF_INET6:
-        port = ntohs(sockAddress.sin6_port).Port
+
+      when typeof(address) is string:
+        address = getAddrString(cast[ptr SockAddr](addr(sockAddress)))
+        when domain == AF_INET6:
+          port = ntohs(sockAddress.sin6_port).Port
+        else:
+          port = ntohs(sockAddress.sin_port).Port
       else:
-        port = ntohs(sockAddress.sin_port).Port
+        data.setLen(result)
+        sockAddress.fromSockAddr(addrLen, address, port)
     else:
       raiseOSError(osLastError())
 
   assert(socket.protocol != IPPROTO_TCP, "Cannot `recvFrom` on a TCP socket")
   # TODO: Buffered sockets
   data.setLen(length)
+
   case socket.domain
   of AF_INET6:
     var sockAddress: Sockaddr_in6
-    adaptRecvFromToDomain(AF_INET6)
+    adaptRecvFromToDomain(sockAddress, AF_INET6)
   of AF_INET:
     var sockAddress: Sockaddr_in
-    adaptRecvFromToDomain(AF_INET)
+    adaptRecvFromToDomain(sockAddress, AF_INET)
   else:
     raise newException(ValueError, "Unknown socket address family")
 
@@ -1704,7 +1717,8 @@ proc sendTo*(socket: Socket, address: string, port: Port, data: pointer,
              tags: [WriteIOEffect].} =
   ## This proc sends `data` to the specified `address`,
   ## which may be an IP address or a hostname, if a hostname is specified
-  ## this function will try each IP of that hostname.
+  ## this function will try each IP of that hostname. This function
+  ## should normally be used with connection-less sockets (UDP sockets).
   ##
   ## If an error occurs an OSError exception will be raised.
   ##
@@ -1738,12 +1752,38 @@ proc sendTo*(socket: Socket, address: string, port: Port,
   ## This proc sends `data` to the specified `address`,
   ## which may be an IP address or a hostname, if a hostname is specified
   ## this function will try each IP of that hostname.
+  ## 
+  ## Generally for use with connection-less (UDP) sockets.
   ##
   ## If an error occurs an OSError exception will be raised.
   ##
   ## This is the high-level version of the above `sendTo` function.
   socket.sendTo(address, port, cstring(data), data.len, socket.domain)
 
+proc sendTo*(socket: Socket, address: IpAddress, port: Port,
+             data: string, flags = 0'i32): int {.
+              discardable, tags: [WriteIOEffect].} =
+  ## This proc sends `data` to the specified `IpAddress` and returns
+  ## the number of bytes written. 
+  ##
+  ## Generally for use with connection-less (UDP) sockets. 
+  ##
+  ## If an error occurs an OSError exception will be raised.
+  ##
+  ## This is the high-level version of the above `sendTo` function.
+  assert(socket.protocol != IPPROTO_TCP, "Cannot `sendTo` on a TCP socket")
+  assert(not socket.isClosed, "Cannot `sendTo` on a closed socket")
+
+  var sa: Sockaddr_storage
+  var sl: SockLen
+  toSockAddr(address, port, sa, sl)
+  result = sendto(socket.fd, cstring(data), data.len().cint, flags.cint,
+                  cast[ptr SockAddr](addr sa), sl)
+
+  if result == -1'i32:
+    let osError = osLastError()
+    raiseOSError(osError)
+
 
 proc isSsl*(socket: Socket): bool =
   ## Determines whether `socket` is a SSL socket.
diff --git a/lib/pure/oids.nim b/lib/pure/oids.nim
index da285a187e2..776c046b155 100644
--- a/lib/pure/oids.nim
+++ b/lib/pure/oids.nim
@@ -67,11 +67,6 @@ template toStringImpl[T: string | cstring](result: var T, oid: Oid) =
   when T is cstring:
     result[N] = '\0'
 
-proc oidToString*(oid: Oid, str: cstring) {.deprecated: "unsafe; use `$`".} =
-  ## Converts an oid to a string which must have space allocated for 25 elements.
-  # work around a compiler bug:
-  var str = str
-  toStringImpl(str, oid)
 
 proc `$`*(oid: Oid): string =
   ## Converts an OID to a string.
diff --git a/lib/pure/os.nim b/lib/pure/os.nim
index beb69a5fa8c..61bf2b02f9c 100644
--- a/lib/pure/os.nim
+++ b/lib/pure/os.nim
@@ -2134,7 +2134,7 @@ iterator walkPattern*(pattern: string): string {.tags: [ReadDirEffect], noWeirdT
   ## Iterate over all the files and directories that match the `pattern`.
   ##
   ## On POSIX this uses the `glob`:idx: call.
-  ## `pattern` is OS dependent, but at least the `"\*.ext"`
+  ## `pattern` is OS dependent, but at least the `"*.ext"`
   ## notation is supported.
   ##
   ## See also:
@@ -2153,7 +2153,7 @@ iterator walkFiles*(pattern: string): string {.tags: [ReadDirEffect], noWeirdTar
   ## Iterate over all the files that match the `pattern`.
   ##
   ## On POSIX this uses the `glob`:idx: call.
-  ## `pattern` is OS dependent, but at least the `"\*.ext"`
+  ## `pattern` is OS dependent, but at least the `"*.ext"`
   ## notation is supported.
   ##
   ## See also:
@@ -2170,7 +2170,7 @@ iterator walkDirs*(pattern: string): string {.tags: [ReadDirEffect], noWeirdTarg
   ## Iterate over all the directories that match the `pattern`.
   ##
   ## On POSIX this uses the `glob`:idx: call.
-  ## `pattern` is OS dependent, but at least the `"\*.ext"`
+  ## `pattern` is OS dependent, but at least the `"*.ext"`
   ## notation is supported.
   ##
   ## See also:
@@ -2896,7 +2896,7 @@ when defined(nimdoc):
 
 elif defined(nimscript): discard
 elif defined(nodejs):
-  type Argv = object of JSRoot
+  type Argv = object of JsRoot
   let argv {.importjs: "process.argv".} : Argv
   proc len(argv: Argv): int {.importjs: "#.length".}
   proc `[]`(argv: Argv, i: int): cstring {.importjs: "#[#]".}
@@ -3224,11 +3224,10 @@ proc getFileSize*(file: string): BiggestInt {.rtl, extern: "nos$1",
     result = rdFileSize(a)
     findClose(resA)
   else:
-    var f: File
-    if open(f, file):
-      result = getFileSize(f)
-      close(f)
-    else: raiseOSError(osLastError(), file)
+    var rawInfo: Stat
+    if stat(file, rawInfo) < 0'i32:
+      raiseOSError(osLastError(), file)
+    rawInfo.st_size
 
 when defined(windows) or weirdTarget:
   type
@@ -3263,7 +3262,11 @@ template rawToFormalFileInfo(rawInfo, path, formalInfo): untyped =
   ## 'rawInfo' is either a 'BY_HANDLE_FILE_INFORMATION' structure on Windows,
   ## or a 'Stat' structure on posix
   when defined(windows):
-    template merge(a, b): untyped = a or (b shl 32)
+    template merge(a, b): untyped =
+      int64(
+        (uint64(cast[uint32](a))) or
+        (uint64(cast[uint32](b)) shl 32)
+       )
     formalInfo.id.device = rawInfo.dwVolumeSerialNumber
     formalInfo.id.file = merge(rawInfo.nFileIndexLow, rawInfo.nFileIndexHigh)
     formalInfo.size = merge(rawInfo.nFileSizeLow, rawInfo.nFileSizeHigh)
diff --git a/lib/pure/punycode.nim b/lib/pure/punycode.nim
index dfeeea35e4a..49e46496ebe 100644
--- a/lib/pure/punycode.nim
+++ b/lib/pure/punycode.nim
@@ -28,7 +28,7 @@ const
 type
   PunyError* = object of ValueError
 
-proc decodeDigit(x: char): int {.raises: [PunyError].} =
+func decodeDigit(x: char): int {.raises: [PunyError].} =
   if '0' <= x and x <= '9':
     result = ord(x) - (ord('0') - 26)
   elif 'A' <= x and x <= 'Z':
@@ -38,7 +38,7 @@ proc decodeDigit(x: char): int {.raises: [PunyError].} =
   else:
     raise newException(PunyError, "Bad input")
 
-proc encodeDigit(digit: int): Rune {.raises: [PunyError].} =
+func encodeDigit(digit: int): Rune {.raises: [PunyError].} =
   if 0 <= digit and digit < 26:
     result = Rune(digit + ord('a'))
   elif 26 <= digit and digit < 36:
@@ -46,10 +46,10 @@ proc encodeDigit(digit: int): Rune {.raises: [PunyError].} =
   else:
     raise newException(PunyError, "internal error in punycode encoding")
 
-proc isBasic(c: char): bool = ord(c) < 0x80
-proc isBasic(r: Rune): bool = int(r) < 0x80
+func isBasic(c: char): bool = ord(c) < 0x80
+func isBasic(r: Rune): bool = int(r) < 0x80
 
-proc adapt(delta, numPoints: int, first: bool): int =
+func adapt(delta, numPoints: int, first: bool): int =
   var d = if first: delta div Damp else: delta div 2
   d += d div numPoints
   var k = 0
@@ -58,7 +58,7 @@ proc adapt(delta, numPoints: int, first: bool): int =
     k += Base
   result = k + (Base - TMin + 1) * d div (d + Skew)
 
-proc encode*(prefix, s: string): string {.raises: [PunyError].} =
+func encode*(prefix, s: string): string {.raises: [PunyError].} =
   ## Encode a string that may contain Unicode.
   ## Prepend `prefix` to the result
   result = prefix
@@ -114,18 +114,18 @@ proc encode*(prefix, s: string): string {.raises: [PunyError].} =
     inc d
     inc n
 
-proc encode*(s: string): string {.raises: [PunyError].} =
+func encode*(s: string): string {.raises: [PunyError].} =
   ## Encode a string that may contain Unicode. Prefix is empty.
   result = encode("", s)
 
-proc decode*(encoded: string): string {.raises: [PunyError].} =
+func decode*(encoded: string): string {.raises: [PunyError].} =
   ## Decode a Punycode-encoded string
   var
     n = InitialN
     i = 0
     bias = InitialBias
   var d = rfind(encoded, Delimiter)
-  result = ""
+  var output: seq[Rune]
 
   if d > 0:
     # found Delimiter
@@ -133,7 +133,7 @@ proc decode*(encoded: string): string {.raises: [PunyError].} =
       var c = encoded[j] # char
       if not c.isBasic:
         raise newException(PunyError, "Encoded contains a non-basic char")
-      result.add(c) # add the character
+      output.add(Rune(c)) # add the character
     inc d
   else:
     d = 0 # set to first index
@@ -161,16 +161,17 @@ proc decode*(encoded: string): string {.raises: [PunyError].} =
         break
       w *= Base - t
       k += Base
-    bias = adapt(i - oldi, runeLen(result) + 1, oldi == 0)
+    bias = adapt(i - oldi, len(output) + 1, oldi == 0)
 
-    if i div (runeLen(result) + 1) > high(int32) - n:
+    if i div (len(output) + 1) > high(int32) - n:
       raise newException(PunyError, "Value too large")
 
-    n += i div (runeLen(result) + 1)
-    i = i mod (runeLen(result) + 1)
-    insert(result, $Rune(n), i)
+    n += i div (len(output) + 1)
+    i = i mod (len(output) + 1)
+    insert(output, Rune(n), i)
     inc i
 
+  result = $output
 
 runnableExamples:
   static:
diff --git a/lib/pure/reservedmem.nim b/lib/pure/reservedmem.nim
index 232a2b38385..99fbe142935 100644
--- a/lib/pure/reservedmem.nim
+++ b/lib/pure/reservedmem.nim
@@ -42,25 +42,10 @@ type
 
 when defined(windows):
   import winlean
-
-  type
-    SYSTEM_INFO {.final, pure.} = object
-      u1: uint32
-      dwPageSize: uint32
-      lpMinimumApplicationAddress: pointer
-      lpMaximumApplicationAddress: pointer
-      dwActiveProcessorMask: ptr uint32
-      dwNumberOfProcessors: uint32
-      dwProcessorType: uint32
-      dwAllocationGranularity: uint32
-      wProcessorLevel: uint16
-      wProcessorRevision: uint16
-
-  proc getSystemInfo(lpSystemInfo: ptr SYSTEM_INFO) {.stdcall,
-      dynlib: "kernel32", importc: "GetSystemInfo".}
+  import std/private/win_getsysteminfo
 
   proc getAllocationGranularity: uint =
-    var sysInfo: SYSTEM_INFO
+    var sysInfo: SystemInfo
     getSystemInfo(addr sysInfo)
     return uint(sysInfo.dwAllocationGranularity)
 
diff --git a/lib/pure/strformat.nim b/lib/pure/strformat.nim
index 746f01aceb3..40a33951c01 100644
--- a/lib/pure/strformat.nim
+++ b/lib/pure/strformat.nim
@@ -574,6 +574,9 @@ template formatValue(result: var string; value: cstring; specifier: string) =
   result.add value
 
 proc strformatImpl(f: string; openChar, closeChar: char): NimNode =
+  template missingCloseChar =
+    error("invalid format string: missing closing character '" & closeChar & "'")
+
   if openChar == ':' or closeChar == ':':
     error "openChar and closeChar must not be ':'"
   var i = 0
@@ -618,6 +621,8 @@ proc strformatImpl(f: string; openChar, closeChar: char): NimNode =
             let start = i
             inc i
             i += f.skipWhitespace(i)
+            if i == f.len:
+              missingCloseChar
             if f[i] == closeChar or f[i] == ':':
               result.add newCall(bindSym"add", res, newLit(subexpr & f[start ..< i]))
             else:
@@ -627,6 +632,9 @@ proc strformatImpl(f: string; openChar, closeChar: char): NimNode =
           subexpr.add f[i]
           inc i
 
+        if i == f.len:
+          missingCloseChar
+
         var x: NimNode
         try:
           x = parseExpr(subexpr)
@@ -639,10 +647,10 @@ proc strformatImpl(f: string; openChar, closeChar: char): NimNode =
           while i < f.len and f[i] != closeChar:
             options.add f[i]
             inc i
+        if i == f.len:
+          missingCloseChar
         if f[i] == closeChar:
           inc i
-        else:
-          doAssert false, "invalid format string: missing '}'"
         result.add newCall(formatSym, res, x, newLit(options))
     elif f[i] == closeChar:
       if i<f.len-1 and f[i+1] == closeChar:
diff --git a/lib/pure/strutils.nim b/lib/pure/strutils.nim
index b9630237098..1e894080f70 100644
--- a/lib/pure/strutils.nim
+++ b/lib/pure/strutils.nim
@@ -276,8 +276,9 @@ func nimIdentNormalize*(s: string): string =
   runnableExamples:
     doAssert nimIdentNormalize("Foo_bar") == "Foobar"
   result = newString(s.len)
-  if s.len > 0:
-    result[0] = s[0]
+  if s.len == 0:
+    return
+  result[0] = s[0]
   var j = 1
   for i in 1..len(s) - 1:
     if s[i] in {'A'..'Z'}:
@@ -1859,7 +1860,7 @@ func find*(s: string, sub: char, start: Natural = 0, last = 0): int {.rtl,
   ## Use `s[start..last].rfind` for a `start`-origin index.
   ##
   ## See also:
-  ## * `rfind func<#rfind,string,char,Natural>`_
+  ## * `rfind func<#rfind,string,char,Natural,int>`_
   ## * `replace func<#replace,string,char,char>`_
   let last = if last == 0: s.high else: last
   when nimvm:
@@ -1887,7 +1888,7 @@ func find*(s: string, chars: set[char], start: Natural = 0, last = 0): int {.
   ## Use `s[start..last].find` for a `start`-origin index.
   ##
   ## See also:
-  ## * `rfind func<#rfind,string,set[char],Natural>`_
+  ## * `rfind func<#rfind,string,set[char],Natural,int>`_
   ## * `multiReplace func<#multiReplace,string,varargs[]>`_
   let last = if last == 0: s.high else: last
   for i in int(start)..last:
@@ -1904,7 +1905,7 @@ func find*(s, sub: string, start: Natural = 0, last = 0): int {.rtl,
   ## Use `s[start..last].find` for a `start`-origin index.
   ##
   ## See also:
-  ## * `rfind func<#rfind,string,string,Natural>`_
+  ## * `rfind func<#rfind,string,string,Natural,int>`_
   ## * `replace func<#replace,string,string,string>`_
   if sub.len > s.len - start: return -1
   if sub.len == 1: return find(s, sub[0], start, last)
diff --git a/lib/pure/terminal.nim b/lib/pure/terminal.nim
index 65404e0669b..cc62526a79b 100644
--- a/lib/pure/terminal.nim
+++ b/lib/pure/terminal.nim
@@ -170,6 +170,7 @@ when defined(windows):
     return 0
 
   proc terminalWidth*(): int =
+    ## Returns the terminal width in columns.
     var w: int = 0
     w = terminalWidthIoctl([getStdHandle(STD_INPUT_HANDLE),
                              getStdHandle(STD_OUTPUT_HANDLE),
@@ -178,6 +179,7 @@ when defined(windows):
     return 80
 
   proc terminalHeight*(): int =
+    ## Returns the terminal height in rows.
     var h: int = 0
     h = terminalHeightIoctl([getStdHandle(STD_INPUT_HANDLE),
                               getStdHandle(STD_OUTPUT_HANDLE),
@@ -389,6 +391,9 @@ when defined(windows):
 
 proc cursorUp*(f: File, count = 1) =
   ## Moves the cursor up by `count` rows.
+  runnableExamples("-r:off"):
+    stdout.cursorUp(2)
+    write(stdout, "Hello World!") # anything written at that location will be erased/replaced with this
   when defined(windows):
     let h = conHandle(f)
     var p = getCursorPos(h)
@@ -399,6 +404,9 @@ proc cursorUp*(f: File, count = 1) =
 
 proc cursorDown*(f: File, count = 1) =
   ## Moves the cursor down by `count` rows.
+  runnableExamples("-r:off"):
+    stdout.cursorDown(2)
+    write(stdout, "Hello World!") # anything written at that location will be erased/replaced with this
   when defined(windows):
     let h = conHandle(f)
     var p = getCursorPos(h)
@@ -409,6 +417,9 @@ proc cursorDown*(f: File, count = 1) =
 
 proc cursorForward*(f: File, count = 1) =
   ## Moves the cursor forward by `count` columns.
+  runnableExamples("-r:off"):
+    stdout.cursorForward(2)
+    write(stdout, "Hello World!") # anything written at that location will be erased/replaced with this
   when defined(windows):
     let h = conHandle(f)
     var p = getCursorPos(h)
@@ -419,6 +430,9 @@ proc cursorForward*(f: File, count = 1) =
 
 proc cursorBackward*(f: File, count = 1) =
   ## Moves the cursor backward by `count` columns.
+  runnableExamples("-r:off"):
+    stdout.cursorBackward(2)
+    write(stdout, "Hello World!") # anything written at that location will be erased/replaced with this
   when defined(windows):
     let h = conHandle(f)
     var p = getCursorPos(h)
diff --git a/lib/pure/uri.nim b/lib/pure/uri.nim
index a828298c299..7583dbd1ec0 100644
--- a/lib/pure/uri.nim
+++ b/lib/pure/uri.nim
@@ -151,10 +151,10 @@ func encodeQuery*(query: openArray[(string, string)], usePlus = true,
       result.add(encodeUrl(val, usePlus))
 
 iterator decodeQuery*(data: string): tuple[key, value: string] =
-  ## Reads and decodes query string `data` and yields the `(key, value)` pairs
-  ## the data consists of. If compiled with `-d:nimLegacyParseQueryStrict`, an
-  ## error is raised when there is an unencoded `=` character in a decoded
-  ## value, which was the behavior in Nim < 1.5.1
+  ## Reads and decodes the query string `data` and yields the `(key, value)` pairs
+  ## the data consists of. If compiled with `-d:nimLegacyParseQueryStrict`,
+  ## a `UriParseError` is raised when there is an unencoded `=` character in a decoded
+  ## value, which was the behavior in Nim < 1.5.1.
   runnableExamples:
     import std/sequtils
     assert toSeq(decodeQuery("foo=1&bar=2=3")) == @[("foo", "1"), ("bar", "2=3")]
diff --git a/lib/std/enumutils.nim b/lib/std/enumutils.nim
index 81e602ad583..b7d2b9f89b0 100644
--- a/lib/std/enumutils.nim
+++ b/lib/std/enumutils.nim
@@ -14,7 +14,7 @@ from typetraits import OrdinalEnum, HoleyEnum
 
 macro genEnumCaseStmt*(typ: typedesc, argSym: typed, default: typed,
             userMin, userMax: static[int], normalizer: static[proc(s :string): string]): untyped =
-  # generates a case stmt, which assigns the correct enum field given
+  # Generates a case stmt, which assigns the correct enum field given
   # a normalized string comparison to the `argSym` input.
   # string normalization is done using passed normalizer.
   # NOTE: for an enum with fields Foo, Bar, ... we cannot generate
@@ -49,7 +49,12 @@ macro genEnumCaseStmt*(typ: typedesc, argSym: typed, default: typed,
       of nnkIntLit:
         fStr = f[0].strVal
         fNum = f[1].intVal
-      else: error("Invalid tuple syntax!", f[1])
+      else:
+        let fAst = f[0].getImpl
+        if fAst.kind == nnkStrLit:
+          fStr = fAst.strVal
+        else:
+          error("Invalid tuple syntax!", f[1])
     else: error("Invalid node for enum type `" & $f.kind & "`!", f)
     # add field if string not already added
     if fNum >= userMin and fNum <= userMax:
diff --git a/lib/std/jsfetch.nim b/lib/std/jsfetch.nim
index a25fe7ca82d..808d699b0f0 100644
--- a/lib/std/jsfetch.nim
+++ b/lib/std/jsfetch.nim
@@ -1,5 +1,4 @@
 ## - Fetch for the JavaScript target: https://developer.mozilla.org/docs/Web/API/Fetch_API
-## .. Note:: jsfetch is Experimental.
 when not defined(js):
   {.fatal: "Module jsfetch is designed to be used with the JavaScript backend.".}
 
@@ -12,6 +11,7 @@ type
     keepalive*: bool
     metod* {.importjs: "method".}: cstring
     body*, integrity*, referrer*, mode*, credentials*, cache*, redirect*, referrerPolicy*: cstring
+    headers*: Headers
 
   FetchModes* = enum  ## Mode options.
     fmCors = "cors"
@@ -42,16 +42,13 @@ type
     frpOriginWhenCrossOrigin = "origin-when-cross-origin"
     frpUnsafeUrl = "unsafe-url"
 
-  Body* = ref object of JsRoot  ## https://developer.mozilla.org/en-US/docs/Web/API/Body
-    bodyUsed*: bool
-
   Response* = ref object of JsRoot  ## https://developer.mozilla.org/en-US/docs/Web/API/Response
     bodyUsed*, ok*, redirected*: bool
     typ* {.importjs: "type".}: cstring
     url*, statusText*: cstring
     status*: cint
     headers*: Headers
-    body*: Body
+    body*: cstring
 
   Request* = ref object of JsRoot  ## https://developer.mozilla.org/en-US/docs/Web/API/Request
     bodyUsed*, ok*, redirected*: bool
@@ -59,8 +56,7 @@ type
     url*, statusText*: cstring
     status*: cint
     headers*: Headers
-    body*: Body
-
+    body*: cstring
 
 func newResponse*(body: cstring | FormData): Response {.importjs: "(new Response(#))".}
   ## Constructor for `Response`. This does *not* call `fetch()`. Same as `new Response()`.
@@ -68,30 +64,34 @@ func newResponse*(body: cstring | FormData): Response {.importjs: "(new Response
 func newRequest*(url: cstring): Request {.importjs: "(new Request(#))".}
   ## Constructor for `Request`. This does *not* call `fetch()`. Same as `new Request()`.
 
+func newRequest*(url: cstring; fetchOptions: FetchOptions): Request {.importjs: "(new Request(#, #))".}
+  ## Constructor for `Request` with `fetchOptions`. Same as `fetch(url, fetchOptions)`.
+
 func clone*(self: Response | Request): Response {.importjs: "#.$1()".}
   ## https://developer.mozilla.org/en-US/docs/Web/API/Response/clone
 
 proc text*(self: Response): Future[cstring] {.importjs: "#.$1()".}
-  ## https://developer.mozilla.org/en-US/docs/Web/API/Body/text
+  ## https://developer.mozilla.org/en-US/docs/Web/API/Response/text
 
 proc json*(self: Response): Future[JsObject] {.importjs: "#.$1()".}
-  ## https://developer.mozilla.org/en-US/docs/Web/API/Body/json
+  ## https://developer.mozilla.org/en-US/docs/Web/API/Response/json
 
-proc formData*(self: Body): Future[FormData] {.importjs: "#.$1()".}
-  ## https://developer.mozilla.org/en-US/docs/Web/API/Body/formData
+proc formData*(self: Response): Future[FormData] {.importjs: "#.$1()".}
+  ## https://developer.mozilla.org/en-US/docs/Web/API/Response/formData
 
 proc unsafeNewFetchOptions*(metod, body, mode, credentials, cache, referrerPolicy: cstring;
-    keepalive: bool; redirect = "follow".cstring; referrer = "client".cstring; integrity = "".cstring): FetchOptions {.importjs:
-    "{method: #, body: #, mode: #, credentials: #, cache: #, referrerPolicy: #, keepalive: #, redirect: #, referrer: #, integrity: #}".}
+    keepalive: bool; redirect = "follow".cstring; referrer = "client".cstring; integrity = "".cstring; headers: Headers = newHeaders()): FetchOptions {.importjs:
+    "{method: #, body: #, mode: #, credentials: #, cache: #, referrerPolicy: #, keepalive: #, redirect: #, referrer: #, integrity: #, headers: #}".}
   ## .. warning:: Unsafe `newfetchOptions`.
 
 func newfetchOptions*(metod: HttpMethod; body: cstring;
     mode: FetchModes; credentials: FetchCredentials; cache: FetchCaches; referrerPolicy: FetchReferrerPolicies;
-    keepalive: bool; redirect = frFollow; referrer = "client".cstring; integrity = "".cstring): FetchOptions =
+    keepalive: bool; redirect = frFollow; referrer = "client".cstring; integrity = "".cstring,
+    headers: Headers = newHeaders()): FetchOptions =
   ## Constructor for `FetchOptions`.
   result = FetchOptions(
-    body: body, mode: $mode, credentials: $credentials, cache: $cache, referrerPolicy: $referrerPolicy,
-    keepalive: keepalive, redirect: $redirect, referrer: referrer, integrity: integrity,
+    body: body, mode: cstring($mode), credentials: cstring($credentials), cache: cstring($cache), referrerPolicy: cstring($referrerPolicy),
+    keepalive: keepalive, redirect: cstring($redirect), referrer: referrer, integrity: integrity,
     metod: (case metod
       of HttpHead:   "HEAD".cstring
       of HttpGet:    "GET".cstring
@@ -109,9 +109,9 @@ proc fetch*(url: cstring | Request): Future[Response] {.importjs: "$1(#)".}
 proc fetch*(url: cstring | Request; options: FetchOptions): Future[Response] {.importjs: "$1(#, #)".}
   ## `fetch()` API that takes a `FetchOptions`, returns a `Future[Response]`.
 
-func toCstring*(self: Request | Response | Body | FetchOptions): cstring {.importjs: "JSON.stringify(#)".}
+func toCstring*(self: Request | Response | FetchOptions): cstring {.importjs: "JSON.stringify(#)".}
 
-func `$`*(self: Request | Response | Body | FetchOptions): string = $toCstring(self)
+func `$`*(self: Request | Response | FetchOptions): string = $toCstring(self)
 
 
 runnableExamples("-r:off"):
@@ -131,7 +131,8 @@ runnableExamples("-r:off"):
       keepalive = false,
       redirect = "follow".cstring,
       referrer = "client".cstring,
-      integrity = "".cstring
+      integrity = "".cstring,
+      headers = newHeaders()
     )
     assert options0.keepalive == false
     assert options0.metod == "POST".cstring
@@ -143,6 +144,7 @@ runnableExamples("-r:off"):
     assert options0.redirect == "follow".cstring
     assert options0.referrer == "client".cstring
     assert options0.integrity == "".cstring
+    assert options0.headers.len == 0
 
   block:
     let options1: FetchOptions = newFetchOptions(
@@ -155,7 +157,8 @@ runnableExamples("-r:off"):
       keepalive = false,
       redirect = frFollow,
       referrer = "client".cstring,
-      integrity = "".cstring
+      integrity = "".cstring,
+      headers = newHeaders()
     )
     assert options1.keepalive == false
     assert options1.metod == $HttpPost
@@ -167,6 +170,7 @@ runnableExamples("-r:off"):
     assert options1.redirect == $frFollow
     assert options1.referrer == "client".cstring
     assert options1.integrity == "".cstring
+    assert options1.headers.len == 0
 
   block:
     let response: Response = newResponse(body = "-. .. --".cstring)
@@ -182,7 +186,7 @@ runnableExamples("-r:off"):
         assert response.ok
         assert response.status == 200.cint
         assert response.headers is Headers
-        assert response.body is Body
+        assert response.body is cstring
 
       discard example()
 
diff --git a/lib/std/private/win_getsysteminfo.nim b/lib/std/private/win_getsysteminfo.nim
new file mode 100644
index 00000000000..b98478231b2
--- /dev/null
+++ b/lib/std/private/win_getsysteminfo.nim
@@ -0,0 +1,15 @@
+type
+  SystemInfo* = object
+    u1: uint32
+    dwPageSize: uint32
+    lpMinimumApplicationAddress: pointer
+    lpMaximumApplicationAddress: pointer
+    dwActiveProcessorMask: ptr uint32
+    dwNumberOfProcessors*: uint32
+    dwProcessorType: uint32
+    dwAllocationGranularity*: uint32
+    wProcessorLevel: uint16
+    wProcessorRevision: uint16
+
+proc getSystemInfo*(lpSystemInfo: ptr SystemInfo) {.stdcall,
+    dynlib: "kernel32", importc: "GetSystemInfo".}
diff --git a/lib/std/private/win_setenv.nim b/lib/std/private/win_setenv.nim
index 067e656a317..0dfe0ed46dc 100644
--- a/lib/std/private/win_setenv.nim
+++ b/lib/std/private/win_setenv.nim
@@ -23,50 +23,52 @@ check errno_t vs cint
 
 when not defined(windows): discard
 else:
+  type wchar_t  {.importc: "wchar_t".} = int16
+
   proc setEnvironmentVariableA*(lpName, lpValue: cstring): int32 {.
     stdcall, dynlib: "kernel32", importc: "SetEnvironmentVariableA", sideEffect.}
     # same as winlean.setEnvironmentVariableA
 
   proc c_getenv(env: cstring): cstring {.importc: "getenv", header: "<stdlib.h>".}
-  proc c_putenv_s(envname: cstring, envval: cstring): cint {.importc: "_putenv_s", header: "<stdlib.h>".}
-  proc c_wgetenv(varname: WideCString): WideCString {.importc: "_wgetenv", header: "<stdlib.h>".}
+  proc c_putenv(envstring: cstring): cint {.importc: "_putenv", header: "<stdlib.h>".}
+  proc c_wgetenv(varname: ptr wchar_t): ptr wchar_t {.importc: "_wgetenv", header: "<stdlib.h>".}
 
   var errno {.importc, header: "<errno.h>".}: cint
-  type wchar_t  {.importc: "wchar_t".} = int16
-  var gWenviron {.importc:"_wenviron".}: ptr ptr wchar_t
+  var gWenviron {.importc: "_wenviron".}: ptr ptr wchar_t
     # xxx `ptr UncheckedArray[WideCString]` did not work
 
-  proc mbstowcs_s(pReturnValue: ptr csize_t, wcstr: WideCString, sizeInWords: csize_t, mbstr: cstring, count: csize_t): cint {.importc: "mbstowcs_s", header: "<stdlib.h>".}
+  proc mbstowcs(wcstr: ptr wchar_t, mbstr: cstring, count: csize_t): csize_t {.importc: "mbstowcs", header: "<stdlib.h>".}
     # xxx cint vs errno_t?
 
-  proc setEnvImpl*(name: cstring, value: cstring, overwrite: cint): cint =
+  proc setEnvImpl*(name: string, value: string, overwrite: cint): cint =
     const EINVAL = cint(22)
-    const MAX_ENV = 32767
-      # xxx get it from: `var MAX_ENV {.importc: "_MAX_ENV", header:"<stdlib.h>".}: cint`
-    if overwrite == 0 and c_getenv(name) != nil: return 0
-    if value[0] != '\0':
-      let e = c_putenv_s(name, value)
+    if overwrite == 0 and c_getenv(cstring(name)) != nil: return 0
+    if value != "":
+      let envstring = name & "=" & value
+      let e = c_putenv(cstring(envstring))
       if e != 0:
-        errno = e
+        errno = EINVAL
         return -1
       return 0
     #[
-    We are trying to set the value to an empty string, but `_putenv_s` deletes
+    We are trying to set the value to an empty string, but `_putenv` deletes
     entries if the value is an empty string, and just calling
     SetEnvironmentVariableA doesn't update `_environ`,
     so we have to do these terrible things.
     ]#
-    if c_putenv_s(name, "  ") != 0:
+    let envstring = name & "=  "
+    if c_putenv(cstring(envstring)) != 0:
       errno = EINVAL
       return -1
     # Here lies the documentation we blatently ignore to make this work.
-    var s = c_getenv(name)
+    var s = c_getenv(cstring(name))
     s[0] = '\0'
     #[
     This would result in a double null termination, which normally signifies the
     end of the environment variable list, so we stick a completely empty
     environment variable into the list instead.
     ]#
+    s = c_getenv(cstring(name))
     s[1] = '='
     #[
     If gWenviron is null, the wide environment has not been initialized
@@ -76,17 +78,19 @@ else:
     ]#
     if gWenviron != nil:
       # var buf: array[MAX_ENV + 1, WideCString]
-      var buf: array[MAX_ENV + 1, Utf16Char]
-      let buf2 = cast[WideCString](buf[0].addr)
-      var len: csize_t
-      if mbstowcs_s(len.addr, buf2, buf.len.csize_t, name, MAX_ENV) != 0:
+      let requiredSize = mbstowcs(nil, cstring(name), 0).int
+      var buf = newSeq[Utf16Char](requiredSize + 1)
+      let buf2 = cast[ptr wchar_t](buf[0].addr)
+      if mbstowcs(buf2, cstring(name), csize_t(requiredSize + 1)) == csize_t(high(uint)):
         errno = EINVAL
         return -1
-      c_wgetenv(buf2)[0] = '\0'.Utf16Char
-      c_wgetenv(buf2)[1] = '='.Utf16Char
+      var ptrToEnv = cast[WideCString](c_wgetenv(buf2))
+      ptrToEnv[0] = '\0'.Utf16Char
+      ptrToEnv = cast[WideCString](c_wgetenv(buf2))
+      ptrToEnv[1] = '='.Utf16Char
 
     # And now, we have to update the outer environment to have a proper empty value.
-    if setEnvironmentVariableA(name, value) == 0:
+    if setEnvironmentVariableA(cstring(name), cstring(value)) == 0:
       errno = EINVAL
       return -1
     return 0
diff --git a/lib/std/sha1.nim b/lib/std/sha1.nim
index 120a81702fa..ed962707bf9 100644
--- a/lib/std/sha1.nim
+++ b/lib/std/sha1.nim
@@ -12,9 +12,9 @@
 ##
 ## See also
 ## ========
-## * `base64 module<base64.html>`_ implements a Base64 encoder and decoder
+## * `base64 module<base64.html>`_ for a Base64 encoder and decoder
 ## * `hashes module<hashes.html>`_ for efficient computations of hash values for diverse Nim types
-## * `md5 module<md5.html>`_ implements the MD5 checksum algorithm
+## * `md5 module<md5.html>`_ for the MD5 checksum algorithm
 
 runnableExamples:
   let accessName = secureHash("John Doe")
diff --git a/lib/std/sysrand.nim b/lib/std/sysrand.nim
index 75983e3c6cd..7620db64e9b 100644
--- a/lib/std/sysrand.nim
+++ b/lib/std/sysrand.nim
@@ -159,7 +159,7 @@ elif defined(windows):
 
     result = randomBytes(addr dest[0], size)
 
-elif defined(linux):
+elif defined(linux) and not defined(emscripten):
   # TODO using let, pending bootstrap >= 1.4.0
   var SYS_getrandom {.importc: "SYS_getrandom", header: "<sys/syscall.h>".}: clong
   const syscallHeader = """#include <unistd.h>
diff --git a/lib/system.nim b/lib/system.nim
index 8f2164a597b..23efb0ef215 100644
--- a/lib/system.nim
+++ b/lib/system.nim
@@ -190,8 +190,16 @@ when defined(nimHasDeclaredMagic):
 else:
   proc declaredInScope*(x: untyped): bool {.magic: "DefinedInScope", noSideEffect, compileTime.}
 
-proc `addr`*[T](x: var T): ptr T {.magic: "Addr", noSideEffect.} =
+proc `addr`*[T](x: T): ptr T {.magic: "Addr", noSideEffect.} =
   ## Builtin `addr` operator for taking the address of a memory location.
+  ##
+  ## .. note:: This works for `let` variables or parameters
+  ##   for better interop with C. When you use it to write a wrapper
+  ##   for a C library and take the address of `let` variables or parameters,
+  ##   you should always check that the original library
+  ##   does never write to data behind the pointer that is returned from
+  ##   this procedure.
+  ##
   ## Cannot be overloaded.
   ##
   ## See also:
@@ -207,13 +215,14 @@ proc `addr`*[T](x: var T): ptr T {.magic: "Addr", noSideEffect.} =
 
 proc unsafeAddr*[T](x: T): ptr T {.magic: "Addr", noSideEffect.} =
   ## Builtin `addr` operator for taking the address of a memory
-  ## location. This works even for `let` variables or parameters
-  ## for better interop with C and so it is considered even more
-  ## unsafe than the ordinary `addr <#addr,T>`_.
+  ## location.
   ##
-  ## **Note**: When you use it to write a wrapper for a C library, you should
-  ## always check that the original library does never write to data behind the
-  ## pointer that is returned from this procedure.
+  ## .. note:: This works for `let` variables or parameters
+  ##   for better interop with C. When you use it to write a wrapper
+  ##   for a C library and take the address of `let` variables or parameters,
+  ##   you should always check that the original library
+  ##   does never write to data behind the pointer that is returned from
+  ##   this procedure.
   ##
   ## Cannot be overloaded.
   discard
@@ -1123,7 +1132,7 @@ const
     ## Possible values:
     ## `"i386"`, `"alpha"`, `"powerpc"`, `"powerpc64"`, `"powerpc64el"`,
     ## `"sparc"`, `"amd64"`, `"mips"`, `"mipsel"`, `"arm"`, `"arm64"`,
-    ## `"mips64"`, `"mips64el"`, `"riscv32"`, `"riscv64"`.
+    ## `"mips64"`, `"mips64el"`, `"riscv32"`, `"riscv64"`, '"loongarch64"'.
 
   seqShallowFlag = low(int)
   strlitFlag = 1 shl (sizeof(int)*8 - 2) # later versions of the codegen \
@@ -2305,6 +2314,15 @@ when notJSnotNims:
   proc setControlCHook*(hook: proc () {.noconv.})
     ## Allows you to override the behaviour of your application when CTRL+C
     ## is pressed. Only one such hook is supported.
+    ## Example:
+    ##
+    ## .. code-block:: Nim
+    ##   proc ctrlc() {.noconv.} =
+    ##     echo "Ctrl+C fired!"
+    ##     # do clean up stuff
+    ##     quit()
+    ##
+    ##   setControlCHook(ctrlc)
 
   when not defined(noSignalHandler) and not defined(useNimRtl):
     proc unsetControlCHook*()
diff --git a/lib/system/ansi_c.nim b/lib/system/ansi_c.nim
index e5f26e07036..8169226fb62 100644
--- a/lib/system/ansi_c.nim
+++ b/lib/system/ansi_c.nim
@@ -31,7 +31,10 @@ proc c_abort*() {.
   importc: "abort", header: "<stdlib.h>", noSideEffect, noreturn.}
 
 
-when defined(linux) and defined(amd64):
+when defined(nimBuiltinSetjmp):
+  type
+    C_JmpBuf* = array[5, pointer]
+elif defined(linux) and defined(amd64):
   type
     C_JmpBuf* {.importc: "jmp_buf", header: "<setjmp.h>", bycopy.} = object
         abi: array[200 div sizeof(clong), clong]
@@ -92,18 +95,47 @@ when defined(macosx):
 elif defined(haiku):
   const SIGBUS* = cint(30)
 
-when defined(nimSigSetjmp) and not defined(nimStdSetjmp):
+# "nimRawSetjmp" is defined by default for certain platforms, so we need the
+# "nimStdSetjmp" escape hatch with it.
+when defined(nimSigSetjmp):
   proc c_longjmp*(jmpb: C_JmpBuf, retval: cint) {.
     header: "<setjmp.h>", importc: "siglongjmp".}
-  template c_setjmp*(jmpb: C_JmpBuf): cint =
+  proc c_setjmp*(jmpb: C_JmpBuf): cint =
     proc c_sigsetjmp(jmpb: C_JmpBuf, savemask: cint): cint {.
       header: "<setjmp.h>", importc: "sigsetjmp".}
     c_sigsetjmp(jmpb, 0)
+elif defined(nimBuiltinSetjmp):
+  proc c_longjmp*(jmpb: C_JmpBuf, retval: cint) =
+    # Apple's Clang++ has trouble converting array names to pointers, so we need
+    # to be very explicit here.
+    proc c_builtin_longjmp(jmpb: ptr pointer, retval: cint) {.
+      importc: "__builtin_longjmp", nodecl.}
+    # The second parameter needs to be 1 and sometimes the C/C++ compiler checks it.
+    c_builtin_longjmp(unsafeAddr jmpb[0], 1)
+  proc c_setjmp*(jmpb: C_JmpBuf): cint =
+    proc c_builtin_setjmp(jmpb: ptr pointer): cint {.
+      importc: "__builtin_setjmp", nodecl.}
+    c_builtin_setjmp(unsafeAddr jmpb[0])
 elif defined(nimRawSetjmp) and not defined(nimStdSetjmp):
-  proc c_longjmp*(jmpb: C_JmpBuf, retval: cint) {.
-    header: "<setjmp.h>", importc: "_longjmp".}
-  proc c_setjmp*(jmpb: C_JmpBuf): cint {.
-    header: "<setjmp.h>", importc: "_setjmp".}
+  when defined(windows):
+    # No `_longjmp()` on Windows.
+    proc c_longjmp*(jmpb: C_JmpBuf, retval: cint) {.
+      header: "<setjmp.h>", importc: "longjmp".}
+    # The Windows `_setjmp()` takes two arguments, with the second being an
+    # undocumented buffer used by the SEH mechanism for stack unwinding.
+    # Mingw-w64 has been trying to get it right for years, but it's still
+    # prone to stack corruption during unwinding, so we disable that by setting
+    # it to NULL.
+    # More details: https://github.com/status-im/nimbus-eth2/issues/3121
+    proc c_setjmp*(jmpb: C_JmpBuf): cint =
+      proc c_setjmp_win(jmpb: C_JmpBuf, ctx: pointer): cint {.
+        header: "<setjmp.h>", importc: "_setjmp".}
+      c_setjmp_win(jmpb, nil)
+  else:
+    proc c_longjmp*(jmpb: C_JmpBuf, retval: cint) {.
+      header: "<setjmp.h>", importc: "_longjmp".}
+    proc c_setjmp*(jmpb: C_JmpBuf): cint {.
+      header: "<setjmp.h>", importc: "_setjmp".}
 else:
   proc c_longjmp*(jmpb: C_JmpBuf, retval: cint) {.
     header: "<setjmp.h>", importc: "longjmp".}
diff --git a/lib/system/atomics.nim b/lib/system/atomics.nim
index f69cb753d83..75731764b6e 100644
--- a/lib/system/atomics.nim
+++ b/lib/system/atomics.nim
@@ -73,7 +73,7 @@ when someGcc and hasThreadSupport:
 
   proc atomicCompareExchangeN*[T: AtomType](p, expected: ptr T, desired: T,
     weak: bool, success_memmodel: AtomMemModel, failure_memmodel: AtomMemModel): bool {.
-    importc: "__atomic_compare_exchange_n ", nodecl.}
+    importc: "__atomic_compare_exchange_n", nodecl.}
     ## This proc implements an atomic compare and exchange operation. This compares the
     ## contents at p with the contents at expected and if equal, writes desired at p.
     ## If they are not equal, the current contents at p is written into expected.
@@ -100,13 +100,13 @@ when someGcc and hasThreadSupport:
   proc atomicSubFetch*[T: AtomType](p: ptr T, val: T, mem: AtomMemModel): T {.
     importc: "__atomic_sub_fetch", nodecl.}
   proc atomicOrFetch*[T: AtomType](p: ptr T, val: T, mem: AtomMemModel): T {.
-    importc: "__atomic_or_fetch ", nodecl.}
+    importc: "__atomic_or_fetch", nodecl.}
   proc atomicAndFetch*[T: AtomType](p: ptr T, val: T, mem: AtomMemModel): T {.
     importc: "__atomic_and_fetch", nodecl.}
   proc atomicXorFetch*[T: AtomType](p: ptr T, val: T, mem: AtomMemModel): T {.
     importc: "__atomic_xor_fetch", nodecl.}
   proc atomicNandFetch*[T: AtomType](p: ptr T, val: T, mem: AtomMemModel): T {.
-    importc: "__atomic_nand_fetch ", nodecl.}
+    importc: "__atomic_nand_fetch", nodecl.}
 
   ## Perform the operation return the old value, all memory models are valid
   proc atomicFetchAdd*[T: AtomType](p: ptr T, val: T, mem: AtomMemModel): T {.
@@ -177,8 +177,8 @@ elif someVcc and hasThreadSupport:
 
   proc `==`(x1, x2: AtomMemModel): bool {.borrow.}
 
-  proc readBarrier() {.importc: "_ReadBarrier",  header: "<intrin.h>".}
-  proc writeBarrier() {.importc: "_WriteBarrier",  header: "<intrin.h>".}
+  proc readBarrier() {.importc: "_ReadBarrier", header: "<intrin.h>".}
+  proc writeBarrier() {.importc: "_WriteBarrier", header: "<intrin.h>".}
   proc fence*() {.importc: "_ReadWriteBarrier", header: "<intrin.h>".}
 
   template barrier(mem: AtomMemModel) =
diff --git a/lib/system/chcks.nim b/lib/system/chcks.nim
index 8c7c957958f..a404e9d40b3 100644
--- a/lib/system/chcks.nim
+++ b/lib/system/chcks.nim
@@ -29,7 +29,7 @@ proc raiseFieldError(f: string) {.compilerproc, noinline.} =
   ## remove after bootstrap > 1.5.1
   sysFatal(FieldDefect, f)
 
-when defined(gcdestructors):
+when defined(nimV2):
   proc raiseFieldError2(f: string, discVal: int) {.compilerproc, noinline.} =
     ## raised when field is inaccessible given runtime value of discriminant
     sysFatal(FieldError, f & $discVal & "'")
diff --git a/lib/system/io.nim b/lib/system/io.nim
index 59f070f73d2..066228cd0fc 100644
--- a/lib/system/io.nim
+++ b/lib/system/io.nim
@@ -22,6 +22,8 @@ type
 
   FileMode* = enum           ## The file mode when opening a file.
     fmRead,                   ## Open the file for read access only.
+                              ## If the file does not exist, it will not
+                              ## be created.
     fmWrite,                  ## Open the file for write access only.
                               ## If the file does not exist, it will be
                               ## created. Existing files will be cleared!
@@ -32,7 +34,8 @@ type
                               ## If the file does not exist, it will not be
                               ## created. The existing file will not be cleared.
     fmAppend                  ## Open the file for writing only; append data
-                              ## at the end.
+                              ## at the end. If the file does not exist, it
+                              ## will be created.
 
   FileHandle* = cint ## type that represents an OS file handle; this is
                       ## useful for low-level file access
@@ -108,8 +111,22 @@ when defined(windows):
   else:
     proc c_fseek(f: File, offset: int64, whence: cint): cint {.
       importc: "_fseeki64", header: "<stdio.h>", tags: [].}
-    proc c_ftell(f: File): int64 {.
-      importc: "_ftelli64", header: "<stdio.h>", tags: [].}
+    when defined(tcc):
+      proc c_fsetpos(f: File, pos: var int64): int32 {.
+        importc: "fsetpos", header: "<stdio.h>", tags: [].}
+      proc c_fgetpos(f: File, pos: var int64): int32 {.
+        importc: "fgetpos", header: "<stdio.h>", tags: [].}
+      proc c_telli64(f: cint): int64 {.
+        importc: "_telli64", header: "<io.h>", tags: [].}
+      proc c_ftell(f: File): int64 =
+        # Taken from https://pt.osdn.net/projects/mingw/scm/git/mingw-org-wsl/blobs/5.4-trunk/mingwrt/mingwex/stdio/ftelli64.c
+        result = -1'i64
+        var pos: int64
+        if c_fgetpos(f, pos) == 0 and c_fsetpos(f, pos) == 0:
+          result = c_telli64(c_fileno(f))
+    else:
+      proc c_ftell(f: File): int64 {.
+        importc: "_ftelli64", header: "<stdio.h>", tags: [].}
 else:
   proc c_fseek(f: File, offset: int64, whence: cint): cint {.
     importc: "fseeko", header: "<stdio.h>", tags: [].}
diff --git a/lib/system/jssys.nim b/lib/system/jssys.nim
index cd4f378be13..ae3fa78b19f 100644
--- a/lib/system/jssys.nim
+++ b/lib/system/jssys.nim
@@ -587,7 +587,33 @@ proc nimCopy(dest, src: JSRef, ti: PNimType): JSRef =
     else:
       asm "`result` = (`dest` === null || `dest` === undefined) ? {} : `dest`;"
     nimCopyAux(result, src, ti.node)
-  of tySequence, tyArrayConstr, tyOpenArray, tyArray:
+  of tyArrayConstr, tyArray:
+    # In order to prevent a type change (TypedArray -> Array) and to have better copying performance,
+    # arrays constructors are considered separately
+    asm """
+      if(ArrayBuffer.isView(`src`)) { 
+        if(`dest` === null || `dest` === undefined || `dest`.length != `src`.length) {
+          `dest` = new `src`.constructor(`src`);
+        } else {
+          `dest`.set(`src`, 0);
+        }
+        `result` = `dest`;
+      } else {
+        if (`src` === null) {
+          `result` = null;
+        }
+        else {
+          if (`dest` === null || `dest` === undefined || `dest`.length != `src`.length) {
+            `dest` = new Array(`src`.length);
+          }
+          `result` = `dest`;
+          for (var i = 0; i < `src`.length; ++i) {
+            `result`[i] = nimCopy(`result`[i], `src`[i], `ti`.base);
+          }
+        }
+      }
+    """
+  of tySequence, tyOpenArray:
     asm """
       if (`src` === null) {
         `result` = null;
diff --git a/lib/system/memalloc.nim b/lib/system/memalloc.nim
index f8ebc8c5f66..49766e69db4 100644
--- a/lib/system/memalloc.nim
+++ b/lib/system/memalloc.nim
@@ -116,6 +116,9 @@ when hasAlloc and not defined(js):
     ##
     ## See also:
     ## * `create <#create,typedesc>`_
+    static:
+      when sizeof(T) <= 0:
+        {.fatal: "createU does not support types T where sizeof(T) == 0".}
     cast[ptr T](alloc(T.sizeof * size))
 
   template alloc0*(size: Natural): pointer =
@@ -141,6 +144,9 @@ when hasAlloc and not defined(js):
     ##
     ## The allocated memory belongs to its allocating thread!
     ## Use `createShared <#createShared,typedesc>`_ to allocate from a shared heap.
+    static:
+      when sizeof(T) <= 0:
+        {.fatal: "create does not support types T where sizeof(T) == 0".}
     cast[ptr T](alloc0(sizeof(T) * size))
 
   template realloc*(p: pointer, newSize: Natural): pointer =
diff --git a/lib/system/orc.nim b/lib/system/orc.nim
index 6273e1a216e..f9f5cd81fc6 100644
--- a/lib/system/orc.nim
+++ b/lib/system/orc.nim
@@ -79,10 +79,12 @@ proc trace(s: Cell; desc: PNimTypeV2; j: var GcEnv) {.inline.} =
     var p = s +! sizeof(RefHeader)
     cast[TraceProc](desc.traceImpl)(p, addr(j))
 
+include threadids
+
 when logOrc:
   proc writeCell(msg: cstring; s: Cell; desc: PNimTypeV2) =
-    cfprintf(cstderr, "%s %s %ld root index: %ld; RC: %ld; color: %ld\n",
-      msg, desc.name, s.refId, s.rootIdx, s.rc shr rcShift, s.color)
+    cfprintf(cstderr, "%s %s %ld root index: %ld; RC: %ld; color: %ld; thread: %ld\n",
+      msg, desc.name, s.refId, s.rootIdx, s.rc shr rcShift, s.color, getThreadId())
 
 proc free(s: Cell; desc: PNimTypeV2) {.inline.} =
   when traceCollector:
@@ -419,6 +421,7 @@ proc registerCycle(s: Cell; desc: PNimTypeV2) =
 proc GC_runOrc* =
   ## Forces a cycle collection pass.
   collectCycles()
+  orcAssert roots.len == 0, "roots not empty!"
 
 proc GC_enableOrc*() =
   ## Enables the cycle collector subsystem of `--gc:orc`. This is a `--gc:orc`
diff --git a/lib/system/platforms.nim b/lib/system/platforms.nim
index bd6541b6acf..b4c9f1f06e1 100644
--- a/lib/system/platforms.nim
+++ b/lib/system/platforms.nim
@@ -35,7 +35,9 @@ type
     msp430,                    ## TI MSP430 microcontroller
     riscv32,                   ## RISC-V 32-bit processor
     riscv64,                   ## RISC-V 64-bit processor
-    wasm32                     ## WASM, 32-bit
+    wasm32,                    ## WASM, 32-bit
+    e2k,                       ## MCST Elbrus 2000
+    loongarch64                ## LoongArch 64-bit processor
 
   OsPlatform* {.pure.} = enum ## the OS this program will run on.
     none, dos, windows, os2, linux, morphos, skyos, solaris,
@@ -93,5 +95,7 @@ const
                elif defined(riscv32): CpuPlatform.riscv32
                elif defined(riscv64): CpuPlatform.riscv64
                elif defined(wasm32): CpuPlatform.wasm32
+               elif defined(e2k): CpuPlatform.e2k
+               elif defined(loongarch64): CpuPlatform.loongarch64
                else: CpuPlatform.none
     ## the CPU this program will run on.
diff --git a/lib/system/threadids.nim b/lib/system/threadids.nim
new file mode 100644
index 00000000000..3a6eadcbbbc
--- /dev/null
+++ b/lib/system/threadids.nim
@@ -0,0 +1,103 @@
+#
+#
+#            Nim's Runtime Library
+#        (c) Copyright 2020 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+# we need to cache current threadId to not perform syscall all the time
+var threadId {.threadvar.}: int
+
+when defined(windows):
+  proc getCurrentThreadId(): int32 {.
+    stdcall, dynlib: "kernel32", importc: "GetCurrentThreadId".}
+
+  proc getThreadId*(): int =
+    ## Gets the ID of the currently running thread.
+    if threadId == 0:
+      threadId = int(getCurrentThreadId())
+    result = threadId
+
+elif defined(linux):
+  proc syscall(arg: clong): clong {.varargs, importc: "syscall", header: "<unistd.h>".}
+  when defined(amd64):
+    const NR_gettid = clong(186)
+  else:
+    var NR_gettid {.importc: "__NR_gettid", header: "<sys/syscall.h>".}: clong
+
+  proc getThreadId*(): int =
+    ## Gets the ID of the currently running thread.
+    if threadId == 0:
+      threadId = int(syscall(NR_gettid))
+    result = threadId
+
+elif defined(dragonfly):
+  proc lwp_gettid(): int32 {.importc, header: "unistd.h".}
+
+  proc getThreadId*(): int =
+    ## Gets the ID of the currently running thread.
+    if threadId == 0:
+      threadId = int(lwp_gettid())
+    result = threadId
+
+elif defined(openbsd):
+  proc getthrid(): int32 {.importc: "getthrid", header: "<unistd.h>".}
+
+  proc getThreadId*(): int =
+    ## Gets the ID of the currently running thread.
+    if threadId == 0:
+      threadId = int(getthrid())
+    result = threadId
+
+elif defined(netbsd):
+  proc lwp_self(): int32 {.importc: "_lwp_self", header: "<lwp.h>".}
+
+  proc getThreadId*(): int =
+    ## Gets the ID of the currently running thread.
+    if threadId == 0:
+      threadId = int(lwp_self())
+    result = threadId
+
+elif defined(freebsd):
+  proc syscall(arg: cint, arg0: ptr cint): cint {.varargs, importc: "syscall", header: "<unistd.h>".}
+  var SYS_thr_self {.importc:"SYS_thr_self", header:"<sys/syscall.h>".}: cint
+
+  proc getThreadId*(): int =
+    ## Gets the ID of the currently running thread.
+    var tid = 0.cint
+    if threadId == 0:
+      discard syscall(SYS_thr_self, addr tid)
+      threadId = tid
+    result = threadId
+
+elif defined(macosx):
+  proc syscall(arg: cint): cint {.varargs, importc: "syscall", header: "<unistd.h>".}
+  var SYS_thread_selfid {.importc:"SYS_thread_selfid", header:"<sys/syscall.h>".}: cint
+
+  proc getThreadId*(): int =
+    ## Gets the ID of the currently running thread.
+    if threadId == 0:
+      threadId = int(syscall(SYS_thread_selfid))
+    result = threadId
+
+elif defined(solaris):
+  type thread_t {.importc: "thread_t", header: "<thread.h>".} = distinct int
+  proc thr_self(): thread_t {.importc, header: "<thread.h>".}
+
+  proc getThreadId*(): int =
+    ## Gets the ID of the currently running thread.
+    if threadId == 0:
+      threadId = int(thr_self())
+    result = threadId
+
+elif defined(haiku):
+  type thr_id {.importc: "thread_id", header: "<OS.h>".} = distinct int32
+  proc find_thread(name: cstring): thr_id {.importc, header: "<OS.h>".}
+
+  proc getThreadId*(): int =
+    ## Gets the ID of the currently running thread.
+    if threadId == 0:
+      threadId = int(find_thread(nil))
+    result = threadId
diff --git a/lib/system/threadlocalstorage.nim b/lib/system/threadlocalstorage.nim
index 30962ef77fc..e772f270c59 100644
--- a/lib/system/threadlocalstorage.nim
+++ b/lib/system/threadlocalstorage.nim
@@ -29,9 +29,6 @@ when defined(windows):
   proc terminateThread(hThread: SysThread, dwExitCode: int32): int32 {.
     stdcall, dynlib: "kernel32", importc: "TerminateThread".}
 
-  proc getCurrentThreadId(): int32 {.
-    stdcall, dynlib: "kernel32", importc: "GetCurrentThreadId".}
-
   type
     ThreadVarSlot = distinct int32
 
diff --git a/lib/system/threads.nim b/lib/system/threads.nim
index a9006b0c5c0..0e5198035a0 100644
--- a/lib/system/threads.nim
+++ b/lib/system/threads.nim
@@ -190,7 +190,7 @@ when defined(windows):
     threadProcWrapperBody(closure)
     # implicitly return 0
 elif defined(genode):
-   proc threadProcWrapper[TArg](closure: pointer) {.noconv.} =
+  proc threadProcWrapper[TArg](closure: pointer) {.noconv.} =
     threadProcWrapperBody(closure)
 else:
   proc threadProcWrapper[TArg](closure: pointer): pointer {.noconv.} =
@@ -343,94 +343,5 @@ else:
 proc createThread*(t: var Thread[void], tp: proc () {.thread, nimcall.}) =
   createThread[void](t, tp)
 
-# we need to cache current threadId to not perform syscall all the time
-var threadId {.threadvar.}: int
-
-when defined(windows):
-  proc getThreadId*(): int =
-    ## Gets the ID of the currently running thread.
-    if threadId == 0:
-      threadId = int(getCurrentThreadId())
-    result = threadId
-
-elif defined(linux):
-  proc syscall(arg: clong): clong {.varargs, importc: "syscall", header: "<unistd.h>".}
-  when defined(amd64):
-    const NR_gettid = clong(186)
-  else:
-    var NR_gettid {.importc: "__NR_gettid", header: "<sys/syscall.h>".}: clong
-
-  proc getThreadId*(): int =
-    ## Gets the ID of the currently running thread.
-    if threadId == 0:
-      threadId = int(syscall(NR_gettid))
-    result = threadId
-
-elif defined(dragonfly):
-  proc lwp_gettid(): int32 {.importc, header: "unistd.h".}
-
-  proc getThreadId*(): int =
-    ## Gets the ID of the currently running thread.
-    if threadId == 0:
-      threadId = int(lwp_gettid())
-    result = threadId
-
-elif defined(openbsd):
-  proc getthrid(): int32 {.importc: "getthrid", header: "<unistd.h>".}
-
-  proc getThreadId*(): int =
-    ## get the ID of the currently running thread.
-    if threadId == 0:
-      threadId = int(getthrid())
-    result = threadId
-
-elif defined(netbsd):
-  proc lwp_self(): int32 {.importc: "_lwp_self", header: "<lwp.h>".}
-
-  proc getThreadId*(): int =
-    ## Gets the ID of the currently running thread.
-    if threadId == 0:
-      threadId = int(lwp_self())
-    result = threadId
-
-elif defined(freebsd):
-  proc syscall(arg: cint, arg0: ptr cint): cint {.varargs, importc: "syscall", header: "<unistd.h>".}
-  var SYS_thr_self {.importc:"SYS_thr_self", header:"<sys/syscall.h>".}: cint
-
-  proc getThreadId*(): int =
-    ## Gets the ID of the currently running thread.
-    var tid = 0.cint
-    if threadId == 0:
-      discard syscall(SYS_thr_self, addr tid)
-      threadId = tid
-    result = threadId
-
-elif defined(macosx):
-  proc syscall(arg: cint): cint {.varargs, importc: "syscall", header: "<unistd.h>".}
-  var SYS_thread_selfid {.importc:"SYS_thread_selfid", header:"<sys/syscall.h>".}: cint
-
-  proc getThreadId*(): int =
-    ## Gets the ID of the currently running thread.
-    if threadId == 0:
-      threadId = int(syscall(SYS_thread_selfid))
-    result = threadId
-
-elif defined(solaris):
-  type thread_t {.importc: "thread_t", header: "<thread.h>".} = distinct int
-  proc thr_self(): thread_t {.importc, header: "<thread.h>".}
-
-  proc getThreadId*(): int =
-    ## Gets the ID of the currently running thread.
-    if threadId == 0:
-      threadId = int(thr_self())
-    result = threadId
-
-elif defined(haiku):
-  type thr_id {.importc: "thread_id", header: "<OS.h>".} = distinct int32
-  proc find_thread(name: cstring): thr_id {.importc, header: "<OS.h>".}
-
-  proc getThreadId*(): int =
-    ## Gets the ID of the currently running thread.
-    if threadId == 0:
-      threadId = int(find_thread(nil))
-    result = threadId
+when not defined(gcOrc):
+  include threadids
diff --git a/lib/system_overview.rst b/lib/system_overview.rst
index df22697e012..0e4ffaf17c2 100644
--- a/lib/system_overview.rst
+++ b/lib/system_overview.rst
@@ -1,4 +1,5 @@
 .. default-role:: code
+.. include:: ../doc/rstcommon.rst
 
 The System module imports several separate modules, and their documentation
 is in separate files:
diff --git a/lib/windows/winlean.nim b/lib/windows/winlean.nim
index b8f3886d70d..6e626e4bacd 100644
--- a/lib/windows/winlean.nim
+++ b/lib/windows/winlean.nim
@@ -478,7 +478,7 @@ type
 
   PSockAddr = ptr SockAddr
 
-  InAddr* {.importc: "IN_ADDR", header: "winsock2.h".} = object
+  InAddr* {.importc: "IN_ADDR", header: "winsock2.h", union.} = object
     s_addr*: uint32  # IP address
 
   Sockaddr_in* {.importc: "SOCKADDR_IN",
diff --git a/lib/wrappers/openssl.nim b/lib/wrappers/openssl.nim
index c756fa938aa..00ec160cbc3 100644
--- a/lib/wrappers/openssl.nim
+++ b/lib/wrappers/openssl.nim
@@ -847,3 +847,17 @@ when not defined(nimDisableCertificateValidation) and not defined(windows):
     let cert = d2i_X509(certbytes)
     let encoded = cert.i2d_X509()
     assert encoded == certbytes
+
+# Application Layer Protocol Negociation extension (TLS-ALPN, RFC7301)
+# Available in at least OpenSSL 1.1.1 and later, not sure if earlier
+# --Iced Quinn
+
+proc SSL_CTX_set_alpn_protos*(ctx: SslCtx; protos: cstring; protos_len: cuint): cint {.cdecl, dynlib: DLLSSLName, importc.}
+proc SSL_set_alpn_protos*(ssl: SslPtr; protos: cstring; protos_len: cuint): cint {.cdecl, dynlib: DLLSSLName, importc.}
+proc SSL_CTX_set_alpn_select_cb*(ctx: SslCtx; cb: proc(ssl: SslPtr; out_proto: ptr cstring; outlen: cstring; in_proto: cstring; inlen: cuint; arg: pointer): cint {.cdecl.}; arg: pointer): cint {.cdecl, dynlib: DLLSSLName, importc.}
+proc SSL_get0_alpn_selected*(ssl: SslPtr; data: ptr cstring; len: ptr cuint) {.cdecl, dynlib: DLLSSLName, importc.}
+proc SSL_CTX_set_next_protos_advertised_cb*(ctx: SslCtx; cb: proc(ssl: SslPtr; out_proto: ptr cstring; outlen: ptr cuint; arg: pointer): cint {.cdecl.}; arg: pointer) {.cdecl, dynlib: DLLSSLName, importc.}
+proc SSL_CTX_set_next_proto_select_cb*(ctx: SslCtx; cb: proc(s: SslPtr; out_proto: cstring; outlen: cstring; in_proto: cstring; inlen: cuint; arg: pointer): cint {.cdecl.}; arg: pointer) {.cdecl, dynlib: DLLSSLName, importc.}
+proc SSL_select_next_proto*(out_proto: ptr cstring; outlen: cstring; server: cstring; server_len: cuint; client: cstring; client_len: cuint): cint {.cdecl, dynlib: DLLSSLName, importc.}
+proc SSL_get0_next_proto_negotiated*(s: SslPtr; data: ptr cstring; len: ptr cuint) {.cdecl, dynlib: DLLSSLName, importc.}
+
diff --git a/nimpretty/nimpretty.nim b/nimpretty/nimpretty.nim
index b35a46f87ad..2a4d87bf190 100644
--- a/nimpretty/nimpretty.nim
+++ b/nimpretty/nimpretty.nim
@@ -82,8 +82,8 @@ proc main =
 
   var backup = false
     # when `on`, create a backup file of input in case
-    # `prettyPrint` could over-write it (note that the backup may happen even
-    # if input is not actually over-written, when nimpretty is a noop).
+    # `prettyPrint` could overwrite it (note that the backup may happen even
+    # if input is not actually overwritten, when nimpretty is a noop).
     # --backup was un-documented (rely on git instead).
   var opt = PrettyOptions(indWidth: 0, maxLineLen: 80)
 
diff --git a/testament/testament.nim b/testament/testament.nim
index b7d3756a0e6..ae76e240b45 100644
--- a/testament/testament.nim
+++ b/testament/testament.nim
@@ -1021,7 +1021,6 @@ proc makeRawTest(test, options: string, cat: Category): TTest {.used.} =
 # TODO: fix these files
 const disabledFilesDefault = @[
   "LockFreeHash.nim",
-  "sharedstrings.nim",
   "tableimpl.nim",
   "setimpl.nim",
   "hashcommon.nim",
diff --git a/tests/arc/t18971.nim b/tests/arc/t18971.nim
new file mode 100644
index 00000000000..9b587d95624
--- /dev/null
+++ b/tests/arc/t18971.nim
@@ -0,0 +1,10 @@
+discard """
+  cmd: "nim c --gc:arc $file"
+"""
+
+type MyObj = ref object
+
+var o = MyObj()
+proc x: var MyObj = o
+
+var o2 = x()
diff --git a/tests/arc/tarc_orc.nim b/tests/arc/tarc_orc.nim
new file mode 100644
index 00000000000..861e36df0c7
--- /dev/null
+++ b/tests/arc/tarc_orc.nim
@@ -0,0 +1,22 @@
+discard """
+  matrix: "--gc:arc; --gc:orc"
+"""
+
+block:
+  type
+    PublicKey = array[32, uint8]
+    PrivateKey = array[64, uint8]
+
+  proc ed25519_create_keypair(publicKey: ptr PublicKey; privateKey: ptr PrivateKey) =
+    publicKey[][0] = uint8(88)
+
+  type
+    KeyPair = object
+      public: PublicKey
+      private: PrivateKey
+
+  proc initKeyPair(): KeyPair =
+    ed25519_create_keypair(result.public.addr, result.private.addr)
+
+  let keys = initKeyPair()
+  doAssert keys.public[0] == 88
diff --git a/tests/arc/tarcmisc.nim b/tests/arc/tarcmisc.nim
index d259e119720..45d1514cd22 100644
--- a/tests/arc/tarcmisc.nim
+++ b/tests/arc/tarcmisc.nim
@@ -30,6 +30,7 @@ ok
 true
 copying
 123
+42
 closed
 destroying variable: 20
 destroying variable: 10
@@ -482,3 +483,17 @@ method testMethod(self: BrokenObject) {.base.} =
 
 let mikasa = BrokenObject()
 mikasa.testMethod()
+
+# bug #19205
+type
+  InputSectionBase* = object of RootObj
+    relocations*: seq[int]   # traced reference. string has a similar SIGSEGV.
+  InputSection* = object of InputSectionBase
+
+proc fooz(sec: var InputSectionBase) =
+  if sec of InputSection:  # this line SIGSEGV.
+    echo 42
+
+var sec = create(InputSection)
+sec[] = InputSection(relocations: newSeq[int]())
+fooz sec[]
diff --git a/tests/arc/tconst_to_sink.nim b/tests/arc/tconst_to_sink.nim
index ddcc46e67ee..25f65934195 100644
--- a/tests/arc/tconst_to_sink.nim
+++ b/tests/arc/tconst_to_sink.nim
@@ -1,6 +1,7 @@
 discard """
   output: '''@[(s1: "333", s2: ""), (s1: "abc", s2: "def"), (s1: "3x", s2: ""), (s1: "3x", s2: ""), (s1: "3x", s2: ""), (s1: "3x", s2: ""), (s1: "lastone", s2: "")]'''
-  cmd: "nim c --gc:arc $file"
+  matrix: "--gc:arc"
+  targets: "c cpp"
 """
 
 # bug #13240
diff --git a/tests/arc/tcustomtrace.nim b/tests/arc/tcustomtrace.nim
index 3977194d942..5e0ecfb2484 100644
--- a/tests/arc/tcustomtrace.nim
+++ b/tests/arc/tcustomtrace.nim
@@ -130,7 +130,7 @@ proc createSeq*[T](elems: varargs[T]): myseq[T] =
   result.data = cast[type(result.data)](alloc0(result.cap * sizeof(T)))
   inc allocCount
   when supportsCopyMem(T):
-    copyMem(result.data, unsafeAddr(elems[0]), result.cap * sizeof(T))
+    copyMem(result.data, addr(elems[0]), result.cap * sizeof(T))
   else:
     for i in 0..<result.len:
       result.data[i] = elems[i]
diff --git a/tests/arc/thard_alignment.nim b/tests/arc/thard_alignment.nim
index e644572f07a..baa964c77db 100644
--- a/tests/arc/thard_alignment.nim
+++ b/tests/arc/thard_alignment.nim
@@ -18,7 +18,7 @@ type
 proc set1(x: float): m256d {.importc: "_mm256_set1_pd", header: "immintrin.h".}
 func `+`(a,b: m256d): m256d {.importc: "_mm256_add_pd", header: "immintrin.h".}
 proc `$`(a: m256d): string =  
-  result = $(cast[ptr float](a.unsafeAddr)[])
+  result = $(cast[ptr float](a.addr)[])
 
 
 var res: seq[seq[m256d]]
diff --git a/tests/ccgbugs/tmangle.nim b/tests/ccgbugs/tmangle.nim
new file mode 100644
index 00000000000..0050cef921c
--- /dev/null
+++ b/tests/ccgbugs/tmangle.nim
@@ -0,0 +1,16 @@
+block:
+  proc hello() =
+    let NAN_INFINITY = 12
+    doAssert NAN_INFINITY == 12
+    let INF = "2.0"
+    doAssert INF == "2.0"
+    let NAN = 2.3
+    doAssert NAN == 2.3
+
+  hello()
+
+block:
+  proc hello(NAN: float) =
+    doAssert NAN == 2.0
+
+  hello(2.0)
diff --git a/tests/ccgbugs/tnoalias.nim b/tests/ccgbugs/tnoalias.nim
index 0c6e84e44b5..f200992d752 100644
--- a/tests/ccgbugs/tnoalias.nim
+++ b/tests/ccgbugs/tnoalias.nim
@@ -7,7 +7,7 @@ type
     field {.noalias.}: ptr UncheckedArray[int]
 
 proc p(x {.noalias.}: openArray[char]) =
-  var q {.noalias.}: pointer = unsafeAddr(x[0])
+  var q {.noalias.}: pointer = addr(x[0])
 
 var bn: BigNum
 p "abc"
diff --git a/tests/compiles/t8630.nim b/tests/compiles/t8630.nim
index aa2be11cd5e..8b447d06109 100644
--- a/tests/compiles/t8630.nim
+++ b/tests/compiles/t8630.nim
@@ -7,7 +7,7 @@ bar
 
 proc test(strings: seq[string]) =
   for s in strings:
-    var p3 = unsafeAddr(s)
+    var p3 = addr(s)
     echo p3[]
 
 test(@["foo", "bar"])
diff --git a/tests/concepts/tconcepts_issues.nim b/tests/concepts/tconcepts_issues.nim
index c76049bddef..418faf6981f 100644
--- a/tests/concepts/tconcepts_issues.nim
+++ b/tests/concepts/tconcepts_issues.nim
@@ -484,10 +484,10 @@ type
 var address = pointer(nil)
 proc prod(r: var QuadraticExt, b: QuadraticExt) =
   if address == nil:
-    address = unsafeAddr b
+    address = addr b
     prod(r, b)
   else:
-    assert address == unsafeAddr b
+    assert address == addr b
 
 type
   Fp2[N: static int, T] {.byref.} = object
diff --git a/tests/converter/mdontleak.nim b/tests/converter/mdontleak.nim
new file mode 100644
index 00000000000..e55c3f87c2f
--- /dev/null
+++ b/tests/converter/mdontleak.nim
@@ -0,0 +1,3 @@
+
+converter toBool(x: uint32): bool = x != 0
+# Note: This convertes is not exported!
diff --git a/tests/converter/tdontleak.nim b/tests/converter/tdontleak.nim
new file mode 100644
index 00000000000..4965fa90adc
--- /dev/null
+++ b/tests/converter/tdontleak.nim
@@ -0,0 +1,10 @@
+discard """
+  output: '''5'''
+joinable: false
+"""
+
+import mdontleak
+# bug #19213
+
+let a = 5'u32
+echo a
diff --git a/tests/cpp/torc.nim b/tests/cpp/torc.nim
new file mode 100644
index 00000000000..7fc474f94d4
--- /dev/null
+++ b/tests/cpp/torc.nim
@@ -0,0 +1,15 @@
+discard """
+  targets: "cpp"
+  matrix: "--gc:orc"
+"""
+
+import std/options
+
+# bug #18410
+type
+  O = object of RootObj
+   val: pointer
+
+proc p(): Option[O] = none(O)
+
+doAssert $p() == "none(O)"
\ No newline at end of file
diff --git a/tests/destructor/t12037.nim b/tests/destructor/t12037.nim
index c2c41dfb54e..30266690ffd 100644
--- a/tests/destructor/t12037.nim
+++ b/tests/destructor/t12037.nim
@@ -9,11 +9,11 @@ copy length and contents 1 @[42]
 proc test() =
   var sq1 = @[42]
   echo "showing original type, length, and contents ", sq1.typeof, " ", sq1.len, " ", sq1
-  doAssert cast[int](sq1[0].unsafeAddr) != 0
+  doAssert cast[int](sq1[0].addr) != 0
   var sq2 = sq1 # copy of original
   echo "copy length and contents ", sq2.len, " ", sq2
-  doAssert cast[int](sq2[0].unsafeAddr) != 0
-  doAssert cast[int](sq1[0].unsafeAddr) != 0
+  doAssert cast[int](sq2[0].addr) != 0
+  doAssert cast[int](sq1[0].addr) != 0
 
 test()
 
diff --git a/tests/destructor/tarray_indexing.nim b/tests/destructor/tarray_indexing.nim
index 657101c4d26..a9dfdf4ed22 100644
--- a/tests/destructor/tarray_indexing.nim
+++ b/tests/destructor/tarray_indexing.nim
@@ -63,7 +63,7 @@ proc fillPages*(mem: UserProcessMemory, start: uint32, data: seq[byte]) =
         #echo cast[uint64](addr mem.pageAccess[i])
         let page = mem.pageAccess[i]
         assert page != nil
-        #copyMem(page, unsafeAddr data[i * 0x1000 - start], 0x1000)
+        #copyMem(page, addr data[i * 0x1000 - start], 0x1000)
 
 const base = 0x00100000
 
diff --git a/tests/destructor/tcustomseqs.nim b/tests/destructor/tcustomseqs.nim
index 4087dc4a83d..17a19f871f8 100644
--- a/tests/destructor/tcustomseqs.nim
+++ b/tests/destructor/tcustomseqs.nim
@@ -121,7 +121,7 @@ proc createSeq*[T](elems: varargs[T]): myseq[T] =
   result.data = cast[type(result.data)](alloc(result.cap * sizeof(T)))
   inc allocCount
   when supportsCopyMem(T):
-    copyMem(result.data, unsafeAddr(elems[0]), result.cap * sizeof(T))
+    copyMem(result.data, addr(elems[0]), result.cap * sizeof(T))
   else:
     for i in 0..<result.len:
       result.data[i] = elems[i]
diff --git a/tests/destructor/tcustomstrings.nim b/tests/destructor/tcustomstrings.nim
index 9ee2da33a42..119bfec2c5c 100644
--- a/tests/destructor/tcustomstrings.nim
+++ b/tests/destructor/tcustomstrings.nim
@@ -75,7 +75,7 @@ proc add*(self: var mystring; y: mystring) =
 proc create*(lit: string): mystring =
   let newLen = lit.len
   ensure(result, newLen)
-  copyMem(addr result.data[result.len], unsafeAddr lit[0], newLen + 1)
+  copyMem(addr result.data[result.len], addr lit[0], newLen + 1)
   result.len = newLen
 
 proc `&`*(a, b: mystring): mystring =
diff --git a/tests/destructor/tuse_result_prevents_sinks.nim b/tests/destructor/tuse_result_prevents_sinks.nim
index d2777bd9769..e74c16da36f 100644
--- a/tests/destructor/tuse_result_prevents_sinks.nim
+++ b/tests/destructor/tuse_result_prevents_sinks.nim
@@ -18,7 +18,7 @@ proc `=sink`(self: var Foo; other: Foo) =
 proc `=destroy`(self: var Foo) = discard
 
 template preventCursorInference(x) =
-  let p = unsafeAddr(x)
+  let p = addr(x)
 
 proc test(): Foo =
   result = Foo()
diff --git a/tests/errmsgs/t10594.nim b/tests/errmsgs/t10594.nim
index c9506c5425e..d27dd64332c 100644
--- a/tests/errmsgs/t10594.nim
+++ b/tests/errmsgs/t10594.nim
@@ -3,5 +3,5 @@ discard """
   line: 7
 """
 
-template foo(v: varargs[int]) = unsafeAddr v 
+template foo(v: varargs[int]) = addr v 
 foo(1, 2)
diff --git a/tests/errmsgs/t10735.nim b/tests/errmsgs/t10735.nim
index 9d28d335b46..02b15c44597 100644
--- a/tests/errmsgs/t10735.nim
+++ b/tests/errmsgs/t10735.nim
@@ -1,10 +1,10 @@
 discard """
   cmd: "nim check $file"
-  errormsg: "selector must be of an ordinal type, float, or string"
+  action: reject
   nimout: '''
-t10735.nim(38, 5) Error: 'let' symbol requires an initialization
-t10735.nim(39, 10) Error: undeclared identifier: 'pos'
-t10735.nim(39, 9) Error: type mismatch: got <cstring, >
+t10735.nim(37, 5) Error: 'let' symbol requires an initialization
+t10735.nim(38, 10) Error: undeclared identifier: 'pos'
+t10735.nim(38, 9) Error: type mismatch: got <cstring, >
 but expected one of:
 proc `[]`(s: string; i: BackwardsIndex): char
   first type mismatch at position: 0
@@ -30,7 +30,6 @@ template `[]`(s: string; i: int): char
   first type mismatch at position: 0
 
 expression: `[]`(buf, pos)
-t10735.nim(39, 9) Error: selector must be of an ordinal type, float, or string
 '''
   joinable: false
 """
diff --git a/tests/errmsgs/tnon_concrete_cast.nim b/tests/errmsgs/tnon_concrete_cast.nim
index e4ae890ce80..9e05c736c7e 100644
--- a/tests/errmsgs/tnon_concrete_cast.nim
+++ b/tests/errmsgs/tnon_concrete_cast.nim
@@ -34,7 +34,7 @@ proc write(rw: var MyReadWrite; value: SomeNumber): void =
 proc write[T](rw: var MyReadWrite; value: seq[T]): void =
   rw.write value.len
   let dst  = cast[ptr SomeNumber](cast[uint](rw.memfile.mem) + uint(rw.offset))
-  let src  = cast[pointer](value[0].unsafeAddr)
+  let src  = cast[pointer](value[0].addr)
   let size = sizeof(T) * value.len
   copyMem(dst, src, size)
   rw.offset += size
diff --git a/tests/exception/texceptions.nim b/tests/exception/texceptions.nim
index adee5d1d5b8..62d24c9341c 100644
--- a/tests/exception/texceptions.nim
+++ b/tests/exception/texceptions.nim
@@ -1,4 +1,6 @@
 discard """
+  disabled: "windows" # no sigsetjmp() there
+  matrix: "-d:nimStdSetjmp; -d:nimSigSetjmp; -d:nimRawSetjmp; -d:nimBuiltinSetjmp"
   output: '''
 
 BEFORE
@@ -17,7 +19,7 @@ FINALLY
 
 echo ""
 
-proc no_expcetion =
+proc no_exception =
   try:
     echo "BEFORE"
 
@@ -28,7 +30,7 @@ proc no_expcetion =
   finally:
     echo "FINALLY"
 
-try: no_expcetion()
+try: no_exception()
 except: echo "RECOVER"
 
 echo ""
diff --git a/tests/exception/texceptions2.nim b/tests/exception/texceptions2.nim
new file mode 100644
index 00000000000..97fd856a027
--- /dev/null
+++ b/tests/exception/texceptions2.nim
@@ -0,0 +1,130 @@
+discard """
+  disabled: "posix" # already covered by texceptions.nim
+  matrix: "-d:nimStdSetjmp; -d:nimRawSetjmp; -d:nimBuiltinSetjmp"
+  output: '''
+
+BEFORE
+FINALLY
+
+BEFORE
+EXCEPT
+FINALLY
+RECOVER
+
+BEFORE
+EXCEPT: IOError: hi
+FINALLY
+'''
+"""
+
+echo ""
+
+proc no_exception =
+  try:
+    echo "BEFORE"
+
+  except:
+    echo "EXCEPT"
+    raise
+
+  finally:
+    echo "FINALLY"
+
+try: no_exception()
+except: echo "RECOVER"
+
+echo ""
+
+proc reraise_in_except =
+  try:
+    echo "BEFORE"
+    raise newException(IOError, "")
+
+  except IOError:
+    echo "EXCEPT"
+    raise
+
+  finally:
+    echo "FINALLY"
+
+try: reraise_in_except()
+except: echo "RECOVER"
+
+echo ""
+
+proc return_in_except =
+  try:
+    echo "BEFORE"
+    raise newException(IOError, "hi")
+
+  except:
+    echo "EXCEPT: ", getCurrentException().name, ": ", getCurrentExceptionMsg()
+    return
+
+  finally:
+    echo "FINALLY"
+
+try: return_in_except()
+except: echo "RECOVER"
+
+block: #10417
+  proc moo() {.noreturn.} = discard
+
+  let bar =
+    try:
+      1
+    except:
+      moo()
+
+  doAssert(bar == 1)
+
+# Make sure the VM handles the exceptions correctly
+block:
+  proc fun1(): seq[int] =
+    try:
+      try:
+        raise newException(ValueError, "xx")
+      except:
+        doAssert("xx" == getCurrentExceptionMsg())
+        raise newException(KeyError, "yy")
+    except:
+      doAssert("yy" == getCurrentExceptionMsg())
+      result.add(1212)
+    try:
+      try:
+        raise newException(AssertionDefect, "a")
+      finally:
+        result.add(42)
+    except AssertionDefect:
+      result.add(99)
+    finally:
+      result.add(10)
+    result.add(4)
+    result.add(0)
+    try:
+      result.add(1)
+    except KeyError:
+      result.add(-1)
+    except ValueError:
+      result.add(-1)
+    except IndexDefect:
+      result.add(2)
+    except:
+      result.add(3)
+
+    try:
+      try:
+        result.add(1)
+        return
+      except:
+        result.add(-1)
+      finally:
+        result.add(2)
+    except KeyError:
+      doAssert(false)
+    finally:
+      result.add(3)
+
+  let x1 = fun1()
+  const x2 = fun1()
+  doAssert(x1 == x2)
diff --git a/tests/generics/tgenerics_issues.nim b/tests/generics/tgenerics_issues.nim
index 9e70efcd292..d78c36ab655 100644
--- a/tests/generics/tgenerics_issues.nim
+++ b/tests/generics/tgenerics_issues.nim
@@ -860,3 +860,15 @@ type
 
 var a: Tile3[int]
 
+block: # Ensure no segfault from constraint
+  type
+    Regex[A: SomeOrdinal] = ref object
+      val: Regex[A]
+    MyConstraint = (seq or enum or set)
+    MyOtherType[A: MyConstraint] = ref object
+      val: MyOtherType[A]
+
+  var
+    a = Regex[int]()
+    b = Regex[bool]()
+    c = MyOtherType[seq[int]]()
diff --git a/tests/js/tfieldchecks.nim b/tests/js/tfieldchecks.nim
index 3916cae74a4..a0679a34906 100644
--- a/tests/js/tfieldchecks.nim
+++ b/tests/js/tfieldchecks.nim
@@ -30,7 +30,7 @@ block:
 block:
   let a0 = addr(obj.f0)
   echo a0[]
-  # let a1 = unsafeAddr(obj.f1)
+  # let a1 = addr(obj.f1)
   # echo a1[]
   doAssertRaises(FieldDefect):
     let a2 = addr(obj.f2)
diff --git a/tests/js/tlent.nim b/tests/js/tlent.nim
new file mode 100644
index 00000000000..2546e5b1dee
--- /dev/null
+++ b/tests/js/tlent.nim
@@ -0,0 +1,33 @@
+discard """
+  output: '''
+hmm
+100
+hmm
+100
+'''
+"""
+
+# #16800
+
+type A = object
+  b: int
+var t = A(b: 100)
+block:
+  proc getValues: lent int =
+    echo "hmm"
+    result = t.b
+  echo getValues()
+block:
+  proc getValues: lent int =
+    echo "hmm"
+    t.b
+  echo getValues()
+
+when false: # still an issue, #16908
+  template main =
+    iterator fn[T](a:T): lent T = yield a
+    let a = @[10]
+    for b in fn(a): echo b
+
+  static: main()
+  main()
diff --git a/tests/js/tstdlib_imports.nim b/tests/js/tstdlib_imports.nim
index 07a9dbb180d..8633c48789b 100644
--- a/tests/js/tstdlib_imports.nim
+++ b/tests/js/tstdlib_imports.nim
@@ -7,46 +7,48 @@ discard """
 import std/[
   # Core:
   bitops, typetraits, lenientops, macros, volatile, typeinfo,
-  # fails: endians, rlocks
-  # works but shouldn't: cpuinfo, locks
+  # fails due to FFI: rlocks
+  # fails due to cstring cast/copyMem: endians
+  # works but uses FFI: cpuinfo, locks
 
   # Algorithms:
-  algorithm, sequtils,
+  algorithm, enumutils, sequtils, setutils,
   
   # Collections:
   critbits, deques, heapqueue, intsets, lists, options, sets,
-  sharedlist, tables,
-  # fails: sharedtables
+  tables, packedsets,
 
   # Strings:
   cstrutils, editdistance, wordwrap, parseutils, ropes,
   pegs, punycode, strformat, strmisc, strscans, strtabs,
   strutils, unicode, unidecode,
-  # fails: encodings
+  # fails due to FFI: encodings
 
   # Time handling:
   monotimes, times,
 
   # Generic operator system services:
   os, streams,
-  # fails: distros, dynlib, marshal, memfiles, osproc, terminal
+  # fails intentionally: dynlib, marshal, memfiles
+  # fails due to FFI: osproc, terminal
+  # fails due to osproc import: distros
 
   # Math libraries:
-  complex, math, mersenne, random, rationals, stats, sums,
-  # works but shouldn't: fenv
+  complex, math, random, rationals, stats, sums, sysrand,
+  # works but uses FFI: fenv
 
   # Internet protocols:
   cookies, httpcore, mimetypes, uri,
-  # fails: asyncdispatch, asyncfile, asyncftpclient, asynchttpserver,
+  # fails due to FFI: asyncdispatch, asyncfile, asyncftpclient, asynchttpserver,
   # asyncnet, cgi, httpclient, nativesockets, net, selectors, smtp
-  # works but shouldn't test: asyncstreams, asyncfutures
+  # works but no need to test: asyncstreams, asyncfutures
   
   # Threading:
-  # fails: threadpool
+  # fails due to FFI: threadpool
 
   # Parsers:
   htmlparser, json, lexbase, parsecfg, parsecsv, parsesql, parsexml,
-  parseopt,
+  parseopt, jsonutils,
 
   # XML processing:
   xmltree, xmlparser,
@@ -56,16 +58,19 @@ import std/[
 
   # Hashing:
   base64, hashes,
-  # fails: md5, oids, sha1
+  # fails due to cstring cast/zeroMem/copyMem/moveMem: md5
+  # fails due to cstring cast/endians import: oids
+  # fails due to copyMem/endians import: sha1
 
   # Miscellaneous:
-  colors, logging, sugar, unittest, varints,
-  # fails: browsers
-  # works but shouldn't: segfaults
+  colors, logging, sugar, unittest, varints, enumerate, with,
+  # fails due to FFI: browsers
+  # works but uses FFI: segfaults
 
   # Modules for JS backend:
-  asyncjs, dom, jsconsole, jscore, jsffi,
+  asyncjs, dom, jsconsole, jscore, jsffi, jsbigints,
 
   # Unlisted in lib.html:
-  compilesettings, with, wrapnils
+  compilesettings, wrapnils, exitprocs, effecttraits,
+  genasts, importutils, isolation, jsfetch, jsformdata, jsheaders
 ]
diff --git a/tests/lent/tbasic_lent_check.nim b/tests/lent/tbasic_lent_check.nim
index 049fa276a01..5323ed47157 100644
--- a/tests/lent/tbasic_lent_check.nim
+++ b/tests/lent/tbasic_lent_check.nim
@@ -17,22 +17,26 @@ proc main =
 main()
 
 template main2 = # bug #15958
+  when defined(js):
+    proc sameAddress[T](a, b: T): bool {.importjs: "(# === #)".}
+  else:
+    template sameAddress(a, b): bool = a.unsafeAddr == b.unsafeAddr
   proc byLent[T](a: T): lent T = a
   let a = [11,12]
   let b = @[21,23]
   let ss = {1, 2, 3, 5}
   doAssert byLent(a) == [11,12]
-  doAssert byLent(a).unsafeAddr == a.unsafeAddr
+  doAssert sameAddress(byLent(a), a)
   doAssert byLent(b) == @[21,23]
-  when not defined(js): # pending bug #16073
-    doAssert byLent(b).unsafeAddr == b.unsafeAddr
+  # pending bug #16073
+  doAssert sameAddress(byLent(b), b)
   doAssert byLent(ss) == {1, 2, 3, 5}
-  doAssert byLent(ss).unsafeAddr == ss.unsafeAddr
+  doAssert sameAddress(byLent(ss), ss)
 
   let r = new(float)
   r[] = 10.0
-  when not defined(js): # pending bug #16073
-    doAssert byLent(r)[] == 10.0
+  # bug #16073
+  doAssert byLent(r)[] == 10.0
 
   when not defined(js): # pending bug https://github.com/timotheecour/Nim/issues/372
     let p = create(float)
@@ -41,9 +45,9 @@ template main2 = # bug #15958
 
   proc byLent2[T](a: openarray[T]): lent T = a[0]
   doAssert byLent2(a) == 11
-  doAssert byLent2(a).unsafeAddr == a[0].unsafeAddr
+  doAssert sameAddress(byLent2(a), a[0])
   doAssert byLent2(b) == 21
-  doAssert byLent2(b).unsafeAddr == b[0].unsafeAddr
+  doAssert sameAddress(byLent2(b), b[0])
 
   proc byLent3[T](a: varargs[T]): lent T = a[1]
   let 
diff --git a/tests/macros/tcasestmtmacro.nim b/tests/macros/tcasestmtmacro.nim
index 26519f637c7..32019a92a6c 100644
--- a/tests/macros/tcasestmtmacro.nim
+++ b/tests/macros/tcasestmtmacro.nim
@@ -4,8 +4,6 @@ yes
 '''
 """
 
-{.experimental: "caseStmtMacros".}
-
 import macros
 
 macro `case`(n: tuple): untyped =
diff --git a/tests/macros/tmacros_various.nim b/tests/macros/tmacros_various.nim
index 00d74cb5c97..d702db56a81 100644
--- a/tests/macros/tmacros_various.nim
+++ b/tests/macros/tmacros_various.nim
@@ -23,6 +23,8 @@ x: some string
 ([("key", "val"), ("keyB", "2")], [("val", "key"), ("2", "keyB")])
 ([("key", "val"), ("keyB", "2")], [("val", "key"), ("2", "keyB")])
 0
+0
+0
 '''
 """
 
@@ -270,3 +272,61 @@ block: # bug #13511
 
     debugAst:
       add(foo(), component)
+
+block: # bug #15118
+  macro flop(name: static string) =
+    let id = genSym(nskType, "env")
+    let r =
+      nnkStmtList.newTree(
+        nnkTypeSection.newTree(
+          nnkTypeDef.newTree(
+            id,
+            newEmptyNode(),
+            nnkRefTy.newTree(
+              nnkObjectTy.newTree(
+                newEmptyNode(),
+                newEmptyNode(),
+                nnkRecList.newTree(
+                  nnkIdentDefs.newTree(
+                    newIdentNode(name),
+                    newIdentNode("int"),
+                    newEmptyNode()
+                  )
+                )
+              ) 
+            )
+          )
+        ),
+
+        # var f: T
+  
+        nnkVarSection.newTree(
+          nnkIdentDefs.newTree(
+            newIdentNode("f"),
+            id,
+            newEmptyNode()
+          )
+        ),
+
+        # echo f.a
+        nnkCommand.newTree(
+          newIdentNode("new"),
+          newIdentNode("f")
+        ),
+
+        nnkCommand.newTree(
+          newIdentNode("echo"),
+          nnkDotExpr.newTree(
+            newIdentNode("f"),
+            newIdentNode(name)
+          )
+        )
+      )
+    r
+
+
+  block:
+    flop("a")
+
+  block:
+    flop("b")
diff --git a/tests/misc/taddr.nim b/tests/misc/taddr.nim
index bac26896d32..631c9f265d2 100644
--- a/tests/misc/taddr.nim
+++ b/tests/misc/taddr.nim
@@ -83,7 +83,7 @@ block:
   # bug #14576
   # lots of these used to give: Error: internal error: genAddr: 2
   proc byLent[T](a: T): lent T = a
-  proc byPtr[T](a: T): ptr T = a.unsafeAddr
+  proc byPtr[T](a: T): ptr T = a.addr
 
   block:
     let a = (10,11)
diff --git a/tests/overload/t8829.nim b/tests/overload/t8829.nim
index a688e18cbda..fe0dbf2bf39 100644
--- a/tests/overload/t8829.nim
+++ b/tests/overload/t8829.nim
@@ -4,7 +4,7 @@ block:
   template `[]`[T](p: ptr T, span: Slice[int]): untyped =
     toOpenArray(cast[ptr array[0, T]](p)[], span.a, span.b)
 
-  doAssert $cast[ptr uint8](txt[0].unsafeAddr)[0 ..< txt.len] == 
+  doAssert $cast[ptr uint8](txt[0].addr)[0 ..< txt.len] == 
                 "[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]"
 
 
@@ -14,5 +14,5 @@ block:
   template `[]`[T](p: ptr T, span: Slice[int]): untyped =
     toOpenArray(cast[ptr array[0, T]](p)[], span.a, span.b)
 
-  doAssert $cast[ptr uint8](txt[0].unsafeAddr)[0 ..< txt.len] == 
+  doAssert $cast[ptr uint8](txt[0].addr)[0 ..< txt.len] == 
                 "[72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]"
diff --git a/tests/overload/tstatic_with_converter.nim b/tests/overload/tstatic_with_converter.nim
index 8209e839987..e830e8a2230 100644
--- a/tests/overload/tstatic_with_converter.nim
+++ b/tests/overload/tstatic_with_converter.nim
@@ -42,7 +42,7 @@ proc `^`(x: vfloat, exp: static[float]): vfloat =
    pow(x, exp)
  
 proc `$`(x: vfloat): string =
-  let y = cast[ptr float](unsafeAddr x)
+  let y = cast[ptr float](addr x)
   # xxx not sure if intentional in this issue, but this returns ""
   echo y[]
  
diff --git a/tests/parser/tdo.nim b/tests/parser/tdo.nim
index 7bd1f741162..382d033985b 100644
--- a/tests/parser/tdo.nim
+++ b/tests/parser/tdo.nim
@@ -1,8 +1,12 @@
 discard """
-  output: '''true
+  output: '''
 true
 true
-true inner B'''
+true
+true inner B
+running with pragma
+ran with pragma
+'''
 """
 
 template withValue(a, b, c, d, e: untyped) =
@@ -77,3 +81,14 @@ proc main2 =
       echo "true inner B"
 
 main2()
+
+proc withPragma(foo: int, bar: proc() {.raises: [].}) =
+  echo "running with pragma"
+  bar()
+
+withPragma(3) do {.raises: [].}:
+  echo "ran with pragma"
+
+doAssert not (compiles do:
+  withPragma(3) do {.raises: [].}:
+    raise newException(Exception))
diff --git a/tests/pragmas/tcustom_pragma.nim b/tests/pragmas/tcustom_pragma.nim
index df7c5ffb04d..d1ab3fc219c 100644
--- a/tests/pragmas/tcustom_pragma.nim
+++ b/tests/pragmas/tcustom_pragma.nim
@@ -17,10 +17,26 @@ block:
     MyObj = object
       myField1, myField2 {.myAttr: "hi".}: int
 
+    MyGenericObj[T] = object
+      myField1, myField2 {.myAttr: "hi".}: int
+
+    MyOtherObj = MyObj
+
+
   var o: MyObj
   static:
     doAssert o.myField2.hasCustomPragma(myAttr)
     doAssert(not o.myField1.hasCustomPragma(myAttr))
+    doAssert(not o.myField1.hasCustomPragma(MyObj))
+    doAssert(not o.myField1.hasCustomPragma(MyOtherObj))
+
+  var ogen: MyGenericObj[int]
+  static:
+    doAssert ogen.myField2.hasCustomPragma(myAttr)
+    doAssert(not ogen.myField1.hasCustomPragma(myAttr))
+    doAssert(not ogen.myField1.hasCustomPragma(MyGenericObj))
+    doAssert(not ogen.myField1.hasCustomPragma(MyGenericObj))
+
 
 import custom_pragma
 block: # A bit more advanced case
diff --git a/tests/proc/t15949.nim b/tests/proc/t15949.nim
new file mode 100644
index 00000000000..bc3fddc842a
--- /dev/null
+++ b/tests/proc/t15949.nim
@@ -0,0 +1,20 @@
+# bug #15949
+
+discard """
+errormsg: "parameter 'a' requires a type"
+nimout: '''
+t15949.nim(20, 14) Error: parameter 'a' requires a type'''
+"""
+
+
+# line 10
+proc procGood(a, b = 1): (int, int) = (a, b)
+
+doAssert procGood() == (1, 1)
+doAssert procGood(b = 3) == (1, 3)
+doAssert procGood(a = 2) == (2, 1)
+doAssert procGood(a = 5, b = 6) == (5, 6)
+
+# The type (and default value propagation breaks in the below example
+# as semicolon is used instead of comma.
+proc procBad(a; b = 1): (int, int) = (a, b)
diff --git a/tests/sets/t15435.nim b/tests/sets/t15435.nim
new file mode 100644
index 00000000000..5ead7e641be
--- /dev/null
+++ b/tests/sets/t15435.nim
@@ -0,0 +1,29 @@
+# bug #15435
+discard """
+errormsg: "type mismatch: got <set[uint8], set[range 1..5(uint8)]>"
+nimout: '''t15435.nim(28, 13) Error: type mismatch: got <set[uint8], set[range 1..5(uint8)]>
+but expected one of:
+proc `<`[T](x, y: set[T]): bool
+  first type mismatch at position: 2
+  required type for y: set[T]
+  but expression 'x' is of type: set[range 1..5(uint8)]
+20 other mismatching symbols have been suppressed; compile with --showAllMismatches:on to see them
+
+expression: {1'u8, 5} < x'''
+"""
+
+
+
+
+
+
+## line 20
+var
+  x: set[range[1u8..5u8]]
+
+x.incl(1)
+x.incl(3)
+x.incl(5)
+
+if {1u8, 5} < x:
+  echo "successful"
diff --git a/tests/stdlib/concurrency/atomicSample.nim b/tests/stdlib/concurrency/atomicSample.nim
new file mode 100644
index 00000000000..d56d867df3e
--- /dev/null
+++ b/tests/stdlib/concurrency/atomicSample.nim
@@ -0,0 +1,9 @@
+import atomics
+
+type
+  AtomicWithGeneric*[T] = object
+    value: Atomic[T]
+
+proc initAtomicWithGeneric*[T](value: T): AtomicWithGeneric[T] =
+  result.value.store(value)
+
diff --git a/tests/stdlib/concurrency/tatomic_import.nim b/tests/stdlib/concurrency/tatomic_import.nim
new file mode 100644
index 00000000000..e8faaae2040
--- /dev/null
+++ b/tests/stdlib/concurrency/tatomic_import.nim
@@ -0,0 +1,11 @@
+import atomicSample
+
+block crossFileObjectContainingAGenericWithAComplexObject:
+  discard initAtomicWithGeneric[string]("foo")
+
+block crossFileObjectContainingAGenericWithAnInteger:
+  discard initAtomicWithGeneric[int](1)
+  discard initAtomicWithGeneric[int8](1)
+  discard initAtomicWithGeneric[int16](1)
+  discard initAtomicWithGeneric[int32](1)
+  discard initAtomicWithGeneric[int64](1)
diff --git a/tests/stdlib/thttpclient_ssl.nim b/tests/stdlib/thttpclient_ssl.nim
index 1c531eae946..3acdacfe369 100644
--- a/tests/stdlib/thttpclient_ssl.nim
+++ b/tests/stdlib/thttpclient_ssl.nim
@@ -129,3 +129,19 @@ when not defined(windows):
           msg.contains("certificate verify failed")):
           echo "CVerifyPeer exception: " & msg
           check(false)
+
+    test "HttpClient with CVerifyPeerUseEnvVars":
+      const port = 12346.Port
+      let t = spawn runServer(port)
+      sleep(100)
+
+      putEnv("SSL_CERT_FILE", getCurrentDir() / certFile)
+      var client = newHttpClient(sslContext=newContext(verifyMode=CVerifyPeerUseEnvVars))
+      try:
+        log "client: connect"
+        discard client.getContent("https://127.0.0.1:12346")
+      except:
+        let msg = getCurrentExceptionMsg()
+        log "client: exception: " & msg
+        log "getContent should not have raised an exception"
+        fail()
diff --git a/tests/stdlib/tlists.nim b/tests/stdlib/tlists.nim
index 54fa8b24fd1..00c5b1a27ba 100644
--- a/tests/stdlib/tlists.nim
+++ b/tests/stdlib/tlists.nim
@@ -233,6 +233,43 @@ template main =
     doAssert l.toSeq == [1]
     doAssert l.remove(l.head) == true
     doAssert l.toSeq == []
+  
+  block issue19297: # add (appends a shallow copy)
+    var a: SinglyLinkedList[int]
+    var b: SinglyLinkedList[int]
+
+    doAssert a.toSeq == @[]
+    a.add(1)
+    doAssert a.toSeq == @[1]
+    a.add(b)
+    doAssert a.toSeq == @[1]
+    a.add(2)
+    doAssert a.toSeq == @[1, 2]
+  
+  block issue19314: # add (appends a shallow copy)
+    var a: DoublyLinkedList[int]
+    var b: DoublyLinkedList[int]
+
+    doAssert a.toSeq == @[]
+    a.add(1)
+    doAssert a.toSeq == @[1]
+    a.add(b)
+    doAssert a.toSeq == @[1]
+    a.add(2)
+    doAssert a.toSeq == @[1, 2]
+
+  block RemoveLastNodeFromSinglyLinkedList:
+    var list = initSinglyLinkedList[string]()
+    let n1 = newSinglyLinkedNode("sonic")
+    let n2 = newSinglyLinkedNode("the")
+    let n3 = newSinglyLinkedNode("tiger")
+    let n4 = newSinglyLinkedNode("hedgehog")
+    list.add(n1)
+    list.add(n2)
+    list.add(n3)
+    list.remove(n3)
+    list.add(n4)
+    doAssert list.toSeq == @["sonic", "the", "hedgehog"]
 
 static: main()
 main()
diff --git a/tests/stdlib/tmacros.nim b/tests/stdlib/tmacros.nim
index d83869a44f8..8ec2f563426 100644
--- a/tests/stdlib/tmacros.nim
+++ b/tests/stdlib/tmacros.nim
@@ -124,3 +124,23 @@ block: # SameType
     assert not testTensorInt(x1)
     assert testTensorInt(x2)
     assert not testTensorInt(x3)
+
+block: # extractDocCommentsAndRunnables
+  macro checkRunnables(prc: untyped) =
+    let runnables = prc.body.extractDocCommentsAndRunnables()
+    doAssert runnables[0][0].eqIdent("runnableExamples")
+
+  macro checkComments(comment: static[string], prc: untyped) =
+    let comments = prc.body.extractDocCommentsAndRunnables()
+    doAssert comments[0].strVal == comment
+    
+  proc a() {.checkRunnables.} =
+    runnableExamples: discard
+    discard
+
+  proc b() {.checkRunnables.} =
+    runnableExamples "-d:ssl": discard
+    discard
+    
+  proc c() {.checkComments("Hello world").} =
+    ## Hello world
diff --git a/tests/stdlib/tmath.nim b/tests/stdlib/tmath.nim
index 9bc5b994f79..5e501c09bbb 100644
--- a/tests/stdlib/tmath.nim
+++ b/tests/stdlib/tmath.nim
@@ -437,12 +437,6 @@ template main() =
       doAssert lgamma(-0.0) == Inf
       doAssert lgamma(-1.0) == Inf
 
-      when nimvm: discard
-      else:
-        var exponent: cint
-        doAssert c_frexp(0.0, exponent) == 0.0
-        doAssert c_frexp(-0.0, exponent) == -0.0
-        doAssert classify(c_frexp(-0.0, exponent)) == fcNegZero
 
 static: main()
 main()
diff --git a/tests/stdlib/tmemory.nim b/tests/stdlib/tmemory.nim
index 25b5d526ac8..0349ba03507 100644
--- a/tests/stdlib/tmemory.nim
+++ b/tests/stdlib/tmemory.nim
@@ -12,4 +12,4 @@ block: # cmpMem
 
   doAssert cmpMem(a.addr, b.addr, sizeof(SomeHash)) > 0
   doAssert cmpMem(b.addr, a.addr, sizeof(SomeHash)) < 0
-  doAssert cmpMem(a.addr, c.unsafeAddr, sizeof(SomeHash)) == 0
+  doAssert cmpMem(a.addr, c.addr, sizeof(SomeHash)) == 0
diff --git a/tests/stdlib/tmimetypes.nim b/tests/stdlib/tmimetypes.nim
index 93c20d4a33f..6435309e117 100644
--- a/tests/stdlib/tmimetypes.nim
+++ b/tests/stdlib/tmimetypes.nim
@@ -7,6 +7,8 @@ template main() =
   var m = newMimetypes()
   doAssert m.getMimetype("mp4") == "video/mp4"
   doAssert m.getExt("application/json") == "json"
+  m.register("foo", "baa")
+  doAssert m.getMimetype("foo") == "baa"
   # see also `runnableExamples`.
   # xxx we should have a way to avoid duplicating code between runnableExamples and tests
 
diff --git a/tests/stdlib/tnet_ll.nim b/tests/stdlib/tnet_ll.nim
index affa21947fc..2d340cea804 100644
--- a/tests/stdlib/tnet_ll.nim
+++ b/tests/stdlib/tnet_ll.nim
@@ -1,43 +1,51 @@
-discard """
-  action: run
-  output: '''
-
-[Suite] inet_ntop tests
-'''
-"""
-
-when defined(windows):
-  import winlean
-elif defined(posix):
-  import posix
-else:
-  {.error: "Unsupported OS".}
-
-import unittest, strutils
-
-suite "inet_ntop tests":
-
-  setup:
-    when defined(windows):
-      var wsa: WSAData
-      discard wsaStartup(0x101'i16, wsa.addr)
-  
-  test "IP V4":
-    var ip4 = 0x10111213
-    var buff: array[0..255, char]
-    let r = inet_ntop(AF_INET, ip4.addr, buff[0].addr, buff.sizeof.int32)
-    let res = if r == nil: "" else: $r
-    check: res == "19.18.17.16"
-      
-
-  test "IP V6":
-    when defined(windows):
-      let ipv6Support = (getVersion() and 0xff) > 0x5
-    else:
-      let ipv6Support = true
-          
-    var ip6 = [0x1000'u16, 0x1001, 0x2000, 0x2001, 0x3000, 0x3001, 0x4000, 0x4001]
-    var buff: array[0..255, char]
-    let r = inet_ntop(AF_INET6, ip6[0].addr, buff[0].addr, buff.sizeof.int32)
-    let res = if r == nil: "" else: $r
-    check: not ipv6Support or res == "10:110:20:120:30:130:40:140"
+discard """
+  action: run
+  output: '''
+
+[Suite] inet_ntop tests
+'''
+"""
+
+when defined(windows):
+  import winlean
+elif defined(posix):
+  import posix
+else:
+  {.error: "Unsupported OS".}
+
+import unittest, strutils
+
+suite "inet_ntop tests":
+
+  setup:
+    when defined(windows):
+      var wsa: WSAData
+      discard wsaStartup(0x101'i16, wsa.addr)
+  
+  test "IP V4":
+    # regular
+    var ip4 = InAddr()
+    ip4.s_addr = 0x10111213'u32
+    check: ip4.s_addr == 0x10111213'u32
+
+    var buff: array[0..255, char]
+    let r = inet_ntop(AF_INET, cast[pointer](ip4.s_addr.addr), buff[0].addr, buff.len.int32)
+    let res = if r == nil: "" else: $r
+    check: res == "19.18.17.16"
+      
+  test "IP V6":
+    when defined(windows):
+      let ipv6Support = (getVersion() and 0xff) > 0x5
+    else:
+      let ipv6Support = true
+          
+    var ip6 = [0x1000'u16, 0x1001, 0x2000, 0x2001, 0x3000, 0x3001, 0x4000, 0x4001]
+    var buff: array[0..255, char]
+    let r = inet_ntop(AF_INET6, cast[pointer](ip6[0].addr), buff[0].addr, buff.len.int32)
+    let res = if r == nil: "" else: $r
+    check: not ipv6Support or res == "10:110:20:120:30:130:40:140"
+
+  test "InAddr":
+    # issue 19244
+    var ip4 = InAddr(s_addr: 0x10111213'u32)
+    check: ip4.s_addr == 0x10111213'u32
diff --git a/tests/stdlib/tpunycode.nim b/tests/stdlib/tpunycode.nim
index 596c5ef63e4..bb2b4beb4f6 100644
--- a/tests/stdlib/tpunycode.nim
+++ b/tests/stdlib/tpunycode.nim
@@ -1,5 +1,205 @@
-import punycode
+import punycode, std/unicode
 
 doAssert(decode(encode("", "bücher")) == "bücher")
 doAssert(decode(encode("münchen")) == "münchen")
 doAssert encode("xn--", "münchen") == "xn--mnchen-3ya"
+
+# source: https://datatracker.ietf.org/doc/html/rfc3492.html#section-7
+let punycode_testcases = [
+  # (A) Arabic (Egyptian):
+  (
+    input:
+      "\u0644\u064A\u0647\u0645\u0627\u0628\u062A\u0643\u0644" &
+      "\u0645\u0648\u0634\u0639\u0631\u0628\u064A\u061F",
+    output:
+      "egbpdaj6bu4bxfgehfvwxn"
+  ),
+
+  # (B) Chinese (simplified):
+  (
+    input:
+      "\u4ED6\u4EEC\u4E3A\u4EC0\u4E48\u4E0D\u8BF4\u4E2D\u6587",
+    output:
+      "ihqwcrb4cv8a8dqg056pqjye"
+  ),
+
+  # (C) Chinese (traditional):
+  (
+    input:
+      "\u4ED6\u5011\u7232\u4EC0\u9EBD\u4E0D\u8AAA\u4E2D\u6587",
+    output:
+      "ihqwctvzc91f659drss3x8bo0yb"
+  ),
+
+  # (D) Czech: Pro<ccaron>prost<ecaron>nemluv<iacute><ccaron>esky
+  (
+    input:
+      "\u0050\u0072\u006F\u010D\u0070\u0072\u006F\u0073\u0074" &
+      "\u011B\u006E\u0065\u006D\u006C\u0075\u0076\u00ED\u010D" &
+      "\u0065\u0073\u006B\u0079",
+    output:
+      "Proprostnemluvesky-uyb24dma41a"
+  ),
+
+  # (E) Hebrew:
+  (
+    input:
+      "\u05DC\u05DE\u05D4\u05D4\u05DD\u05E4\u05E9\u05D5\u05D8" &
+      "\u05DC\u05D0\u05DE\u05D3\u05D1\u05E8\u05D9\u05DD\u05E2" &
+      "\u05D1\u05E8\u05D9\u05EA",
+    output:
+      "4dbcagdahymbxekheh6e0a7fei0b"
+  ),
+
+  # (F) Hindi (Devanagari):
+  (
+    input:
+      "\u092F\u0939\u0932\u094B\u0917\u0939\u093F\u0928\u094D" &
+      "\u0926\u0940\u0915\u094D\u092F\u094B\u0902\u0928\u0939" &
+      "\u0940\u0902\u092C\u094B\u0932\u0938\u0915\u0924\u0947" &
+      "\u0939\u0948\u0902",
+    output:
+      "i1baa7eci9glrd9b2ae1bj0hfcgg6iyaf8o0a1dig0cd"
+  ),
+
+  # (G) Japanese (kanji and hiragana):
+  (
+    input:
+      "\u306A\u305C\u307F\u3093\u306A\u65E5\u672C\u8A9E\u3092" &
+      "\u8A71\u3057\u3066\u304F\u308C\u306A\u3044\u306E\u304B",
+    output:
+      "n8jok5ay5dzabd5bym9f0cm5685rrjetr6pdxa"
+  ),
+
+  # (H) Korean (Hangul syllables):
+  (
+    input:
+      "\uC138\uACC4\uC758\uBAA8\uB4E0\uC0AC\uB78C\uB4E4\uC774" &
+      "\uD55C\uAD6D\uC5B4\uB97C\uC774\uD574\uD55C\uB2E4\uBA74" &
+      "\uC5BC\uB9C8\uB098\uC88B\uC744\uAE4C",
+    output:
+      "989aomsvi5e83db1d2a355cv1e0vak1dwrv93d5xbh15a0dt30a5jpsd879ccm6fea98c"
+  ),
+
+  # (I) Russian (Cyrillic):
+  (
+    input:
+      "\u043F\u043E\u0447\u0435\u043C\u0443\u0436\u0435\u043E" &
+      "\u043D\u0438\u043D\u0435\u0433\u043E\u0432\u043E\u0440" &
+      "\u044F\u0442\u043F\u043E\u0440\u0443\u0441\u0441\u043A" &
+      "\u0438",
+    output:
+      "b1abfaaepdrnnbgefbaDotcwatmq2g4l"
+  ),
+
+  # (J) Spanish: Porqu<eacute>nopuedensimplementehablarenEspa<ntilde>ol
+  (
+    input:
+      "\u0050\u006F\u0072\u0071\u0075\u00E9\u006E\u006F\u0070" &
+      "\u0075\u0065\u0064\u0065\u006E\u0073\u0069\u006D\u0070" &
+      "\u006C\u0065\u006D\u0065\u006E\u0074\u0065\u0068\u0061" &
+      "\u0062\u006C\u0061\u0072\u0065\u006E\u0045\u0073\u0070" &
+      "\u0061\u00F1\u006F\u006C",
+    output:
+      "PorqunopuedensimplementehablarenEspaol-fmd56a"
+  ),
+
+  # (K) Vietnamese:
+  #  T<adotbelow>isaoh<odotbelow>kh<ocirc>ngth<ecirchookabove>ch\
+  #   <ihookabove>n<oacute>iti<ecircacute>ngVi<ecircdotbelow>t
+  (
+    input:
+      "\u0054\u1EA1\u0069\u0073\u0061\u006F\u0068\u1ECD\u006B" &
+      "\u0068\u00F4\u006E\u0067\u0074\u0068\u1EC3\u0063\u0068" &
+      "\u1EC9\u006E\u00F3\u0069\u0074\u0069\u1EBF\u006E\u0067" &
+      "\u0056\u0069\u1EC7\u0074",
+    output:
+      "TisaohkhngthchnitingVit-kjcr8268qyxafd2f1b9g"
+  ),
+
+  # (L) 3<nen>B<gumi><kinpachi><sensei>
+  (
+    input:
+      "\u0033\u5E74\u0042\u7D44\u91D1\u516B\u5148\u751F",
+    output:
+      "3B-ww4c5e180e575a65lsy2b"
+  ),
+
+  # (M) <amuro><namie>-with-SUPER-MONKEYS
+  (
+    input:
+      "\u5B89\u5BA4\u5948\u7F8E\u6075\u002D\u0077\u0069\u0074" &
+      "\u0068\u002D\u0053\u0055\u0050\u0045\u0052\u002D\u004D" &
+      "\u004F\u004E\u004B\u0045\u0059\u0053",
+    output:
+      "-with-SUPER-MONKEYS-pc58ag80a8qai00g7n9n"
+  ),
+
+  # (N) Hello-Another-Way-<sorezore><no><basho>
+  (
+    input:
+      "\u0048\u0065\u006C\u006C\u006F\u002D\u0041\u006E\u006F" &
+      "\u0074\u0068\u0065\u0072\u002D\u0057\u0061\u0079\u002D" &
+      "\u305D\u308C\u305E\u308C\u306E\u5834\u6240",
+    output:
+      "Hello-Another-Way--fc4qua05auwb3674vfr0b"
+  ),
+
+  # (O) <hitotsu><yane><no><shita>2
+  (
+    input:
+      "\u3072\u3068\u3064\u5C4B\u6839\u306E\u4E0B\u0032",
+    output:
+      "2-u9tlzr9756bt3uc0v"
+  ),
+
+  # (P) Maji<de>Koi<suru>5<byou><mae>
+  (
+    input:
+      "\u004D\u0061\u006A\u0069\u3067\u004B\u006F\u0069\u3059" &
+      "\u308B\u0035\u79D2\u524D",
+    output:
+      "MajiKoi5-783gue6qz075azm5e"
+  ),
+
+    # (Q) <pafii>de<runba>
+  (
+    input:
+      "\u30D1\u30D5\u30A3\u30FC\u0064\u0065\u30EB\u30F3\u30D0",
+    output:
+      "de-jg4avhby1noc0d"
+  ),
+
+  # (R) <sono><supiido><de>
+  (
+    input:
+      "\u305D\u306E\u30B9\u30D4\u30FC\u30C9\u3067",
+    output:
+      "d9juau41awczczp"
+  ),
+
+  # (S) -> $1.00 <-
+  (
+    input:
+      "\u002D\u003E\u0020\u0024\u0031\u002E\u0030\u0030\u0020" &
+      "\u003C\u002D",
+    output:
+      "-> $1.00 <--"
+  )
+]
+
+block encodeTests:
+  for (uni, puny) in punycode_testcases:
+    # Need to convert both strings to lower case, since
+    # some of the extended encodings use upper case, but our
+    # code produces only lower case. Converting just puny to
+    # lower is also insufficient, since some of the input characters
+    # are upper case.
+    doAssert encode(uni).toLower() == puny.toLower()
+
+block decodeTests:
+  for (uni, puny) in punycode_testcases:
+    doAssert decode(puny) == uni
+
+block decodeInvalidTest:
+  doAssertRaises(PunyError): discard decode("xn--w&")
diff --git a/tests/stdlib/tre.nim b/tests/stdlib/tre.nim
index 2857c6c9e58..9f27f7db222 100644
--- a/tests/stdlib/tre.nim
+++ b/tests/stdlib/tre.nim
@@ -108,4 +108,10 @@ proc testAll() =
     doAssert replace("foo", re"", "-") == "-f-o-o-"
     doAssert replace("ooo", re"o", "-") == "---"
 
+  block: # bug #14468
+    accum = @[]
+    for word in split("this is an example", re"\b"):
+      accum.add(word)
+    doAssert(accum == @["this", " ", "is", " ", "an", " ", "example"])
+
 testAll()
diff --git a/tests/stdlib/tsqlitebindatas.nim b/tests/stdlib/tsqlitebindatas.nim
index 754c80ae1d3..b2c3247fad0 100644
--- a/tests/stdlib/tsqlitebindatas.nim
+++ b/tests/stdlib/tsqlitebindatas.nim
@@ -27,7 +27,7 @@ block tsqlitebindatas: ## db_sqlite binary data
   db.exec(createTableStr)
 
   var dbuf = newSeq[byte](orig.len*sizeof(float64))
-  copyMem(unsafeAddr(dbuf[0]), unsafeAddr(orig[0]), dbuf.len)
+  copyMem(addr(dbuf[0]), addr(orig[0]), dbuf.len)
 
   var insertStmt = db.prepare("INSERT INTO test (id, name, data) VALUES (?, ?, ?)")
   insertStmt.bindParams(1, origName, dbuf)
@@ -42,7 +42,7 @@ block tsqlitebindatas: ## db_sqlite binary data
   var dataTest = db.getValue(sql"SELECT data FROM test WHERE id = ?", 1)
   let seqSize = int(dataTest.len*sizeof(byte)/sizeof(float64))
   var res: seq[float64] = newSeq[float64](seqSize)
-  copyMem(unsafeAddr(res[0]), addr(dataTest[0]), dataTest.len)
+  copyMem(addr(res[0]), addr(dataTest[0]), dataTest.len)
   doAssert res.len == orig.len
   doAssert res == orig
 
diff --git a/tests/stdlib/tstrutils.nim b/tests/stdlib/tstrutils.nim
index 185188b8527..d8b6d848e69 100644
--- a/tests/stdlib/tstrutils.nim
+++ b/tests/stdlib/tstrutils.nim
@@ -586,6 +586,17 @@ template main() =
       let g = parseEnum[Foo]("Bar", A)
       doAssert g == A
 
+    block: # bug #19463
+      const CAMPAIGN_TABLE = "wikientries_campaign"
+      const CHARACTER_TABLE = "wikientries_character"
+
+      type Tables = enum
+        a = CAMPAIGN_TABLE,
+        b = CHARACTER_TABLE,
+
+      let myA = CAMPAIGN_TABLE
+      doAssert $parseEnum[Tables](myA) == "wikientries_campaign"
+
     block: # check enum defined in block
       type
         Bar = enum
@@ -844,5 +855,12 @@ bar
     doAssert s.endsWith('a') == false
     doAssert s.endsWith('\0') == false
 
+  block: # nimIdentNormalize
+    doAssert nimIdentNormalize("") == ""
+    doAssert nimIdentNormalize("foo") == "foo"
+    doAssert nimIdentNormalize("foo_bar") == "foobar"
+    doAssert nimIdentNormalize("Foo_bar") == "Foobar"
+    doAssert nimIdentNormalize("_Foo_bar") == "_foobar"
+
 static: main()
 main()
diff --git a/tests/strictnotnil/tnilcheck.nim b/tests/strictnotnil/tnilcheck.nim
index 5b9292522c8..c2d009b709a 100644
--- a/tests/strictnotnil/tnilcheck.nim
+++ b/tests/strictnotnil/tnilcheck.nim
@@ -194,7 +194,7 @@ proc testAliasChanging(a: Nilable) =
 # # proc testPtrAlias(a: Nilable) =
 # #   # pointer to a: hm.
 # #   # alias to a?
-# #   var ptrA = a.unsafeAddr # {0, 1} 
+# #   var ptrA = a.addr # {0, 1} 
 # #   if not a.isNil: # {0, 1}
 # #     ptrA[] = nil # {0, 1} 0: MaybeNil 1: MaybeNil
 # #     echo a.a #[ tt.Warning
diff --git a/tests/stylecheck/taccept.nim b/tests/stylecheck/taccept.nim
new file mode 100644
index 00000000000..eaa18b3d277
--- /dev/null
+++ b/tests/stylecheck/taccept.nim
@@ -0,0 +1,15 @@
+discard """
+  matrix: "--styleCheck:error --styleCheck:usages"
+"""
+
+type
+  Name = object
+    id: int
+
+template hello =
+  var iD = "string"
+  var name: Name
+  doAssert name.id == 0
+  doAssert iD == "string"
+
+hello()
diff --git a/tests/stylecheck/treject.nim b/tests/stylecheck/treject.nim
new file mode 100644
index 00000000000..b86594abdc7
--- /dev/null
+++ b/tests/stylecheck/treject.nim
@@ -0,0 +1,17 @@
+discard """
+  action: reject
+  nimout: '''treject.nim(14, 13) Error: 'iD' should be: 'id' [field declared in treject.nim(9, 5)] [Name]'''
+  matrix: "--styleCheck:error --styleCheck:usages"
+"""
+
+type
+  Name = object
+    id: int
+
+template hello =
+  var iD = "string"
+  var name: Name
+  echo name.iD
+  echo iD
+
+hello()
diff --git a/tests/system/tdollars.nim b/tests/system/tdollars.nim
index effaa9a9ec1..e52caa99f27 100644
--- a/tests/system/tdollars.nim
+++ b/tests/system/tdollars.nim
@@ -187,5 +187,12 @@ proc main()=
     test2 high(int8), "127"
     test2 low(int8), "-128"
 
+  block:
+    const
+      a: array[3, char] = ['N', 'i', 'm']
+      aStr = $(a)
+
+    doAssert aStr == """['N', 'i', 'm']"""
+
 static: main()
 main()
diff --git a/tests/system/tostring.nim b/tests/system/tostring.nim
index fa82acc3bf8..9d8bd0ef84d 100644
--- a/tests/system/tostring.nim
+++ b/tests/system/tostring.nim
@@ -47,7 +47,7 @@ import strutils
 
 let arr = ['H','e','l','l','o',' ','W','o','r','l','d','!','\0']
 doAssert $arr == "['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!', '\\x00']"
-doAssert $cstring(unsafeAddr arr) == "Hello World!"
+doAssert $cstring(addr arr) == "Hello World!"
 
 proc takes(c: cstring) =
   doAssert c == cstring""
diff --git a/tests/system/tstatic_callable.nim b/tests/system/tstatic_callable.nim
new file mode 100644
index 00000000000..92d1fca8d9e
--- /dev/null
+++ b/tests/system/tstatic_callable.nim
@@ -0,0 +1,12 @@
+# bug #16987
+
+proc getNum(a: int): int = a
+
+# Below calls "doAssert getNum(123) == 123" at compile time.
+static:
+  doAssert getNum(123) == 123
+
+# Below calls evaluate the "getNum(123)" at compile time, but the
+# results of those calls get used at run time.
+doAssert (static getNum(123)) == 123
+doAssert (static(getNum(123))) == 123
diff --git a/tests/system/tstatic_callable_error.nim b/tests/system/tstatic_callable_error.nim
new file mode 100644
index 00000000000..c6f1e3d0767
--- /dev/null
+++ b/tests/system/tstatic_callable_error.nim
@@ -0,0 +1,14 @@
+# bug #16987
+
+discard """
+errormsg: "cannot evaluate at compile time: inp"
+nimout: '''
+tstatic_callable_error.nim(14, 21) Error: cannot evaluate at compile time: inp'''
+"""
+
+
+# line 10
+proc getNum(a: int): int = a
+
+let inp = 123
+echo (static getNum(inp))
diff --git a/tests/template/t6217.nim b/tests/template/t6217.nim
new file mode 100644
index 00000000000..b27b61881de
--- /dev/null
+++ b/tests/template/t6217.nim
@@ -0,0 +1,19 @@
+discard """
+  output: '''
+start
+side effect!
+end
+'''
+"""
+
+# bug #6217
+
+template optMul{`*`(a, 2)}(a: int{noSideEffect}): int = a+a
+
+proc f(): int =
+  echo "side effect!"
+  result = 55
+
+echo "start"
+doAssert f() * 2 == 110
+echo "end"
diff --git a/tests/test_nimscript.nims b/tests/test_nimscript.nims
index 6736fb38537..ffb35e074ad 100644
--- a/tests/test_nimscript.nims
+++ b/tests/test_nimscript.nims
@@ -8,47 +8,49 @@ from stdtest/specialpaths import buildDir
 import std/[
   # Core:
   bitops, typetraits, lenientops, macros, volatile,
-  # fails: typeinfo, endians
-  # works but shouldn't: cpuinfo, rlocks, locks
+  # fails due to FFI: typeinfo
+  # fails due to cstring cast/copyMem: endians
+  # works but uses FFI: cpuinfo, rlocks, locks
 
   # Algorithms:
-  algorithm, sequtils,
+  algorithm, enumutils, sequtils, setutils,
 
   # Collections:
   critbits, deques, heapqueue, intsets, lists, options, sets,
-  sharedlist, tables,
-  # fails: sharedtables
+  tables, packedsets,
 
   # Strings:
   editdistance, wordwrap, parseutils, ropes,
   pegs, punycode, strformat, strmisc, strscans, strtabs,
-  strutils, unicode, unidecode,
-  # works but shouldn't: cstrutils, encodings
+  strutils, unicode, unidecode, cstrutils,
+  # works but uses FFI: encodings
 
   # Time handling:
-  # fails: monotimes, times
+  # fails due to FFI: monotimes, times
   # but times.getTime() implemented for VM
 
   # Generic operator system services:
-  os, streams,
-  # fails: distros, dynlib, marshal, memfiles, osproc, terminal
+  os, streams, distros,
+  # fails due to FFI: memfiles, osproc, terminal
+  # works but uses FFI: dynlib
+  # intentionally fails: marshal
 
   # Math libraries:
-  complex, math, mersenne, random, rationals, stats, sums,
-  # works but shouldn't: fenv
+  complex, math, random, rationals, stats, sums,
+  # works but uses FFI: fenv, sysrand
 
   # Internet protocols:
   httpcore, mimetypes, uri,
-  # fails: asyncdispatch, asyncfile, asyncftpclient, asynchttpserver,
+  # fails due to FFI: asyncdispatch, asyncfile, asyncftpclient, asynchttpserver,
   # asyncnet, cgi, cookies, httpclient, nativesockets, net, selectors, smtp
-  # works but shouldn't test: asyncstreams, asyncfutures
+  # works but no need to test: asyncstreams, asyncfutures
 
   # Threading:
-  # fails: threadpool
+  # fails due to FFI: threadpool
 
   # Parsers:
   htmlparser, json, lexbase, parsecfg, parsecsv, parsesql, parsexml,
-  parseopt,
+  parseopt, jsonutils,
 
   # XML processing:
   xmltree, xmlparser,
@@ -58,17 +60,23 @@ import std/[
 
   # Hashing:
   base64, hashes,
-  # fails: md5, oids, sha1
+  # fails due to cstring cast/zeroMem/copyMem/moveMem: md5
+  # fails due to cstring cast/times import/endians import: oids
+  # fails due to copyMem/endians import: sha1
 
   # Miscellaneous:
-  colors, sugar, varints,
-  # fails: browsers, logging (times), segfaults, unittest (uses methods)
+  colors, sugar, varints, enumerate, with,
+  # fails due to FFI: browsers, segfaults
+  # fails due to times import/methods: logging
+  # fails due to methods: unittest
 
   # Modules for JS backend:
-  # fails: asyncjs, dom, jsconsole, jscore, jsffi,
+  # fails intentionally: asyncjs, dom, jsconsole, jscore, jsffi, jsbigints,
+  # jsfetch, jsformdata, jsheaders
 
   # Unlisted in lib.html:
-  decls, compilesettings, with, wrapnils
+  decls, compilesettings, wrapnils, effecttraits, genasts,
+  importutils, isolation
 ]
 
 # non-std imports
diff --git a/tests/types/tlent_var.nim b/tests/types/tlent_var.nim
index 491f6fde876..73b5bef9b4a 100644
--- a/tests/types/tlent_var.nim
+++ b/tests/types/tlent_var.nim
@@ -15,7 +15,7 @@ proc test_var(x: var MyObj): var int =
 var x = MyObj(a: 5)
 
 doAssert: test_var(x).addr == x.a.addr
-doAssert: test_lent(x).unsafeAddr == x.a.addr
+doAssert: test_lent(x).addr == x.a.addr
 
 proc varProc(x: var int) =
   x = 100
diff --git a/tools/koch/koch.nim b/tools/koch/koch.nim
index 7581dd34a66..9f8257976c2 100644
--- a/tools/koch/koch.nim
+++ b/tools/koch/koch.nim
@@ -566,9 +566,8 @@ proc runCI(cmd: string) =
   testTools(cmd)
 
   when not defined(bsd):
-    if not doUseCpp:
-      # the BSDs are overwhelmed already, so only run this test on the other machines:
-      kochExecFold("Boot Nim ORC", "boot -d:release --gc:orc --lib:lib")
+    # the BSDs are overwhelmed already, so only run this test on the other machines:
+    kochExecFold("Boot Nim ORC", "boot -d:release --gc:orc --lib:lib")
 
 proc valgrind(cmd: string) =
   # somewhat hacky: '=' sign means "pass to valgrind" else "pass to Nim"
diff --git a/tools/koch/kochdocs.nim b/tools/koch/kochdocs.nim
index cfa9e913950..c8efca5fdb5 100644
--- a/tools/koch/kochdocs.nim
+++ b/tools/koch/kochdocs.nim
@@ -414,6 +414,12 @@ proc nim2pdf(src: string, dst: string, nimArgs: string) =
     # `>` should work on windows, if not, we can use `execCmdEx`
     let cmd = "xelatex -interaction=nonstopmode -output-directory=$# $# > $#" % [outDir.quoteShell, texFile.quoteShell, xelatexLog.quoteShell]
     exec(cmd) # on error, user can inspect `xelatexLog`
+    if i == 1:  # build .ind file
+      var texFileBase = texFile
+      texFileBase.removeSuffix(".tex")
+      let cmd = "makeindex $# > $#" % [
+          texFileBase.quoteShell, xelatexLog.quoteShell]
+      exec(cmd)
   moveFile(texFile.changeFileExt("pdf"), dst)
 
 proc nimKeywordsBuildCheck() =
diff --git a/tools/nim.zsh-completion b/tools/nim.zsh-completion
index f7aeb72c636..1c3670fd939 100644
--- a/tools/nim.zsh-completion
+++ b/tools/nim.zsh-completion
@@ -1,148 +1,120 @@
 #compdef nim
 
+# Installation note:
+# Please name this file as _nim (with underscore!) and copy it to a
+# completions directory, either:
+# - system wide one, like /usr/share/zsh/functions/Completion/Unix/ on Linux
+# - or to a user directory like ~/scripts. Then you also need to add
+#   that directory in your ~/.zshrc to `fpath` array like so:
+#     fpath=( ~/scripts "${fpath[@]}" )
+
 _nim() {
-  _arguments -C \
-    ':command:((
-      {compile,c}\:compile\ project\ with\ default\ code\ generator\ C
-      doc\:generate\ the\ documentation\ for\ inputfile
-      {compileToC,cc}\:compile\ project\ with\ C\ code\ generator
-      {compileToCpp,cpp}\:compile\ project\ to\ C++\ code
-      {compileToOC,objc}\:compile\ project\ to\ Objective\ C\ code
-      js\:compile\ project\ to\ Javascript
-      e\:run\ a\ Nimscript\ file
-      rst2html\:convert\ a\ reStructuredText\ file\ to\ HTML
-      rst2tex\:convert\ a\ reStructuredText\ file\ to\ TeX
-      jsondoc\:extract\ the\ documentation\ to\ a\ json\ file
-      buildIndex\:build\ an\ index\ for\ the\ whole\ documentation
-      genDepend\:generate\ a\ DOT\ file\ containing\ the\ module\ dependency\ graph
-      dump\:dump\ all\ defined\ conditionals\ and\ search\ paths
-      check\:checks\ the\ project\ for\ syntax\ and\ semantic
-    ))' \
-    '*-r[run the application]' \
-    '*--run[run the application]' \
-    '*-p=[add path to search paths]' \
-    '*--path=[add path to search paths]' \
-    '*-d=[define a conditional symbol]' \
-    '*--define=[define a conditional symbol]' \
-    '*-u=[undefine a conditional symbol]' \
-    '*--undef=[undefine a conditional symbol]' \
-    '*-f[force rebuilding of all modules]' \
-    '*--forceBuild[force rebuilding of all modules]' \
-    '*--stackTrace=on[turn stack tracing on]' \
-    '*--stackTrace=off[turn stack tracing off]' \
-    '*--lineTrace=on[turn line tracing on]' \
-    '*--lineTrace=off[turn line tracing off]' \
-    '*--threads=on[turn support for multi-threading on]' \
-    '*--threads=off[turn support for multi-threading off]' \
-    '*-x=on[turn all runtime checks on]' \
-    '*-x=off[turn all runtime checks off]' \
-    '*--checks=on[turn all runtime checks on]' \
-    '*--checks=off[turn all runtime checks off]' \
-    '*--objChecks=on[turn obj conversion checks on]' \
-    '*--objChecks=off[turn obj conversion checks off]' \
-    '*--fieldChecks=on[turn case variant field checks on]' \
-    '*--fieldChecks=off[turn case variant field checks off]' \
-    '*--rangeChecks=on[turn range checks on]' \
-    '*--rangeChecks=off[turn range checks off]' \
-    '*--boundChecks=on[turn bound checks on]' \
-    '*--boundChecks=off[turn bound checks off]' \
-    '*--overflowChecks=on[turn int over-/underflow checks on]' \
-    '*--overflowChecks=off[turn int over-/underflow checks off]' \
-    '*-a[turn assertions on]' \
-    '*-a[turn assertions off]' \
-    '*--assertions=on[turn assertions on]' \
-    '*--assertions=off[turn assertions off]' \
-    '*--floatChecks=on[turn all floating point (NaN/Inf) checks on]' \
-    '*--floatChecks=off[turn all floating point (NaN/Inf) checks off]' \
-    '*--nanChecks=on[turn NaN checks on]' \
-    '*--nanChecks=off[turn NaN checks off]' \
-    '*--infChecks=on[turn Inf checks on]' \
-    '*--infChecks=off[turn Inf checks off]' \
-    '*--nilChecks=on[turn nil checks on]' \
-    '*--nilChecks=off[turn nil checks off]' \
-    '*--opt=none[do not optimize]' \
-    '*--opt=speed[optimize for speed|size - use -d:release for a release build]' \
-    '*--opt=size[optimize for size]' \
-    '*--debugger:native[use native debugger (gdb)]' \
-    '*--app=console[generate a console app]' \
-    '*--app=gui[generate a GUI app]' \
-    '*--app=lib[generate a dynamic library]' \
-    '*--app=staticlib[generate a static library]' \
-    '*--cpu=alpha[compile for Alpha architecture]' \
-    '*--cpu=amd64[compile for x86_64 architecture]' \
-    '*--cpu=arm[compile for ARM architecture]' \
-    '*--cpu=arm64[compile for ARM64 architecture]' \
-    '*--cpu=avr[compile for AVR architecture]' \
-    '*--cpu=esp[compile for ESP architecture]' \
-    '*--cpu=hppa[compile for HPPA architecture]' \
-    '*--cpu=i386[compile for i386 architecture]' \
-    '*--cpu=ia64[compile for ia64 architecture]' \
-    '*--cpu=js[compile to JavaScript]' \
-    '*--cpu=m68k[compile for m68k architecture]' \
-    '*--cpu=mips[compile for MIPS architecture]' \
-    '*--cpu=mipsel[compile for MIPS EL architecture]' \
-    '*--cpu=mips64[compile for MIPS64 architecture]' \
-    '*--cpu=mips64el[compile for MIPS64 EL architecture]' \
-    '*--cpu=msp430[compile for msp430 architecture]' \
-    '*--cpu=nimvm[compile for Nim VM]' \
-    '*--cpu=powerpc[compile for PowerPC architecture]' \
-    '*--cpu=powerpc64[compile for PowerPC64 architecture]' \
-    '*--cpu=powerpc64el[compile for PowerPC64 EL architecture]' \
-    '*--cpu=riscv32[compile for RISC-V 32 architecture]' \
-    '*--cpu=riscv64[compile for RISC-V 64 architecture]' \
-    '*--cpu=sparc[compile for SPARC architecture]' \
-    '*--cpu=sparc64[compile for SPARC64 architecture]' \
-    '*--cpu=vm[compile for Nim VM]' \
-    '*--cpu=wasm32[compile to WASM 32]' \
-    '*--gc=refc[use reference counting garbage collection]' \
-    '*--gc=arc[use ARC garbage collection]' \
-    '*--gc=orc[use ORC garbage collection]' \
-    '*--gc=markAndSweep[use mark-and-sweep garbage collection]' \
-    '*--gc=boehm[use Boehm garbage collection]' \
-    '*--gc=go[use Go garbage collection]' \
-    '*--gc=regions[use region-based memory management]' \
-    '*--gc=none[disable garbage collection]' \
-    '*--os=Standalone[generate a stand-alone executable]' \
-    '*--os=AIX[compile for AIX]' \
-    '*--os=Amiga[compile for Amiga OS]' \
-    '*--os=Android[compile for Android]' \
-    '*--os=Any[compile for any OS]' \
-    '*--os=Atari[compile for Atari]' \
-    '*--os=DOS[compile for DOS]' \
-    '*--os=DragonFly[compile for DragonFly]' \
-    '*--os=FreeBSD[compile for FreeBSD]' \
-    '*--os=FreeRTOS[compile for FreeRTOS]' \
-    '*--os=Genode[compile for Genode]' \
-    '*--os=Haiku[compile for Haiku]' \
-    '*--os=iOS[compile for iOS]' \
-    '*--os=Irix[compile for Irix]' \
-    '*--os=Linux[compile for Linux]' \
-    '*--os=MacOS[compile for MacOS]' \
-    '*--os=MacOSX[compile for MacOSX]' \
-    '*--os=MorphOS[compile for MorphOS]' \
-    '*--os=NetBSD[compile for NetBSD]' \
-    '*--os=Netware[compile for Netware]' \
-    '*--os=NimVM[compile for NimVM]' \
-    '*--os=NintendoSwitch[compile for NintendoSwitch]' \
-    '*--os=OS2[compile for OS2]' \
-    '*--os=OpenBSD[compile for OpenBSD]' \
-    '*--os=PalmOS[compile for PalmOS]' \
-    '*--os=QNX[compile for QNX]' \
-    '*--os=SkyOS[compile for SkyOS]' \
-    '*--os=Solaris[compile for Solaris]' \
-    '*--os=VxWorks[compile for VxWorks]' \
-    '*--os=Windows[compile for Windows]' \
-    '*--os=JS[generate javascript]' \
-    '*--panics=off[turn panics into process terminations: off by default]' \
-    '*--panics=on[turn panics into process terminations]' \
-    '*--verbosity=0[set verbosity to 0]' \
-    '*--verbosity=1[set verbosity to 1 (default)]' \
-    '*--verbosity=2[set verbosity to 2]' \
-    '*--verbosity=3[set verbosity to 3]' \
-    '*--hints=on[print compilation hints]' \
-    '*--hints=off[disable compilation hints]' \
-    '*--hints=list[print compilation hints list]' \
-    ':filename:_files -g"*.nim"'
+  local -a nimCommands=(
+    {compile,c}:'compile project with default code generator C'
+    {compileToC,cc}:'compile project with C code generator'
+    {compileToCpp,cpp}:'compile project to C++ code'
+    {compileToOC,objc}:'compile project to Objective C code'
+    'js:compile project to Javascript'
+    'e:run a Nimscript file'
+    'doc:generate the HTML documentation for inputfile'
+    'rst2html:convert a reStructuredText file to HTML'
+    'doc2tex:generate the documentation for inputfile to LaTeX'
+    'rst2tex:convert a reStructuredText file to TeX'
+    'jsondoc:extract the documentation to a json file'
+    'buildIndex:build an index for the whole documentation'
+    'genDepend:generate a DOT file containing the module dependency graph'
+    'dump:dump all defined conditionals and search paths'
+    'check:checks the project for syntax and semantic'
+    {--help,-h}:'basic help'
+    '--fullhelp:show all switches'
+    {-v,--version}:'show version'
+  )
+
+  _arguments '*:: :->anyState' && return 0
+
+  if (( CURRENT == 1 )); then
+    _describe -t commands "Nim commands" nimCommands -V1
+    return
+  fi
+
+  local -a conditionalSymbols=(
+    release danger mingw androidNDK useNimRtl useMalloc noSignalHandler ssl
+    debug leanCompiler gcDestructors)
+  local -a sharedOpts=(
+    {--define\\:-,-d\\:-}'[define a conditional symbol]:x:($conditionalSymbols)'
+    {--undef\\:-,-u\\:-}'[undefine a conditional symbol]:x:($conditionalSymbols)'
+    {--path\\:-,-p\\:-}'[add path to search paths]:x:_files'
+    '--verbosity\:-[set verbosity level (default\: 1)]:x:(0 1 2 3)'
+    '--hints\:-[print compilation hints? (or `list`)]:x:(on off list)'
+  )
+  local runOpts=(
+    {--run,-r}'[run the application]'
+  )
+  local docOpts=(
+    '--index\:-[enable index .idx files?]:x:(on off)'
+    '--project\:-[output any dependency for doc?]:x:(on off)'
+    '--docInternal\:-[generate module-private documentation?]:x:(on off)'
+  )
+  local -a codeOpts=(
+    {--forceBuild,-f}'[force rebuilding of all modules]'
+    '--stackTrace\:-[enable stack tracing?]:x:(on off)'
+    '--lineTrace\:-[enable line tracing?]:x:(on off)'
+    '--threads\:-[enable support for multi-threading?]:x:(on off)'
+    {--checks\\:-,-x\\:-}'[enable/disable all runtime checks?]:x:(on off)'
+    '--objChecks\:-[enable obj conversion checks]:x:(on off)'
+    '--fieldChecks\:-[enable case variant field checks?]:x:(on off)'
+    '--rangeChecks\:-[enable range checks?]:x:(on off)'
+    '--boundChecks\:-[enable bound checks?]:x:(on off)'
+    '--overflowChecks\:-[enable integer over-/underflow checks?]:x:(on off)'
+    {--assertions\\:-,-a\\:-}'[enable assertions?]:x:(on off)'
+    '--floatChecks\:-[enable floating point (NaN/Inf) checks?]:x:(on off)'
+    '--nanChecks\:-[enable NaN checks?]:x:(on off)'
+    '--infChecks\:-[enable Inf checks?]:x:(on off)'
+    '--nilChecks\:-[enable nil checks?]:x:(on off)'
+    '--expandArc\:-[show how given proc looks before final backend pass]'
+    '--expandMacro\:-[dump every generated AST from given macro]'
+  )
+  local -a nativeOpts=(
+    '--opt\:-[optimization mode]:x:(none speed size)'
+    '--debugger\:native[use native debugger (gdb)]'
+    '--app\:-[generate this type of app (lib=dynamic)]:x:(console gui lib staticlib)'
+    '--cpu\:-[target architecture]:x:(alpha amd64 arm arm64 avr e2k esp hppa i386 ia64 js loongarch64 m68k mips mipsel mips64 mips64el msp430 nimvm powerpc powerpc64 powerpc64el riscv32 riscv64 sparc sparc64 vm wasm32)'
+    '--gc\:-[memory management algorithm to use (default\: refc)]:x:(refc arc orc markAndSweep boehm go regions none)'
+    '--os\:-[operating system to compile for]:x:(AIX Amiga Android Any Atari DOS DragonFly FreeBSD FreeRTOS Genode Haiku iOS Irix JS Linux MacOS MacOSX MorphOS NetBSD Netware NimVM NintendoSwitch OS2 OpenBSD PalmOS Standalone QNX SkyOS Solaris VxWorks Windows)'
+    '--panics\:-[turn panics into process termination (default\: off)]:x:(off on)'
+  )
+
+  case "$words[1]" in
+    compile|c|compileToC|cpp|compileToCpp|compileToOC|objc)
+      _arguments $codeOpts $runOpts $sharedOpts $nativeOpts \
+          '*:filename:_files -g"*.nim"'
+    ;;
+    js)
+      _arguments $codeOpts $runOpts $sharedOpts \
+          '*:filename:_files -g"*.nim"'
+    ;;
+    e)
+      _arguments $codeOpts $runOpts $sharedOpts \
+          '*:filename:_files -g"*.nims"'
+    ;;
+    doc|doc2tex|jsondoc)
+      _arguments $runOpts $sharedOpts '*:filename:_files -g"*.nim"'
+    ;;
+    rst2html|rst2tex)
+      _arguments $runOpts $sharedOpts $docOpts '*:filename:_files -g"*.rst"'
+    ;;
+    buildIndex|genDepend|check)
+      _arguments $sharedOpts '*:filename:_files -g"*.nim"'
+    ;;
+    dump)
+      _arguments $sharedOpts
+    ;;
+    *)
+      _arguments '*:filename:_files -g"*"'
+    ;;
+  esac
+
+  return 1
 }
 
 _nim "$@"
diff --git a/tools/niminst/buildsh.nimf b/tools/niminst/buildsh.nimf
index 015506ea356..26356dd0984 100644
--- a/tools/niminst/buildsh.nimf
+++ b/tools/niminst/buildsh.nimf
@@ -188,8 +188,10 @@ case $ucpu in
     mycpu="powerpc64" ;;
   *power*|*ppc* )
     if [ "$myos" = "freebsd" ] ; then
-      COMP_FLAGS="$COMP_FLAGS -m64"
-      LINK_FLAGS="$LINK_FLAGS -m64"
+      if [ "$ucpu" != "powerpc" ] ; then
+        COMP_FLAGS="$COMP_FLAGS -m64"
+        LINK_FLAGS="$LINK_FLAGS -m64"
+      fi
       mycpu=`uname -p`
       case $mycpu in
         powerpc64le)
@@ -223,6 +225,10 @@ case $ucpu in
     mycpu="arm" ;;
   *riscv64|riscv* )
     mycpu="riscv64" ;;
+  *e2k* )
+    mycpu="e2k" ;;
+  *loongarch64* )
+    mycpu="loongarch64" ;;
   *)
     echo 2>&1 "Error: unknown processor: $ucpu"
     exit 1
diff --git a/tools/niminst/makefile.nimf b/tools/niminst/makefile.nimf
index 5118b0f5316..c68ecb84626 100644
--- a/tools/niminst/makefile.nimf
+++ b/tools/niminst/makefile.nimf
@@ -160,6 +160,12 @@ endif
 ifeq ($(ucpu),riscv64)
   mycpu = riscv64
 endif
+ifeq ($(ucpu),e2k)
+  mycpu = e2k
+endif
+ifeq ($(ucpu),loongarch64)
+  mycpu = loongarch64
+endif
 ifndef mycpu
   $(error unknown CPU architecture: $(ucpu) See makefile.nimf)
 endif