diff --git a/src/spicelib/devices/bjt/bjtnoise.c b/src/spicelib/devices/bjt/bjtnoise.c
index 6e7258491..e26cfa53f 100644
--- a/src/spicelib/devices/bjt/bjtnoise.c
+++ b/src/spicelib/devices/bjt/bjtnoise.c
@@ -82,17 +82,23 @@ BJTnoise(int mode, int operation, GENmodel*genmodel, CKTcircuit *ckt,
                 switch (mode) {
 
                 case N_DENS:
-                    NevalSrc(&noizDens[BJTRCNOIZ],&lnNdens[BJTRCNOIZ],
+                    double dtemp;
+                    if (inst->BJTtempGiven)
+                        dtemp = inst->BJTtemp - ckt->CKTtemp + (model->BJTtnom-CONSTCtoK);
+                    else
+                        dtemp = inst->BJTdtemp;
+
+                    NevalSrcInstanceTemp(&noizDens[BJTRCNOIZ],&lnNdens[BJTRCNOIZ],
                         ckt, THERMNOISE, inst->BJTcollCXNode, inst->BJTcolNode,
-                        inst->BJTtcollectorConduct * inst->BJTm);
+                        inst->BJTtcollectorConduct * inst->BJTm, dtemp);
 
-                    NevalSrc(&noizDens[BJTRBNOIZ],&lnNdens[BJTRBNOIZ],
+                    NevalSrcInstanceTemp(&noizDens[BJTRBNOIZ],&lnNdens[BJTRBNOIZ],
                         ckt, THERMNOISE, inst->BJTbasePrimeNode, inst->BJTbaseNode,
-                        *(ckt->CKTstate0 + inst->BJTgx) * inst->BJTm);
+                        *(ckt->CKTstate0 + inst->BJTgx) * inst->BJTm, dtemp);
 
-                    NevalSrc(&noizDens[BJT_RE_NOISE],&lnNdens[BJT_RE_NOISE],
+                    NevalSrcInstanceTemp(&noizDens[BJT_RE_NOISE],&lnNdens[BJT_RE_NOISE],
                         ckt, THERMNOISE, inst->BJTemitPrimeNode, inst->BJTemitNode,
-                        inst->BJTtemitterConduct * inst->BJTm);
+                        inst->BJTtemitterConduct * inst->BJTm, dtemp);
 
                     NevalSrc(&noizDens[BJTICNOIZ],&lnNdens[BJTICNOIZ],
                         ckt, SHOTNOISE, inst->BJTcolPrimeNode, inst->BJTemitPrimeNode,
diff --git a/src/spicelib/devices/dio/dionoise.c b/src/spicelib/devices/dio/dionoise.c
index 1331977ab..ea893826d 100644
--- a/src/spicelib/devices/dio/dionoise.c
+++ b/src/spicelib/devices/dio/dionoise.c
@@ -80,9 +80,17 @@ DIOnoise(int mode, int operation, GENmodel *genmodel, CKTcircuit *ckt,
                 switch (mode) {
 
                 case N_DENS:
-                    NevalSrc(&noizDens[DIORSNOIZ],&lnNdens[DIORSNOIZ],
+
+                    double dtemp;
+                    if (inst->DIOtempGiven)
+                        dtemp = inst->DIOtemp - ckt->CKTtemp + (model->DIOnomTemp-CONSTCtoK);
+                    else
+                        dtemp = inst->DIOdtemp;
+
+                    NevalSrcInstanceTemp(&noizDens[DIORSNOIZ],&lnNdens[DIORSNOIZ],
                         ckt, THERMNOISE, inst->DIOposPrimeNode, inst->DIOposNode,
-                        inst->DIOtConductance * inst->DIOarea * inst->DIOm);
+                        inst->DIOtConductance * inst->DIOarea * inst->DIOm, dtemp);
+
                     NevalSrc(&noizDens[DIOIDNOIZ],&lnNdens[DIOIDNOIZ],
                         ckt, SHOTNOISE, inst->DIOposPrimeNode, inst->DIOnegNode,
                         *(ckt->CKTstate0 + inst->DIOcurrent));
diff --git a/src/spicelib/devices/jfet/jfetnoi.c b/src/spicelib/devices/jfet/jfetnoi.c
index d36d66e98..b4194758c 100644
--- a/src/spicelib/devices/jfet/jfetnoi.c
+++ b/src/spicelib/devices/jfet/jfetnoi.c
@@ -80,20 +80,27 @@ JFETnoise(int mode, int operation, GENmodel *genmodel, CKTcircuit *ckt, Ndata *d
                 switch (mode) {
 
                 case N_DENS:
-                    NevalSrc(&noizDens[JFETRDNOIZ],&lnNdens[JFETRDNOIZ],
-                        ckt, THERMNOISE, inst->JFETdrainPrimeNode, inst->JFETdrainNode,
-                        model->JFETdrainConduct * inst->JFETarea * inst->JFETm);
 
-                    NevalSrc(&noizDens[JFETRSNOIZ],&lnNdens[JFETRSNOIZ],
+                    double dtemp;
+                    if (inst->JFETtempGiven)
+                        dtemp = inst->JFETtemp - ckt->CKTtemp + (model->JFETtnom-CONSTCtoK);
+                    else
+                        dtemp = inst->JFETdtemp;
+
+                    NevalSrcInstanceTemp(&noizDens[JFETRDNOIZ],&lnNdens[JFETRDNOIZ],
+                        ckt, THERMNOISE, inst->JFETdrainPrimeNode, inst->JFETdrainNode,
+                        model->JFETdrainConduct * inst->JFETarea * inst->JFETm, dtemp);
+
+                    NevalSrcInstanceTemp(&noizDens[JFETRSNOIZ],&lnNdens[JFETRSNOIZ],
                         ckt, THERMNOISE, inst->JFETsourcePrimeNode,
                         inst->JFETsourceNode, model->JFETsourceConduct *
-                        inst->JFETarea * inst->JFETm);
+                        inst->JFETarea * inst->JFETm, inst->JFETdtemp);
 
                     if (model->JFETnlev < 3) {
-                        NevalSrc(&noizDens[JFETIDNOIZ],&lnNdens[JFETIDNOIZ],
+                        NevalSrcInstanceTemp(&noizDens[JFETIDNOIZ],&lnNdens[JFETIDNOIZ],
                             ckt, THERMNOISE, inst->JFETdrainPrimeNode,
                             inst->JFETsourcePrimeNode,
-                            (2.0 / 3.0 * inst->JFETm * fabs(*(ckt->CKTstate0 + inst->JFETgm))));
+                            (2.0 / 3.0 * inst->JFETm * fabs(*(ckt->CKTstate0 + inst->JFETgm))), inst->JFETdtemp);
                     } else {
                         vgs = *(ckt->CKTstate0 + inst->JFETvgs);
                         vds = vgs - *(ckt->CKTstate0 + inst->JFETvgd);
@@ -104,16 +111,16 @@ JFETnoise(int mode, int operation, GENmodel *genmodel, CKTcircuit *ckt, Ndata *d
                             alpha = 0; /* saturation region */
                         beta = inst->JFETtBeta * inst->JFETarea * inst->JFETm;
 
-                        NevalSrc(&noizDens[JFETIDNOIZ],&lnNdens[JFETIDNOIZ],
+                        NevalSrcInstanceTemp(&noizDens[JFETIDNOIZ],&lnNdens[JFETIDNOIZ],
                             ckt, THERMNOISE, inst->JFETdrainPrimeNode,
                             inst->JFETsourcePrimeNode,
-                            (2.0 / 3.0*beta*vgst*(1 + alpha + alpha*alpha) / (1 + alpha) * model->JFETgdsnoi));
+                            (2.0 / 3.0*beta*vgst*(1 + alpha + alpha*alpha) / (1 + alpha) * model->JFETgdsnoi), inst->JFETdtemp);
                     }
 
                     NevalSrc(&noizDens[JFETFLNOIZ], NULL, ckt,
                         N_GAIN, inst->JFETdrainPrimeNode,
                         inst->JFETsourcePrimeNode, (double) 0.0);
-                    noizDens[JFETFLNOIZ] *= inst->JFETm*model->JFETfNcoef *
+                    noizDens[JFETFLNOIZ] *= inst->JFETm * model->JFETfNcoef *
                         exp(model->JFETfNexp *
                             log(MAX(fabs(*(ckt->CKTstate0 + inst->JFETcd)), N_MINLOG))) /
                         data->freq;
diff --git a/src/spicelib/devices/res/resnoise.c b/src/spicelib/devices/res/resnoise.c
index 491fde3b1..459db4e26 100644
--- a/src/spicelib/devices/res/resnoise.c
+++ b/src/spicelib/devices/res/resnoise.c
@@ -88,17 +88,23 @@ RESnoise(int mode, int operation, GENmodel*genmodel, CKTcircuit *ckt,
 
                 case N_DENS:
 
+                    double dtemp;
+                    if (inst->REStempGiven)
+                        dtemp = inst->REStemp - ckt->CKTtemp + (model->REStnom-CONSTCtoK);
+                    else
+                        dtemp = inst->RESdtemp;
+
                     NevalSrcInstanceTemp(&noizDens[RESTHNOIZ],&lnNdens[RESTHNOIZ],
                         ckt, THERMNOISE, inst->RESposNode, inst->RESnegNode,
-                        inst->RESconduct, inst->RESdtemp);
+                        inst->RESconduct, dtemp);
 
-                    NevalSrcInstanceTemp(&noizDens[RESFLNOIZ], NULL, ckt,
+                    NevalSrc(&noizDens[RESFLNOIZ], NULL, ckt,
                         N_GAIN, inst->RESposNode, inst->RESnegNode,
-                        (double) 0.0, (double) 0.0);
+                        (double) 0.0);
 
-                    #if 0
+#if 0
                     printf("DC current in resistor %s: %e\n", inst->RESname, inst->REScurrent);
-                    #endif
+#endif
 
                     noizDens[RESFLNOIZ] *= inst->RESm * model->RESfNcoef *
                         pow(fabs(inst->REScurrent / inst->RESm), model->RESfNexp) /