diff --git a/AUTHORS.md b/AUTHORS.md
new file mode 100644
index 0000000..58a51bb
--- /dev/null
+++ b/AUTHORS.md
@@ -0,0 +1,18 @@
+ChronoShare Authors
+===================
+
+## The primary authors are (and/or have been):
+
+* Zhenkai Zhu           <http://irl.cs.ucla.edu/~zhenkai/>
+* Alexander Afanasyev   <http://lasr.cs.ucla.edu/afanasyev/index.html>
+* Lijing Wang           <wanglj11@mails.tsinghua.edu.cn>
+* Yukai Tu              <ytu@cs.ucla.edu>
+
+## All project authors and contributors
+
+The following is an inevitably incomplete list of MUCH-APPRECIATED CONTRIBUTORS,
+people who have reported bugs, submitted patches, and implemented new features
+in the library:
+
+* Ilya Moiseenko        <http://ilyamoiseenko.com/>
+* Jared Lindblom        <lindblom@cs.ucla.edu>
