diff -u3 -r cl-who-0.10.0/packages.lisp ../site/cl-who-0.10.0/packages.lisp
--- cl-who-0.10.0/packages.lisp	2007-07-24 17:53:30.000000000 -0400
+++ ../site/cl-who-0.10.0/packages.lisp	2007-08-10 19:52:36.000000000 -0400
@@ -36,7 +36,7 @@
   (:export :*attribute-quote-char*
            :*escape-char-p*
            :*prologue*
-           :*downcase-tags-p*
+           :*downcase-tokens-p*
            :*html-empty-tags*
            :*html-empty-tag-aware-p*
            :conc
diff -u3 -r cl-who-0.10.0/specials.lisp ../site/cl-who-0.10.0/specials.lisp
--- cl-who-0.10.0/specials.lisp	2007-04-27 05:33:42.000000000 -0400
+++ ../site/cl-who-0.10.0/specials.lisp	2007-08-10 20:07:23.000000000 -0400
@@ -53,10 +53,10 @@
 (defvar *html-mode* :xml
   ":SGML for \(SGML-)HTML, :XML \(default) for XHTML.")
 
-(defvar *downcase-tags-p* t
-  "If NIL, a keyword symbol representing a tag name will not be
-automatically converted to lowercase.  This is useful when one needs
-to output case sensitive XML tags.")
+(defvar *downcase-tokens-p* t
+  "If NIL, a keyword symbol representing a tag or attribute name will
+not be automatically converted to lowercase.  This is useful when one
+needs to output case sensitive XML tags or attributes.")
 
 (defparameter *attribute-quote-char* #\'
   "Quote character for attributes.")
diff -u3 -r cl-who-0.10.0/who.lisp ../site/cl-who-0.10.0/who.lisp
--- cl-who-0.10.0/who.lisp	2007-07-24 17:53:30.000000000 -0400
+++ ../site/cl-who-0.10.0/who.lisp	2007-08-10 20:15:18.000000000 -0400
@@ -185,15 +185,20 @@
   (declare (optimize speed space))
   (loop with =var= = (gensym)
         with attribute-quote = (string *attribute-quote-char*)
-        for (attr . val) in attr-list
+        for (attr . val) in (mapcar #'(lambda (attr-slot)
+                                        (cons (if *downcase-tokens-p*
+                                                  (string-downcase (car attr-slot))
+                                                  (string (car attr-slot)))
+                                              (cdr attr-slot)))
+                                    attr-list)
         unless (null val) ;; no attribute at all if VAL is NIL
           if (constantp val)
             if (and (eq *html-mode* :sgml) (eq val t)) ; special case for SGML
-              nconc (list " " (string-downcase attr))
+              nconc (list " " attr)
             else
               nconc (list " "
                           ;; name of attribute
-                          (string-downcase attr)
+                          attr
                           (format nil "=~C" *attribute-quote-char*)
                           ;; value of attribute
                           (cond ((stringp val)
@@ -203,7 +208,7 @@
                                  val)
                                 ((eq val t)
                                  ;; VAL is T, use attribute's name
-                                 (string-downcase attr))
+                                 attr)
                                 (t
                                  ;; constant form, PRINC it -
                                  ;; EVAL is OK here because of CONSTANTP
@@ -217,18 +222,16 @@
                                 ((eq ,=var= t) 
                                  ,(case *html-mode*
                                         (:sgml
-                                         `(htm ,(format nil " ~A"
-                                                        (string-downcase attr))))
+                                         `(htm ,(format nil " ~A" attr)))
                                         ;; otherwise default to :xml mode
                                         (t
                                          `(htm ,(format nil " ~A=~C~A~C"
-                                                        (string-downcase attr)
+                                                        attr
                                                         *attribute-quote-char*
-                                                        (string-downcase attr)
+                                                        attr
                                                         *attribute-quote-char*)))))
                                 (t
-                                 (htm ,(format nil " ~A=~C" (string-downcase attr)
-                                               *attribute-quote-char*)
+                                 (htm ,(format nil " ~A=~C" attr *attribute-quote-char*)
                                       (str ,=var=)
                                       ,attribute-quote)))))))
 
@@ -244,7 +247,7 @@
   "The standard method which is not specialized.  The idea is that you
 can use EQL specializers on the first argument."
   (declare (optimize speed space))
-  (let ((tag (if *downcase-tags-p* (string-downcase tag) (string tag))))
+  (let ((tag (if *downcase-tokens-p* (string-downcase tag) (string tag))))
     (nconc
      (if *indent*
        ;; indent by *INDENT* spaces