diff --git a/compiler/ccgcalls.nim b/compiler/ccgcalls.nim
index feb5babeacad5..6bbae673a2350 100644
--- a/compiler/ccgcalls.nim
+++ b/compiler/ccgcalls.nim
@@ -146,7 +146,11 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
           else:
             if d.k == locNone: d = getTemp(p, typ.returnType)
             var list = initLoc(locCall, d.lode, OnUnknown)
-            list.snippet = extract(result)
+            var rval = extract(result)
+            # the function returns T& but the temp is T*, so we need &
+            if tfVarIsPtr in typ.returnType.flags:
+              rval = cAddr(rval)
+            list.snippet = rval
             genAssignment(p, d, list, {needAssignCall}) # no need for deep copying
             if canRaise: raiseExit(p)
 
@@ -589,6 +593,8 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
         list.snippet = callIter(rp, pars)
       else:
         list.snippet = callProc(rp, pars, rawProc)
+      if tfVarIsPtr in typ.returnType.flags:
+        list.snippet = cAddr(list.snippet)
       genAssignment(p, d, list, {}) # no need for deep copying
       if canRaise: raiseExit(p)
     else:
@@ -601,6 +607,8 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
         list.snippet = callIter(rp, pars)
       else:
         list.snippet = callProc(rp, pars, rawProc)
+      if tfVarIsPtr in typ.returnType.flags:
+        list.snippet = cAddr(list.snippet)
       genAssignment(p, tmp, list, {})
       if canRaise: raiseExit(p)
       genAssignment(p, d, tmp, {})
diff --git a/compiler/ccgexprs.nim b/compiler/ccgexprs.nim
index e023eeee7bb85..a3a467d706ad3 100644
--- a/compiler/ccgexprs.nim
+++ b/compiler/ccgexprs.nim
@@ -929,6 +929,13 @@ proc genDeref(p: BProc, e: PNode, d: var TLoc) =
     # bug #23453 #25265
     if e.typ != nil and e.typ.skipTypes(abstractInst).kind == tyObject:
       discard getTypeDesc(p.module, e.typ)
+    # C++: genProcParams strips tfVarIsPtr from the signature, so a var T
+    # return is T&. When used directly (lfSingleUse, a.k == locCall) it's a
+    # reference and must not be dereferenced. Temps hold T* (via cAddr) and
+    # still need '*'. The AST type keeps tfVarIsPtr (markResultVarIsPtr),
+    # so we check a.k to tell the two paths apart.
+    let isCppCallRef = p.module.compileToCpp and typ.kind in {tyVar} and
+        tfVarIsPtr in typ.flags and a.k == locCall
     if d.k == locNone:
       # dest = *a;  <-- We do not know that 'dest' is on the heap!
       # It is completely wrong to set 'd.storage' here, unless it's not yet
@@ -938,7 +945,7 @@ proc genDeref(p: BProc, e: PNode, d: var TLoc) =
         d.storage = OnHeap
       of tyVar, tyLent:
         d.storage = OnUnknown
-        if tfVarIsPtr notin typ.flags and p.module.compileToCpp and
+        if (tfVarIsPtr notin typ.flags or isCppCallRef) and p.module.compileToCpp and
             e.kind == nkHiddenDeref:
           putIntoDest(p, d, e, rdLoc(a), a.storage)
           return
@@ -947,7 +954,7 @@ proc genDeref(p: BProc, e: PNode, d: var TLoc) =
       else:
         internalError(p.config, e.info, "genDeref " & $typ.kind)
     elif p.module.compileToCpp:
-      if typ.kind in {tyVar} and tfVarIsPtr notin typ.flags and
+      if typ.kind in {tyVar} and (tfVarIsPtr notin typ.flags or isCppCallRef) and
            e.kind == nkHiddenDeref:
         putIntoDest(p, d, e, rdLoc(a), a.storage)
         return
diff --git a/compiler/ccgtypes.nim b/compiler/ccgtypes.nim
index cd2e325deec76..b63de2df87cad 100644
--- a/compiler/ccgtypes.nim
+++ b/compiler/ccgtypes.nim
@@ -665,7 +665,13 @@ proc genProcParams(m: BModule; t: PType, rettype: var Rope, params: var Builder,
   if t.returnType == nil or isInvalidReturnType(m.config, t):
     rettype = CVoid
   else:
-    rettype = getTypeDescWeak(m, t.returnType, check, dkResult)
+    var rt = t.returnType
+    if m.config.backend == backendCpp and
+        tfVarIsPtr in rt.flags and
+        rt.skipTypes(abstractInst).kind == tyVar:
+      rt = rt.exactReplica(m.idgen)
+      rt.excl(tfVarIsPtr)
+    rettype = getTypeDescWeak(m, rt, check, dkResult)
   var paramBuilder: ProcParamBuilder
   params.addProcParams(paramBuilder):
     for i in 1..<t.n.len:
diff --git a/compiler/cgen.nim b/compiler/cgen.nim
index 52c87264855b5..918ef59572e5e 100644
--- a/compiler/cgen.nim
+++ b/compiler/cgen.nim
@@ -746,10 +746,14 @@ proc getTempCpp(p: BProc, t: PType, value: Rope): TLoc =
   inc(p.labels)
   result = TLoc(snippet: "T" & rope(p.labels) & "_", k: locTemp, lode: lodeTyp t,
                 storage: OnStack, flags: {})
+  let isVarRet = p.module.compileToCpp and
+                 t.skipTypes(abstractInst).kind == tyVar
+  let tmpTyp = if isVarRet: getTypeDesc(p.module, t, dkVar) else: "auto"
+  let initVal = if isVarRet and tfVarIsPtr in t.flags: cAddr(value) else: value
   p.s(cpsStmts).addVar(kind = Local,
     name = result.snippet,
-    typ = "auto",
-    initializer = value)
+    typ = tmpTyp,
+    initializer = initVal)
 
 proc getIntTemp(p: BProc): TLoc =
   inc(p.labels)
@@ -1520,7 +1524,18 @@ proc genProcLvl3*(m: BModule, prc: PSym) =
         else:
           initLocalVar(p, res, immediateAsgn=false)
       var returnBuilder = newBuilder("\t")
-      let rres = rdLoc(res.loc)
+      var rres = rdLoc(res.loc)
+      # Match genProcParams: it checks prc.typ.returnType.flags (not res.typ.flags)
+      # because markResultVarIsPtr sets tfVarIsPtr on the result sym's type, which
+      # can be a different object than prc.typ.returnType for generic instances.
+      # For tyVar of tyArray, genProcParams forces '*' (ctPtrToArray path in
+      # getTypeDescAux overwrites '&' with '*'), so the signature is T* and we
+      # must return 'result' (the pointer), not '*result' (the element).
+      let rt = prc.typ.returnType
+      if m.compileToCpp and rt.skipTypes(abstractInst).kind == tyVar and
+          tfVarIsPtr in rt.flags and
+          mapType(m.config, rt, false) != ctPtrToArray:
+        rres = cDeref(rres)
       returnBuilder.addReturn(rres)
       returnStmt = extract(returnBuilder)
     elif sfConstructor in prc.flags:
diff --git a/tests/cpp_var_typical.nim b/tests/cpp_var_typical.nim
new file mode 100644
index 0000000000000..87253bebed64d
--- /dev/null
+++ b/tests/cpp_var_typical.nim
@@ -0,0 +1,35 @@
+discard """
+  targets: "c cpp"
+  matrix: "--mm:refc; --mm:arc"
+  output: "ok"
+"""
+
+# lfSingleUse path: a var T call result used directly is T& in C++,
+# genDeref must not emit '*' for it.
+block: # bug: C++ genDeref wrongly emitted '*' for a T& reference
+  type Obj = object
+    field: tuple[a, b: int]
+  func get(v: var Obj): var tuple[a, b: int] = v.field
+  var v = Obj(field: (1, 2))
+  doAssert get(v).a == 1
+  doAssert get(v).b == 2
+  get(v).a = 99
+  doAssert v.field.a == 99
+  # tuple unpacking also takes the lfSingleUse path
+  var (xa, xb) = get(v)
+  doAssert xa == 99
+  doAssert xb == 2
+
+# temp path: cAddr turns T& into T*, so '*' must still be emitted.
+block: # ensure the temp path still generates '*' dereference
+  proc id(x: var int): var int = x
+  var n = 42
+  doAssert id(n) == 42
+  id(n) = 99
+  doAssert n == 99
+  # nested call: inner result goes to a temp, outer takes lfSingleUse
+  doAssert id(id(n)) == 99
+  id(id(n)) = 100
+  doAssert n == 100
+
+echo "ok"
diff --git a/tests/proc/tprocvar_var_ret.nim b/tests/proc/tprocvar_var_ret.nim
new file mode 100644
index 0000000000000..6440d3f8c38b1
--- /dev/null
+++ b/tests/proc/tprocvar_var_ret.nim
@@ -0,0 +1,54 @@
+discard """
+  targets: "c cpp"
+"""
+
+proc testVarRet(x: var int): var int = x
+
+proc testProcTypeParam(prc: proc (x: var int): var int {.nimcall.}) =
+  var x = 123
+  prc(x) = 321
+  doAssert x == 321
+
+testProcTypeParam(testVarRet)
+
+var v = 42
+doAssert testVarRet(v) == 42
+testVarRet(v) = 99
+doAssert v == 99
+
+var pVarRet = testVarRet
+var testVar = 1234
+pVarRet(testVar) = 5678
+doAssert testVar == 5678
+
+proc testVarRetStr(x: var string): var string = x
+
+proc testProcTypeParamStr(prc: proc (x: var string): var string {.nimcall.}) =
+  var x = "foo"
+  prc(x) = "bar"
+  doAssert x == "bar"
+
+testProcTypeParamStr(testVarRetStr)
+
+type
+  FooObj = object
+    x, y: int
+
+proc testVarRetObj(x: var FooObj): var FooObj = x
+
+proc testProcTypeParamObj(prc: proc (x: var FooObj): var FooObj {.nimcall.}) =
+  var x = FooObj(x: 111, y: 222)
+  prc(x) = FooObj(x: 333, y: 444)
+  doAssert x == FooObj(x: 333, y: 444)
+
+testProcTypeParamObj(testVarRetObj)
+
+proc testProcTypeParamChain(prc: proc (x: var int): var int {.nimcall.}) =
+  var x = 100
+  var y = 200
+  prc(x) = prc(y)
+  doAssert x == 200
+
+testProcTypeParamChain(testVarRet)
+
+echo "ok"