diff --git a/docs/envvars.html b/docs/envvars.html
index 789f5e9..cf57ca5 100644
--- a/docs/envvars.html
+++ b/docs/envvars.html
@@ -217,6 +217,8 @@
     disable for unencumbered viewing the rest of the time. For example, set
     GALLIUM_HUD_VISIBLE to false and GALLIUM_HUD_TOGGLE_SIGNAL to 10 (SIGUSR1).
     Use kill -10 <pid> to toggle the hud as desired.
+<li>GALLIUM_DRIVER - useful in combination with LIBGL_ALWAYS_SOFTWARE=1 for
+    choosing one of the software renderers "softpipe", "llvmpipe" or "swr".
 <li>GALLIUM_LOG_FILE - specifies a file for logging all errors, warnings, etc.
     rather than stderr.
 <li>GALLIUM_PRINT_OPTIONS - if non-zero, print all the Gallium environment
