diff --git a/runtime/compiler/tidy.vim b/runtime/compiler/tidy.vim
index 52bc526..56baee2 100644
--- a/runtime/compiler/tidy.vim
+++ b/runtime/compiler/tidy.vim
@@ -1,11 +1,7 @@
 " Vim compiler file
 " Compiler:	HTML Tidy
-" Maintainer:	Doug Kearns <djkea2@gus.gscit.monash.edu.au>
-" URL:		http://gus.gscit.monash.edu.au/~djkea2/vim/compiler/tidy.vim
-" Last Change:	2004 Nov 27
-
-" NOTE: set 'tidy_compiler_040800' if you are using the 4th August 2000 release
-"       of HTML Tidy.
+" Maintainer:	Doug Kearns <dougkearns@gmail.com>
+" Last Change:	2013 Jul 7
 
 if exists("current_compiler")
   finish
@@ -16,13 +12,7 @@
   command -nargs=* CompilerSet setlocal <args>
 endif
 
-" this is needed to work around a bug in the 04/08/00 release of tidy which
-" failed to set the filename if the -quiet option was used
-if exists("tidy_compiler_040800")
-  CompilerSet makeprg=tidy\ -errors\ --gnu-emacs\ yes\ %
-else
-  CompilerSet makeprg=tidy\ -quiet\ -errors\ --gnu-emacs\ yes\ %
-endif
+CompilerSet makeprg=tidy\ -quiet\ -errors\ --gnu-emacs\ yes\ %
 
 " sample warning: foo.html:8:1: Warning: inserting missing 'foobar' element
 " sample error:   foo.html:9:2: Error: <foobar> is not recognized!
