diff --git a/.gitignore b/.gitignore
index 63bc563d..2c25960b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,6 @@
 *~
 
-# You have to ignore this genrated file or git will complain that it is an
+# You have to ignore this generated file or git will complain that it is an
 # unknown file!
 /make.inc
 
diff --git a/CMakeLists.txt b/CMakeLists.txt
index ad1dd46c..72094fa0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -8,7 +8,7 @@ set(VERSION_MINOR "0")
 set(VERSION_BugFix "0")
 set(PROJECT_VERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_BugFix})
 
-# Compatiblitly to xSDK standard
+# Compatibility to xSDK standard
 # (Extreme-scale Scientific Software Development Kit)
 #
 #MESSAGE("\nProcess XSDK defaults ...")
diff --git a/EXAMPLE/README b/EXAMPLE/README
index 8330d0ef..8dc1ac00 100644
--- a/EXAMPLE/README
+++ b/EXAMPLE/README
@@ -1,7 +1,7 @@
 		SuperLU EXAMPLES
 
 This directory contains sample programs to illustrate how to use
-various functions provded in SuperLU. You can modify these
+various functions provided in SuperLU. You can modify these
 examples to suit your applications.
 
 Here are the descriptions of the double precision examples:
diff --git a/EXAMPLE/cfgmr.c b/EXAMPLE/cfgmr.c
index 083db515..ada934db 100644
--- a/EXAMPLE/cfgmr.c
+++ b/EXAMPLE/cfgmr.c
@@ -103,7 +103,7 @@ int cfgmr(int n,
 +-----------------------------------------------------------------------
 | subroutines called :
 | matvec - matrix-vector multiplication operation
-| psolve - (right) preconditionning operation
+| psolve - (right) preconditioning operation
 |	   psolve can be a NULL pointer (GMRES without preconditioner)
 +---------------------------------------------------------------------*/
 
@@ -239,7 +239,7 @@ int cfgmr(int n,
 	            cs_mult(&vv[i1][k], &vv[i1][k], t);
 	    }
 	    /*---------------------------------------------------
-	    |     done with modified gram schimdt and arnoldi step
+	    |     done with modified gram schmidt and arnoldi step
 	    |     now  update factorization of hh
 	    +--------------------------------------------------*/
 
diff --git a/EXAMPLE/citersol.c b/EXAMPLE/citersol.c
index 974635c2..2b96f219 100644
--- a/EXAMPLE/citersol.c
+++ b/EXAMPLE/citersol.c
@@ -88,7 +88,7 @@ void cpsolve(int n, singlecomplex x[], singlecomplex y[])
 
 
 /*!
- * \brief Performs matrix-vector multipliation sp_cgemv with original matrix A.
+ * \brief Performs matrix-vector multiplication sp_cgemv with original matrix A.
  *
  * The operations is y := alpha*A*x + beta*y. See documentation of sp_cgemv
  * for further details.
diff --git a/EXAMPLE/citersol1.c b/EXAMPLE/citersol1.c
index 47c7c026..71574c74 100644
--- a/EXAMPLE/citersol1.c
+++ b/EXAMPLE/citersol1.c
@@ -88,7 +88,7 @@ void cpsolve(int n, singlecomplex x[], singlecomplex y[])
 }
 
 /*!
- * \brief Performs matrix-vector multipliation sp_cgemv with original matrix A.
+ * \brief Performs matrix-vector multiplication sp_cgemv with original matrix A.
  *
  * The operations is y := alpha*A*x + beta*y. See documentation of sp_cgemv
  * for further details.
diff --git a/EXAMPLE/dfgmr.c b/EXAMPLE/dfgmr.c
index 1376075d..6b04d0d3 100644
--- a/EXAMPLE/dfgmr.c
+++ b/EXAMPLE/dfgmr.c
@@ -103,7 +103,7 @@ int dfgmr(int n,
 +-----------------------------------------------------------------------
 | subroutines called :
 | matvec - matrix-vector multiplication operation
-| psolve - (right) preconditionning operation
+| psolve - (right) preconditioning operation
 |	   psolve can be a NULL pointer (GMRES without preconditioner)
 +---------------------------------------------------------------------*/
 
@@ -216,7 +216,7 @@ int dfgmr(int n,
 		    vv[i1][k] = vv[i1][k] * t;
 	    }
 	    /*---------------------------------------------------
-	    |     done with modified gram schimdt and arnoldi step
+	    |     done with modified gram schmidt and arnoldi step
 	    |     now  update factorization of hh
 	    +--------------------------------------------------*/
 
diff --git a/EXAMPLE/ditersol.c b/EXAMPLE/ditersol.c
index d4fd99cd..e4de2584 100644
--- a/EXAMPLE/ditersol.c
+++ b/EXAMPLE/ditersol.c
@@ -88,7 +88,7 @@ void dpsolve(int n, double x[], double y[])
 
 
 /*!
- * \brief Performs matrix-vector multipliation sp_dgemv with original matrix A.
+ * \brief Performs matrix-vector multiplication sp_dgemv with original matrix A.
  *
  * The operations is y := alpha*A*x + beta*y. See documentation of sp_dgemv
  * for further details.
diff --git a/EXAMPLE/ditersol1.c b/EXAMPLE/ditersol1.c
index d619f63b..2b58d9c2 100644
--- a/EXAMPLE/ditersol1.c
+++ b/EXAMPLE/ditersol1.c
@@ -88,7 +88,7 @@ void dpsolve(int n, double x[], double y[])
 }
 
 /*!
- * \brief Performs matrix-vector multipliation sp_dgemv with original matrix A.
+ * \brief Performs matrix-vector multiplication sp_dgemv with original matrix A.
  *
  * The operations is y := alpha*A*x + beta*y. See documentation of sp_dgemv
  * for further details.
diff --git a/EXAMPLE/sfgmr.c b/EXAMPLE/sfgmr.c
index ed7456af..68e2cf64 100644
--- a/EXAMPLE/sfgmr.c
+++ b/EXAMPLE/sfgmr.c
@@ -103,7 +103,7 @@ int sfgmr(int n,
 +-----------------------------------------------------------------------
 | subroutines called :
 | matvec - matrix-vector multiplication operation
-| psolve - (right) preconditionning operation
+| psolve - (right) preconditioning operation
 |	   psolve can be a NULL pointer (GMRES without preconditioner)
 +---------------------------------------------------------------------*/
 
@@ -216,7 +216,7 @@ int sfgmr(int n,
 		    vv[i1][k] = vv[i1][k] * t;
 	    }
 	    /*---------------------------------------------------
-	    |     done with modified gram schimdt and arnoldi step
+	    |     done with modified gram schmidt and arnoldi step
 	    |     now  update factorization of hh
 	    +--------------------------------------------------*/
 
diff --git a/EXAMPLE/sitersol.c b/EXAMPLE/sitersol.c
index c0263484..2220c9ff 100644
--- a/EXAMPLE/sitersol.c
+++ b/EXAMPLE/sitersol.c
@@ -88,7 +88,7 @@ void spsolve(int n, float x[], float y[])
 
 
 /*!
- * \brief Performs matrix-vector multipliation sp_sgemv with original matrix A.
+ * \brief Performs matrix-vector multiplication sp_sgemv with original matrix A.
  *
  * The operations is y := alpha*A*x + beta*y. See documentation of sp_sgemv
  * for further details.
diff --git a/EXAMPLE/sitersol1.c b/EXAMPLE/sitersol1.c
index 76caa611..ebb36fdb 100644
--- a/EXAMPLE/sitersol1.c
+++ b/EXAMPLE/sitersol1.c
@@ -88,7 +88,7 @@ void spsolve(int n, float x[], float y[])
 }
 
 /*!
- * \brief Performs matrix-vector multipliation sp_sgemv with original matrix A.
+ * \brief Performs matrix-vector multiplication sp_sgemv with original matrix A.
  *
  * The operations is y := alpha*A*x + beta*y. See documentation of sp_sgemv
  * for further details.
diff --git a/EXAMPLE/zfgmr.c b/EXAMPLE/zfgmr.c
index 3ce0d4b9..ec0e2406 100644
--- a/EXAMPLE/zfgmr.c
+++ b/EXAMPLE/zfgmr.c
@@ -103,7 +103,7 @@ int zfgmr(int n,
 +-----------------------------------------------------------------------
 | subroutines called :
 | matvec - matrix-vector multiplication operation
-| psolve - (right) preconditionning operation
+| psolve - (right) preconditioning operation
 |	   psolve can be a NULL pointer (GMRES without preconditioner)
 +---------------------------------------------------------------------*/
 
@@ -239,7 +239,7 @@ int zfgmr(int n,
 	            zd_mult(&vv[i1][k], &vv[i1][k], t);
 	    }
 	    /*---------------------------------------------------
-	    |     done with modified gram schimdt and arnoldi step
+	    |     done with modified gram schmidt and arnoldi step
 	    |     now  update factorization of hh
 	    +--------------------------------------------------*/
 
diff --git a/EXAMPLE/zitersol.c b/EXAMPLE/zitersol.c
index 616ff335..a17d8cb4 100644
--- a/EXAMPLE/zitersol.c
+++ b/EXAMPLE/zitersol.c
@@ -88,7 +88,7 @@ void zpsolve(int n, doublecomplex x[], doublecomplex y[])
 
 
 /*!
- * \brief Performs matrix-vector multipliation sp_zgemv with original matrix A.
+ * \brief Performs matrix-vector multiplication sp_zgemv with original matrix A.
  *
  * The operations is y := alpha*A*x + beta*y. See documentation of sp_zgemv
  * for further details.
diff --git a/EXAMPLE/zitersol1.c b/EXAMPLE/zitersol1.c
index 17db1b03..24418bd1 100644
--- a/EXAMPLE/zitersol1.c
+++ b/EXAMPLE/zitersol1.c
@@ -88,7 +88,7 @@ void zpsolve(int n, doublecomplex x[], doublecomplex y[])
 }
 
 /*!
- * \brief Performs matrix-vector multipliation sp_zgemv with original matrix A.
+ * \brief Performs matrix-vector multiplication sp_zgemv with original matrix A.
  *
  * The operations is y := alpha*A*x + beta*y. See documentation of sp_zgemv
  * for further details.
diff --git a/FORTRAN/c_fortran_cgssv.c b/FORTRAN/c_fortran_cgssv.c
index 7e69fb8e..09418149 100644
--- a/FORTRAN/c_fortran_cgssv.c
+++ b/FORTRAN/c_fortran_cgssv.c
@@ -58,7 +58,7 @@ c_fortran_cgssv_(int *iopt, int *n, int_t *nnz, int *nrhs,
     SuperLUStat_t stat;
     factors_t *LUfactors;
     GlobalLU_t Glu;   /* Not needed on return. */
-    int_t    *rowind0;  /* counter 1-based indexing from Frotran arrays. */
+    int_t    *rowind0;  /* counter 1-based indexing from Fortran arrays. */
     int_t    *colptr0;  
 
     trans = NOTRANS;
diff --git a/FORTRAN/c_fortran_dgssv.c b/FORTRAN/c_fortran_dgssv.c
index 80151ac0..68ac02f0 100644
--- a/FORTRAN/c_fortran_dgssv.c
+++ b/FORTRAN/c_fortran_dgssv.c
@@ -58,7 +58,7 @@ c_fortran_dgssv_(int *iopt, int *n, int_t *nnz, int *nrhs,
     SuperLUStat_t stat;
     factors_t *LUfactors;
     GlobalLU_t Glu;   /* Not needed on return. */
-    int_t    *rowind0;  /* counter 1-based indexing from Frotran arrays. */
+    int_t    *rowind0;  /* counter 1-based indexing from Fortran arrays. */
     int_t    *colptr0;  
 
     trans = NOTRANS;
diff --git a/FORTRAN/c_fortran_sgssv.c b/FORTRAN/c_fortran_sgssv.c
index 53e13883..c7777e9b 100644
--- a/FORTRAN/c_fortran_sgssv.c
+++ b/FORTRAN/c_fortran_sgssv.c
@@ -58,7 +58,7 @@ c_fortran_sgssv_(int *iopt, int *n, int_t *nnz, int *nrhs,
     SuperLUStat_t stat;
     factors_t *LUfactors;
     GlobalLU_t Glu;   /* Not needed on return. */
-    int_t    *rowind0;  /* counter 1-based indexing from Frotran arrays. */
+    int_t    *rowind0;  /* counter 1-based indexing from Fortran arrays. */
     int_t    *colptr0;  
 
     trans = NOTRANS;
diff --git a/FORTRAN/c_fortran_zgssv.c b/FORTRAN/c_fortran_zgssv.c
index 9cf841bd..c56a80d9 100644
--- a/FORTRAN/c_fortran_zgssv.c
+++ b/FORTRAN/c_fortran_zgssv.c
@@ -58,7 +58,7 @@ c_fortran_zgssv_(int *iopt, int *n, int_t *nnz, int *nrhs,
     SuperLUStat_t stat;
     factors_t *LUfactors;
     GlobalLU_t Glu;   /* Not needed on return. */
-    int_t    *rowind0;  /* counter 1-based indexing from Frotran arrays. */
+    int_t    *rowind0;  /* counter 1-based indexing from Fortran arrays. */
     int_t    *colptr0;  
 
     trans = NOTRANS;
diff --git a/MATLAB/hbo.m b/MATLAB/hbo.m
index 30467afc..90a33c09 100644
--- a/MATLAB/hbo.m
+++ b/MATLAB/hbo.m
@@ -92,7 +92,7 @@
    error(['Harwell-Boeing type ' hbtype ' unexpected.'])
 end
 
-% Remove any explict zeros
+% Remove any explicit zeros
 
 if exist('hbzero')
    k = find(A == hbzero);
diff --git a/SRC/cgsisx.c b/SRC/cgsisx.c
index 20e6d500..ad98d743 100644
--- a/SRC/cgsisx.c
+++ b/SRC/cgsisx.c
@@ -105,7 +105,7 @@ at the top-level directory.
  *			      p = gamma * nnz(A(:,j)).
  *		DROP_AREA:    Variation of ILUTP, for j-th column, use
  *			      nnz(F(:,1:j)) / nnz(A(:,1:j)) to control memory.
- *		DROP_DYNAMIC: Modify the threshold tau during factorizaion:
+ *		DROP_DYNAMIC: Modify the threshold tau during factorization:
  *			      If nnz(L(:,1:j)) / nnz(A(:,1:j)) > gamma
  *				  tau_L(j) := MIN(tau_0, tau_L(j-1) * 2);
  *			      Otherwise
@@ -231,7 +231,7 @@ at the top-level directory.
  *            obtained from MC64.
  *            If MC64 fails, cgsequ() is used to equilibrate the system,
  *            and A is scaled as above, but no permutation is involved.
- *            On exit, A is restored to the orginal row numbering, so
+ *            On exit, A is restored to the original row numbering, so
  *            Dr*A*Dc is returned.
  *
  * perm_c  (input/output) int*
diff --git a/SRC/cgsitrf.c b/SRC/cgsitrf.c
index 6563b524..55097cae 100644
--- a/SRC/cgsitrf.c
+++ b/SRC/cgsitrf.c
@@ -198,7 +198,7 @@ cgsitrf(superlu_options_t *options, SuperMatrix *A, int relax, int panel_size,
     int       *iperm_c; /* inverse of perm_c */
     int       *swap, *iswap; /* swap is used to store the row permutation
 				during the factorization. Initially, it is set
-				to iperm_c (row indeces of Pc*A*Pc').
+				to iperm_c (row indices of Pc*A*Pc').
 				iswap is the inverse of swap. After the
 				factorization, it is equal to perm_r. */
     int       *iwork;
@@ -219,7 +219,7 @@ cgsitrf(superlu_options_t *options, SuperMatrix *A, int relax, int panel_size,
     int_t     nzlumax;
     float    *amax; 
     singlecomplex    drop_sum;
-    float alpha, omega;  /* used in MILU, mimicing DRIC */
+    float alpha, omega;  /* used in MILU, mimicking DRIC */
     float    *swork2;	   /* used by the second dropping rule */
 
     /* Local scalars */
diff --git a/SRC/clacon2.c b/SRC/clacon2.c
index 8c08f230..74ffbc37 100644
--- a/SRC/clacon2.c
+++ b/SRC/clacon2.c
@@ -198,7 +198,7 @@ clacon2_(int *n, singlecomplex *v, singlecomplex *x, float *est, int *kase, int
     return 0;
 
     /*     ................ ENTRY   (isave[0] == 4)
-	   X HAS BEEN OVERWRITTEN BY TRANDPOSE(A)*X. */
+	   X HAS BEEN OVERWRITTEN BY TRANSPOSE(A)*X. */
 L110:
     jlast = isave[1];  /* j; */
     isave[1] = icmax1_slu(n, &x[0], &c__1); /* j */
diff --git a/SRC/colamd.c b/SRC/colamd.c
index 34d0eea5..c3c54f16 100644
--- a/SRC/colamd.c
+++ b/SRC/colamd.c
@@ -423,7 +423,7 @@ at the top-level directory.
 
 	    int n ;		Input argument.
 
-	    	Number of rows and columns in the symmetrix matrix A.
+	    	Number of rows and columns in the symmetric matrix A.
 		Restriction:  n >= 0.
 		Symamd returns FALSE if n is negative.
 
@@ -2785,7 +2785,7 @@ PRIVATE void order_children
 		c = Col [c].shared1.parent ;
 
 		/* continue until we hit an ordered column.  There are */
-		/* guarranteed not to be anymore unordered columns */
+		/* guaranteed not to be anymore unordered columns */
 		/* above an ordered column */
 	    } while (Col [c].shared2.order == EMPTY) ;
 
@@ -2936,7 +2936,7 @@ PRIVATE void detect_super_cols
 		    ASSERT (ROW_IS_ALIVE (*cp1))  ;
 		    ASSERT (ROW_IS_ALIVE (*cp2))  ;
 		    /* row indices will same order for both supercols, */
-		    /* no gather scatter nessasary */
+		    /* no gather scatter necessary */
 		    if (*cp1++ != *cp2++)
 		    {
 			break ;
@@ -2986,7 +2986,7 @@ PRIVATE void detect_super_cols
 
 /*
     Defragments and compacts columns and rows in the workspace A.  Used when
-    all avaliable memory has been used while performing row merging.  Returns
+    all available memory has been used while performing row merging.  Returns
     the index of the first free position in A, after garbage collection.  The
     time taken by this routine is linear is the size of the array A, which is
     itself linear in the number of nonzeros in the input matrix.
diff --git a/SRC/cpanel_dfs.c b/SRC/cpanel_dfs.c
index d681a440..1bc618af 100644
--- a/SRC/cpanel_dfs.c
+++ b/SRC/cpanel_dfs.c
@@ -10,7 +10,7 @@ at the top-level directory.
 */
 
 /*! @file cpanel_dfs.c
- * \brief Peforms a symbolic factorization on a panel of symbols
+ * \brief Performs a symbolic factorization on a panel of symbols
  *
  * <pre>
  * -- SuperLU routine (version 2.0) --
diff --git a/SRC/creadrb.c b/SRC/creadrb.c
index a38d62fc..ebfba9eb 100644
--- a/SRC/creadrb.c
+++ b/SRC/creadrb.c
@@ -42,7 +42,7 @@ at the top-level directory.
  *      Col. 30 - 42  Compressed Column: Number of columns (NCOL)
  *                    Elemental: Number of element matrices (NELT)
  *      Col. 44 - 56  Compressed Column: Number of entries (NNZERO)
- *                    Elemental: Number of variable indeces (NVARIX)
+ *                    Elemental: Number of variable indices (NVARIX)
  *      Col. 58 - 70  Compressed Column: Unused, explicitly zero
  *                    Elemental: Number of elemental matrix entries (NELTVL)
  *
diff --git a/SRC/dgsisx.c b/SRC/dgsisx.c
index ef6c899e..d59d567c 100644
--- a/SRC/dgsisx.c
+++ b/SRC/dgsisx.c
@@ -105,7 +105,7 @@ at the top-level directory.
  *			      p = gamma * nnz(A(:,j)).
  *		DROP_AREA:    Variation of ILUTP, for j-th column, use
  *			      nnz(F(:,1:j)) / nnz(A(:,1:j)) to control memory.
- *		DROP_DYNAMIC: Modify the threshold tau during factorizaion:
+ *		DROP_DYNAMIC: Modify the threshold tau during factorization:
  *			      If nnz(L(:,1:j)) / nnz(A(:,1:j)) > gamma
  *				  tau_L(j) := MIN(tau_0, tau_L(j-1) * 2);
  *			      Otherwise
@@ -231,7 +231,7 @@ at the top-level directory.
  *            obtained from MC64.
  *            If MC64 fails, dgsequ() is used to equilibrate the system,
  *            and A is scaled as above, but no permutation is involved.
- *            On exit, A is restored to the orginal row numbering, so
+ *            On exit, A is restored to the original row numbering, so
  *            Dr*A*Dc is returned.
  *
  * perm_c  (input/output) int*
diff --git a/SRC/dgsitrf.c b/SRC/dgsitrf.c
index ab6c61de..749e5ff6 100644
--- a/SRC/dgsitrf.c
+++ b/SRC/dgsitrf.c
@@ -198,7 +198,7 @@ dgsitrf(superlu_options_t *options, SuperMatrix *A, int relax, int panel_size,
     int       *iperm_c; /* inverse of perm_c */
     int       *swap, *iswap; /* swap is used to store the row permutation
 				during the factorization. Initially, it is set
-				to iperm_c (row indeces of Pc*A*Pc').
+				to iperm_c (row indices of Pc*A*Pc').
 				iswap is the inverse of swap. After the
 				factorization, it is equal to perm_r. */
     int       *iwork;
@@ -218,7 +218,7 @@ dgsitrf(superlu_options_t *options, SuperMatrix *A, int relax, int panel_size,
     int_t     nzlumax;
     double    *amax; 
     double    drop_sum;
-    double alpha, omega;  /* used in MILU, mimicing DRIC */
+    double alpha, omega;  /* used in MILU, mimicking DRIC */
     double    *dwork2;	   /* used by the second dropping rule */
 
     /* Local scalars */
diff --git a/SRC/dlacon2.c b/SRC/dlacon2.c
index 79476fe6..656f3d82 100644
--- a/SRC/dlacon2.c
+++ b/SRC/dlacon2.c
@@ -205,7 +205,7 @@ dlacon2_(int *n, double *v, double *x, int *isgn, double *est, int *kase, int is
     return 0;
 
     /*     ................ ENTRY   (isave[0] == 4)
-	   X HAS BEEN OVERWRITTEN BY TRANDPOSE(A)*X. */
+	   X HAS BEEN OVERWRITTEN BY TRANSPOSE(A)*X. */
 L110:
     jlast = isave[1];  /* j; */
 #ifdef _CRAY
diff --git a/SRC/dpanel_dfs.c b/SRC/dpanel_dfs.c
index 45bc2cdd..478fcf8b 100644
--- a/SRC/dpanel_dfs.c
+++ b/SRC/dpanel_dfs.c
@@ -10,7 +10,7 @@ at the top-level directory.
 */
 
 /*! @file dpanel_dfs.c
- * \brief Peforms a symbolic factorization on a panel of symbols
+ * \brief Performs a symbolic factorization on a panel of symbols
  *
  * <pre>
  * -- SuperLU routine (version 2.0) --
diff --git a/SRC/dreadrb.c b/SRC/dreadrb.c
index 6f848134..dfdd0403 100644
--- a/SRC/dreadrb.c
+++ b/SRC/dreadrb.c
@@ -42,7 +42,7 @@ at the top-level directory.
  *      Col. 30 - 42  Compressed Column: Number of columns (NCOL)
  *                    Elemental: Number of element matrices (NELT)
  *      Col. 44 - 56  Compressed Column: Number of entries (NNZERO)
- *                    Elemental: Number of variable indeces (NVARIX)
+ *                    Elemental: Number of variable indices (NVARIX)
  *      Col. 58 - 70  Compressed Column: Unused, explicitly zero
  *                    Elemental: Number of elemental matrix entries (NELTVL)
  *
diff --git a/SRC/ilu_cdrop_row.c b/SRC/ilu_cdrop_row.c
index c1dc7fcf..68feb64c 100644
--- a/SRC/ilu_cdrop_row.c
+++ b/SRC/ilu_cdrop_row.c
@@ -267,7 +267,7 @@ int ilu_cdrop_row(
 	return 0;
     }
 
-    /* add dropped entries to the diagnal */
+    /* add dropped entries to the diagonal */
     if (milu != SILU)
     {
 	register int j;
diff --git a/SRC/ilu_cpanel_dfs.c b/SRC/ilu_cpanel_dfs.c
index 02a1aa3d..a492e91a 100644
--- a/SRC/ilu_cpanel_dfs.c
+++ b/SRC/ilu_cpanel_dfs.c
@@ -10,7 +10,7 @@ at the top-level directory.
 */
 
 /*! @file ilu_cpanel_dfs.c
- * \brief Peforms a symbolic factorization on a panel of symbols and
+ * \brief Performs a symbolic factorization on a panel of symbols and
  * record the entries with maximum absolute value in each column
  *
  * <pre>
diff --git a/SRC/ilu_ddrop_row.c b/SRC/ilu_ddrop_row.c
index 8189e7fb..74f665a8 100644
--- a/SRC/ilu_ddrop_row.c
+++ b/SRC/ilu_ddrop_row.c
@@ -265,7 +265,7 @@ int ilu_ddrop_row(
 	return 0;
     }
 
-    /* add dropped entries to the diagnal */
+    /* add dropped entries to the diagonal */
     if (milu != SILU)
     {
 	register int j;
diff --git a/SRC/ilu_dpanel_dfs.c b/SRC/ilu_dpanel_dfs.c
index 1edb2f41..b73deb0f 100644
--- a/SRC/ilu_dpanel_dfs.c
+++ b/SRC/ilu_dpanel_dfs.c
@@ -10,7 +10,7 @@ at the top-level directory.
 */
 
 /*! @file ilu_dpanel_dfs.c
- * \brief Peforms a symbolic factorization on a panel of symbols and
+ * \brief Performs a symbolic factorization on a panel of symbols and
  * record the entries with maximum absolute value in each column
  *
  * <pre>
diff --git a/SRC/ilu_sdrop_row.c b/SRC/ilu_sdrop_row.c
index e611c330..f4acd501 100644
--- a/SRC/ilu_sdrop_row.c
+++ b/SRC/ilu_sdrop_row.c
@@ -265,7 +265,7 @@ int ilu_sdrop_row(
 	return 0;
     }
 
-    /* add dropped entries to the diagnal */
+    /* add dropped entries to the diagonal */
     if (milu != SILU)
     {
 	register int j;
diff --git a/SRC/ilu_spanel_dfs.c b/SRC/ilu_spanel_dfs.c
index cb696569..9836b4c5 100644
--- a/SRC/ilu_spanel_dfs.c
+++ b/SRC/ilu_spanel_dfs.c
@@ -10,7 +10,7 @@ at the top-level directory.
 */
 
 /*! @file ilu_spanel_dfs.c
- * \brief Peforms a symbolic factorization on a panel of symbols and
+ * \brief Performs a symbolic factorization on a panel of symbols and
  * record the entries with maximum absolute value in each column
  *
  * <pre>
diff --git a/SRC/ilu_zdrop_row.c b/SRC/ilu_zdrop_row.c
index 231759e4..edc12f5c 100644
--- a/SRC/ilu_zdrop_row.c
+++ b/SRC/ilu_zdrop_row.c
@@ -267,7 +267,7 @@ int ilu_zdrop_row(
 	return 0;
     }
 
-    /* add dropped entries to the diagnal */
+    /* add dropped entries to the diagonal */
     if (milu != SILU)
     {
 	register int j;
diff --git a/SRC/ilu_zpanel_dfs.c b/SRC/ilu_zpanel_dfs.c
index 68f954fd..22863eaf 100644
--- a/SRC/ilu_zpanel_dfs.c
+++ b/SRC/ilu_zpanel_dfs.c
@@ -10,7 +10,7 @@ at the top-level directory.
 */
 
 /*! @file ilu_zpanel_dfs.c
- * \brief Peforms a symbolic factorization on a panel of symbols and
+ * \brief Performs a symbolic factorization on a panel of symbols and
  * record the entries with maximum absolute value in each column
  *
  * <pre>
diff --git a/SRC/mc64ad.c b/SRC/mc64ad.c
index 97fa7366..fc6c066b 100644
--- a/SRC/mc64ad.c
+++ b/SRC/mc64ad.c
@@ -88,7 +88,7 @@ static int_t c__2 = 2;
 /*     If it is negative, these messages are suppressed. */
 
 /*    ICNTL(4) has default value 0. */
-/*     If left at the defaut value, the incoming data is checked for */
+/*     If left at the default value, the incoming data is checked for */
 /*     out-of-range indices and duplicates.  Setting ICNTL(4) to any */
 /*     other will avoid the checks but is likely to cause problems */
 /*     later if out-of-range indices or duplicates are present. */
diff --git a/SRC/sgsisx.c b/SRC/sgsisx.c
index 1bec3a12..421fcad0 100644
--- a/SRC/sgsisx.c
+++ b/SRC/sgsisx.c
@@ -105,7 +105,7 @@ at the top-level directory.
  *			      p = gamma * nnz(A(:,j)).
  *		DROP_AREA:    Variation of ILUTP, for j-th column, use
  *			      nnz(F(:,1:j)) / nnz(A(:,1:j)) to control memory.
- *		DROP_DYNAMIC: Modify the threshold tau during factorizaion:
+ *		DROP_DYNAMIC: Modify the threshold tau during factorization:
  *			      If nnz(L(:,1:j)) / nnz(A(:,1:j)) > gamma
  *				  tau_L(j) := MIN(tau_0, tau_L(j-1) * 2);
  *			      Otherwise
@@ -231,7 +231,7 @@ at the top-level directory.
  *            obtained from MC64.
  *            If MC64 fails, sgsequ() is used to equilibrate the system,
  *            and A is scaled as above, but no permutation is involved.
- *            On exit, A is restored to the orginal row numbering, so
+ *            On exit, A is restored to the original row numbering, so
  *            Dr*A*Dc is returned.
  *
  * perm_c  (input/output) int*
diff --git a/SRC/sgsitrf.c b/SRC/sgsitrf.c
index de8581f3..7e726bcb 100644
--- a/SRC/sgsitrf.c
+++ b/SRC/sgsitrf.c
@@ -198,7 +198,7 @@ sgsitrf(superlu_options_t *options, SuperMatrix *A, int relax, int panel_size,
     int       *iperm_c; /* inverse of perm_c */
     int       *swap, *iswap; /* swap is used to store the row permutation
 				during the factorization. Initially, it is set
-				to iperm_c (row indeces of Pc*A*Pc').
+				to iperm_c (row indices of Pc*A*Pc').
 				iswap is the inverse of swap. After the
 				factorization, it is equal to perm_r. */
     int       *iwork;
@@ -218,7 +218,7 @@ sgsitrf(superlu_options_t *options, SuperMatrix *A, int relax, int panel_size,
     int_t     nzlumax;
     float    *amax; 
     float    drop_sum;
-    float alpha, omega;  /* used in MILU, mimicing DRIC */
+    float alpha, omega;  /* used in MILU, mimicking DRIC */
     float    *swork2;	   /* used by the second dropping rule */
 
     /* Local scalars */
diff --git a/SRC/slacon2.c b/SRC/slacon2.c
index e8ab5afc..5b197e4d 100644
--- a/SRC/slacon2.c
+++ b/SRC/slacon2.c
@@ -205,7 +205,7 @@ slacon2_(int *n, float *v, float *x, int *isgn, float *est, int *kase, int isave
     return 0;
 
     /*     ................ ENTRY   (isave[0] == 4)
-	   X HAS BEEN OVERWRITTEN BY TRANDPOSE(A)*X. */
+	   X HAS BEEN OVERWRITTEN BY TRANSPOSE(A)*X. */
 L110:
     jlast = isave[1];  /* j; */
 #ifdef _CRAY
diff --git a/SRC/slu_cdefs.h b/SRC/slu_cdefs.h
index 04b801bb..b015c1e5 100644
--- a/SRC/slu_cdefs.h
+++ b/SRC/slu_cdefs.h
@@ -55,7 +55,7 @@ at the top-level directory.
  *	values.
  *
  *	The last column structures (for pruning) will be removed
- *	after the numercial LU factorization phase.
+ *	after the numerical LU factorization phase.
  *
  *   (xlusup,lusup): lusup[*] contains the numerical values of the
  *	rectangular supernodes; xlusup[j] points to the starting
diff --git a/SRC/slu_ddefs.h b/SRC/slu_ddefs.h
index caac7ffe..f49ef183 100644
--- a/SRC/slu_ddefs.h
+++ b/SRC/slu_ddefs.h
@@ -55,7 +55,7 @@ at the top-level directory.
  *	values.
  *
  *	The last column structures (for pruning) will be removed
- *	after the numercial LU factorization phase.
+ *	after the numerical LU factorization phase.
  *
  *   (xlusup,lusup): lusup[*] contains the numerical values of the
  *	rectangular supernodes; xlusup[j] points to the starting
diff --git a/SRC/slu_sdefs.h b/SRC/slu_sdefs.h
index 738bca9b..17103f76 100644
--- a/SRC/slu_sdefs.h
+++ b/SRC/slu_sdefs.h
@@ -55,7 +55,7 @@ at the top-level directory.
  *	values.
  *
  *	The last column structures (for pruning) will be removed
- *	after the numercial LU factorization phase.
+ *	after the numerical LU factorization phase.
  *
  *   (xlusup,lusup): lusup[*] contains the numerical values of the
  *	rectangular supernodes; xlusup[j] points to the starting
diff --git a/SRC/slu_util.h b/SRC/slu_util.h
index f34886a0..a984f487 100644
--- a/SRC/slu_util.h
+++ b/SRC/slu_util.h
@@ -154,7 +154,7 @@ typedef unsigned char Logical;
  * Fact   (fact_t)
  *        Specifies whether or not the factored form of the matrix
  *        A is supplied on entry, and if not, how the matrix A should
- *        be factorizaed.
+ *        be factorized.
  *        = DOFACT: The matrix A will be factorized from scratch, and the
  *             factors will be stored in L and U.
  *        = SamePattern: The matrix A will be factorized assuming
diff --git a/SRC/slu_zdefs.h b/SRC/slu_zdefs.h
index 19e18273..4b0f06ff 100644
--- a/SRC/slu_zdefs.h
+++ b/SRC/slu_zdefs.h
@@ -55,7 +55,7 @@ at the top-level directory.
  *	values.
  *
  *	The last column structures (for pruning) will be removed
- *	after the numercial LU factorization phase.
+ *	after the numerical LU factorization phase.
  *
  *   (xlusup,lusup): lusup[*] contains the numerical values of the
  *	rectangular supernodes; xlusup[j] points to the starting
diff --git a/SRC/sp_coletree.c b/SRC/sp_coletree.c
index 38b32597..eeb51416 100644
--- a/SRC/sp_coletree.c
+++ b/SRC/sp_coletree.c
@@ -174,7 +174,7 @@ sp_coletree(
 	    int *parent	               /* parent in elim tree */
 	    )
 {
-	int	*root;			/* root of subtee of etree 	*/
+	int	*root;			/* root of subtree of etree 	*/
 	int     *firstcol;		/* first nonzero col in each row*/
 	int	rset, cset;             
 	int	row, col;
diff --git a/SRC/spanel_dfs.c b/SRC/spanel_dfs.c
index 40786338..ace6e2bb 100644
--- a/SRC/spanel_dfs.c
+++ b/SRC/spanel_dfs.c
@@ -10,7 +10,7 @@ at the top-level directory.
 */
 
 /*! @file spanel_dfs.c
- * \brief Peforms a symbolic factorization on a panel of symbols
+ * \brief Performs a symbolic factorization on a panel of symbols
  *
  * <pre>
  * -- SuperLU routine (version 2.0) --
diff --git a/SRC/sreadrb.c b/SRC/sreadrb.c
index 5947c263..ec166a10 100644
--- a/SRC/sreadrb.c
+++ b/SRC/sreadrb.c
@@ -42,7 +42,7 @@ at the top-level directory.
  *      Col. 30 - 42  Compressed Column: Number of columns (NCOL)
  *                    Elemental: Number of element matrices (NELT)
  *      Col. 44 - 56  Compressed Column: Number of entries (NNZERO)
- *                    Elemental: Number of variable indeces (NVARIX)
+ *                    Elemental: Number of variable indices (NVARIX)
  *      Col. 58 - 70  Compressed Column: Unused, explicitly zero
  *                    Elemental: Number of elemental matrix entries (NELTVL)
  *
diff --git a/SRC/supermatrix.h b/SRC/supermatrix.h
index e7d9348c..2736df33 100644
--- a/SRC/supermatrix.h
+++ b/SRC/supermatrix.h
@@ -189,7 +189,7 @@ typedef struct {
 
 
 /* Data structure for storing 3D matrix on layer 0 of the 2D process grid
-   Only grid-0 has meanful values of these data structures.   */
+   Only grid-0 has meaningful values of these data structures.   */
 typedef struct NRformat_loc3d
 {
     NRformat_loc *A_nfmt; // Gathered A matrix on 2D grid-0 
diff --git a/SRC/zgsisx.c b/SRC/zgsisx.c
index 292d80d9..e8a33f71 100644
--- a/SRC/zgsisx.c
+++ b/SRC/zgsisx.c
@@ -105,7 +105,7 @@ at the top-level directory.
  *			      p = gamma * nnz(A(:,j)).
  *		DROP_AREA:    Variation of ILUTP, for j-th column, use
  *			      nnz(F(:,1:j)) / nnz(A(:,1:j)) to control memory.
- *		DROP_DYNAMIC: Modify the threshold tau during factorizaion:
+ *		DROP_DYNAMIC: Modify the threshold tau during factorization:
  *			      If nnz(L(:,1:j)) / nnz(A(:,1:j)) > gamma
  *				  tau_L(j) := MIN(tau_0, tau_L(j-1) * 2);
  *			      Otherwise
@@ -231,7 +231,7 @@ at the top-level directory.
  *            obtained from MC64.
  *            If MC64 fails, zgsequ() is used to equilibrate the system,
  *            and A is scaled as above, but no permutation is involved.
- *            On exit, A is restored to the orginal row numbering, so
+ *            On exit, A is restored to the original row numbering, so
  *            Dr*A*Dc is returned.
  *
  * perm_c  (input/output) int*
diff --git a/SRC/zgsitrf.c b/SRC/zgsitrf.c
index e39514f3..e07c9fec 100644
--- a/SRC/zgsitrf.c
+++ b/SRC/zgsitrf.c
@@ -198,7 +198,7 @@ zgsitrf(superlu_options_t *options, SuperMatrix *A, int relax, int panel_size,
     int       *iperm_c; /* inverse of perm_c */
     int       *swap, *iswap; /* swap is used to store the row permutation
 				during the factorization. Initially, it is set
-				to iperm_c (row indeces of Pc*A*Pc').
+				to iperm_c (row indices of Pc*A*Pc').
 				iswap is the inverse of swap. After the
 				factorization, it is equal to perm_r. */
     int       *iwork;
@@ -219,7 +219,7 @@ zgsitrf(superlu_options_t *options, SuperMatrix *A, int relax, int panel_size,
     int_t     nzlumax;
     double    *amax; 
     doublecomplex    drop_sum;
-    double alpha, omega;  /* used in MILU, mimicing DRIC */
+    double alpha, omega;  /* used in MILU, mimicking DRIC */
     double    *dwork2;	   /* used by the second dropping rule */
 
     /* Local scalars */
diff --git a/SRC/zlacon2.c b/SRC/zlacon2.c
index 386b99cd..028b75eb 100644
--- a/SRC/zlacon2.c
+++ b/SRC/zlacon2.c
@@ -198,7 +198,7 @@ zlacon2_(int *n, doublecomplex *v, doublecomplex *x, double *est, int *kase, int
     return 0;
 
     /*     ................ ENTRY   (isave[0] == 4)
-	   X HAS BEEN OVERWRITTEN BY TRANDPOSE(A)*X. */
+	   X HAS BEEN OVERWRITTEN BY TRANSPOSE(A)*X. */
 L110:
     jlast = isave[1];  /* j; */
     isave[1] = izmax1_slu(n, &x[0], &c__1); /* j */
diff --git a/SRC/zpanel_dfs.c b/SRC/zpanel_dfs.c
index b5416141..8e6b9825 100644
--- a/SRC/zpanel_dfs.c
+++ b/SRC/zpanel_dfs.c
@@ -10,7 +10,7 @@ at the top-level directory.
 */
 
 /*! @file zpanel_dfs.c
- * \brief Peforms a symbolic factorization on a panel of symbols
+ * \brief Performs a symbolic factorization on a panel of symbols
  *
  * <pre>
  * -- SuperLU routine (version 2.0) --
diff --git a/SRC/zreadrb.c b/SRC/zreadrb.c
index 6b56c52d..60377e75 100644
--- a/SRC/zreadrb.c
+++ b/SRC/zreadrb.c
@@ -42,7 +42,7 @@ at the top-level directory.
  *      Col. 30 - 42  Compressed Column: Number of columns (NCOL)
  *                    Elemental: Number of element matrices (NELT)
  *      Col. 44 - 56  Compressed Column: Number of entries (NNZERO)
- *                    Elemental: Number of variable indeces (NVARIX)
+ *                    Elemental: Number of variable indices (NVARIX)
  *      Col. 58 - 70  Compressed Column: Unused, explicitly zero
  *                    Elemental: Number of elemental matrix entries (NELTVL)
  *
diff --git a/TESTING/CMakeLists.txt b/TESTING/CMakeLists.txt
index 01dcd0f6..3446160e 100644
--- a/TESTING/CMakeLists.txt
+++ b/TESTING/CMakeLists.txt
@@ -40,7 +40,7 @@ endfunction(add_superlu_test)
 
 # prevent creating testing for Windows if WinGetOps is not found
 if(MSVC AND NOT WinGetOpt_FOUND)
-  message("Disabled tests s_test, d_test, c_test, and z_test because optinal dependency WinGetOpt is missing")
+  message("Disabled tests s_test, d_test, c_test, and z_test because optional dependency WinGetOpt is missing")
   return()
 endif()
 
diff --git a/TESTING/MATGEN/claror.c b/TESTING/MATGEN/claror.c
index b726c18a..57feb0af 100644
--- a/TESTING/MATGEN/claror.c
+++ b/TESTING/MATGEN/claror.c
@@ -94,7 +94,7 @@ static int c__1 = 1;
              columns will be orthogonal, the remaining columns being   
              zero.   
              For matrices where M > N, just use the previous   
-             explaination, interchanging 'L' and 'R' and "rows" and   
+             explanation, interchanging 'L' and 'R' and "rows" and   
              "columns".   
 
              Not modified.   
diff --git a/TESTING/MATGEN/clarot.c b/TESTING/MATGEN/clarot.c
index 136403c9..1ac79135 100644
--- a/TESTING/MATGEN/clarot.c
+++ b/TESTING/MATGEN/clarot.c
@@ -38,7 +38,7 @@ int clarot_slu(bool *lrows, bool *lleft, bool *lright,
 
        CLAROT applies a (Givens) rotation to two adjacent rows or   
        columns, where one element of the first and/or last column/row   
-       may be a separate variable.  This is specifically indended   
+       may be a separate variable.  This is specifically intended   
        for use on matrices stored in some format other than GE, so   
        that elements of the matrix may be used or modified for which   
        no array element is provided.   
diff --git a/TESTING/MATGEN/dlarot.c b/TESTING/MATGEN/dlarot.c
index c573f4bb..42c0e731 100644
--- a/TESTING/MATGEN/dlarot.c
+++ b/TESTING/MATGEN/dlarot.c
@@ -38,7 +38,7 @@ int dlarot_slu(bool *lrows, bool *lleft, bool *lright,
 
        DLAROT applies a (Givens) rotation to two adjacent rows or   
        columns, where one element of the first and/or last column/row   
-       may be a separate variable.  This is specifically indended   
+       may be a separate variable.  This is specifically intended   
        for use on matrices stored in some format other than GE, so   
        that elements of the matrix may be used or modified for which   
        no array element is provided.   
diff --git a/TESTING/MATGEN/slarot.c b/TESTING/MATGEN/slarot.c
index af59b722..95339d69 100644
--- a/TESTING/MATGEN/slarot.c
+++ b/TESTING/MATGEN/slarot.c
@@ -38,7 +38,7 @@ int slarot_slu(bool *lrows, bool *lleft, bool *lright,
 
        SLAROT applies a (Givens) rotation to two adjacent rows or   
        columns, where one element of the first and/or last column/row   
-       may be a separate variable.  This is specifically indended   
+       may be a separate variable.  This is specifically intended   
        for use on matrices stored in some format other than GE, so   
        that elements of the matrix may be used or modified for which   
        no array element is provided.   
diff --git a/TESTING/MATGEN/zlaror.c b/TESTING/MATGEN/zlaror.c
index 13452c4c..44ec8482 100644
--- a/TESTING/MATGEN/zlaror.c
+++ b/TESTING/MATGEN/zlaror.c
@@ -97,7 +97,7 @@ static int c__1 = 1;
              columns will be orthogonal, the remaining columns being   
              zero.   
              For matrices where M > N, just use the previous   
-             explaination, interchanging 'L' and 'R' and "rows" and   
+             explanation, interchanging 'L' and 'R' and "rows" and   
              "columns".   
 
              Not modified.   
diff --git a/TESTING/MATGEN/zlarot.c b/TESTING/MATGEN/zlarot.c
index 86f0a4d2..33acdc18 100644
--- a/TESTING/MATGEN/zlarot.c
+++ b/TESTING/MATGEN/zlarot.c
@@ -38,7 +38,7 @@ int zlarot_slu(bool *lrows, bool *lleft, bool *lright,
 
        ZLAROT applies a (Givens) rotation to two adjacent rows or   
        columns, where one element of the first and/or last column/row   
-       may be a separate variable.  This is specifically indended   
+       may be a separate variable.  This is specifically intended   
        for use on matrices stored in some format other than GE, so   
        that elements of the matrix may be used or modified for which   
        no array element is provided.   
diff --git a/TESTING/cdrive.c b/TESTING/cdrive.c
index d5c578b6..137a7470 100644
--- a/TESTING/cdrive.c
+++ b/TESTING/cdrive.c
@@ -81,7 +81,7 @@ int main(int argc, char *argv[])
     int            nfact, ifact, itran;
     int            kl, ku, mode, lda, ioff;
     int            zerot; /* indicate whether the matrix is singular */
-    int            izero; /* incidate the first column that is entirely zero */
+    int            izero; /* indicate the first column that is entirely zero */
     double         u;
     float         anorm, cndnum;
     singlecomplex         *Afull;
diff --git a/TESTING/ddrive.c b/TESTING/ddrive.c
index 9bb18db5..0c71fe63 100644
--- a/TESTING/ddrive.c
+++ b/TESTING/ddrive.c
@@ -81,7 +81,7 @@ int main(int argc, char *argv[])
     int            nfact, ifact, itran;
     int            kl, ku, mode, lda, ioff;
     int            zerot; /* indicate whether the matrix is singular */
-    int            izero; /* incidate the first column that is entirely zero */
+    int            izero; /* indicate the first column that is entirely zero */
     double         u;
     double         anorm, cndnum;
     double         *Afull;
diff --git a/TESTING/sdrive.c b/TESTING/sdrive.c
index e2623d8c..208088f1 100644
--- a/TESTING/sdrive.c
+++ b/TESTING/sdrive.c
@@ -81,7 +81,7 @@ int main(int argc, char *argv[])
     int            nfact, ifact, itran;
     int            kl, ku, mode, lda, ioff;
     int            zerot; /* indicate whether the matrix is singular */
-    int            izero; /* incidate the first column that is entirely zero */
+    int            izero; /* indicate the first column that is entirely zero */
     double         u;
     float         anorm, cndnum;
     float         *Afull;
diff --git a/TESTING/zdrive.c b/TESTING/zdrive.c
index 3af14703..50b7ecdc 100644
--- a/TESTING/zdrive.c
+++ b/TESTING/zdrive.c
@@ -81,7 +81,7 @@ int main(int argc, char *argv[])
     int            nfact, ifact, itran;
     int            kl, ku, mode, lda, ioff;
     int            zerot; /* indicate whether the matrix is singular */
-    int            izero; /* incidate the first column that is entirely zero */
+    int            izero; /* indicate the first column that is entirely zero */
     double         u;
     double         anorm, cndnum;
     doublecomplex         *Afull;