diff --git a/compiler/ast.nim b/compiler/ast.nim
index 27e4fab63374b..50e8438f0b8dd 100644
--- a/compiler/ast.nim
+++ b/compiler/ast.nim
@@ -503,6 +503,7 @@ type
     nfLastRead  # this node is a last read
     nfFirstWrite# this node is a first write
     nfHasComment # node has a comment
+    nfUseDefaultField
 
   TNodeFlags* = set[TNodeFlag]
   TTypeFlag* = enum   # keep below 32 for efficiency reasons (now: 45)
@@ -1433,6 +1434,17 @@ proc newIntTypeNode*(intVal: BiggestInt, typ: PType): PNode =
   result.intVal = intVal
   result.typ = typ
 
+proc newFloatTypeNode*(floatVal: BiggestFloat, typ: PType): PNode =
+  let kind = skipTypes(typ, abstractVarRange).kind
+  case kind
+  of tyFloat32:
+    result = newNode(nkFloat32Lit)
+  of tyFloat64, tyFloat:
+    result = newNode(nkFloatLit)
+  else: doAssert false, $kind
+  result.floatVal = floatVal
+  result.typ = typ
+
 proc newIntTypeNode*(intVal: Int128, typ: PType): PNode =
   # XXX: introduce range check
   newIntTypeNode(castToInt64(intVal), typ)
diff --git a/compiler/parser.nim b/compiler/parser.nim
index 52466d9fa0f04..2f89efc560d7c 100644
--- a/compiler/parser.nim
+++ b/compiler/parser.nim
@@ -1963,11 +1963,7 @@ proc parseObjectCase(p: var Parser): PNode =
   #|             | IND{=} objectBranches)
   result = newNodeP(nkRecCase, p)
   getTokNoInd(p)
-  var a = newNodeP(nkIdentDefs, p)
-  a.add(identWithPragma(p))
-  eat(p, tkColon)
-  a.add(parseTypeDesc(p))
-  a.add(p.emptyNode)
+  var a = parseIdentColonEquals(p, {withPragma})
   result.add(a)
   if p.tok.tokType == tkColon: getTok(p)
   flexComment(p, result)
diff --git a/compiler/sem.nim b/compiler/sem.nim
index 70c57864c5d09..3ecadf3fc5c68 100644
--- a/compiler/sem.nim
+++ b/compiler/sem.nim
@@ -535,6 +535,164 @@ proc setGenericParamsMisc(c: PContext; n: PNode) =
   else:
     n[miscPos][1] = orig
 
+proc caseBranchMatchesExpr(branch, matched: PNode): bool =
+  for i in 0 ..< branch.len-1:
+    if branch[i].kind == nkRange:
+      if overlap(branch[i], matched): return true
+    elif exprStructuralEquivalent(branch[i], matched):
+      return true
+
+proc pickCaseBranchIndex(caseExpr, matched: PNode): int =
+  let endsWithElse = caseExpr[^1].kind == nkElse
+  for i in 1..<caseExpr.len - endsWithElse.int:
+    if caseExpr[i].caseBranchMatchesExpr(matched):
+      return i
+  if endsWithElse:
+    return caseExpr.len - 1
+
+proc defaultFieldsForTheUninitialized(c: PContext, recNode: PNode, hasDefault: var bool): seq[PNode] =
+  case recNode.kind
+  of nkRecList:
+    for field in recNode:
+      result.add defaultFieldsForTheUninitialized(c, field, hasDefault)
+  of nkRecCase:
+    let discriminator = recNode[0]
+    var selectedBranch: int
+    let defaultValue = discriminator.sym.ast
+    if defaultValue == nil:
+      # None of the branches were explicitly selected by the user and no value
+      # was given to the discrimator. We can assume that it will be initialized
+      # to zero and this will select a particular branch as a result:
+      selectedBranch = recNode.pickCaseBranchIndex newIntNode(nkIntLit#[c.graph]#, 0)
+    else: # Try to use default value
+      selectedBranch = recNode.pickCaseBranchIndex defaultValue
+      result.add newTree(nkExprColonExpr, discriminator, defaultValue)
+    result.add defaultFieldsForTheUninitialized(c, recNode[selectedBranch][^1], hasDefault)
+  of nkSym:
+    let field = recNode.sym
+    let recType = recNode.typ.skipTypes({tyGenericInst, tyAlias, tySink})
+    if field.ast != nil: #Try to use default value
+      result.add newTree(nkExprColonExpr, recNode, field.ast)
+      hasDefault = true
+    elif recType.kind == tyObject:
+      var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, recNode.info, recNode.typ))
+      asgnExpr.typ = recNode.typ
+      asgnExpr.flags.incl nfUseDefaultField
+      asgnExpr.sons.add defaultFieldsForTheUninitialized(c, recType.n, hasDefault)
+      result.add newTree(nkExprColonExpr, recNode, asgnExpr)
+    elif recType.kind == tyArray and recType[1].skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyObject:
+      var objExpr = newTree(nkObjConstr, newNodeIT(nkType, recNode.info, recType[1]))
+      objExpr.typ = recType[1].skipTypes({tyGenericInst, tyAlias, tySink})
+      var t = objExpr.typ
+      while true:
+        objExpr.sons.add defaultFieldsForTheUninitialized(c, t.n, hasDefault)
+        let base = t[0]
+        if base == nil:
+          break
+        t = skipTypes(base, skipPtrs)
+
+
+      let node = newNode(nkIntLit)
+      node.intVal = toInt(lengthOrd(c.graph.config, recType))
+      var asgnExpr = newTree(nkCall, newSymNode(getSysSym(c.graph, recNode.info, "newDefaultArray"), recNode.info),
+      # var asgnExpr = newTree(nkCall, newSymNode(getCompilerProc(c.graph, "newDefaultArray")),
+              node,
+              objExpr
+              )
+      asgnExpr.typ = recNode.typ
+      asgnExpr.flags.incl nfUseDefaultField
+
+      # asgnExpr.sons.setLen(toInt(lengthOrd(c, recType)))
+      # for i in 0..<asgnExpr.sons.len:
+      #   asgnExpr[i] = objExpr
+      let asgnExpr2 = semExprWithType(c, asgnExpr)
+      result.add newTree(nkExprColonExpr, recNode, asgnExpr2)
+
+      # asgnExpr.sons.setLen(toInt(lengthOrd(c.graph.config, recType)))
+      # for i in 0..<asgnExpr.sons.len:
+      #   asgnExpr[i] = objExpr
+      # result.add newTree(nkExprColonExpr, recNode,
+      #   asgnExpr)
+    elif recType.kind == tyTuple:
+      # doAssert false
+      discard
+    elif recType.kind in {tyInt..tyInt64, tyUInt..tyUInt64}:
+      let asgnExpr = newIntTypeNode(int64(0), recType)
+      asgnExpr.flags.incl nfUseDefaultField
+      result.add newTree(nkExprColonExpr, recNode,
+              asgnExpr)
+    elif recType.kind in tyFloat..tyFloat64:
+      let asgnExpr = newFloatTypeNode(BiggestFloat(0.0), recType)
+      asgnExpr.flags.incl nfUseDefaultField
+      result.add newTree(nkExprColonExpr, recNode,
+              asgnExpr)
+
+  else:
+    assert false
+
+proc defaultNodeField(c: PContext, a: PNode): PNode =
+  let aTyp = a.typ
+  var hasDefault: bool
+  if aTyp.skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyObject:
+    var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, a.info, aTyp))
+    asgnExpr.typ = aTyp
+    asgnExpr.sons.add defaultFieldsForTheUninitialized(c, aTyp.skipTypes({tyGenericInst, tyAlias, tySink}).n, hasDefault)
+    if hasDefault:
+      result = asgnExpr
+  elif aTyp.kind == tyArray and aTyp[1].skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyObject:
+    var objExpr = newTree(nkObjConstr, newNodeIT(nkType, a.info, aTyp[1]))
+    objExpr.typ = aTyp[1].skipTypes({tyGenericInst, tyAlias, tySink})
+    # objExpr.sons.add defaults # todo create clean?
+
+    var t = objExpr.typ
+    while true:
+      objExpr.sons.add defaultFieldsForTheUninitialized(c, t.n, hasDefault)
+      let base = t[0]
+      if base == nil:
+        break
+      t = skipTypes(base, skipPtrs)
+
+    let node = newNode(nkIntLit)
+    node.intVal = toInt(lengthOrd(c.graph.config, aTyp))
+    var asgnExpr = newTree(nkCall, newSymNode(getSysSym(c.graph, a.info, "newDefaultArray"), a.info),
+    # var asgnExpr = newTree(nkCall, newSymNode(getCompilerProc(c.graph, "newDefaultArray")),
+            node,
+            objExpr
+            )
+    asgnExpr.typ = a.typ
+    asgnExpr.flags.incl nfUseDefaultField
+
+    # asgnExpr.sons.setLen(toInt(lengthOrd(c, recType)))
+    # for i in 0..<asgnExpr.sons.len:
+    #   asgnExpr[i] = objExpr
+    let asgnExpr2 = semExprWithType(c, asgnExpr)
+    if hasDefault:
+      result = asgnExpr2
+  elif aTyp.kind == tyTuple:
+    var tupleExpr = newNodeI(nkTupleConstr, a.info)
+    tupleExpr.typ = aTyp
+    for s in aTyp.sons:
+      let sType = s.skipTypes({tyGenericInst, tyAlias, tySink})
+      if sType.kind == tyObject:
+        var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, a.info, s))
+        asgnExpr.typ = s
+        asgnExpr.sons.add defaultFieldsForTheUninitialized(c, sType.n, hasDefault)
+        tupleExpr.add asgnExpr
+      elif sType.kind in {tyInt..tyInt64, tyUInt..tyUInt64}:
+        let asgnExpr = newIntTypeNode(int64(0), sType)
+        asgnExpr.flags.incl nfUseDefaultField
+        tupleExpr.add asgnExpr
+      elif sType.kind in tyFloat..tyFloat64:
+        let asgnExpr =
+          if sType.kind == tyFloat32:
+            newFloatNode(nkFloat32Lit, BiggestFloat(0.0))
+          else:
+            newFloatNode(nkFloatLit, BiggestFloat(0.0))
+        asgnExpr.flags.incl nfUseDefaultField
+        tupleExpr.add asgnExpr
+    if hasDefault:
+      result = tupleExpr
+
 include semtempl, semgnrc, semstmts, semexprs
 
 proc addCodeForGenerics(c: PContext, n: PNode) =
diff --git a/compiler/semexprs.nim b/compiler/semexprs.nim
index d3c62629d3c00..f14c438d0bdf8 100644
--- a/compiler/semexprs.nim
+++ b/compiler/semexprs.nim
@@ -900,8 +900,6 @@ proc semOverloadedCallAnalyseEffects(c: PContext, n: PNode, nOrig: PNode,
           rawAddSon(typ, result.typ)
           result.typ = typ
 
-proc semObjConstr(c: PContext, n: PNode, flags: TExprFlags): PNode
-
 proc resolveIndirectCall(c: PContext; n, nOrig: PNode;
                          t: PType): TCandidate =
   initCandidate(c, result, t)
@@ -2397,6 +2395,16 @@ proc semMagic(c: PContext, n: PNode, s: PSym, flags: TExprFlags): PNode =
   of mSizeOf:
     markUsed(c, n.info, s)
     result = semSizeof(c, setMs(n, s))
+  of mDefault:
+    result = semDirectOp(c, n, flags)
+    let typ = result[^1].typ.skipTypes({tyTypeDesc})
+    if typ.skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyObject:
+      var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, result[^1].info, typ))
+      asgnExpr.typ = typ
+      var hasDefault: bool
+      asgnExpr.sons.add defaultFieldsForTheUninitialized(c, typ.skipTypes({tyGenericInst, tyAlias, tySink}).n, hasDefault)
+      if hasDefault:
+        result = semObjConstr(c, asgnExpr, flags)
   else:
     result = semDirectOp(c, n, flags)
 
diff --git a/compiler/semmagic.nim b/compiler/semmagic.nim
index d3e12670b2343..696bd8130db1d 100644
--- a/compiler/semmagic.nim
+++ b/compiler/semmagic.nim
@@ -10,6 +10,8 @@
 # This include file implements the semantic checking for magics.
 # included from sem.nim
 
+proc semObjConstr(c: PContext, n: PNode, flags: TExprFlags): PNode
+
 proc semAddrArg(c: PContext; n: PNode): PNode =
   let x = semExprWithType(c, n)
   if x.kind == nkSym:
@@ -512,6 +514,23 @@ proc magicsAfterOverloadResolution(c: PContext, n: PNode,
       result = n
     else:
       result = plugin(c, n)
+  of mNew:
+    result = n
+    let typ = result[^1].typ
+    if typ.skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyRef and typ.skipTypes({tyGenericInst, tyAlias, tySink})[0].kind == tyObject:
+      var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, result[^1].info, typ))
+      asgnExpr.typ = typ
+      var hasDefault: bool
+      var t = typ.skipTypes({tyGenericInst, tyAlias, tySink})[0]
+      while true:
+        asgnExpr.sons.add defaultFieldsForTheUninitialized(c, t.n, hasDefault)
+        let base = t[0]
+        if base == nil:
+          break
+        t = skipTypes(base, skipPtrs)
+
+      if hasDefault: # todo apply default
+        result = newTree(nkAsgn, result[^1], asgnExpr)
   of mNewFinalize:
     # Make sure the finalizer procedure refers to a procedure
     if n[^1].kind == nkSym and n[^1].sym.kind notin {skProc, skFunc}:
diff --git a/compiler/semobjconstr.nim b/compiler/semobjconstr.nim
index 6d11d321ec24d..c518c11345224 100644
--- a/compiler/semobjconstr.nim
+++ b/compiler/semobjconstr.nim
@@ -29,6 +29,10 @@ type
     initNone     # None of the fields have been initialized
     initConflict # Fields from different branches have been initialized
 
+
+proc semConstructFields(c: PContext, n: PNode, constrCtx: var ObjConstrContext,
+                        flags: TExprFlags): tuple[status: InitStatus, defaults: seq[PNode]]
+
 proc mergeInitStatus(existing: var InitStatus, newStatus: InitStatus) =
   case newStatus
   of initConflict:
@@ -72,7 +76,9 @@ proc semConstrField(c: PContext, flags: TExprFlags,
   let assignment = locateFieldInInitExpr(c, field, initExpr)
   if assignment != nil:
     if nfSem in assignment.flags: return assignment[1]
-    if not fieldVisible(c, field):
+    if nfUseDefaultField in assignment[1].flags:
+      discard
+    elif not fieldVisible(c, field):
       localError(c.config, initExpr.info,
         "the field '$1' is not accessible." % [field.name.s])
       return
@@ -85,15 +91,6 @@ proc semConstrField(c: PContext, flags: TExprFlags,
     assignment.flags.incl nfSem
     return initValue
 
-proc caseBranchMatchesExpr(branch, matched: PNode): bool =
-  for i in 0..<branch.len-1:
-    if branch[i].kind == nkRange:
-      if overlap(branch[i], matched): return true
-    elif exprStructuralEquivalent(branch[i], matched):
-      return true
-
-  return false
-
 proc branchVals(c: PContext, caseNode: PNode, caseIdx: int,
                 isStmtBranch: bool): IntSet =
   if caseNode[caseIdx].kind == nkOfBranch:
@@ -155,18 +152,14 @@ proc collectMissingFields(c: PContext, fieldsRecList: PNode,
       if assignment == nil:
         constrCtx.missingFields.add r.sym
 
-
-proc semConstructFields(c: PContext, n: PNode,
-                        constrCtx: var ObjConstrContext,
-                        flags: TExprFlags): InitStatus =
-  result = initUnknown
-
+proc semConstructFields(c: PContext, n: PNode, constrCtx: var ObjConstrContext,
+                        flags: TExprFlags): tuple[status: InitStatus, defaults: seq[PNode]] =
   case n.kind
   of nkRecList:
     for field in n:
-      let status = semConstructFields(c, field, constrCtx, flags)
-      mergeInitStatus(result, status)
-
+      let (subSt, subDf) = semConstructFields(c, field, constrCtx, flags)
+      result.status.mergeInitStatus subSt
+      result.defaults.add subDf
   of nkRecCase:
     template fieldsPresentInBranch(branchIdx: int): string =
       let branch = n[branchIdx]
@@ -184,9 +177,9 @@ proc semConstructFields(c: PContext, n: PNode,
 
     for i in 1..<n.len:
       let innerRecords = n[i][^1]
-      let status = semConstructFields(c, innerRecords, constrCtx, flags)
+      let (status, _) = semConstructFields(c, innerRecords, constrCtx, flags) # todo
       if status notin {initNone, initUnknown}:
-        mergeInitStatus(result, status)
+        result.status.mergeInitStatus status
         if selectedBranch != -1:
           let prevFields = fieldsPresentInBranch(selectedBranch)
           let currentFields = fieldsPresentInBranch(i)
@@ -194,7 +187,7 @@ proc semConstructFields(c: PContext, n: PNode,
             ("The fields '$1' and '$2' cannot be initialized together, " &
             "because they are from conflicting branches in the case object.") %
             [prevFields, currentFields])
-          result = initConflict
+          result.status = initConflict
         else:
           selectedBranch = i
 
@@ -206,7 +199,7 @@ proc semConstructFields(c: PContext, n: PNode,
             ("cannot prove that it's safe to initialize $1 with " &
             "the runtime value for the discriminator '$2' ") %
             [fields, discriminator.sym.name.s])
-        mergeInitStatus(result, initNone)
+        mergeInitStatus(result.status, initNone)
 
       template wrongBranchError(i) =
         if c.inUncheckedAssignSection == 0:
@@ -289,13 +282,16 @@ proc semConstructFields(c: PContext, n: PNode,
           else:
             wrongBranchError(failedBranch)
 
+      let (_, defaults) = semConstructFields(c, branchNode[^1], constrCtx, flags)
+      result.defaults.add defaults
+
       # When a branch is selected with a partial match, some of the fields
       # that were not initialized may be mandatory. We must check for this:
-      if result == initPartial:
+      if result.status == initPartial:
         collectMissingFields branchNode
 
     else:
-      result = initNone
+      result.status = initNone
       let discriminatorVal = semConstrField(c, flags + {efPreferStatic},
                                             discriminator.sym,
                                             constrCtx.initExpr)
@@ -308,33 +304,41 @@ proc semConstructFields(c: PContext, n: PNode,
         let matchedBranch = n.pickCaseBranch defaultValue
         collectMissingFields matchedBranch
       else:
-        result = initPartial
+        result.status = initPartial
         if discriminatorVal.kind == nkIntLit:
           # When the discriminator is a compile-time value, we also know
           # which branch will be selected:
           let matchedBranch = n.pickCaseBranch discriminatorVal
-          if matchedBranch != nil: collectMissingFields matchedBranch
+          if matchedBranch != nil:
+            let (_, defaults) = semConstructFields(c, matchedBranch[^1], constrCtx, flags)
+            result.defaults.add defaults
+            collectMissingFields matchedBranch
         else:
           # All bets are off. If any of the branches has a mandatory
           # fields we must produce an error:
           for i in 1..<n.len: collectMissingFields n[i]
-
   of nkSym:
     let field = n.sym
     let e = semConstrField(c, flags, field, constrCtx.initExpr)
-    result = if e != nil: initFull else: initNone
-
+    if e != nil:
+      result.status = initFull
+    elif field.ast != nil:
+      result.status = initUnknown
+      result.defaults.add newTree(nkExprColonExpr, n, field.ast)
+    else:
+      result.status = initNone
   else:
     internalAssert c.config, false
 
 proc semConstructTypeAux(c: PContext,
                          constrCtx: var ObjConstrContext,
-                         flags: TExprFlags): InitStatus =
-  result = initUnknown
+                         flags: TExprFlags): tuple[status: InitStatus, defaults: seq[PNode]] =
+  result.status = initUnknown
   var t = constrCtx.typ
   while true:
-    let status = semConstructFields(c, t.n, constrCtx, flags)
-    mergeInitStatus(result, status)
+    let (status, defaults) = semConstructFields(c, t.n, constrCtx, flags)
+    result.status.mergeInitStatus status
+    result.defaults.add defaults
     if status in {initPartial, initNone, initUnknown}:
       collectMissingFields c, t.n, constrCtx
     let base = t[0]
@@ -378,7 +382,9 @@ proc defaultConstructionError(c: PContext, t: PType, info: TLineInfo) =
 proc semObjConstr(c: PContext, n: PNode, flags: TExprFlags): PNode =
   var t = semTypeNode(c, n[0], nil)
   result = newNodeIT(nkObjConstr, n.info, t)
-  for child in n: result.add child
+  result.add newNodeIT(nkType, n.info, t) #This will contain the default values to be added in transf
+  for i in 1..<n.len:
+    result.add n[i]
 
   if t == nil:
     return localErrorNode(c, result, "object constructor needs an object type")
@@ -399,7 +405,8 @@ proc semObjConstr(c: PContext, n: PNode, flags: TExprFlags): PNode =
   # field (if this is a case object, initialized fields in two different
   # branches will be reported as an error):
   var constrCtx = initConstrContext(t, result)
-  let initResult = semConstructTypeAux(c, constrCtx, flags)
+  let (initResult, defaults) = semConstructTypeAux(c, constrCtx, flags)
+  result[0].sons.add defaults
   var hasError = false # needed to split error detect/report for better msgs
 
   # It's possible that the object was not fully initialized while
diff --git a/compiler/semstmts.nim b/compiler/semstmts.nim
index 8b0691abf4d19..a8b5ef59f31b0 100644
--- a/compiler/semstmts.nim
+++ b/compiler/semstmts.nim
@@ -596,6 +596,15 @@ proc semVarOrLet(c: PContext, n: PNode, symkind: TSymKind): PNode =
     var typFlags: TTypeAllowedFlags
 
     var def: PNode = c.graph.emptyNode
+    if a[^1].kind == nkEmpty and symkind == skVar and a[^2].typ != nil:
+      let m = copyTree(a[0])
+      # var v = semIdentDef(c, m, symkind, false)
+      # if {sfThread, sfNoInit} * v.flags != {}: # todo var m1, m2 {threadvar}
+      #   discard # todo init threadvar properly
+      # else:
+      let field = defaultNodeField(c, a[^2])
+      if field != nil:
+        a[^1] = field
     if a[^1].kind != nkEmpty:
       def = semExprWithType(c, a[^1], {})
 
@@ -664,6 +673,9 @@ proc semVarOrLet(c: PContext, n: PNode, symkind: TSymKind): PNode =
         addToVarSection(c, result, n, a)
         continue
       var v = semIdentDef(c, a[j], symkind, false)
+      if {sfThread, sfNoInit} * v.flags != {}:
+        a[^1] = c.graph.emptyNode
+        def = c.graph.emptyNode
       styleCheckDef(c, v)
       onDef(a[j].info, v)
       if sfGenSym notin v.flags:
diff --git a/compiler/semtypes.nim b/compiler/semtypes.nim
index 584da13051591..948776d43f7c3 100644
--- a/compiler/semtypes.nim
+++ b/compiler/semtypes.nim
@@ -777,14 +777,21 @@ proc semRecordNodeAux(c: PContext, n: PNode, check: var IntSet, pos: var int,
     var a: PNode
     if father.kind != nkRecList and n.len >= 4: a = newNodeI(nkRecList, n.info)
     else: a = newNodeI(nkEmpty, n.info)
-    if n[^1].kind != nkEmpty:
-      localError(c.config, n[^1].info, errInitHereNotAllowed)
     var typ: PType
-    if n[^2].kind == nkEmpty:
+    var hasDefaultField = n[^1].kind != nkEmpty
+    if hasDefaultField:
+      n[^1] = semConstExpr(c, n[^1])
+      typ = n[^1].typ
+      propagateToOwner(rectype, typ)
+    elif n[^2].kind == nkEmpty:
       localError(c.config, n.info, errTypeExpected)
       typ = errorType(c)
     else:
       typ = semTypeNode(c, n[^2], nil)
+      if c.graph.config.isDefined("nimRangeDefault") and typ.skipTypes(abstractInst).kind in {tyRange, tyOrdinal}:
+        n[^1] = newIntNode(nkIntLit, firstOrd(c.config, typ))
+        n[^1].typ = typ
+        hasDefaultField = true
       propagateToOwner(rectype, typ)
     var fieldOwner = if c.inGenericContext > 0: c.getCurrOwner
                      else: rectype.sym
@@ -806,8 +813,12 @@ proc semRecordNodeAux(c: PContext, n: PNode, check: var IntSet, pos: var int,
       inc(pos)
       if containsOrIncl(check, f.name.id):
         localError(c.config, info, "attempt to redefine: '" & f.name.s & "'")
-      if a.kind == nkEmpty: father.add newSymNode(f)
-      else: a.add newSymNode(f)
+      let fSym = newSymNode(f)
+      if hasDefaultField:
+        fSym.sym.ast = n[^1]
+        fSym.sym.ast.flags.incl nfUseDefaultField
+      if a.kind == nkEmpty: father.add fSym
+      else: a.add fSym
       styleCheckDef(c, f)
       onDef(f.info, f)
     if a.kind != nkEmpty: father.add a
diff --git a/compiler/transf.nim b/compiler/transf.nim
index bdd7c680ccd51..b44c45a6b659a 100644
--- a/compiler/transf.nim
+++ b/compiler/transf.nim
@@ -46,7 +46,7 @@ type
     module: PSym
     transCon: PTransCon      # top of a TransCon stack
     inlining: int            # > 0 if we are in inlining context (copy vars)
-    nestedProcs: int         # > 0 if we are in a nested proc
+    genResult: bool
     contSyms, breakSyms: seq[PSym]  # to transform 'continue' and 'break'
     deferDetected, tooEarly: bool
     graph: ModuleGraph
@@ -935,6 +935,21 @@ proc transform(c: PTransf, n: PNode): PNode =
                   nkBlockStmt, nkBlockExpr}:
       oldDeferAnchor = c.deferAnchor
       c.deferAnchor = n
+
+  # if c.genResult:
+  #   c.genResult = false
+  #   result = newNodeIT(nkStmtList, n.info, nil)
+  #   let toInit = c.getCurrOwner().ast[resultPos]
+
+  #   if toInit.typ != nil:
+  #     let field = defaultNodeField(c.graph, toInit)
+
+  #     if field != nil:
+  #       result.add newTree(nkAsgn, toInit, field)
+
+  #   result.add transform(c, n)
+  #   return result
+
   case n.kind
   of nkSym:
     result = transformSym(c, n)
@@ -1052,6 +1067,13 @@ proc transform(c: PTransf, n: PNode): PNode =
       result = n
   of nkExceptBranch:
     result = transformExceptBranch(c, n)
+  of nkObjConstr:
+    result = n
+    if result.typ.skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyObject or
+       result.typ.skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyRef and result.typ.skipTypes({tyGenericInst, tyAlias, tySink})[0].kind == tyObject:
+      result.sons.add result[0].sons
+      result[0] = newNodeIT(nkType, result.info, result.typ)
+    result = transformSons(c, result)
   of nkCheckedFieldExpr:
     result = transformSons(c, n)
     if result[0].kind != nkDotExpr:
@@ -1079,6 +1101,7 @@ proc processTransf(c: PTransf, n: PNode, owner: PSym): PNode =
   # nodes into an empty node.
   if nfTransf in n.flags: return n
   pushTransCon(c, newTransCon(owner))
+  c.genResult = c.getCurrOwner().kind in routineKinds and c.transCon.owner.ast.len > resultPos and c.transCon.owner.ast[resultPos] != nil
   result = transform(c, n)
   popTransCon(c)
   incl(result.flags, nfTransf)
diff --git a/lib/system.nim b/lib/system.nim
index 738666e8da32e..faf79f6a91770 100644
--- a/lib/system.nim
+++ b/lib/system.nim
@@ -573,6 +573,11 @@ when notJSnotNims and not defined(nimSeqsV2):
   template space(s: PGenericSeq): int {.dirty.} =
     s.reserved and not (seqShallowFlag or strlitFlag)
 
+
+proc newDefaultArray*[T](N: static int, y: T): array[N, T] =
+  for i in 0..N-1:
+    result[i] = y
+
 when notJSnotNims:
   include "system/hti"
 
diff --git a/tests/objects/mobject_default_value.nim b/tests/objects/mobject_default_value.nim
new file mode 100644
index 0000000000000..2245495015075
--- /dev/null
+++ b/tests/objects/mobject_default_value.nim
@@ -0,0 +1,15 @@
+type
+  Clean = object
+    mem: int
+  Default* = object
+    poi: int = 12
+    clc: Clean
+    se*: range[0'i32 .. high(int32)]
+
+  NonDefault* = object
+    poi: int
+
+  PrellDeque*[T] = object
+    pendingTasks*: range[0'i32 .. high(int32)]
+    head: T
+    tail: T
diff --git a/tests/objects/tobject_default_value.nim b/tests/objects/tobject_default_value.nim
new file mode 100644
index 0000000000000..82e1275edacdc
--- /dev/null
+++ b/tests/objects/tobject_default_value.nim
@@ -0,0 +1,238 @@
+discard """
+  matrix: "-d:nimRangeDefault"
+  targets: "c cpp js"
+"""
+
+import times
+
+type
+  Guess = object
+    poi: DateTime
+
+block:
+  var x: Guess
+  discard x
+
+  discard Guess()
+
+import mobject_default_value
+
+block:
+  let x = Default()
+  doAssert x.se == 0'i32
+# echo Default(poi: 12)
+# echo Default(poi: 17)
+
+# echo NonDefault(poi: 77)
+
+block:
+  var x: Default
+  doAssert x.se == 0'i32
+
+type
+  ObjectBase = object of RootObj
+    value = 12
+
+  Object = object of ObjectBase
+    time: float = 1.2
+    date: int
+    scale: range[1..10]
+
+  Object2 = object
+    name: Object
+
+  Object3 = object
+    obj: Object2
+
+  ObjectTuple = tuple
+    base: ObjectBase
+    typ: int
+    obj: Object
+
+  Ref = ref object of ObjectBase
+
+  RefInt = ref object of Ref
+    data = 73
+
+var t {.threadvar.}: Default
+# var m1, m2 {.threadvar.}: Default
+
+block:
+  doAssert t.se == 0'i32
+
+block:
+  var x: ObjectBase
+  doAssert x.value == 12
+  let y = default(ObjectBase)
+  doAssert y.value == 12
+
+block:
+  var x: Object
+  doAssert x.value == 12
+  doAssert x.time == 1.2
+  doAssert x.scale == 1
+  let y = default(Object)
+  doAssert y.value == 12
+  doAssert y.time == 1.2
+  doAssert y.scale == 1
+
+  var x1, x2, x3: Object
+  doAssert x1.value == 12
+  doAssert x1.time == 1.2
+  doAssert x1.scale == 1
+  doAssert x2.value == 12
+  doAssert x2.time == 1.2
+  doAssert x2.scale == 1
+  doAssert x3.value == 12
+  doAssert x3.time == 1.2
+  doAssert x3.scale == 1
+
+block:
+  var x: Ref
+  new(x)
+  doAssert x.value == 12, "Ref.value = " & $x.value
+
+  var y: RefInt
+  new(y)
+  doAssert y.value == 12
+  doAssert y.data == 73
+
+# block: # object array
+#   var x: ObjectArray
+#   echo x
+
+block:
+  var x: Object2
+  doAssert x.name.value == 12
+  doAssert x.name.time == 1.2
+  doAssert x.name.scale == 1
+
+block:
+  var x: Object3
+  doAssert x.obj.name.value == 12
+  doAssert x.obj.name.time == 1.2
+  doAssert x.obj.name.scale == 1
+
+# block: #seq
+#   var x = newSeq[Object](10)
+#   echo x
+
+block: # array
+  var x: array[10, Object]
+  let y = x[0]
+  doAssert y.value == 12
+  doAssert y.time == 1.2
+  doAssert y.scale == 1
+
+block: # array
+  var x {.noinit.}: array[10, Object]
+  discard x
+
+# block: # tuple
+#   var x: ObjectTuple
+#   doAssert x.base.value == 12
+#   doAssert x.typ == 0
+#   doAssert x.obj.time == 1.2
+#   doAssert x.obj.date == 0
+#   doAssert x.obj.scale == 1
+#   doAssert x.obj.value == 12
+
+type
+  ObjectArray = object
+    data: array[10, Object]
+
+block:
+  var x: ObjectArray
+  let y = x.data[0]
+  doAssert y.value == 12
+  doAssert y.time == 1.2
+  doAssert y.scale == 1
+
+
+block:
+  var x: PrellDeque[int]
+  doAssert x.pendingTasks == 0
+
+type
+  Color = enum
+    Red, Blue, Yellow
+
+  ObjectVarint = object
+    case kind: Color
+    of Red:
+      data: int = 10
+    of Blue:
+      fill = "123"
+    of Yellow:
+      time = 1.8'f32
+
+  ObjectVarint1 = object
+    case kind: Color = Blue
+    of Red:
+      data1: int = 10
+    of Blue:
+      fill2 = "123"
+      cry: float
+    of Yellow:
+      time3 = 1.8'f32
+      him: int
+
+block:
+  var x = ObjectVarint(kind: Red)
+  doAssert x.kind == Red
+  doAssert x.data == 10
+
+block:
+  var x = ObjectVarint(kind: Blue)
+  doAssert x.kind == Blue
+  doAssert x.fill == "123"
+
+block:
+  var x = ObjectVarint(kind: Yellow)
+  doAssert x.kind == Yellow
+  doAssert typeof(x.time) is float32
+
+block:
+  var x: ObjectVarint1
+  doAssert x.kind == Blue
+  doAssert x.fill2 == "123"
+  x.cry = 326
+
+
+type
+  ObjectVarint2 = object
+    case kind: Color
+    of Red:
+      data: int = 10
+    of Blue:
+      fill = "123"
+    of Yellow:
+      time = 1.8'f32
+
+  ObjectVarint3 = object
+    case kind: Color = Blue
+    of Red:
+      data1: int = 10
+    of Blue:
+      case name: Color = Blue
+      of Blue:
+        go = 12
+      else:
+        temp = 66
+      fill2 = "123"
+      cry: float
+    of Yellow:
+      time3 = 1.8'f32
+      him: int
+
+block:
+  var x: ObjectVarint3
+  doAssert x.kind == Blue
+  doAssert x.name == Blue
+  doAssert x.go == 12
+
+block:
+  var x = ObjectVarint3(kind: Blue, name: Red, temp: 99)
+  doAssert x.kind == Blue
+  doAssert x.name == Red
+  doAssert x.temp == 99