diff --git a/docs/envvars.html b/docs/envvars.html
index 3cc3c80..31d14a4 100644
--- a/docs/envvars.html
+++ b/docs/envvars.html
@@ -47,7 +47,7 @@
 <li>MESA_NO_SSE - if set, disables Intel SSE optimizations
 <li>MESA_DEBUG - if set, error messages are printed to stderr.  For example,
    if the application generates a GL_INVALID_ENUM error, a corresponding error
-   message indicating where the error occured, and possibly why, will be
+   message indicating where the error occurred, and possibly why, will be
    printed to stderr.<br>
    If the value of MESA_DEBUG is 'FP' floating point arithmetic errors will
    generate exceptions.
@@ -201,14 +201,14 @@
     to stderr
 <li>SOFTPIPE_NO_RAST - if set, rasterization is no-op'd.  For profiling purposes.
 <li>SOFTPIPE_USE_LLVM - if set, the softpipe driver will try to use LLVM JIT for
-    vertex shading procesing.
+    vertex shading processing.
 </ul>
 
 
 <h3>LLVMpipe driver environment variables</h3>
 <ul>
 <li>LP_NO_RAST - if set LLVMpipe will no-op rasterization
-<li>LP_DEBUG - a comma-separated list of debug options is acceptec.  See the
+<li>LP_DEBUG - a comma-separated list of debug options is accepted.  See the
     source code for details.
 <li>LP_PERF - a comma-separated list of options to selectively no-op various
     parts of the driver.  See the source code for details.
