diff --git a/runtime/doc/pi_zip.txt b/runtime/doc/pi_zip.txt
new file mode 100644
index 0000000..1358a11
--- /dev/null
+++ b/runtime/doc/pi_zip.txt
@@ -0,0 +1,41 @@
+*zip.txt*	Zip File Interface				Nov 22, 2005
+
+Author:  Charles E. Campbell, Jr.  <NdrOchip@ScampbellPfamily.AbizM>
+	  (remove NOSPAM from Campbell's email first)
+Copyright:    Copyright (C) 2005 Charles E. Campbell, Jr. {{{1 *zip-copyright*
+              Permission is hereby granted to use and distribute this code,
+	      with or without modifications, provided that this copyright
+	      notice is copied with it. Like anything else that's free,
+	      zip.vim and zipPlugin.vim are provided *as is* and comes with no
+	      warranty of any kind, either expressed or implied. By using this
+	      plugin, you agree that in no event will the copyright holder be
+	      liable for any damages resulting from the use of this software.
+
+==============================================================================
+1. Contents					*zip* *zip-contents*
+   1. Contents..................................................|zip-contents|
+   2. Usage.....................................................|zip-usage|
+   3. History...................................................|zip-history|
+
+==============================================================================
+2. Usage					*zip-usage* *zip-manual*
+
+   When one edits a *.zip file, this plugin will handle displaying a
+   contents page.  Select a file to edit by moving the cursor atop
+   the desired file, then hit the <return> key.  After editing, one may
+   also write to the file.  Currently, one may not make a new file in
+   zip archives via the plugin.
+
+==============================================================================
+3. History					*zip-history*
+   v5 Nov 22, 2005 * report option workaround installed
+   v3 Oct 18, 2005 * <amatch> used instead of <afile> in autocmds
+   v2 Sep 16, 2005 * silenced some commands (avoiding hit-enter prompt)
+                   * began testing under Windows; works thus far
+		   * filetype detection fixed
+      Nov 03, 2005 * handles writing zipfiles across a network using
+                     netrw#NetWrite()
+   v1 Sep 15, 2005 * Initial release, had browsing, reading, and writing
+
+==============================================================================
+vim:tw=78:ts=8:ft=help
