diff --git a/AUTHORS.md b/AUTHORS.md
new file mode 100644
index 0000000..87bed85
--- /dev/null
+++ b/AUTHORS.md
@@ -0,0 +1,19 @@
+NFD Android authors
+===================
+
+## The primary authors are (and/or have been):
+
+* Ivan Yeo              <ivanyeo@cs.ucla.edu>
+* Sanjeev Mehrotra      <smehrotra@ucla.edu>
+* Alexander Afanasyev   <http://lasr.cs.ucla.edu/afanasyev/index.html>
+
+## 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 NFD Android:
+
+* Lixia Zhang           <http://www.cs.ucla.edu/~lixia/>
+* Beichuan Zhang        <http://www.cs.arizona.edu/~bzhang/>
+* Junxiao Shi           <http://www.cs.arizona.edu/people/shijunxiao/>
+* Yi Huang              <ethanhuang1991@gmail.com>
