diff --git a/aqt/addcards.py b/aqt/addcards.py
index c49b28f08..598207ad7 100644
--- a/aqt/addcards.py
+++ b/aqt/addcards.py
@@ -6,7 +6,6 @@ from aqt.qt import *
 import sys, re
 import aqt.forms
 import anki
-from anki.facts import Fact
 from anki.errors import *
 from anki.utils import stripHTML
 from aqt.utils import saveGeom, restoreGeom, showWarning, askUser, shortcut, \
@@ -37,7 +36,7 @@ class AddCards(QDialog):
         addHook('currentModelChanged', self.onReset)
         self.mw.requireReset(modal=True)
         self.open()
-        self.setupNewFact()
+        self.setupNewNote()
 
     def setupEditor(self):
         self.editor = aqt.editor.Editor(self.mw, self.form.fieldsArea, True)
@@ -75,78 +74,78 @@ class AddCards(QDialog):
         b.setEnabled(False)
         self.historyButton = b
 
-    # FIXME: need to make sure to clean up fact on exit
-    def setupNewFact(self, set=True):
-        f = self.mw.deck.newFact()
+    # FIXME: need to make sure to clean up note on exit
+    def setupNewNote(self, set=True):
+        f = self.mw.deck.newNote()
         f.tags = f.model()['tags']
         if set:
-            self.editor.setFact(f)
+            self.editor.setNote(f)
         return f
 
     def onReset(self, model=None, keep=False):
-        oldFact = self.editor.fact
-        fact = self.setupNewFact(set=False)
-        flds = fact.model()['flds']
-        # copy fields from old fact
-        if oldFact:
+        oldNote = self.editor.note
+        note = self.setupNewNote(set=False)
+        flds = note.model()['flds']
+        # copy fields from old note
+        if oldNote:
             if not keep:
-                self.removeTempFact(oldFact)
-            for n in range(len(fact.fields)):
+                self.removeTempNote(oldNote)
+            for n in range(len(note.fields)):
                 try:
                     if not keep or flds[n]['sticky']:
-                        fact.fields[n] = oldFact.fields[n]
+                        note.fields[n] = oldNote.fields[n]
                     else:
-                        fact.fields[n] = ""
+                        note.fields[n] = ""
                 except IndexError:
                     break
-        self.editor.setFact(fact)
+        self.editor.setNote(note)
 
-    def removeTempFact(self, fact):
-        if not fact or not fact.id:
+    def removeTempNote(self, note):
+        if not note or not note.id:
             return
-        # we don't have to worry about cards; just the fact
-        self.mw.deck._remFacts([fact.id])
+        # we don't have to worry about cards; just the note
+        self.mw.deck._remNotes([note.id])
 
-    def addHistory(self, fact):
-        txt = stripHTMLMedia(",".join(fact.fields))[:30]
-        self.history.append((fact.id, txt))
+    def addHistory(self, note):
+        txt = stripHTMLMedia(",".join(note.fields))[:30]
+        self.history.append((note.id, txt))
         self.history = self.history[-15:]
         self.historyButton.setEnabled(True)
 
     def onHistory(self):
         m = QMenu(self)
-        for fid, txt in self.history:
+        for nid, txt in self.history:
             a = m.addAction(_("Edit %s" % txt))
             a.connect(a, SIGNAL("triggered()"),
-                      lambda fid=fid: self.editHistory(fid))
+                      lambda nid=nid: self.editHistory(nid))
         m.exec_(self.historyButton.mapToGlobal(QPoint(0,0)))
 
-    def editHistory(self, fid):
+    def editHistory(self, nid):
         browser = aqt.dialogs.open("Browser", self.mw)
-        browser.form.searchEdit.setText("fid:%d" % fid)
+        browser.form.searchEdit.setText("nid:%d" % nid)
         browser.onSearch()
 
-    def addFact(self, fact):
-        if any(fact.problems()):
+    def addNote(self, note):
+        if any(note.problems()):
             showWarning(_(
                 "Some fields are missing or not unique."),
                      help="AddItems#AddError")
             return
-        cards = self.mw.deck.addFact(fact)
+        cards = self.mw.deck.addNote(note)
         if not cards:
             showWarning(_("""\
 The input you have provided would make an empty
 question or answer on all cards."""), help="AddItems")
             return
-        self.addHistory(fact)
+        self.addHistory(note)
         # FIXME: return to overview on add?
-        return fact
+        return note
 
     def addCards(self):
         self.editor.saveNow()
-        fact = self.editor.fact
-        fact = self.addFact(fact)
-        if not fact:
+        note = self.editor.note
+        note = self.addNote(note)
+        if not note:
             return
         tooltip("Added", period=500)
         # stop anything playing
@@ -168,8 +167,8 @@ question or answer on all cards."""), help="AddItems")
         removeHook('reset', self.onReset)
         removeHook('currentModelChanged', self.onReset)
         clearAudioQueue()
-        self.removeTempFact(self.editor.fact)
-        self.editor.setFact(None)
+        self.removeTempNote(self.editor.note)
+        self.editor.setNote(None)
         self.modelChooser.cleanup()
         self.mw.maybeReset()
         saveGeom(self, "add")
diff --git a/aqt/browser.py b/aqt/browser.py
index 2f86dc46d..a8f782830 100644
--- a/aqt/browser.py
+++ b/aqt/browser.py
@@ -36,7 +36,7 @@ class DeckModel(QAbstractTableModel):
         self.deck = browser.deck
         self.sortKey = None
         self.activeCols = self.deck.conf.get(
-            "activeCols", ["factFld", "template", "cardDue", "cardEase"])
+            "activeCols", ["noteFld", "template", "cardDue", "cardEase"])
         self.cards = []
         self.cardObjs = {}
 
@@ -46,9 +46,9 @@ class DeckModel(QAbstractTableModel):
             self.cardObjs[id] = self.deck.getCard(id)
         return self.cardObjs[id]
 
-    def refreshFact(self, fact):
+    def refreshNote(self, note):
         refresh = False
-        for c in fact.cards():
+        for c in note.cards():
             if c.id in self.cardObjs:
                 del self.cardObjs[c.id]
                 refresh = True
@@ -123,7 +123,7 @@ class DeckModel(QAbstractTableModel):
 
     def beginReset(self):
         self.browser.editor.saveNow()
-        self.browser.editor.setFact(None, hide=False)
+        self.browser.editor.setNote(None, hide=False)
         self.browser.mw.progress.start()
         self.saveSelection()
         self.beginResetModel()
@@ -192,7 +192,7 @@ class DeckModel(QAbstractTableModel):
         except:
             # debugging
             print column, self.activeCols
-            return "factFld"
+            return "noteFld"
         return type
 
     def columnData(self, index):
@@ -204,17 +204,17 @@ class DeckModel(QAbstractTableModel):
             return self.question()
         elif type == "answer":
             return self.answer()
-        elif type == "factFld":
-            f = c.fact()
+        elif type == "noteFld":
+            f = c.note()
             return self.formatQA(f.fields[self.deck.models.sortIdx(f.model())])
         elif type == "template":
             return c.template()['name']
         elif type == "cardDue":
             return self.nextDue(c, index)
-        elif type == "factCrt":
-            return time.strftime("%Y-%m-%d", time.localtime(c.fact().id/1000))
-        elif type == "factMod":
-            return time.strftime("%Y-%m-%d", time.localtime(c.fact().mod))
+        elif type == "noteCrt":
+            return time.strftime("%Y-%m-%d", time.localtime(c.note().id/1000))
+        elif type == "noteMod":
+            return time.strftime("%Y-%m-%d", time.localtime(c.note().mod))
         elif type == "cardMod":
             return time.strftime("%Y-%m-%d", time.localtime(c.mod))
         elif type == "cardReps":
@@ -231,8 +231,8 @@ class DeckModel(QAbstractTableModel):
             return "%d%%" % (c.factor/10)
         elif type == "cardGroup":
             return self.browser.mw.deck.groups.name(c.gid)
-        elif type == "factGroup":
-            return self.browser.mw.deck.groups.name(c.fact().gid)
+        elif type == "noteGroup":
+            return self.browser.mw.deck.groups.name(c.note().gid)
 
     def question(self):
         return self.formatQA(c.a())
@@ -280,7 +280,7 @@ class StatusDelegate(QItemDelegate):
             painter.save()
             painter.fillRect(option.rect, brush)
             painter.restore()
-        elif c.fact().hasTag("Marked"):
+        elif c.note().hasTag("Marked"):
             if index.row() % 2 == 0:
                 brush = QBrush(QColor(COLOUR_MARKED1))
             else:
@@ -355,14 +355,14 @@ class Browser(QMainWindow):
         c(f.actionOptions, s, self.onOptions)
         c(f.actionUndo, s, self.mw.onUndo)
         c(f.actionInvertSelection, s, self.invertSelection)
-        c(f.actionSelectFacts, s, self.selectFacts)
+        c(f.actionSelectNotes, s, self.selectNotes)
         c(f.actionFindReplace, s, self.onFindReplace)
         c(f.actionFindDuplicates, s, self.onFindDupes)
         # jumps
         c(f.actionPreviousCard, s, self.onPreviousCard)
         c(f.actionNextCard, s, self.onNextCard)
         c(f.actionFind, s, self.onFind)
-        c(f.actionFact, s, self.onFact)
+        c(f.actionNote, s, self.onNote)
         c(f.actionTags, s, self.onTags)
         c(f.actionSort, s, self.onSort)
         c(f.actionCardList, s, self.onCardList)
@@ -381,7 +381,7 @@ class Browser(QMainWindow):
         saveSplitter(self.form.splitter_2, "editor2")
         saveSplitter(self.form.splitter_3, "editor3")
         self.editor.saveNow()
-        self.editor.setFact(None)
+        self.editor.setNote(None)
         saveGeom(self, "editor")
         saveState(self, "editor")
         saveHeader(self.form.tableView.horizontalHeader(), "editor")
@@ -407,10 +407,10 @@ class Browser(QMainWindow):
             ('answer', _("Answer")),
             ('template', _("Card")),
             ('cardGroup', _("C.Group")),
-            ('factGroup', _("I.Group")),
-            ('factFld', _("Sort Field")),
-            ('factCrt', _("Created")),
-            ('factMod', _("Edited")),
+            ('noteGroup', _("I.Group")),
+            ('noteFld', _("Sort Field")),
+            ('noteCrt', _("Created")),
+            ('noteMod', _("Edited")),
             ('cardMod', _("Reviewed")),
             ('cardDue', _("Due")),
             ('cardIvl', _("Interval")),
@@ -439,7 +439,7 @@ class Browser(QMainWindow):
         self.form.searchEdit.setCompleter(self.searchComp)
 
     def onSearch(self, reset=True):
-        "Careful: if reset is true, the current fact is saved."
+        "Careful: if reset is true, the current note is saved."
         txt = unicode(self.form.searchEdit.text()).strip()
         sh = self.mw.config['searchHistory']
         if txt not in sh:
@@ -471,7 +471,7 @@ class Browser(QMainWindow):
         return selected
 
     def onReset(self):
-        self.editor.setFact(None)
+        self.editor.setNote(None)
         self.onSearch()
 
     # Table view & editor
@@ -494,21 +494,21 @@ class Browser(QMainWindow):
         self.editor.stealFocus = False
 
     def onRowChanged(self, current, previous):
-        "Update current fact and hide/show editor."
+        "Update current note and hide/show editor."
         show = self.model.cards and self.updateTitle() == 1
         self.form.splitter_2.widget(1).setShown(not not show)
         if not show:
-            self.editor.setFact(None)
+            self.editor.setNote(None)
         else:
             self.card = self.model.getCard(
                 self.form.tableView.selectionModel().currentIndex())
-            self.editor.setFact(self.card.fact())
+            self.editor.setNote(self.card.note())
             self.editor.card = self.card
             self.showCardInfo(self.card)
         self.updateToggles()
 
-    def refreshCurrentCard(self, fact):
-        self.model.refreshFact(fact)
+    def refreshCurrentCard(self, note):
+        self.model.refreshNote(note)
 
     # Headers & sorting
     ######################################################################
@@ -533,7 +533,7 @@ class Browser(QMainWindow):
 
     def onSortChanged(self, idx, ord):
         type = self.model.activeCols[idx]
-        noSort = ("question", "answer", "template", "cardGroup", "factGroup")
+        noSort = ("question", "answer", "template", "cardGroup", "noteGroup")
         if type in noSort:
             showInfo(_("Sorting on this column is not supported. Please "
                        "choose another."))
@@ -541,7 +541,7 @@ class Browser(QMainWindow):
         if self.deck.conf['sortType'] != type:
             self.deck.conf['sortType'] = type
             # default to descending for non-text fields
-            if type == "factFld":
+            if type == "noteFld":
                 ord = not ord
             self.deck.conf['sortBackwards'] = ord
             self.onSearch()
@@ -592,7 +592,7 @@ class Browser(QMainWindow):
     def setColumnSizes(self):
         hh = self.form.tableView.horizontalHeader()
         for c, i in enumerate(self.model.activeCols):
-            if i in ("question", "answer", "factFld"):
+            if i in ("question", "answer", "noteFld"):
                 hh.setResizeMode(c, QHeaderView.Stretch)
             else:
                 hh.setResizeMode(c, QHeaderView.Interactive)
@@ -809,24 +809,24 @@ class Browser(QMainWindow):
         return [self.model.cards[idx.row()] for idx in
                 self.form.tableView.selectionModel().selectedRows()]
 
-    def selectedFacts(self):
+    def selectedNotes(self):
         return self.deck.db.list("""
-select distinct fid from cards
+select distinct nid from cards
 where id in %s""" % ids2str(
     [self.model.cards[idx.row()] for idx in
     self.form.tableView.selectionModel().selectedRows()]))
 
-    def selectedFactsAsCards(self):
+    def selectedNotesAsCards(self):
         return self.deck.db.list(
-            "select id from cards where fid in (%s)" %
-            ",".join([str(s) for s in self.selectedFacts()]))
+            "select id from cards where nid in (%s)" %
+            ",".join([str(s) for s in self.selectedNotes()]))
 
-    def oneModelFacts(self):
-        sf = self.selectedFacts()
+    def oneModelNotes(self):
+        sf = self.selectedNotes()
         if not sf:
             return
         mods = self.deck.db.scalar("""
-select count(distinct mid) from facts
+select count(distinct mid) from notes
 where id in %s""" % ids2str(sf))
         if mods > 1:
             showInfo(_("Please select cards from only one model."))
@@ -840,14 +840,14 @@ where id in %s""" % ids2str(sf))
     ######################################################################
 
     def genCards(self):
-        fids = self.oneModelFacts()
-        if fids:
-            GenCards(self, fids)
+        nids = self.oneModelNotes()
+        if nids:
+            GenCards(self, nids)
 
     def onChangeModel(self):
-        fids = self.oneModelFacts()
-        if fids:
-            ChangeModel(self, fids)
+        nids = self.oneModelNotes()
+        if nids:
+            ChangeModel(self, nids)
 
     def cram(self):
         return showInfo("not yet implemented")
@@ -900,11 +900,11 @@ where id in %s""" % ids2str(sf))
                     self.selectedCards()), mod, gid)
             if frm.setInitial.isChecked():
                 self.deck.db.execute(
-                    "update facts set mod=?, gid=? where id in " + ids2str(
-                        self.selectedFacts()), mod, gid)
+                    "update notes set mod=?, gid=? where id in " + ids2str(
+                        self.selectedNotes()), mod, gid)
         else:
             self.deck.db.execute("""
-update cards set mod=?, gid=(select gid from facts where id = cards.fid)
+update cards set mod=?, gid=(select gid from notes where id = cards.nid)
 where id in %s""" % ids2str(self.selectedCards()), mod)
         self.onSearch(reset=False)
         self.mw.requireReset()
@@ -929,7 +929,7 @@ where id in %s""" % ids2str(self.selectedCards()), mod)
             label = _("Add Tags")
         if label:
             self.mw.checkpoint(label)
-        func(self.selectedFacts(), tags)
+        func(self.selectedNotes(), tags)
         self.onSearch(reset=False)
         self.mw.requireReset()
         self.model.endReset()
@@ -962,7 +962,7 @@ where id in %s""" % ids2str(self.selectedCards()), mod)
         self.mw.requireReset()
 
     def isMarked(self):
-        return not not (self.card and self.card.fact().hasTag("Marked"))
+        return not not (self.card and self.card.note().hasTag("Marked"))
 
     def onMark(self, mark):
         if mark:
@@ -1023,9 +1023,9 @@ where id in %s""" % ids2str(self.selectedCards()), mod)
     # Edit: selection
     ######################################################################
 
-    def selectFacts(self):
-        fids = self.selectedFacts()
-        self.form.searchEdit.setText("fid:"+",".join([str(x) for x in fids]))
+    def selectNotes(self):
+        nids = self.selectedNotes()
+        self.form.searchEdit.setText("nid:"+",".join([str(x) for x in nids]))
         # clear the selection so we don't waste energy preserving it
         tv = self.form.tableView
         tv.selectionModel().clear()
@@ -1084,7 +1084,7 @@ where id in %s""" % ids2str(self.selectedCards()), mod)
     ######################################################################
 
     def onFindReplace(self):
-        sf = self.selectedFacts()
+        sf = self.selectedNotes()
         if not sf:
             return
         import anki.find
@@ -1123,8 +1123,8 @@ where id in %s""" % ids2str(self.selectedCards()), mod)
             self.model.endReset()
             self.mw.progress.finish()
         showInfo(ngettext(
-            "%(a)d of %(b)d fact updated",
-            "%(a)d of %(b)d facts updated", len(sf)) % {
+            "%(a)d of %(b)d note updated",
+            "%(a)d of %(b)d notes updated", len(sf)) % {
                 'a': changed,
                 'b': len(sf),
             })
@@ -1141,7 +1141,7 @@ where id in %s""" % ids2str(self.selectedCards()), mod)
         aqt = ankiqt.forms.finddupes.Ui_Dialog()
         dialog.setupUi(win)
         restoreGeom(win, "findDupes")
-        fields = sorted(self.card.fact.model.fieldModels, key=attrgetter("name"))
+        fields = sorted(self.card.note.model.fieldModels, key=attrgetter("name"))
         # per-model data
         data = self.deck.db.all("""
 select fm.id, m.name || '>' || fm.name from fieldmodels fm, models m
@@ -1196,7 +1196,7 @@ select fm.id, fm.name from fieldmodels fm""")
 
         for group in res:
             t += '<li><a href="%s">%s</a>' % (
-                "fid:" + ",".join(str(id) for id in group[1]),
+                "nid:" + ",".join(str(id) for id in group[1]),
                 group[0])
 
         t += "</ol>"
@@ -1207,7 +1207,7 @@ select fm.id, fm.name from fieldmodels fm""")
     def dupeLinkClicked(self, link):
         self.form.searchEdit.setText(link.toString())
         self.onSearch()
-        self.onFact()
+        self.onNote()
 
     # Jumping
     ######################################################################
@@ -1231,7 +1231,7 @@ select fm.id, fm.name from fieldmodels fm""")
         self.form.searchEdit.setFocus()
         self.form.searchEdit.selectAll()
 
-    def onFact(self):
+    def onNote(self):
         self.editor.focus()
 
     def onTags(self):
@@ -1248,10 +1248,10 @@ select fm.id, fm.name from fieldmodels fm""")
 
 class GenCards(QDialog):
 
-    def __init__(self, browser, fids):
+    def __init__(self, browser, nids):
         QDialog.__init__(self, browser)
         self.browser = browser
-        self.fids = fids
+        self.nids = nids
         self.form = aqt.forms.gencards.Ui_Dialog()
         self.form.setupUi(self)
         self.setWindowModality(Qt.WindowModal)
@@ -1262,7 +1262,7 @@ class GenCards(QDialog):
 
     def getSelection(self):
         # get cards to enable
-        f = self.browser.deck.getFact(self.fids[0])
+        f = self.browser.deck.getNote(self.nids[0])
         self.model = f.model()
         self.items = []
         for t in self.model.templates:
@@ -1296,15 +1296,15 @@ class GenCards(QDialog):
         mw = self.browser.mw
         mw.checkpoint(_("Generate Cards"))
         mw.progress.start()
-        for c, fid in enumerate(self.fids):
-            f = mw.deck.getFact(fid)
+        for c, nid in enumerate(self.nids):
+            f = mw.deck.getNote(nid)
             mw.deck.genCards(f, tplates)
             if c % 100 == 0:
                 mw.progress.update()
         if unused:
             cids = mw.deck.db.list("""
-select id from cards where fid in %s and ord in %s""" % (
-                    ids2str(self.fids), ids2str(unused)))
+select id from cards where nid in %s and ord in %s""" % (
+                    ids2str(self.nids), ids2str(unused)))
             mw.deck.remCards(cids)
         mw.progress.finish()
         mw.requireReset()
@@ -1318,11 +1318,11 @@ select id from cards where fid in %s and ord in %s""" % (
 
 class ChangeModel(QDialog):
 
-    def __init__(self, browser, fids):
+    def __init__(self, browser, nids):
         QDialog.__init__(self, browser)
         self.browser = browser
-        self.fids = fids
-        self.oldModel = browser.card.fact().model()
+        self.nids = nids
+        self.oldModel = browser.card.note().model()
         self.form = aqt.forms.changemodel.Ui_Dialog()
         self.form.setupUi(self)
         self.setWindowModality(Qt.WindowModal)
@@ -1461,14 +1461,14 @@ class ChangeModel(QDialog):
         if any(True for c in cmap.values() if c is None):
             if not askUser(_("""\
 Any cards with templates mapped to nothing will be deleted. \
-If a fact has no remaining cards, it will be lost. \
+If a note has no remaining cards, it will be lost. \
 Are you sure you want to continue?""")):
                 return
         self.browser.mw.checkpoint(_("Change Model"))
         b = self.browser
         b.mw.progress.start()
         b.model.beginReset()
-        self.oldModel.changeModel(self.fids, self.targetModel, fmap, cmap)
+        self.oldModel.changeModel(self.nids, self.targetModel, fmap, cmap)
         b.onSearch(reset=False)
         b.model.endReset()
         b.mw.progress.finish()
diff --git a/aqt/clayout.py b/aqt/clayout.py
index c95feda34..5ba4b599f 100644
--- a/aqt/clayout.py
+++ b/aqt/clayout.py
@@ -20,17 +20,17 @@ class ResizingTextEdit(QTextEdit):
 class CardLayout(QDialog):
 
     # type is previewCards() type
-    def __init__(self, mw, fact, type=0, ord=0, parent=None):
+    def __init__(self, mw, note, type=0, ord=0, parent=None):
         QDialog.__init__(self, parent or mw, Qt.Window)
         raise Exception("Remember to disallow media&latex refs in edit.")
         self.mw = aqt.mw
         self.parent = parent or mw
-        self.fact = fact
+        self.note = note
         self.type = type
         self.ord = ord
         self.deck = self.mw.deck
         self.mm = self.mw.deck.models
-        self.model = fact.model()
+        self.model = note.model()
         self.form = aqt.forms.clayout.Ui_Dialog()
         self.form.setupUi(self)
         self.setWindowTitle(_("%s Layout") % self.model['name'])
@@ -50,13 +50,13 @@ class CardLayout(QDialog):
         self.exec_()
 
     def reload(self, first=False):
-        self.cards = self.deck.previewCards(self.fact, self.type)
+        self.cards = self.deck.previewCards(self.note, self.type)
         if not self.cards:
             self.accept()
             if first:
                 showInfo(_("Please enter some text first."))
             else:
-                showInfo(_("The current fact was deleted."))
+                showInfo(_("The current note was deleted."))
             return
         self.fillCardList()
         self.fillFieldList()
@@ -76,7 +76,7 @@ class CardLayout(QDialog):
                 _("Templates that will be created:"))
         elif self.type == 1:
             f.templateType.setText(
-                _("Templates used by fact:"))
+                _("Templates used by note:"))
         else:
             f.templateType.setText(
                 _("All templates:"))
@@ -259,10 +259,10 @@ class CardLayout(QDialog):
         if self.needFieldRebuild:
             modified = True
         if modified:
-            self.fact.model.setModified()
+            self.note.model.setModified()
             self.deck.flushMod()
-            if self.factedit and self.factedit.onChange:
-                self.factedit.onChange("all")
+            if self.noteedit and self.noteedit.onChange:
+                self.noteedit.onChange("all")
                 reset=False
         if reset:
             self.mw.reset()
@@ -358,7 +358,7 @@ class CardLayout(QDialog):
         if fld['name'] != name:
             self.mm.renameField(self.model, fld, name)
             # as the field name has changed, we have to regenerate cards
-            self.cards = self.deck.previewCards(self.fact, self.type)
+            self.cards = self.deck.previewCards(self.note, self.type)
             self.cardChanged(0)
         self.renderPreview()
         self.fillFieldList()
@@ -413,7 +413,7 @@ class CardLayout(QDialog):
         if len(self.model.fields) < 2:
             showInfo(_("Please add a new field first."))
             return
-        if askUser(_("Delete this field and its data from all facts?")):
+        if askUser(_("Delete this field and its data from all notes?")):
             self.mw.progress.start()
             self.model.delField(self.field)
             self.mw.progress.finish()
diff --git a/aqt/editcurrent.py b/aqt/editcurrent.py
index fae60720f..ff33b65cf 100644
--- a/aqt/editcurrent.py
+++ b/aqt/editcurrent.py
@@ -24,7 +24,7 @@ class EditCurrent(QDialog):
                      SIGNAL("rejected()"),
                      self.onSave)
         self.editor = aqt.editor.Editor(self.mw, self.form.fieldsArea)
-        self.editor.setFact(self.mw.reviewer.card.fact())
+        self.editor.setNote(self.mw.reviewer.card.note())
         restoreGeom(self, "editcurrent")
         addHook("closeEditCurrent", self.onSave)
         self.mw.requireReset(modal=True)
@@ -35,7 +35,7 @@ class EditCurrent(QDialog):
     def onSave(self):
         removeHook("closeEditCurrent", self.onSave)
         self.editor.saveNow()
-        self.editor.setFact(None)
+        self.editor.setNote(None)
         r = self.mw.reviewer
         r.card.load()
         r.keep = True
diff --git a/aqt/editor.py b/aqt/editor.py
index 9e54f8923..62096968a 100644
--- a/aqt/editor.py
+++ b/aqt/editor.py
@@ -188,12 +188,12 @@ $(function () {
 </body></html>
 """
 
-# caller is responsible for resetting fact on reset
+# caller is responsible for resetting note on reset
 class Editor(object):
     def __init__(self, mw, widget, addMode=False):
         self.widget = widget
         self.mw = mw
-        self.fact = None
+        self.note = None
         self.stealFocus = True
         self.addMode = addMode
         self._loaded = False
@@ -311,28 +311,28 @@ class Editor(object):
             type = 1; ord = self.card.ord
         else:
             type = 0; ord = 0
-        CardLayout(self.mw, self.fact, type=type, ord=ord, parent=self.widget)
-        self.loadFact()
+        CardLayout(self.mw, self.note, type=type, ord=ord, parent=self.widget)
+        self.loadNote()
 
     # JS->Python bridge
     ######################################################################
 
     def bridge(self, str):
-        if not self.fact or not runHook:
+        if not self.note or not runHook:
             # shutdown
             return
         # focus lost or key/button pressed?
         if str.startswith("blur") or str.startswith("key"):
             (type, txt) = str.split(":", 1)
-            self.fact.fields[self.currentField] = self.mungeHTML(txt)
+            self.note.fields[self.currentField] = self.mungeHTML(txt)
             self.mw.requireReset()
-            self.fact.flush()
+            self.note.flush()
             if type == "blur":
                 if not self._keepButtons:
                     self.disableButtons()
-                runHook("editFocusLost", self.fact)
+                runHook("editFocusLost", self.note)
             else:
-                runHook("editTimer", self.fact)
+                runHook("editTimer", self.note)
             self.checkValid()
         # focused into field?
         elif str.startswith("focus"):
@@ -358,19 +358,19 @@ class Editor(object):
             txt = ""
         return txt
 
-    # Setting/unsetting the current fact
+    # Setting/unsetting the current note
     ######################################################################
 
     def _loadFinished(self, w):
         self._loaded = True
-        if self.fact:
-            self.loadFact()
+        if self.note:
+            self.loadNote()
 
-    def setFact(self, fact, hide=True):
-        "Make FACT the current fact."
-        self.fact = fact
+    def setNote(self, note, hide=True):
+        "Make NOTE the current note."
+        self.note = note
         # change timer
-        if self.fact:
+        if self.note:
             self.web.setHtml(_html % (getBase(self.mw.deck), anki.js.all,
                                   _("Show Duplicates")),
                              loadCB=self._loadFinished)
@@ -379,12 +379,12 @@ class Editor(object):
         elif hide:
             self.widget.hide()
 
-    def loadFact(self, field=0):
+    def loadNote(self, field=0):
         if not self._loaded:
             # will be loaded when page is ready
             return
         self.web.eval("setFields(%s, %d);" % (
-            simplejson.dumps(self.fact.items()), field))
+            simplejson.dumps(self.note.items()), field))
         self.web.eval("setFonts(%s);" % (
             simplejson.dumps(self.fonts())))
         self.checkValid()
@@ -397,11 +397,11 @@ class Editor(object):
 
     def fonts(self):
         return [(f['font'], f['esize'])
-                for f in self.fact.model()['flds']]
+                for f in self.note.model()['flds']]
 
     def saveNow(self):
         "Must call this before adding cards, closing dialog, etc."
-        if not self.fact:
+        if not self.note:
             return
         self._keepButtons = True
         self.web.eval("saveField('blur');")
@@ -411,7 +411,7 @@ class Editor(object):
     def checkValid(self):
         cols = []
         self.dupe = None
-        for c, p in enumerate(self.fact.problems()):
+        for c, p in enumerate(self.note.problems()):
             if not p:
                 cols.append("#fff")
             elif p == "unique":
@@ -426,16 +426,16 @@ class Editor(object):
             self.web.eval("hideDupes();")
 
     def showDupes(self):
-        contents = self.fact.fields[self.dupe]
+        contents = self.note.fields[self.dupe]
         browser = aqt.dialogs.open("Browser", self.mw)
         browser.form.searchEdit.setText(
-            "'model:%s' '%s'" % (self.fact.model().name, contents))
+            "'model:%s' '%s'" % (self.note.model().name, contents))
         browser.onSearch()
 
     def fieldsAreBlank(self):
-        if not self.fact:
+        if not self.note:
             return True
-        for f in self.fact.fields:
+        for f in self.note.fields:
             if f:
                 return False
         return True
@@ -450,12 +450,12 @@ class Editor(object):
         form.setupUi(d)
         d.connect(form.buttonBox, SIGNAL("helpRequested()"),
                  lambda: aqt.openHelp("HtmlEditor"))
-        form.textEdit.setPlainText(self.fact.fields[self.currentField])
+        form.textEdit.setPlainText(self.note.fields[self.currentField])
         form.textEdit.moveCursor(QTextCursor.End)
         d.exec_()
-        self.fact.fields[self.currentField] = unicode(
+        self.note.fields[self.currentField] = unicode(
             form.textEdit.toPlainText())
-        self.loadFact(self.currentField)
+        self.loadNote(self.currentField)
 
     # Tag and group handling
     ######################################################################
@@ -494,32 +494,32 @@ class Editor(object):
             self.tags.setDeck(self.mw.deck)
             if self.addMode:
                 self.group.setDeck(self.mw.deck)
-        self.tags.setText(self.fact.stringTags().strip())
-        if getattr(self.fact, 'gid', None):
-            gid = self.fact.gid
+        self.tags.setText(self.note.stringTags().strip())
+        if getattr(self.note, 'gid', None):
+            gid = self.note.gid
         else:
-            gid = self.fact.model().conf['gid']
+            gid = self.note.model().conf['gid']
         self.group.setText(self.mw.deck.groups.name(gid))
 
     def saveTagsAndGroup(self):
-        if not self.fact:
+        if not self.note:
             return
-        self.fact.tags = self.mw.deck.tags.split(unicode(self.tags.text()))
+        self.note.tags = self.mw.deck.tags.split(unicode(self.tags.text()))
         if self.addMode:
             # save group and tags to model
-            self.fact.gid = self.mw.deck.groups.id(unicode(self.group.text()))
-            m = self.fact.model()
-            m['gid'] = self.fact.gid
-            m['tags'] = self.fact.tags
+            self.note.gid = self.mw.deck.groups.id(unicode(self.group.text()))
+            m = self.note.model()
+            m['gid'] = self.note.gid
+            m['tags'] = self.note.tags
             self.mw.deck.models.save(m)
-        self.fact.flush()
-        runHook("tagsAndGroupUpdated", self.fact)
+        self.note.flush()
+        runHook("tagsAndGroupUpdated", self.note)
 
     def changeGroup(self):
-        id = self.fact.id
+        id = self.note.id
         runHook("closeEditCurrent")
         browser = aqt.dialogs.open("Browser", self.mw)
-        browser.form.searchEdit.setText("fid:%d" % id)
+        browser.form.searchEdit.setText("nid:%d" % id)
         browser.onSearch()
         browser.setGroup(True)
 
@@ -547,7 +547,7 @@ class Editor(object):
     def onCloze(self):
         # check that the model is set up for cloze deletion
         ok = False
-        for t in self.fact.model().templates:
+        for t in self.note.model().templates:
             if "cloze" in t['qfmt'] or "cloze" in t['afmt']:
                 ok = True
                 break
@@ -555,7 +555,7 @@ class Editor(object):
             showInfo(_("Please use a cloze deletion model."),
                  help="ClozeDeletion")
             return
-        f = self.fact.fields[self.currentField]
+        f = self.note.fields[self.currentField]
         # find the highest existing cloze
         m = re.findall("\{\{c(\d+)::", f)
         if m:
diff --git a/aqt/importing.py b/aqt/importing.py
index cefabd23c..89bed3ec1 100644
--- a/aqt/importing.py
+++ b/aqt/importing.py
@@ -214,7 +214,7 @@ you can enter it here. Use \\t to represent tab."""),
             self.parent.deck.finishProgress()
             self.parent.deck.setUndoEnd(n)
         txt = (
-            _("Importing complete. %(num)d facts imported from %(file)s.\n") %
+            _("Importing complete. %(num)d notes imported from %(file)s.\n") %
             {"num": self.importer.total, "file": os.path.basename(self.file)})
         self.dialog.groupBox.setShown(False)
         self.dialog.buttonBox.button(QDialogButtonBox.Close).setFocus()
diff --git a/aqt/main.py b/aqt/main.py
index 5ba6dc730..5966aa0b1 100755
--- a/aqt/main.py
+++ b/aqt/main.py
@@ -123,9 +123,9 @@ class AnkiQt(QMainWindow):
     def _editCurrentState(self, oldState):
         pass
 
-    def factChanged(self, fid):
-        "Called when a card or fact is edited (but not deleted)."
-        runHook("factChanged", fid)
+    def noteChanged(self, nid):
+        "Called when a card or note is edited (but not deleted)."
+        runHook("noteChanged", nid)
 
     # Resetting state
     ##########################################################################
@@ -541,7 +541,7 @@ Debug info:\n%s""") % traceback.format_exc(), help="DeckErrors")
     def closeEvent(self, event):
         "User hit the X button, etc."
         print "fixme: exit from edit current, review, etc"
-        if self.state == "editCurrentFact":
+        if self.state == "editCurrentNote":
             event.ignore()
             return self.moveToState("saveEdit")
         self.close(showBrowser=False)
@@ -602,11 +602,11 @@ Debug info:\n%s""") % traceback.format_exc(), help="DeckErrors")
     def updateMarkAction(self, ):
         self.form.actionMarkCard.blockSignals(True)
         self.form.actionMarkCard.setChecked(
-            self.reviewer.card.fact().hasTag("marked"))
+            self.reviewer.card.note().hasTag("marked"))
         self.form.actionMarkCard.blockSignals(False)
 
     def onMark(self, toggled):
-        f = self.reviewer.card.fact()
+        f = self.reviewer.card.note()
         if f.hasTag("marked"):
             f.delTag("marked")
         else:
@@ -623,9 +623,9 @@ Debug info:\n%s""") % traceback.format_exc(), help="DeckErrors")
         self.deck.remCards([self.reviewer.card.id])
         self.reviewer.nextCard()
 
-    def onBuryFact(self):
+    def onBuryNote(self):
         self.checkpoint(_("Bury"))
-        self.deck.sched.buryFact(self.reviewer.card.fid)
+        self.deck.sched.buryNote(self.reviewer.card.nid)
         self.reviewer.nextCard()
 
     # Undo & autosave
@@ -690,7 +690,7 @@ Debug info:\n%s""") % traceback.format_exc(), help="DeckErrors")
 
     def onCardLayout(self):
         from aqt.clayout import CardLayout
-        CardLayout(self, self.reviewer.card.fact(), type=1,
+        CardLayout(self, self.reviewer.card.note(), type=1,
                    ord=self.reviewer.card.ord)
 
     def onDeckOpts(self):
@@ -829,7 +829,7 @@ Please choose a new deck name:"""))
         self.connect(m.actionGroups, s, self.onGroups)
         self.connect(m.actionDocumentation, s, self.onDocumentation)
         self.connect(m.actionDonate, s, self.onDonate)
-        self.connect(m.actionBuryFact, s, self.onBuryFact)
+        self.connect(m.actionBuryNote, s, self.onBuryNote)
 
     def enableDeckMenuItems(self, enabled=True):
         "setEnabled deck-related items."
@@ -855,7 +855,7 @@ Please choose a new deck name:"""))
 	self.form.actionMarkCard.setEnabled(False)
 	self.form.actionSuspendCard.setEnabled(False)
 	self.form.actionDelete.setEnabled(False)
-	self.form.actionBuryFact.setEnabled(False)
+	self.form.actionBuryNote.setEnabled(False)
         self.form.actionRepeatAudio.setEnabled(False)
         runHook("disableCardMenuItems")
 
@@ -865,7 +865,7 @@ Please choose a new deck name:"""))
 	self.form.actionMarkCard.setEnabled(True)
 	self.form.actionSuspendCard.setEnabled(True)
 	self.form.actionDelete.setEnabled(True)
-	self.form.actionBuryFact.setEnabled(True)
+	self.form.actionBuryNote.setEnabled(True)
         self.form.actionEditCurrent.setEnabled(True)
         self.form.actionEditdeck.setEnabled(True)
         self.updateMarkAction()
diff --git a/aqt/models.py b/aqt/models.py
index 7ad7c4bdc..002b951ae 100644
--- a/aqt/models.py
+++ b/aqt/models.py
@@ -59,8 +59,8 @@ class Models(QDialog):
         self.models = [self.deck.getModel(mid) for mid in mids]
         self.form.modelsList.clear()
         for m in self.models:
-            item = QListWidgetItem(_("%(name)s [%(facts)d facts]") % dict(
-                name=m.name, facts=m.useCount()))
+            item = QListWidgetItem(_("%(name)s [%(notes)d notes]") % dict(
+                name=m.name, notes=m.useCount()))
             self.form.modelsList.addItem(item)
         self.form.modelsList.setCurrentRow(row)
 
@@ -78,23 +78,23 @@ class Models(QDialog):
 
     def onLayout(self):
         # set to current
-        # # see if there's an available fact
+        # # see if there's an available note
         dummy = False
         id = self.deck.db.scalar(
-            "select id from facts where mid = ?", self.model.id)
+            "select id from notes where mid = ?", self.model.id)
         if id:
-            fact = self.deck.getFact(id)
+            note = self.deck.getNote(id)
         else:
             # generate a dummy one
             self.deck.conf['currentModelId'] = self.model.id
-            fact = self.deck.newFact()
-            for f in fact.keys():
-                fact[f] = f
-            self.deck.addFact(fact)
+            note = self.deck.newNote()
+            for f in note.keys():
+                note[f] = f
+            self.deck.addNote(note)
             dummy = True
-        aqt.clayout.CardLayout(self.mw, fact, type=2, parent=self)
+        aqt.clayout.CardLayout(self.mw, note, type=2, parent=self)
         if dummy:
-            self.deck._delFacts([fact.id])
+            self.deck._delNotes([note.id])
 
     def onDelete(self):
         if len(self.models) < 2:
diff --git a/aqt/reviewer.py b/aqt/reviewer.py
index 35a844f65..155ef9486 100644
--- a/aqt/reviewer.py
+++ b/aqt/reviewer.py
@@ -402,7 +402,7 @@ div#filler {
         ord = self.typeAns()
         try:
             cor = self.mw.deck.media.strip(
-                stripHTML(self.card.fact().fields[ord]))
+                stripHTML(self.card.note().fields[ord]))
         except IndexError:
             self.card.template()['typeAns'] = None
             self.card.model().flush()
diff --git a/aqt/share.py b/aqt/share.py
index 7544299b8..c5997e3ba 100644
--- a/aqt/share.py
+++ b/aqt/share.py
@@ -54,14 +54,14 @@
         self.deck.updateProgress()
         d.s.statement("vacuum")
         self.deck.updateProgress()
-        nfacts = d.factCount
+        nnotes = d.noteCount
         mdir = self.deck.mediaDir()
         d.close()
         dir = os.path.dirname(path)
         zippath = os.path.join(dir, "shared-%d.zip" % time.time())
         # zip it up
         zip = zipfile.ZipFile(zippath, "w", zipfile.ZIP_DEFLATED)
-        zip.writestr("facts", str(nfacts))
+        zip.writestr("notes", str(nnotes))
         zip.writestr("version", str(2))
         readmep = os.path.join(dir, "README.html")
         readme = open(readmep, "w")
diff --git a/aqt/sync.py b/aqt/sync.py
index 8544cc991..cc9114380 100755
--- a/aqt/sync.py
+++ b/aqt/sync.py
@@ -388,8 +388,8 @@ firewall software temporarily, or try again from a different network.
 Debugging info: %s""") % error.data.get("exc", "<none>")
         else:
             tb = traceback.format_exc()
-            if "missingFacts" in tb:
-                msg=_("""Facts were missing after sync, so the \
+            if "missingNotes" in tb:
+                msg=_("""Notes were missing after sync, so the \
 sync was aborted. Please report this error.""")
             else:
                 msg=_("Unknown error: %s") % tb